Java OOPs Concepts

1. Object Oriented Programming 2. Advantage of OOPs over Procedure-oriented programming language 3. Difference between Objcet-oriented and Objcet-based programming language. we will learn about basics of OOPs. Object Oriented Programming is a paradigm that provides many concepts such as inheritance, data binding, polymorphism etc. Simula is considered as the first object-oriented programming language. The programming paradigm where everything is represented as an object, is known as truly object-oriented programming language. Smalltalk is considered as the first truly object-oriented programming language.

OOPs (Object Oriented Programming System)

Object means a real word entity such as pen, chair, table etc. Object-Oriented Programming is a methodology or paradigm to design a program using classes and objects. It simplifies the software development and maintenance by providing some concepts:

Object Class Inheritance Polymorphism Abstraction Encapsulation

We will learn about these concepts one by one later.

What we will learn in OOPs Concepts ? Advantage of OOPs Naming Convention Object and class Method overloading Constructor static keyword this keyword with 6 usage Inheritance Aggregation Method Overriding Covariant Return Type

super keyword Instance Initializer block final keyword Abstract class Interface Runtime Polymorphism Static and Dynamic Binding Downcasting with instanceof operator Package Access Modifiers Encapsulation Object Cloning

Advantage of OOPs over Procedure-oriented programming language

1) OOPs makes development and maintenance easier where as in Procedure-oriented programming language it is not easy to manage if code grows as project size grows. 2) OOPs provides data hiding whereas in Procedure-oriented prgramming language a global data can be accessed from anywhere. 3) OOPs provides ability to simulate real-world event much more effectively. We can provide the solution of real word problem if we are using the Object-Oriented Programming language.

What is difference between object-oriented programming language and objectbased programming language?
Object based programming language follows all the features of OOPs except Inheritance. JavaScript and VBScript are examples of object based programming languages.

Naming convention
A naming convention is a rule to follow as you decide what to name your identifiers (e.g. class, package, variable, method, etc.), but it is not mandatory to follow that is why it is known as convention not rule. Advantage: By using standard Java naming conventions they make their code easier to read for themselves and for other programmers. Readability of Java code is important because it means less time is spent trying to figure out what the code does.

class name

should begin with uppercase letter and be a noun e.g.String,System,Thread etc. should begin with uppercase letter and be an adjective (whereever possible).

Interface name e.g. Runnable,ActionListener etc. should begin with lowercase letter and be a verb. method name e.g. main(),print(),println(),actionPerformed() etc. should begin with lowercase letter variable name e.g. firstName,orderNumber etc. should be in lowercase letter. package name e.g. java,lang,sql,util etc. should be in uppercase letter. constants name e.g. RED,YELLOW,MAX_PRIORITY etc.

Object and Class (Object-Oriented Programming)

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. Object Class Instace Variable Method Advantage of Method new keyword Example of Object and class that maintains the records of student Different ways to create an object in java Annonymous Object Creating multiple objects by one type

we will learn about the objects and classes. In object-oriented programming, we design a program using objects and classes. Object is the physical entity whereas class is the logical entity. A class works as a template from which we create the objects.

Object
A runtime entity that has state and behaviour is known as an object. For example: chair, table, pen etc. It can be tengible or intengible (physical or logical). An object has three characterstics:

state:represents the data of an object. behaviour:represents the behaviour of an object. identity:Object identity is typically implemented via a unique ID. The value of the ID is not visible to the external user, but is used internally by the JVM to identify each object uniquely.

For Example: Pen is an object. Its name is Reynolds, color is white etc. known as its state. It is used to write, so writing is its behaviour. Object is an instance of a class.Class is a template or blueprint from which objects are created.So object is the instance(result) of a class.

Class
A class is a group of objects that have common property. It is a template or blueprint from which objects are created. A class in java can contain:

data member method constructor block

Syntax to declare a class:

Simple Example of Object and Class

In this example, we have created a Student class that have two data members id and name. We are creating the object of the Student class by new keyword and printing the objects value.

Output:0 null

Instance variable
A variable that is created inside the class but outside the method, is known as instance variable. Instance variable doesn't get memory at compile time. It gets memory at runtime when object(instance) is created. That is why, it is known as instance variable.

Method
In java, a method is like function i.e. used to expose behavior of an object. Advantage of Method

Code Reusability Code Optimization

new keyword
The new keyword is used to allocate memory at runtime.

Example of Object and class that maintains the records of students

In this example, we are creating the two objects of Student class and initializing the value to these objects by invoking the insertRecord method on it. Here, we are displaying the state (data) of the objects by invoking the displayInformation method.

Output:111 Karan 222 Aryan

As you see in the above figure, object gets the memory in Heap area and reference variable refers to the object allocated in the Heap memory area. Here, s1 and s2 both are reference variables that refer to the objects allocated in memory.

Another Example of Object and Class

There is given another example that maintains the records of Rectangle class. Its exaplanation is same as in the above Student class example.

Output: Area of Rectangle :55 Area of Rectangle :45

What are the different ways to create an object in Java?

There are many ways to create an object in java. They are:

By new keyword By newInstance() method By clone() method By factory method etc.

We will learn, these ways to create the object later.

Annonymous object
Annonymous simply means nameless.An object that have no reference is known as annonymous object. If you have to use an object only once, annonymous object is a good approach.

Output:Factorial is 120

Creating multiple objects by one type only

We can create multiple objects by one type only as we do in case of primitives.
Rectangle r1=new Rectangle(),r2=new Rectangle();//creating two objects

Let's see the example:

Output:Area of Rectangle :55 Area of Rectangle :45

Method Overloading in Java

If a class have multiple methods by same name but different parameters, it is known as Method Overloading.

If we have to perform only one operation, having the same name of the methods increases the readability of the program. Suppose you have to perform addition of the given numbers but there can be any number of arguments, if you write the method such as a(int,int) for two parameters, and b(int,int,int) for three parameters then it may be difficult for you as well as other programmers to understand the behaviour of the method because its name differs. So, we perform method overloading to figure out the program quickly.

Advantage of method overloading?

Method overloading increases the readability of the program.

Different ways to overload the method

There are two ways to overload the method in java 1. By changing number of arguments 2. By changing the data type Note: In java, Methood Overloading is not possible by changing return type of the method.

1)Example of Method Overloading by changing the no. of arguments

In this example, we have created two overloaded methods, first sum method performs addition of two numbers and second sum method performs addition of three numbers.

Output:30 40

2)Example of Method Overloading by changing data type of argument

In this example, we have created two overloaded methods that differs in data type. The first sum method receives two integer arguments and second sum method receives two double arguments.

Output:21.0 40

Question: Why Method Overloading is not possible by changing the return type of method?
In java, method overloading is not possible by changing the return type of the method because there

may occur ambiguity. Let's see how ambiguity may occur:

because there was problem:

int result=obj.sum(20,20); //Here how can java determine which sum() method should be called

Can we overload main() method?

Yes, by method overloading. You can have any number of main methods in a class by method overloading. Let's see the simple example:

Output:main() method invoked 10

Method Overloading and TypePromotion

One type is promoted to another implicitly if no matching datatype is found. Let's understand the concept by the figure given below:

As displayed in the above diagram, byte can be promoted to short, int, long, float or double. The short datatype can be promoted to int,long,float or double. The char datatype can be promoted to int,long,float or double and so on.

Example of Method Overloading with TypePromotion

Output:40 60

Example of Method Overloading with TypePromotion if matching found

