Basics of Java
Java is a object oriented programming language. It supports the
writing of many different kinds of executables: applications, applets,
and servlets. To encourage programming on
the computer, the mechanics of compiling and running a Java application
are outlined. Object-oriented programming (OOP) is the
dominant programming paradigm these days, having replaced the
"structured," procedural programming techniques that were developed in
the early 1970s. Java is totally object oriented, and it is impossible
to program it in the procedural style that you may be most comfortable
with.
In real world every thing is a object, so, java also developed in same concept. Object is created by class. Class is only blueprint or template. it contains members (field, method, constructor).
class Person{ //To create the class use keyword class and give some name to class. here name is Person
private String name; // This is field which is type of String, and this will hold the name
private String add;
Person(){ // This is constructor of Person class,
}
public String getName(){ // method which with return type String.
return name;
}
//...............other setter getter method
}
We can create the Object for above Person class by several ways in java-
- By using new operator like -Person person = new Person();
- By using Class.forName() - Person person= (Person) Class.forName("Person").newInstance();
- By using clone() - if object is already present in heap then you can clone another similar object by using like Person anotherPerson =person.clone();
- By deserialization mechanism- if object is already serialized in some filesystem then deserilize is mechanism, which can give object. like- ObjectInputStream inStream = new ObjectInputStream(anInputStream );Person person= (Person) inStream.readObject();
- Class
- Object
- Abstraction
- Encapsulation
- Inheritance
- Polymorphism
Field: field is nothing but the property/attribute of the class or object. which holds the data of specific type.
Method: method is nothing but the operation that an object can perform it define the behavior of object
Constructor:
the purpose of Constructors and methods differ in three aspects of the
signature: modifiers, return type, and name. Like methods, constructors
can have any of the access modifiers: public, protected, private, or
none (often called package or friendly). Unlike methods, constructors
can take only access modifiers. Therefore, constructors cannot be
abstract, final, native, static, or synchronized.and the name of
constructor is same to class name. The purpose of constructor is to
create an instance of a class.static block is calls before the constructor and can be used to initialize the static field/attribute.
Instance Initializer block is used to initialize the instance data member. It run each time when object of the class is created. The initialization of the instance variable can be directly but there can be performed extra operations while initializing the instance variable in the instance initializer block.
Sequence of code execution is- static, constructor, instance-initilizer block.
See below example and output to understand properly-
- class A{
- A(){
- System.out.println("parent class constructor invoked");
- }
- }
- class B extends A{
- B(){
- super(); // after this line compiler put the instance-initilizer block, so after super instance-initilizer will //execute
- System.out.println("child class constructor invoked");
- }
- {System.out.println("instance initializer block is invoked");} //instance-initilizer block
- public static void main(String args[]){
- B b=new B();
- }
- }
Output:parent class constructor invoked instance initializer block is invoked child class constructor invoked
Object
Real-world objects share two characteristics: They all have state and behavior.
Dogs have state (name, color, breed, hungry) and behavior (barking,
fetching, wagging tail). Bicycles also have state (current gear, current
pedal cadence, current speed) and behavior (changing gear, changing
pedal cadence, applying brakes). Identifying the state and behavior for
real-world objects is a great way to begin thinking in terms of
object-oriented programming.
If a class is abstract and cannot be instantiated, the class does not have much use unless it is subclass. This is typically how abstract classes come about during the design phase. A parent class contains the common functionality of a collection of child classes, but the parent class itself is too abstract to be used on its own.
Let's create abstract class-
Abstraction
Abstraction refers to the ability to make a class abstract in OOP. An abstract class is one that cannot be instantiated. All other functionality of the class still exists, and its fields, methods, and constructors are all accessed in the same manner. You cannot create an instance of the abstract class.If a class is abstract and cannot be instantiated, the class does not have much use unless it is subclass. This is typically how abstract classes come about during the design phase. A parent class contains the common functionality of a collection of child classes, but the parent class itself is too abstract to be used on its own.
Let's create abstract class-
public abstract class Employee { private String name; private String address; private int number;
//setter and getter and constructor
}
Here you can not create the object for Employee class -
if you write below code -
Employee e = new Employee()// Compile error
public class Salary extends Employee { private double salary; //Annual salary
}
Here, we cannot instantiate a new Employee, but
if we instantiate a new Salary
object, the Salary object will inherit the three fields
and setter getter methods.
A class can even be declared as abstract even though it has no abstract methods.Abstract classes cannot be instantiated. That is, if a class is declared as abstract, no objects of that class can be created.
Encapsulation
Encapsulation means putting together all the variables (instance variables) and the methods into a single unit called Class. It also means hiding data and methods within an Object. Encapsulation provides the security that keeps data and methods safe from inadvertent changes. Programmers sometimes refer to encapsulation as using a “black box,” or a device that you can use without regard to the internal mechanisms. A programmer can access and use the methods and data contained in the black box but cannot change them. For example car, you never worried about internal part of car like engine, how it works internally. you worry about outer part of car.
Encapsulation means putting together all the variables (instance variables) and the methods into a single unit called Class. It also means hiding data and methods within an Object. Encapsulation provides the security that keeps data and methods safe from inadvertent changes. Programmers sometimes refer to encapsulation as using a “black box,” or a device that you can use without regard to the internal mechanisms. A programmer can access and use the methods and data contained in the black box but cannot change them. For example car, you never worried about internal part of car like engine, how it works internally. you worry about outer part of car.
Inheritance
It is a fundamental concept of object-oriented programming.Let's take one example-
you work for a
company at which managers are treated differently from other employees.
Managers are, of course, just like employees in many respects. Both
employees and managers are paid a salary. However, while employees are
expected to complete their assigned tasks in return for receiving their
salary, managers get bonuses if they actually achieve what they are
supposed to do. This is the kind of situation that cries out for
inheritance. Why? Well, you need to define a new class, Manager, and add
functionality. But you can retain some of what you have already
programmed in the Employee class, and all the fields of the original
class can be preserved. More abstractly, there is an obvious "is–a"
relationship between Manager and Employee. Every manager is an
employee: this "is–a" relationship is the hallmark of inheritance.
Here is how you
define a Manager class that inherits from the Employee class. You use
the Java keyword extends to denote inheritance.
The keyword
extends indicates that you are making a new class that derives from an
existing class. The existing class is called the superclass, base class,
or parent class. The new class is called the subclass, derived class,
or child class
class Manager extends Employee
{
class Manager extends Employee
{
private double bonus;
//added methods and fields
//added methods and fields
public void setBonus(double b) {
bonus = b;
}
}
}
In UML diagram we denote by (------------|> ) arrow in this case Manager-------------|> Employee
Polymorphism
Polymorphism is
the ability of an object to take on many forms. The most common use of
polymorphism in OOP occurs when a parent class reference is used to
refer to a child class object.Any Java object that can pass more than
one IS-A test is considered to be polymorphic. In Java, all Java objects
are polymorphic since any object will pass the IS-A test for their own
type and for the class Object.This is also decide at run time hence
called runtime or dynamic binding.
For example, you can assign a subclass object to a super class variable.
Employee e;
e = new Employee(. . .); // Employee object expected
e = new Manager(. . .); // OK, Manager can be used as well
In the Java
programming language, object variables are polymorphic. A variable of
type Employee can refer to an object of type Employee or to an object of
any subclass of the Employee class (such as Manager, Executive,
Secretary, and so on).
Java Class By Rk: Basics Of Java Or Fundamental Of Java Or Oops Concepts >>>>> Download Now
ReplyDelete>>>>> Download Full
Java Class By Rk: Basics Of Java Or Fundamental Of Java Or Oops Concepts >>>>> Download LINK
>>>>> Download Now
Java Class By Rk: Basics Of Java Or Fundamental Of Java Or Oops Concepts >>>>> Download Full
>>>>> Download LINK