If there are matching type arguments in the method, type promotion is not performed.
class Calculation{ void sum(int a,int b){System.out.println("int arg method invoked");} void sum(long a,long b){System.out.println("long arg method invoked");} public static void main(String args[]){ Calculation obj=new Calculation(); obj.sum(20,20);//now int arg sum() method gets invoked } } Output:int arg method invoked

Example of Method Overloading with TypePromotion in case ambiguity

If there are no matching type arguments in the method, and each method promotes similar number of arguments, there will be ambiguity.
class Calculation{ void sum(int a,long b){System.out.println("a method invoked");}

void sum(long a,int b){System.out.println("b method invoked");} public static void main(String args[]){ Calculation obj=new Calculation(); obj.sum(20,20);//now ambiguity } } Output:Compile Time Error

One type is not depromoted implicitely for example double cannot be depromoted to any type implicitely.

Constructor
1. Types of constructors 1. Default Constructor 2. Parameterized Constructor 2. Constructor Overloading 3. Does constructor return any value 4. Copying the values of one object into another 5. Does constructor perform other task instead initialization Constructor is a special type of method that is used to initialize the state of an object. Constructor is invoked at the time of object creation. It constructs the values i.e. data for the object that is why it is known as constructor. Constructor is just like the instance method but it does not have any explicit return type.

Rules for creating constructor

There are basically two rules defined for the constructor.

1. Constructor name must be same as its class name 2. Constructor must have no explicit return type

Types of constructors

There are two types of constructors: 1. default constructor (no-arg constructor) 2. parameterized constructor

1) Default Constructor
A constructor that have no parameter is known as default constructor.

Syntax of default constructor:

<class_name>(){}

Example of default constructor

In this example, we are creating the no-arg constructor in the Bike class. It will be invoked at the time of object creation.
//example of default constructor class Bike{ Bike(){System.out.println("Bike is created");} public static void main(String args[]){ Bike b=new Bike(); } } Output:Bike is created

Rule: If there is no constructor in a class, compiler automatically creates a default constructor.

Que)What is the purpose of default constructor?

Default constructor provides the default values to the object.

Example of default constructor that displays the default values

//example of default values provided by constructor class Student{ int id; String name; void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student s1=new Student(); Student s2=new Student(); s1.display(); s2.display(); } } Output:0 null 0 null

Explanation:In the above class,you are not creating any constructor so compiler provides you a default constructor.Here 0 and null values are provided by default constructor.

Parameterized constructor
A constructor that have parameter is known as parameterized constructor.

Why use parameterized constructor?

Parameterized constructor is used to provide different values to the distinct objects.

Example of parameterized constructor

In this example, we have created the constructor of Student class that have two parameters. We can have any number of parameters in the constructor.
class Student{ int id; String name; Student(int i,String n){ id = i; name = n; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student s1 = new Student(111,"Karan"); Student s2 = new Student(222,"Aryan"); s1.display(); s2.display(); } } Output:111 Karan 222 Aryan

Constructor Overloading
Constructor overloading is a technique in Java in which a class can have any number of constructors that differ in parameter lists.The compiler differentiates these constructors by taking into account the number of parameters in the list and their type.

Example of Constructor Overloading

//Program of constructor overloading class Student{ int id; String name; int age; Student(int i,String n){ id = i; name = n; } Student(int i,String n,int a){ id = i; name = n; age=a;

} void display(){System.out.println(id+" "+name+" "+age);} public static void main(String args[]){ Student s1 = new Student(111,"Karan"); Student s2 = new Student(222,"Aryan",25); s1.display(); s2.display(); } } Output:111 Karan 0 222 Aryan 25

What is the difference between constructor and method ?

There are many differences between constructors and methods. They are given below. Constructor Method Method is used to expose behaviour of an object. Method must have return type. Method is invoked explicitly. Method is not provided by compiler in any case. Method name may or may not be same as class name.

Constructor is used to initialize the state of an object.

Constructor must not have return type. Constructor is invoked implicitly. The java compiler provides a default constructor if you don't have any constructor.

Constructor name must be same as the class name.

Que)Does constructor return any value?

Ans:yes,that is current class instance (You cannot use return type yet it returns a value).

Copying the values of one object to another like copy constructor in C++
There are many ways to copy the values of one object into another. They are:

By constructor By assigning the values of one object into another By clone() method of Object class

In this example, we are going to copy the values of one object into another using constructor.
//Program of Copying the values of one object to another class Student{ int id; String name; Student(int i,String n){

id = i; name = n; } Student(Student s){ id = s.id; name =s.name; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student s1 = new Student(111,"Karan"); Student s2 = new Student(s1); s1.display(); s2.display(); } } Output:111 Karan 111 Karan

Copying the values of one object to another without constructor

We can copy the values of one object into another by assigning the objects values to another object. In this case, there is no need to create the constructor.
//Anoter program of Copying the values of one object to another

Output:111 Karan 111 Karan

Can constructor perform other tasks instead of initialization?

Yes, like object creation, starting a thread, calling method etc. You can perform any operation in the constructor as you perform in the method.

static keyword
1. 2. 3. 4. 5. 6. 7. Static variable Program of counter without static variable Program of counter with static variable Static method Restrictions for static method Why main method is static ? Static block

8. Can we execute a program without main method ? The static keyword is used in java mainly for memory management. We may apply static keyword with variables, methods and blocks. The static keyword belongs to the class than instance of the class. The static can be:

1. variable (also known as class variable) 2. method (also known as class method) 3. block

1) static variable
If you declare any variable as static, it is known static variable.

The static variable can be used to refer the common property of all objects (that is not unique for each object) e.g. company name of employees,college name of students etc. The static variable gets memory only once in class area at the time of class loading.

Advantage of static variable

It makes your program memory efficient (i.e it saves memory). Understanding problem without static variable
class Student{ int rollno; String name; String college="ITS"; }

Suppose there are 500 students in my college, now all instance data members will get memory each time when object is created.All student have its unique rollno and name so instance data member is good.Here, college refers to the common property of all objects.If we make it static,this field will get memory only once. Note:static field is shared by all objects.

Example of static variable

//Program of static variable class Student{ int rollno; String name;

static String college ="ITS"; Student(int r,String n){ rollno = r; name = n; } void display (){System.out.println(rollno+" "+name+" "+college);} public static void main(String args[]){ Student s1 = new Student (111,"Karan"); Student s2 = new Student (222,"Aryan"); s1.display(); s2.display(); } } Output:111 Karan ITS 222 Aryan ITS

Program of counter without static variable

In this example, we have created an instance variable named count which is incremented in the constructor. Since instance variable gets the memory at the time of object creation, each object will

have the copy of the instance variable, if it is incremented, it won't reflect to other objects. So each objects will have the value 1 in the count variable.
class Counter{ int count=0;//will get memory when instance is created Counter(){ count++; System.out.println(count); } public static void main(String args[]){ Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter(); }} Output:1 1 1

Program of counter by static variable

As we have mentioned above, static variable will get the memory only once, if any object changes the value of the static variable, it will retain its value.
class Counter{ static int count=0;//will get memory only once and retain its value Counter(){ count++; System.out.println(count); } public static void main(String args[]){ Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter(); }} Output:1 2 3

2) static method

If you apply static keyword with any method, it is known as static method.

A static method belongs to the class rather than object of a class. A static method can be invoked without the need for creating an instance of a class. static method can access static data member and can change the value of it.

Example of static method

//Program of changing the common property of all objects(static field). class Student{ int rollno; String name; static String college = "ITS"; static void change(){ college = "BBDIT"; } Student(int r, String n){ rollno = r; name = n; } void display (){System.out.println(rollno+" "+name+" "+college);} public static void main(String args[]){ Student.change(); Student s1 = new Student (111,"Karan"); Student s2 = new Student (222,"Aryan"); Student s3 = new Student (333,"Sonoo"); s1.display(); s2.display(); s3.display(); } } Output:111 Karan BBDIT 222 Aryan BBDIT 333 Sonoo BBDIT

Another example of static method that performs normal calculation

//Program to get cube of a given number by static method Class Calculate{ static int cube(int x){ return x*x*x; }

public static void main(String args[]){ int result=Calculate.cube(5); System.out.println(result); } } Output:125

Restrictions for static method

There are two main restrictions for the static method. They are: 1. The static method can not use non static data member or call non-static method directly. 2. this and super cannot be used in static context.
//Program of accessing non-static data member directly from static method main class A{ int a=40;//non static public static void main(String args[]){ System.out.println(a); } } Output:Compile Time Error

Que)why main method is static?

Ans) because object is not required to call static method if it were non-static method, jvm creats object first then call main() method that will lead the problem of extra memory allocation.

3)static block:

Is used to initialize the static data member. It is excuted before main method at the time of classloading.

Example of static block

//Program of static block class A{ static{System.out.println("static block is invoked");} public static void main(String args[]){ System.out.println("Hello main"); } }

Output:static block is invoked Hello main

Que)Can we execute a program without main() method?

Ans)Yes, one of the way is static block but in previous version of JDK not in JDK 1.7.
//Program of executing a program without main() method class A{ static{ System.out.println("static block is invoked"); System.exit(0); } } Output:static block is invoked (if not JDK7)

this keyword
1. this keyword 2. Usage of this keyword 1. to refer the current class instance variable 2. to invoke the current class constructor 3. to invoke the current class method 4. to pass as an argument in the method call 5. to pass as an argument in the constructor call 6. to return the current class instance 3. Proving this keyword There can be a lot of usage of this keyword. In java, this is a reference variable that refers to the current object.

Usage of this keyword

Here is given the 6 usage of this keyword. 1. 2. 3. 4. 5. this keyword can be used to refer current class instance variable. this() can be used to invoke current class constructor. this keyword can be used to invoke current class method (implicitly) this can be passed as an argument in the method call. this can be passed as argument in the constructor call.

6. this keyword can also be used to return the current class instance.
Suggestion:If you are beginner to java, lookup only two usage of this keyword.

1) The this keyword can be used to refer current class instance variable.
If there is ambiguity between the instance variable and parameter, this keyword resolves the problem of ambiguity. Understanding the problem without this keyword Let's understand the problem if we don't use this keyword by the example given below:
class student{ int id; String name; student(int id,String name){ id = id; name = name; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ student s1 = new student(111,"Karan"); student s2 = new student(321,"Aryan"); s1.display(); s2.display(); } } Output:0 null 0 null

In the above example, parameter (formal arguments) and instance variables are same that is why we are using this keyword to distinguish between local variable and instance variable.

Solution of the above problem by this keyword

example of this keyword class Student{ int id; String name; student(int id,String name){ this.id = id; this.name = name; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student s1 = new Student(111,"Karan"); Student s2 = new Student(222,"Aryan"); s1.display(); s2.display(); } } Output:111 Karan 222 Aryan

If local variables(formal arguments) and instance variables are different, there is no need to use this keyword like in the following program: Program where this keyword is not required
class Student{

int id; String name; student(int i,String n){ id = i; name = n; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student e1 = new Student(111,"karan"); Student e2 = new Student(222,"Aryan"); e1.display(); e2.display(); } } Output:111 Karan 222 Aryan

2) this() can be used to invoked current class constructor.

The this() constructor call can be used to invoke the current class constructor. This approach is better if you have many constructors in the class and want to reuse that constructor.
Program of this() constructor call class Student{ int id; String name; Student (){System.out.println("default constructor is invoked");} Student(int id,String name){ this ();//it is used to invoked current class constructor. this.id = id; this.name = name; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student e1 = new Student(111,"karan"); Student e2 = new Student(222,"Aryan"); e1.display(); e2.display(); } } Output: default constructor is invoked default constructor is invoked 111 Karan 222 Aryan

Where to use this() constructor call?

The this() constructor call should be used to reuse the constructor in the constructor. It maintains the chain between the constructors i.e. it is used for constructor chaining. Let's see the example given below that displays the actual use of this keyword.
class Student{ int id; String name; String city; Student(int id,String name){ this.id = id; this.name = name; } Student(int id,String name,String city){ this(id,name);//now no need to initialize id and name this.city=city; } void display(){System.out.println(id+" "+name+" "+city);} public static void main(String args[]){ Student e1 = new Student(111,"karan"); Student e2 = new Student(222,"Aryan","delhi"); e1.display(); e2.display(); } } Output:111 Karan null 222 Aryan delhi

Rule: Call to this() must be the first statement.

class Student{ int id; String name; Student (){System.out.println("default constructor is invoked");} Student(int id,String name){ id = id; name = name; this ();//must be the first statement } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student e1 = new Student(111,"karan"); Student e2 = new Student(222,"Aryan"); e1.display(); e2.display(); } } Output:Compile Time Error

3)The this keyword can be used to invoke current class method (implicitly).

You may invoke the method of the current class by using the this keyword. If you don't use the this keyword, compiler automatically adds this keyword while invoking the method. Let's see the example
class S{ void m(){ System.out.println("method is invoked"); } void n(){ this.m();//no need because compiler does it for you. } void p(){ n();//complier will add this to invoke n() method as this.n() } public static void main(String args[]){ S s1 = new S(); s1.p(); } } Output:method is invoked

4) The this keyword can be passed as an argument in the method.

The this keyword can also be passed as an argument in the method. It is mainly used in the event handling. Let's see the example:
class S{ void m(S obj){ System.out.println("method is invoked"); } void p(){ m(this); }

public static void main(String args[]){ S s1 = new S(); s1.p(); } } Output:method is invoked

Application of this that can be passed as an argument:

In event handling (or) in a situation where we have to provide reference of a class to another one.

5) The this keyword can be passed as argument in the constructor call.

We can pass the this keyword in the constructor also. It is useful if we have to use one object in multiple classes. Let's see the example:
class B{ A obj; B(A obj){ this.obj=obj; } void display(){ System.out.println(obj.data);//using data member of A class } } class A{ int data=10; A(){ B b=new B(this); b.display(); } public static void main(String args[]){ A a=new A(); } } Output:10

6) The this keyword can be used to return current class instance.

We can return the this keyword as an statement from the method. In such case, return type of the method must be the class type (non-primitive). Let's see the example:

Syntax of this that can be returned as a statement

return_type method_name(){

return this; }

Example of this keyword that you return as a statement from the method
class A{ A getA(){ return this; } void msg(){System.out.println("Hello java");} } class Test{ public static void main(String args[]){ new A().getA().msg(); } } Output:Hello java

Proving this keyword

Let's prove that this keyword refers to the current class instance variable. In this program, we are printing the reference variable and this, output of both variables are same.
class A{ void m(){ System.out.println(this);//prints same reference ID } public static void main(String args[]){ A obj=new A(); System.out.println(obj);//prints the reference ID obj.m(); } } Output:A@13d9c02 A@13d9c02

Inheritance (Object-Oriented Programming)

1. Inheritance 2. Types of Inheritance 3. Why multiple inheritance is not possible in java in case of class?

Inheritance is a mechanism in which one object acquires all the properties and behaviours of parent object. The idea behind inheritance is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you reuse (or inherit) methods and fields, and you add new methods and fields to adapt your new class to new situations.Inheritance represents the IS-A relationship.

Why use Inheritance?

For Method Overriding (So Runtime Polymorphism). For Code Reusability.

Syntax of Inheritance
class Subclass-name extends Superclass-name { //methods and fields }

The keyword extends indicates that you are making a new class that derives from an existing class. In the terminology of Java, a class that is inherited is called a superclass. The new class is called a subclass.

Example of inheritance

As displayed in the above figure, Programmer is the subclass and Employee is the superclass. Relationship between two classes is Programmer IS-A Employee.It means that Programmer is a type of Employee.
class Employee{ int salary=40000; } class Programmer extends Employee{ int bonus=10000;

Public Static void main(String args[]){ Programmer p=new Programmer(); System.out.println("Programmer salary is:"+p.salary); System.out.println("Bonus of Programmer is:"+p.bonus); } } Output:Programmer salary is:40000 Bonus of programmer is:10000

In the above example,Programmer object can access the field of own class as well as of Employee class i.e. code reusability.

Types of Inheritance:

Note:Multiple inheritance is not supported in java in case of class. When a class extends two classes i.e. known as multiple inheritance.For Example:

Que) Why multiple inheritance is not supported in java?

To reduce the complexity and simplify the language,multiple inheritance is not supported in java.For Example:

class A{ void msg(){System.out.println("Hello");} } class B{ void msg(){System.out.println("Welcome");} } class C extends A,B{//suppose if it were Public Static void main(String args[]){ C obj=new C(); obj.msg();//Now which msg() method would be invoked? } }

Aggregation in Java
If a class have an entity reference, it is known as Aggregation. Aggregation represents HAS-A relationship. Consider a situation, Employee object contains many informations such as id, name, emailId etc. It contains one more object named address, which contains its own informations such as city, state, country, zipcode etc. as given below.
class Employee{ int id; String name; Address address;//Address is a class ... }

In such case, Employee has an entity reference address, so relationship is Employee HAS-A address.

Why use Aggregation?

For Code Reusability.

Simple Example of Aggregation

In this example, we have created the reference of Operation class in the Circle class.
class Operation{ int square(int n){ return n*n; } } class Circle{ Operation op;//aggregation double pi=3.14; double area(int radius){ op=new Operation(); int rsquare=op.square(radius);//code reusability (i.e. delegates the method call). return pi*rsquare; }

public static void main(String args[]){ Circle c=new Circle(); double result=c.area(5); System.out.println(result); } } Output:78.5

When use Aggregation?

Code reuse is also best achieved by aggregation when there is no is-a relationship. Inheritance should be used only if the relationship is-a is maintained throughout the lifetime of the objects involved; otherwise, aggregation is the best choice.

Understanding meaningful example of Aggregation

In this example, Employee has an object of Address, address object contains its own informations such as city, state, country etc. In such case relationship is Employee HAS-A address.
Address.java
public class Address { String city,state,country; public Address(String city, String state, String country) { this.city = city; this.state = state; this.country = country; } }

Emp.java
public class Emp { int id; String name; Address address; public Emp(int id, String name,Address address) { this.id = id; this.name = name; this.address=address; } void display(){ System.out.println(id+" "+name); System.out.println(address.city+" "+address.state+" "+address.country); } public static void main(String[] args) { Address address1=new Address("gzb","UP","india"); Address address2=new Address("gno","UP","india"); Emp e=new Emp(111,"varun",address1); Emp e2=new Emp(112,"arun",address2); e.display(); e2.display(); } }

Method Overriding in Java

1. Understanding problem without method overriding 2. Can we override the static method 3. method overloading vs method overriding Having the same method in the subclass as declared in the parent class is known as method overriding. If a subclass provides a specific implementation of a method that is already provided by its super class, it is known as Method Overriding.

Advantage of Method Overriding

Method Overriding is used to provide specific implementation of a method that is already provided by its super class. Method Overriding is used for Runtime Polymorphism

Rules for Method Overriding: 1. method must have same name as in the parent class 2. method must have same parameter as in the parent class.

Understanding the problem without mehtod overriding

Let's understand the problem that we may face in the program if we don't use method overriding.
//Problem without method overriding class Vehicle{ void run(){System.out.println("Vehicle is running");} } class Bike extends Vehicle{ public static void main(String args[]){ Bike obj = new Bike(); obj.run(); } } Output:Vehicle is running

Problem is that I have to provide a specific implementation of run() method in subclass that is why we use method overriding.

Example of method overriding

In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method is same and there is IS-A relationship between the classes, so there is method overriding.
//Example of method overriding class Vehicle{

void run(){System.out.println("Vehicle is running");} } class Bike extends Vehicle{ void run(){System.out.println("Bike is running safely");} public static void main(String args[]){ Bike obj = new Bike(); obj.run(); } } Output:Bike is running safely

Can we override static method?

No, static method cannot be overridden. It can be proved by runtime polymorphism so we will learn it later.

Why we cannot override static method?

because static method is bound with class whereas instance method is bound with object. Static belongs to class area and instance belongs to heap area.

Difference between method Overloading and Method Overriding.

There are three basic differences between the method overloading and method overriding. They are as follows: Method Overloading 1) Method overloading is used to increase the readability of the program. 2) method overlaoding is performed within a class. 3) In case of method overloading parameter must be different. Method Overriding Method overriding is used to provide the specific implementation of the method that is already provided by its super class. Method overriding occurs in two classes that have IS-A relationship. In case of method overriding parameter must be same.

More topics on Method Overriding (Not For Fresher)

Method Overriding with Access Modifier Let's see the concept of method overriding with access modifier. Exception Handling with Method Overriding

Let's see the concept of method overriding with exception handling.

Covariant Return Type

The covariant return type specifies that the return type may vary in the same direction as the subclass. Before Java5, it was not possible to override any method by changing the return type. But now, since Java5, it is possible to override method by changing the return type if subclass overrides any method whose return type is Non-Primitive but it changes its return type to subclass type. Let's take a simple example: Note: If you are beginner to java, skip this topic and return to it after OOPs concepts.

Simple example of Covariant Return Type

class A{ A get(){return this;} } class B extends A{ B get(){return this;} void message(){System.out.println("welcome to covariant return type");} public static void main(String args[]){ new B().get().message(); } } Output:welcome to covariant return type

As you can see in the above example, the return type of the get() method of A class is A but the return type of the get() method of B class is B. Both methods have different return type but it is method overriding. This is known as covariant return type.

super keyword:
super is a reference variable that is used to refer immediate parent class object.

Uses of super Keyword: 1. super is used to refer immediate parent class instance variable.

2. super() is used to invoke immediate parent class constructor. 3. super is used to invoke immediate parent class method.

1.super is used to refer immediate parent class instance variable.

Problem without super keyword
class Vehicle{ int speed=50; } class Bike extends Vehicle{ int speed=100; void display(){ System.out.println(speed);//will print speed of Bike } public static void main(String args[]){ Bike b=new Bike(); b.display(); } } Output:100

In the above example Vehicle and Bike both class have a common property speed. Instance variable of current class is refered by instance bydefault, but I have to refer parent class instance variable that is why we use super keyword to distinguish between parent class instance variable and current class instance variable.

Solution by super keyword

//example of super keyword class Vehicle{ int speed=50; } class Bike extends Vehicle{ int speed=100; void display(){ System.out.println(super.speed);//will print speed of Vehicle now } public static void main(String args[]){ Bike b=new Bike(); b.display(); } }

Output:50

2.super is used to invoke parent class constructor.

The super keyword can also be used to invoke the parent class constructor as given below:

Example of super keyword

class Vehicle{ Vehicle(){System.out.println("Vehicle is created");} } class Bike extends Vehicle{ Bike(){ super();//will invoke parent class constructor System.out.println("Bike is created"); } public static void main(String args[]){ Bike b=new Bike(); } } Output:Vehicle is created Bike is created

Note:super() is added in each class construtor automatically by compiler.

As we know well that default constructor is provided by compiler automatically but it also adds super() for the first statement.If you are creating your own constructor and you don't have either this() or super() as the first statement, compiler will provide super() as the first statement of the consructor.

Another example of super keyword where super() is provided by the compiler implicitely.

class Vehicle{ Vehicle(){System.out.println("Vehicle is created");} } class Bike extends Vehicle{ int speed; Bike(int speed){ this.speed=speed; System.out.println(speed); } public static void main(String args[]){ Bike b=new Bike(10); } } Output:Vehicle is created 10

3. super can be used to invoke immediate parent class method.

The super keyword can also be used to invoke parent class method. It should be used in case subclass contains the same method as parent class as in the example given below:

Program of super that can be used to invoke method of parent class

class Person{ void message(){System.out.println("welcome");} } class Student extends Person{ void message(){System.out.println("welcome to java");} void dislay(){ message();//will invoke current class message() method super.message();//will invoke parent class message() method } public static void main(String args[]){ Student s=new Student(); s.display(); } } Output:welcome to java welcome

In the above example Student and Person both classes have message() method if we call message() method from Student class, it will call the message() method of Student class not of Person class because priority is given to local.

In case there is no method in subclass as parent, there is no need to use super. In the example given below message() method is invoked from Student class but Student class does not have message() method, so you can directly call message() method.

Program in case super is not required

class Person{ void message(){System.out.println("welcome");} } class Student extends Person{ void dislay(){ message();//will invoke parent class message() method }

public static void main(String args[]){ Student s=new Student(); s.display(); } } Output:welcome

Instance initializer block:

1. 2. 3. 4. 5. Instance initializer block Example of Instance initializer block What is invoked firstly instance initializer block or constructor? Rules for instance initializer block Program of instance initializer block that is invoked after super()

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 initilizing the instance variable in the instance initializer block. Que) What is the use of instance initializer block while we can directly assign a value in instance data member? For example:
class Bike{ int speed=100; }

Why use instance initializer block?

Suppose I have to perform some operations while assigning value to instance data member e.g. a for loop to fill a complex array or error handling etc.

Example of Instance initializer block

Let's see the simple example of intance initializer block the performs initialization.
//Program of instance initializer block that initializes values to the instance variable class Bike{ int speed;

Bike(){System.out.println("speed is "+speed);} {speed=100;} public static void main(String args[]){ Bike b1=new Bike(); Bike b2=new Bike(); } } Output:speed is 100 speed is 100

There are three places in java where you can perform operations: 1. method 2. constructor 3. block

What is invoked firstly instance initializer block or constructor?

//Program of instance initializer block class Bike{ int speed; Bike(){System.out.println("constructor is invoked");} {System.out.println("instance initializer block invoked");} public static void main(String args[]){ Bike b1=new Bike(); Bike b2=new Bike(); } } Output:instance initializer block invoked constructor is invoked instance initializer block invoked constructor is invoked

In the above example, it seems that instance initializer block is firstly invoked but NO. Instance intializer block is invoked at the time of object creation. The java compiler copies the instance initializer block in the costructor after the first statement super(). So firstly, constructor is invoked. Let's understand it by the figure given below:

Note: The java compiler copies the code of instance initializer block in every constructor.

Rules for instance initializer block :

There are mainly three rules for the instance initializer block. They are as follows:

1. The instance initializer block is created when instance of the class is created. 2. The instance initializer block is invoked after the parent class constructor is invoked (i.e. after super() constructor call). 3. The instance initializer block comes in the order in which they appear.

Program of instance initializer block that is invoked after super()

//Program of instance initializer block that is invoked after super()

class A{ A(){ System.out.println("parent class constructor invoked"); } } class B extends A{ B(){ super(); System.out.println("child class constructor invoked"); } {System.out.println("instance initializer block is invoked");} public static void main(String args[]){ B b=new B(); } } Output:parent class constructor invoked instance initializer block is invoked child class constructor invoked

//Another example of instance initializer block that is invoked after super() class A{ A(){ System.out.println("parent class constructor invoked"); } } class B extends A{ B(){ super(); System.out.println("child class constructor invoked"); } B(int a){ super(); System.out.println("child class constructor invoked "+a); } {System.out.println("instance initializer block is invoked");} public static void main(String args[]){ B b1=new B();

B b2=new B(10); } } Output:parent class constructor invoked instance initializer block is invoked child class constructor invoked parent class constructor invoked instance initializer block is invoked child class constructor invoked 10

final keyword:
1. 2. 3. 4. 5. 6. 7. 8. Final variable Final method Final class Is final method inherited ? Blank final variable Static blank final variable Final parameter Can you declare a final constructor

The final keyword in java is used to restrict the user. The final keyword can be used in many context. Final can be: 1. variable 2. method 3. class The final keyword can be applied with the variables, that have no value it is called blank final variable. It can be initialized in the constructor only. The blank final variable can be static also which will be initialized in the static block only. We will have detailed learning of these. Let's first learn the basics of final keyword.

1)final variable:
If you make any variable as final, you cannot change the value of final variable(It will be constant).

Example of final variable

There is a final variable speedlimit, we are going to change the value of this variable, but It can't be changed because final variable once assigned a value can never be changed.

class Bike{ final int speedlimit=90;//final variable void run(){ speedlimit=400; } public static void main(String args[]){ Bike obj=new Bike(); obj.run(); } } Output:Compile Time Error

2)final method
If you make any method as final, you cannot override it.

Example of final method

class Bike{ final void run(){System.out.println("running");} } class Honda extends Bike{ void run(){System.out.println("running safely with 100kmph");} public static void main(String args[]){ Honda honda= new Honda(); honda.run(); } } Output:Compile Time Error

3)final class:
If you make any class as final, you cannot extend it.

Example of final class

final class Bike{} class Honda extends Bike{ void run(){System.out.println("running safely with 100kmph");} public static void main(String args[]){ Honda honda= new Honda(); honda.run();

} } Output:Compile Time Error

Que) Is final method inherited?

Ans)Yes, final method is inherited but you cannot override it. For Example:
class Bike{ final void run(){System.out.println("running...");} } class Honda extends Bike{ public static void main(String args[]){ new Honda().run(); } } Output:running...

Que) What is blank final variable?

A final variable that is not initalized at the time of declaration is known as blank final variable. If you want to create a variable that is initialized at the time of creating object and once initialized may not be changed, it is useful. For example PAN CARD number of an employee. It can be initialized only in constuctor.

Example of blank final variable

class Student{ int id; String name; final String PAN_CARD_NUMBER; ... }

Que) Can we intialize blank final variable?

Yes, but only in constructor. For example:
class Bike{ final int speedlimit;//blank final variable Bike(){ speedlimit=70; System.out.println(speedlimit); } public Static void main(String args[]){ new Bike(); }

} Output:70

static blank final variable

A static final variable that is not initalized at the time of declaration is known as static blank final variable. It can be initialized only in static block.

Example of static blank final variable

class A{ static final int data;//static blank final variable static{ data=50;} public Static void main(String args[]){ System.out.println(A.data); } }

Que) What is final parameter?

If you declare any parameter as final, you cannot change the value of it.
class Bike{ int cube(final int n){ n=n+2;//can't be changed as n is final n*n*n; } public Static void main(String args[]){ Bike b=new Bike(); b.cube(5); } } Output:Compile Time Error

Que)Can we declare a constructor as final?

No, because constructor is never inherited.

Abstract class in Java

Before abstract class, let's understand the abstraction first.

Abstraction
Abstraction is a process of hiding the implementation details and showing only functionality to the user. Another way, it shows only important things to the user and hides the internal details. Abstraction lets you focus on what the object does instead of how it does it.

Ways to achieve Abstaction

There are two ways to achieve abstraction in java 1. Abstract class (0 to 100%) 2. Interface (100%)

Abstract class
A class that is declared as abstract is known as abstract class.It needs to be extended and its method implemented. It cannot be instantiated.

Syntax to declare the abstract class

abstract class <class_name>{}

abstract method
A method that is declared as abstract and does not have implementation is known as abstract method.

Syntax to define the abstract method

abstract return_type <method_name>();//no braces{}

Example of abstract class that have abstract method

In this example, Bike the abstract class that contains only one abstract method run. It implementation is provided by the Honda class.

abstract class Bike{ abstract void run(); } class Honda extends Bike{ void run(){System.out.println("running safely..");} public static void main(String args[]){ Bike obj = new Honda(); obj.run(); } } Output:running safely..

Understanding the real scenario of abstract class

In this example, Shape is the abstract class, its implementation is provided by the Rectangle and Circle classes. Mostly, we don't know about the implementation class (i.e. hidden to the end user) and object of the implementation class is provided by the factory method. A factory method is the method that returns the instance of the class. We will learn about the factory method later. In this example, if you create the instance of Rectangle class, draw method of Rectangle class will be invoked.
abstract class Shape{ abstract void draw(); } class Rectangle extends Shape{ void draw(){System.out.println("drawing rectangle");} } class Circle extends Shape{ void draw(){System.out.println("drawing circle");} } class Test{ public static void main(String args[]){ Shape s=new Circle(); //In real scenario, Object is provided through factory method s.draw(); } } Output:drawing circle

Abstract class having constructor, data member, methods etc.

Note: An abstract class can have data member,abstract method,method body,constructor and even main() method.
//example of abstract class that have method body abstract class Bike{ abstract void run(); void changeGear(){System.out.println("gear changed");} } class Honda extends Bike{ void run(){System.out.println("running safely..");} public static void main(String args[]){ Bike obj = new Honda(); obj.run(); obj.changeGear(); } } Output:running safely.. gear changed //example of abstract class having constructor, field and method abstract class Bike { int limit=30; Bike(){System.out.println("constructor is invoked");} void getDetails(){System.out.println("it has two wheels");} abstract void run(); } class Honda extends Bike{ void run(){System.out.println("running safely..");} public static void main(String args[]){ Bike obj = new Honda(); obj.run(); obj.getDetails(); System.out.println(obj.limit); } } Output:constructor is invoked running safely.. it has two wheels 30

Rule: If there is any abstract method in a class, that class must be abstract.
class Bike{ abstract void run(); } Output:compile time error

Rule: If you are extending any abstact class that have abstract method, you must either provide the implementation of the method or make this class abstract.

Another real scenario of abstract class

The abstract class can also be used to provide some implementation of the interface. In such case, the end user may not be forced to override all the methods of the interface.
Note: If you are beginner to java, learn interface first and skip this example.
interface A{ void a(); void b(); void c(); void d(); } abstract class B implements A{ public void c(){System.out.println("I am C");} } class M extends B{ public void a(){System.out.println("I am a");} public void b(){System.out.println("I am b");} public void d(){System.out.println("I am d");} } class Test{ public static void main(String args[]){ A a=new M(); a.a(); a.b(); a.c(); a.d(); }} Output:I am a I am b I am c I am d

Interface
1. 2. 3. 4. 5. 6. Interface Example of Interface Multiple inheritance by Interface Why multiple inheritance is supported in Interface while it is not supported in case of class. Marker Interface Nested Interface

An interface is a blueprint of a class. It has static constants and abstract methods. The interface is a mechanism to achieve abstraction in java. There can be only abstract methods in the interface. It is used to achieve fully abstraction and multiple inheritance in Java.

Why use Interface?

There are mainly three reasons to use interface. They are given below.

It is used to achieve fully abstraction. By interface, we can support the functionality of multiple inheritance. It can be used to achieve loose coupling.

The java compiler converts methods of interface as public and abstract, data members as public,final and static bydefault.

Simple example of Interface

In this exmple, Printable interface have only one method, its implemenation is provided in the A class.

interface printable{ void print(); } class A implements printable{ public void print(){System.out.println("Hello");} public static void main(String args[]){ A obj = new A(); obj.print(); } } Output:Hello

Multiple inheritance by interface

A class cannot extend two classes but it can implement two interfaces. For example:
interface printable{ void print(); } interface Showable{ void show(); } class A implements printable,Showable{ public void print(){System.out.println("Hello");} public void show(){System.out.println("Welcome");} public static void main(String args[]){ A obj = new A(); obj.print(); obj.show(); } } Output:Hello Welcome

Que) Multiple inheritance is not supported in case of class but it is supported in case of interface, why?
As we have explained in the inheritance chapter, multiple inheritance is not supported in case of class. But it is supported in case of interface because there is no ambiguity as implmentation is provided by the implementation class. For example:

interface Printable{ void print(); } interface Showable{ void print(); } class A implements Printable,Showable{ public void print(){System.out.println("Hello");} public static void main(String args[]){ A obj = new A(); obj.print(); } } Output:Hello

As you can see in the above example, Printable and Showable interface have same methods but its implementation is provided by class A, so there is no ambiguity.

Note: A class implements interface but One interface extends another interface .
interface Printable{ void print(); } interface Showable extends Printable{ void show(); } class A implements Showable{ public void print(){System.out.println("Hello");} public void show(){System.out.println("Welcome");} public static void main(String args[]){ A obj = new A(); obj.print(); obj.show(); } } Output:Hello Welcome

Que) What is marker or tagged interface ?

An interface that have no member is known as marker or tagged interface. For example: Serializable, Cloneable, Remote etc. They are used to provide some essential information to the JVM so that JVM

may perform some useful operation.

//How Serializable interface is written? public interface Serializable{ }

Note: An interface can have another interface i.e. known as nested interface. We will learn it in detail in the nested classes chapter. For example:
interface printable{ void print(); interface MessagePrintable{ void msg(); } }

Runtime Polymorphism
1. 2. 3. 4. Runtime Polymorphism Upcasting Example of Runtime Polymorphism Runtime Polymorphism with data members

Runtime polymorphism or Dynamic Method Dispatch is a process in which a call to an overridden method is resolved at runtime rather than compile-time. In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.

Upcasting
When reference variable of Parent class refers to the object of Child class, it is known as upcasting.For example:

class A{} class B extends A{} A a=new B();//upcasting

Example of Runtime Polymorphism

In this example, we are creating two classes Bike and Splendar. Splendar class extends Bike class and overrides its run() method. We are calling the run method by the reference variable of Parent class. Since it refers to the subclass object and subclass method overrides the Parent class method, subclass method is invoked at runtime. Since it is determined by the compiler, which method will be invoked at runtime, so it is known as runtime polymorphism.
class Bike{ void run(){System.out.println("running");} } class Splender extends Bike{ void run(){System.out.println("running safely with 60km");} public static void main(String args[]){ Bike b = new Splender();//upcasting b.run(); } } Output: running safely with 60km.

Runtime Polymorphism with data member

Method is overriden not the datamembers, so runtime polymorphism can't be achieved by data members. In the example given below, both the classes have a datamember speedlimit, we are accessing the datamember by the reference variable of Parent class which refers to the subclass object. Since we are accessing the datamember which is not overridden, hence it will access the datamember of Parent class

always. Rule: Runtime polymorphism can't be achieved by data members.

class Bike{ int speedlimit=90; } class Honda extends Bike{ int speedlimit=150; public static void main(String args[]){ Bike obj=new Honda(); System.out.println(obj.speedlimit);//90 } } Output: 90

Runtime Polymorphism with Multilevel Inheritance

Let's see the simple example of Runtime Polymorphism with multilevel inheritance.
class Animal{ void eat(){System.out.println("eating");} } class Dog extends Animal{ void eat(){System.out.println("eating fruits");} }

class BabyDog extends Dog{ void eat(){System.out.println("drinking milk");} public Animal a1=new a2=new a3=new static void main(String args[]){ a1,a2,a3; Animal(); Dog(); BabyDog();

a1.eat(); a2.eat(); a3.eat(); } } Output: eating eating fruits drinking Milk

Try for Output

class Animal{ void eat(){System.out.println("animal is eating...");} } class Dog extends Animal{ void eat(){System.out.println("dog is eating...");} } class BabyDog extends Dog{ public static void main(String args[]){ Animal a=new BabyDog(); a.eat(); }} Output: Dog is eating

Since, BabyDog is not overriding the eat() method, so eat() method of Dog class is invoked.

Static Binding and Dynamic Binding:

Binding:
Connecting a method call to a method body is called binding. It can be of two types:

static binding(early binding). dynamic binding(late binding).

About type:
1) variables have a type For example: int data=30; Here data variable is a type of int. 2) References have a type
class Dog{ public static void main(String args[]){ Dog d1;//Here d1 is a type of Dog } }

3) Objects have a type An object is an instance of particular java class,but it is also an instance of its superclass.
class Animal{} class Dog extends Animal{ public static void main(String args[]){ Dog d1=new Dog(); } }

Here d1 is an instance of Dog class, but it is also an instance of Animal.

static binding:
When type of the object is determined at compiled time(by the compiler), it is known as static binding. If there is any private,final or static method in a class,it is static binding.

Example of static binding:

class Dog{ private void eat(){System.out.println("dog is eating...");} public static void main(String args[]){ Dog d1=new Dog(); d1.eat(); } }

Dynamic binding:
When type of the object is determined at run-time, it is known as dynamic binding.

Example of dynamic binding:

class Animal{ void eat(){System.out.println("animal is eating...");} } class Dog extends Animal{ void eat(){System.out.println("dog is eating...");} public static void main(String args[]){ Animal a=new Dog();

a.eat(); } } Output:dog is eating...

In the above example object type cannot be determined by the compiler, because the instance of Dog is also an instance of Animal.So compiler doesn't know its type, only its base type.

instanceof operator
1. 2. 3. 4. 5. The instanceof operator Example of instanceof operator Applying the instanceof operator with a variable the have null value Downcasting with instanceof operator Downcasting without instanceof operator

The instanceof operator is used to test whether the object is an instance of the specified type (class or subclass or interface). The instanceof operator is also known as type comparison operator because it compares the instance with type. It returns either true or false. If we apply the instanceof operator with any variable that have null value, it returns false.

Simple example of instanceof operator

Let's see the simple example of instance operator where it tests the current class.
class Simple{ public static void main(String args[]){ Simple s=new Simple(); System.out.println(s instanceof Simple);//true } } Output:true

An object of subclass type is also a type of parent class. For example, if Dog extends Animal then object of Dog can be reffered by either Dog or Animal class.

Another example of instanceof operator

class Animal{}

class Dog extends Animal{//Dog inherits Animal public static void main(String args[]){ Dog d=new Dog(); System.out.println(d instanceof Animal);//true } } Output:true

instanceof operator with a variable that have null value

If we apply instanceof operator with a variable that have null value, it ruturns false. Let's see the example given below where we apply instanceof operator with the variable that have null value.
class Dog{ public static void main(String args[]){ Dog d=null; System.out.println(d instanceof Dog);//false } } Output:false

Downcasting with instanceof operator

When Subclass type refers to the object of Parent class, it is known as downcasting. If we perform it directly, compiler gives Compilation error. If you perform it by typecasting, ClassCastException is thrown at runtime. But if we use instanceof operator, downcasting is possible.
Dog d=new Animal();//Compilation error

If we perform downcasting by typecasting, ClassCastException is thrown at runtime.

Dog d=(Dog)new Animal(); //Compiles successfully but ClassCastException is thrown at runtime

Possibility of downcasting with instanceof operator

Let's see the example, where downcasting is possible by instanceof operator.
class Animal { } class Dog extends Animal { static void method(Animal a) { if(a instanceof Dog){ Dog d=(Dog)a;//downcasting System.out.println("ok downcasting performed");

} } public static void main (String [] args) { Animal a=new Dog(); Dog.method(a); } } Output:ok downcasting performed

Downcasting without the use of instanceof operator

Downcasting can also be performed without the use of instanceof operator as displayed in the following example:
class Animal { } class Dog extends Animal { static void method(Animal a) { Dog d=(Dog)a;//downcasting System.out.println("ok downcasting performed"); } public static void main (String [] args) { Animal a=new Dog(); Dog.method(a); } } Output:ok downcasting performed

Let's take closer look at this, actual object that is referred by a, is an object of Dog class. So if we downcast it, it is fine. But what will happen if we write:
Animal a=new Animal(); Dog.method(a); //Now ClassCastException but not in case of instanceof operator

Understanding Real use of instanceof operator

Let's see the real use of instanceof operator by the example given below.
interface Printable{} class A implements Printable{ public void a(){System.out.println("my a method");} } class B implements Printable{ public void b(){System.out.println("my a method");} }

class Call{ void invoke(Printable p){//upcasting if(p instanceof A){ A a=(A)p;//Downcasting a.a(); } if(p instanceof B){ B b=(B)p;//Downcasting b.b(); } } }//end of Call class class Test{ public static void main(String args[]){ Printable p=new B(); Call c=new Call(); c.invoke(p); } }

Package
1. Package 2. Example of package 3. Accessing package 1. By import packagename.* 2. By import packagename.classname 3. By fully qualified name 4. Subpackage 5. Sending class file to another directory 6. -classpath switch 7. 4 ways to load the class file or jar file 8. How to put two public class in a package 9. Static Import 10. Package class A package is a group of similar types of classs, interfaces and sub-packages. Package can be categorized in two form, built-in package and user-defined package. There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc. In this page, we will have the detailed learning of creating user-defined packages.

Advantage of Package

Package is used to categorize the classes and interfaces so that they can be easily maintained. Package provids access protection. Package removes naming collision.

Simple example of package:

The keyword package is used to create a package.
//save as Simple.java package mypack; public class Simple{ public static void main(String args[]){ System.out.println("Welcome to package"); } }

To Compile: javac -d . Simple.java

To Run: java mypack.Simple

Output:Welcome to package

The -d is a switch that tells the compiler where to put the class file i.e. it represents destination. The . represents the current folder.

How to access package from another package?

There are three ways to access the package from outside the package. 1. import package.*; 2. import package.classname; 3. fully qualified name. If you use package.* then all the classes and interfaces of this package will be accessible but not subpackages. The import keyword is used to make the classes and interface of another package accessible to the current package.

Example of package that import the packagename.*

//save by A.java package pack; public class A{ public void msg(){System.out.println("Hello");} } //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A(); obj.msg(); } } Output:Hello

If you import package.classname then only declared class of this package will be accessible but not subpackages.

Example of package by import package.classname

//save by A.java package pack; public class A{ public void msg(){System.out.println("Hello");} } //save by B.java package mypack; import pack.A; class B{ public static void main(String args[]){ A obj = new A(); obj.msg(); } } Output:Hello

If you use fully qualified name then only declared class of this package will be accessible. Now there is no need to import. But you need to use fully qualified name every time when you are accessing the class or interface.

Example of package by import fully qualified name

//save by A.java package pack; public class A{ public void msg(){System.out.println("Hello");} } //save by B.java package mypack; class B{ public static void main(String args[]){ pack.A obj = new pack.A();//using fully qualified name obj.msg(); } } Output:Hello

Note: Sequence of the program must be package then import then class.

Subpackage
Package inside the package is called the subpackage. It should be created to categorize the package further. Let's take an example, Sun Microsystem has definded a package named java that contains many classes like System, String, Reader, Writer, Socket etc. These classes represent a particular group e.g. Reader and Writer classes are for Input/Output operation, Socket and ServerSocket classes are for networking etc and so on. So, Sun has subcategorized the java package into subpackages such as lang, net, io etc. and put the Input/Output related classes in io package, Server and ServerSocket classes in net packages and so on.

Example of Subpackage
package com.javatpoint.core; class Simple{ public static void main(String args[]){ System.out.println("Hello subpackage"); } }

To Compile: javac -d . Simple.java To Run: java com.javatpoint.core.Simple

Output:Hello subpackage

Note: If you import a package, all the classes and interface of that package will be imported excluding the classes and interfaces of the subpackages. Hence, you need to import the subpackage as well.

How to send the class file to another directory or drive?

There is a scenario, I want to put the class file of A.java source file in classes folder of c: drive. For example:

//save as Simple.java package mypack; public class Simple{ public static void main(String args[]){ System.out.println("Welcome to package"); } }

To Compile:
e:\sources> javac -d c:\classes Simple.java

To Run:

To run this program from e:\source directory, you need to set classpath of the directory where the class file resides. e:\sources> set classpath=c:\classes;.; e:\sources> java mypack.Simple

Another way to run this program by -classpath switch of java:

The -classpath switch can be used with javac and java tool. To run this program from e:\source directory, you can use -classpath switch of java that tells where to look for class file. For example: e:\sources> java -classpath c:\classes mypack.Simple
Output:Welcome to package

Ways to load the class files or jar files

There are two ways to load the class files temporary and permanent.

Temporary o By setting the classpath in the command prompt o By -classpath switch Permanent o By setting the classpath in the environment variables o By creating the jar file, that contains all the class files, and copying the jar file in the jre/lib/ext folder.

Rule: There can be only one public class in a java source file and it must be saved by the public class name.
//save as C.java otherwise Compilte Time Error class A{} class B{} public class C{}

How to put two public classes in a package?

If you want to put two public classes in a package, have two java source files containing one public class,

but keep the package name same. For example:

//save as A.java package javatpoint; public class A{} //save as B.java package javatpoint; public class B{}

What is static import feature of Java5?

Click Static Import feature of Java5.

What about package class?

Click for Package class

Access Modifiers
1. 2. 3. 4. 5. 6. private access modifier Role of private constructor default access modifier protected access modifier public access modifier Applying access modifer with method overriding

There are two types of modifiers access modifier and non-access modifier. The access modifiers specifies accessibility (scope) of a datamember, method, constructor or class. There are 4 types of access modifiers: 1. 2. 3. 4. private default protected public

There are many non-access modifiers such as static, abstract, synchronized, native, volatile, transient etc. Here, we will learn access modifiers.

1) private
The private access modifier is accessible only within class.

Simple example of private access modifer

In this example, we have created two classes A and Simple. A class contains private data member and private method. We are accessing these private members from outside the class, so there is compile time error.
class A{ private int data=40; private void msg(){System.out.println("Hello java");} } public class Simple{ public static void main(String args[]){ A obj=new A(); System.out.println(obj.data);//Compile Time Error obj.msg();//Compile Time Error } }

Role of Private Constructor:

If you make any class constructor private, you cannot create the instance of that class from outside the class. For example:
class A{ private A(){}//private constructor void msg(){System.out.println("Hello java");} } public class Simple{ public static void main(String args[]){ A obj=new A();//Compile Time Error } }

Note: A class cannot be private or protected except nested class.

2) default
If you don't use any modifier, it is treated as default modifier bydefault. The default modifier is

accessible only within package.

Example of default access modifier

In this example, we have created two packages pack and mypack. We are accessing the A class from outside its package, since A class is not public, so it cannot be accessed from outside the package.
//save by A.java package pack; class A{ void msg(){System.out.println("Hello");} } //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A();//Compile Time Error obj.msg();//Compile Time Error } }

In the above example, the scope of class A and its method msg() is default so it cannot be accessed from outside the package.

3) protected
The protected access modifier is accessible within package and outside the package by only through inheritance. The protected access modifier can be applied on the data member, method and constructor. It can't be applied on the class.

Example of protected access modifier

In this example, we have created the two packages pack and mypack. The A class of pack package is public, so can be accessed from outside the package. But msg method of this package is declared as protected, so it can be accessed from outside the class only through inheritance.
//save by A.java package pack; public class A{ protected void msg(){System.out.println("Hello");} } //save by B.java

package mypack; import pack.*; class B extends A{ public static void main(String args[]){ B obj = new B(); obj.msg(); } } Output:Hello

4) public
The public access modifier is accessible everywhere. It has the widest scope among all other modiers.

Example of public access modifier

//save by A.java package pack; public class A{ public void msg(){System.out.println("Hello");} } //save by B.java package mypack; import pack.*; class B{ public static void main(String args[]){ A obj = new A(); obj.msg(); } } Output:Hello

Applying access modifier with method overriding

If you are overriding any method, overriden method (i.e. declared in subclass) must not be more restrictive.
class A{ protected void msg(){System.out.println("Hello java");} } public class Simple extends A{ void msg(){System.out.println("Hello java");}//C.T.Error public static void main(String args[]){ Simple obj=new Simple(); obj.msg();

} }

The default modifier is more restrictive than protected. That is why there is compile time error.

Encapsulation
Encapsulation is a process of wrapping code and data together into a single unit. It is a way to achieve data hiding.

Simple example:
//save as Student.java package mypack; public class student{ private string name; public String getName(){ return name; } public void setName(String name){ this.name=name } } package mypack; class Test public static void main(){ Student s=new Student(); s.setname("vijay"); System.out.println(s.getName()); } }

The clone() method (Object Cloning in Java)

The object cloning is a way to create exact copy of an object. For this purpose, clone() method of Object class is used to clone an object. The java.lang.Cloneable interface must be implemented by the class whose object clone we want to create. If we don't implement Cloneable interface, clone() method gives CloneNotSupportedException. The clone() method is defined in the Object class. Syntax of the clone() method is as follows:
protected Object clone() throws CloneNotSupportedException

Why use clone() method ?

The clone() saves the extra processing task for creating the exact copy of an object. If we perform it by using the new keyword, it will take a lot of processing to be performed that is why we use object cloning.

Example of clone() method (Object cloning)

class Student implements Cloneable{ int rollno; String name; Student(int rollno,String name){ this.rollno=rollno; this.name=name; } public Object clone()throws CloneNotSupportedException{ return super.clone(); } public static void main(String args[]){ try{ Student s1=new Student(101,"amit"); Student s2=(Student)s1.clone(); System.out.println(s1.rollno+" "+s1.name); System.out.println(s2.rollno+" "+s2.name); }catch(CloneNotSupportedException c){} } } Output:101 amit 101 amit

download the example of object cloning As you can see in the above example, both reference variables have the same value. Thus, the clone() copies the values of an object to another. So we don't need to write explicit code to copy the value of an object to another. If we create another object by new keyword and assign the values of another object to this one, it will require a lot of processing on this object. So to save the extra processing task we use clone() method.

Object class
The Object class is the super class of all the classes in java. The Object is beneficial if you want to refer any object whose type you don't know. Notice that parent class reference variable can refer the child class object, know as upcasting. The Object class provides some common behaviours to all the objects such as object can be compared, object can be cloned, object can be notified etc.

Methods of Object class

The Object class provides many methods. They are as follows: 1. public final Class getClass() returns the Class class object of this object. The Class class can further be used to get the metadata of this class. 2. public int hashCode() returns the hashcode number for this object. 3. public boolean equals(Object obj) compares the given object to this object. 4. protected Object clone() throws CloneNotSupportedException creates and returns the exact copy (clone) of this object. 5. public String toString() returns the string representation of this object. 6. public final void notify() wakes up single thread, waiting on this object's monitor. 7. public final void notifyAll() wakes up all the threads, waiting on this object's monitor. 8. public final void wait(long timeout)throws InterruptedException causes the current thread to wait for the specified miliseconds, until another thread notifies (invokes notify() or notifyAll() method). 9. public final void wait(long timeout,int nanos)throws InterruptedExceptioncauses the current thread to wait for the specified miliseconds and nanoseconds, until another thread notifies (invokes notify() or notifyAll() method). 10. public final void wait()throws InterruptedException causes the current thread to wait, until another thread notifies (invokes notify() or notifyAll() method). 11. protected void finalize()throws Throwable is invoked by the garbage collector before object is being garbage collected. We will have the detailed learning of these methods in next chapters.

Array in Java
Normally, array is a collection of similar type of elements that have contigious memory location. In java, array is an object the contains elements of similar data type. It is a data structure where we store similar elements. We can store only fixed elements in an array.

Array is index based, first element of the array is stored at 0 index.

Advantage of Array

Code Optimization: It makes the code optimized, we can retrive or sort the data easily. Random access: We can get any data located at any index position.

Disadvantage of Array

Size Limit: We can store only fixed size of elements in the array. It doesn't grow its size at runtime. To solve this problem, collection framework is used in java.

Types of Array
There are two types of array.

Single Dimensional Array Multidimensional Array

Single Dimensional Array Syntax to Declare an Array in java

dataType[] arrayRefVar; (or) dataType []arrayRefVar; (or) dataType arrayRefVar[];

Instantiation of an Array in java

arrayRefVar=new datatype[size];

Example of single dimensional java array

Let's see the simple example of java array, where we are going to declare, instantiate, initialize and traverse an array.
class B{ public static void main(String args[]){

int a[]=new int[5];//declaration and instantiation a[0]=10;//initialization a[1]=20; a[2]=70; a[3]=40; a[4]=50; //printing array for(int i=0;i<a.length;i++)//length is the property of array System.out.println(a[i]); }} Output:10 20 70 40 50

Declaration, Instantiation and Initialization of Java Array

We can declare, instantiate and initialize the java array together by:
int a[]={33,3,4,5};//declaration, instantiation and initialization

Let's see the simple example to print this array.

class B{ public static void main(String args[]){ int a[]={33,3,4,5};//declaration, instantiation and initialization //printing array for(int i=0;i<a.length;i++)//length is the property of array System.out.println(a[i]); }} Output:33 3 4 5

Passing Java Array in the method

We can pass the array in the method so that we can reuse the same logic on any array. Let's see the simple example to get minimum number of an array using method.
class B{

static void min(int arr[]){ int min=arr[0]; for(int i=1;i<arr.length;i++) if(min>arr[i]) min=arr[i]; System.out.println(min); } public static void main(String args[]){ int a[]={33,3,4,5}; min(a);//passing array in the method }} Output:3

Multidimensional array
In such case, data is stored in row and column based index (also known as matrix form).

Syntax to Declare Multidimensional Array in java

dataType[][] arrayRefVar; (or) dataType [][]arrayRefVar; (or) dataType arrayRefVar[][]; (or) dataType []arrayRefVar[];

Example to initantiate Multidimensional Array in java

int[][] arr=new int[3][3];//3 row and 3 column

Example to initialize Multidimensional Array in java

arr[0][0]=1; arr[0][1]=2; arr[0][2]=3; arr[1][0]=4; arr[1][1]=5; arr[1][2]=6; arr[2][0]=7; arr[2][1]=8; arr[2][2]=9;

Example of Multidimensional java array

Let's see the simple example to declare, instantiate, initialize and print the 2Dimensional array.
class B{ public static void main(String args[]){ //declaring and initializing 2D array

int arr[][]={{1,2,3},{2,4,5},{4,4,5}}; //printing 2D array for(int i=0;i<3;i++){ for(int j=0;j<3;j++){ System.out.print(arr[i][j]+" "); } System.out.println(); } }} Output:1 2 3 2 4 5 4 4 5

What is class name of java array?

In java, array is an object. For array object, an proxy class is created whose name can be obtained by getClass().getName() method on the object.
class B{ public static void main(String args[]){ int arr[]={4,4,5}; Class c=arr.getClass(); String name=c.getName(); System.out.println(name); } }} Output:[I

Copying an array
We can copy an array to another by the arraycopy method of System class.

Syntax of arraycopy method

public static void arraycopy( Object src, int srcPos,Object dest, int destPos, int length )

Example of arraycopy method

class ArrayCopyDemo { public static void main(String[] args) { char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' }; char[] copyTo = new char[7];

System.arraycopy(copyFrom, 2, copyTo, 0, 7); System.out.println(new String(copyTo)); } } Output:caffein

Call by Value and Call by Reference in Java

There is only call by value in java, not call by reference. If we call a method passing a value, it is known as call by value. The changes being done in the called method, is not affected in the calling method.

Example of call by value in java

In case of call by value original value is not changed. Let's take a simple example:
class Operation{ int data=50; void change(int data){ data=data+100;//changes will be in the local variable only } public static void main(String args[]){ Operation op=new Operation(); System.out.println("before change "+op.data); op.change(500); System.out.println("after change "+op.data); } }

download this example

Output:before change 50 after change 50

Another Example of call by value in java

In case of call by reference original value is changed if we made changes in the called method. If we pass object in place of any primitive value, original value will be changed. In this example we are passing

object as a value. Let's take a simple example:

class Operation2{ int data=50; void change(Operation op){ op.data=op.data+100;//changes will be in the instance variable } public static void main(String args[]){ Operation2 op=new Operation2(); System.out.println("before change "+op.data); op.change(op);//passing object System.out.println("after change "+op.data); } }

download this example

Output:before change 50 after change 150

strictfp keyword
The strictfp keyword ensures that you will get the same result on every platform if you perform operations in the floating-point variable. The precision may differ from platform to platform that is why java programming language have provided the strictfp keyword, so that you get same result on every platform. So, now you have better control over the floating-point arithmetic.

Legal code for strictfp keyword

The strictfp keyword can be applied on methods, classes and interfaces.
strictfp class A{}//strictfp applied on class strictfp interface M{}//strictfp applied on interface class A{ void m(){}//strictfp applied on method }

Illegal code for strictfp keyword

The strictfp keyword can be applied on abstract methods, variables or constructors.
class B{ strictfp abstract void m();//Illegal combination of modifiers } class B{ strictfp int data=10;//modifier strictfp not allowed here } class B{ strictfp B(){}//modifier strictfp not allowed here }

Creating API Document | javadoc tool

We can create document api in java by the help of javadoc tool. In the java file, we must use the documentation comment /**... */ to post information for the class, method, constructor, fields etc. Let's see the simple class that contains documentation comment.
package com.abc; /** This class is a user-defined class that contains one methods cube.*/ public class M{ /** The cube method prints cube of the given number */ public static void cube(int n){System.out.println(n*n*n);} }

To create the document API, you need to use the javadoc tool followed by java file name. There is no need to compile the javafile. On the command prompt, you need to write:
javadoc M.java

to generate the document api. Now, there will be created a lot of html files. Open the index.html file to get the information about the classes.

Command Line Argument

1. Command Line Argument 2. Simple example of command-line argument 3. Example of command-line argument that prints all the values The command-line argument is an argument passed at the time of running the java program. The argument can be received in the program and used as an input. So, it provides an convenient way to check out the behaviour of the program on different values. You can pass N numbers of arguments from the command prompt.

Simple example of command-line argument

In this example, we are receiving only one argument and printing it. For running this program, you must pass at least one argument from the command prompt.
class A{ public static void main(String args[]){ System.out.println("first argument is: "+args[0]); } } compile by > javac A.java run by > java A sonoo Output:first argument is: sonoo

Example of command-line argument that prints all the values

In this example, we are printing all the arguments passed from the command-line. For this purpose, we have traversed the array using for loop.
class A{ public static void main(String args[]){ for(int i=0;i<args.length;i++) System.out.println(args[i]); } }

compile by > javac A.java run by > java A sonoo jaiswal 1 3 abc Output: sonoo jaiswal 1 3 abc