PROGRAMMING CONSTRUCTS

Arrays-one dimensional and multidimensional -command line

arguments. Introducing classes –class fundamentals –methods -
objects -constructors –this keyword –-garbage collection-Nested
Classes – Polymorphism. [8 Hours]

Java Arrays

• Normally, an array is a collection of similar type of elements which has contiguous

memory location.

• Java array is an object which contains elements of a similar data type.

• The elements of an array are stored in a contiguous memory location. It is a data

structure where we store similar elements.

• We can store only a fixed set of elements in a Java array.

• Array in Java is index-based, the first element of the array is stored at the 0th index,

2nd element is stored on 1st index and so on.

• Unlike C/C++, we can get the length of the array using the length member. In C/C++,

we need to use the sizeof operator.

• In Java, array is an object of a dynamically generated class.

• Java array inherits the Object class, and implements the Serializable as well as

Cloneable interfaces.

• We can store primitive values or objects in an array in Java.

 • Like C/C++, we can also create single dimentional or multidimentional arrays

in Java.

• Moreover, Java provides the feature of anonymous arrays which is not

available in C/C++.

Advantages

o Code Optimization: It makes the code optimized, we can retrieve or sort the data

efficiently.

o Random access: We can get any data located at an index position.

Disadvantages

o Size Limit: We can store only the fixed size of elements in the array.

o It doesn't grow its size at runtime.

o To solve this problem, collection framework is used in Java which grows

automatically.

Let's see the simple example of java array, where we are going to declare, instantiate,

initialize and traverse an array.

1. //Java Program to illustrate how to declare, instantiate, initialize

2. //and traverse the Java array.

3. class Testarray{

4. public static void main(String args[]){

5. int a[]=new int[5];//declaration and instantiation

6. a[0]=10;//initialization

7. a[1]=20;

8. a[2]=70;

9. a[3]=40;

10. a[4]=50;

11. //traversing array

12. for(int i=0;i<a.length;i++)//length is the property of array

13. System.out.println(a[i]);

14. }}

Output:

10

20

70

40

50

Declaration, Instantiation and Initialization of Java

Array
 We can declare, instantiate and initialize the java array together by:

1. int a[]={33,3,4,5};//declaration, instantiation and initialization

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

1. //Java Program to illustrate the use of declaration, instantiation

2. //and initialization of Java array in a single line

3. class Testarray1{

4. public static void main(String args[]){

5. int a[]={33,3,4,5};//declaration, instantiation and initialization

6. //printing array

7. for(int i=0;i<a.length;i++)//length is the property of array

8. System.out.println(a[i]);

9. }}

Output:

33

For-each Loop for Java Array

• We can also print the Java array using for-each loop.

• The Java for-each loop prints the array elements one by one.

• It holds an array element in a variable, then executes the body of the loop.
 The syntax of the for-each loop is given below:

1. for(data_type variable:array){

2. //body of the loop

3. }

Let us see the example of print the elements of Java array using the for-each loop.

1. //Java Program to print the array elements using for-each loop

2. class Testarray1{

3. public static void main(String args[]){

4. int arr[]={33,3,4,5};

5. //printing array using for-each loop

6. for(int i:arr)

7. System.out.println(i);

8. }}

Output:

33

ArrayIndexOutOfBoundsException
 The Java Virtual Machine (JVM) throws an ArrayIndexOutOfBoundsException if length

of the array in negative, equal to the array size or greater than the array size while

traversing the array.

//Java Program to demonstrate the case of

//ArrayIndexOutOfBoundsException in a Java Array.

public class TestArrayException{

public static void main(String args[]){

int arr[]={50,60,70,80};

for(int i=0;i<=arr.length;i++){

System.out.println(arr[i]);

}}

Output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

at TestArrayException.main(TestArrayException.java:5)

50

60

70

80

Multidimensional Array in Java

 In such case, data is stored in row and column based index (also known as matrix

form).

Syntax to Declare Multidimensional Array in Java

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

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

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

4. dataType []arrayRefVar[];

Example to instantiate Multidimensional Array in Java

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

Example to initialize Multidimensional Array in Java

1. arr[0][0]=1;

2. arr[0][1]=2;

3. arr[0][2]=3;

4. arr[1][0]=4;

5. arr[1][1]=5;

6. arr[1][2]=6;

7. arr[2][0]=7;

8. arr[2][1]=8;

9. arr[2][2]=9;

Example of Multidimensional Java Array

 Let's see the simple example to declare, instantiate, initialize and print the

2Dimensional array.

1. //Java Program to illustrate the use of multidimensional array

2. class Testarray3{

3. public static void main(String args[]){

4. //declaring and initializing 2D array

5. int arr[][]={{1,2,3},{2,4,5},{4,4,5}};

6. //printing 2D array

7. for(int i=0;i<3;i++){

8. for(int j=0;j<3;j++){

9. System.out.print(arr[i][j]+" ");

10. }

11. System.out.println();

12. }

13. }}

Output:

1 2 3

2 4 5

4 4 5

Jagged Array in Java

 If we are creating odd number of columns in a 2D array, it is known as a jagged array.

In other words, it is an array of arrays with different number of columns.

1. //Java Program to illustrate the jagged array

2. class TestJaggedArray{

3. public static void main(String[] args){

4. //declaring a 2D array with odd columns

5. int arr[][] = new int[3][];

6. arr[0] = new int[3];

7. arr[1] = new int[4];

8. arr[2] = new int[2];

9. //initializing a jagged array

10. int count = 0;

11. for (int i=0; i<arr.length; i++)

12. for(int j=0; j<arr[i].length; j++)

13. arr[i][j] = count++;

14.

15. //printing the data of a jagged array

16. for (int i=0; i<arr.length; i++){

17. for (int j=0; j<arr[i].length; j++){

18. System.out.print(arr[i][j]+" ");

19. }

20. System.out.println();//new line

21. }
22. }

23. }

Output:

0 1 2

3 4 5 6

7 8

What is the class name of Java array?

In Java, an array is an object. For array object, a proxy class is created whose name

can be obtained by getClass().getName() method on the object.

//Java Program to get the class name of array in Java

class Testarray4{

public static void main(String args[]){

//declaration and initialization of array

int arr[]={4,4,5};

//getting the class name of Java array

Class c=arr.getClass();

String name=c.getName();

//printing the class name of Java array

System.out.println(name);
}}

Addition of 2 Matrices in Java

Let's see a simple example that adds two matrices.

1. //Java Program to demonstrate the addition of two matrices in Java

2. class Testarray5{

3. public static void main(String args[]){

4. //creating two matrices

5. int a[][]={{1,3,4},{3,4,5}};

6. int b[][]={{1,3,4},{3,4,5}};

7.

8. //creating another matrix to store the sum of two matrices

9. int c[][]=new int[2][3];

10.

11. //adding and printing addition of 2 matrices

12. for(int i=0;i<2;i++){

13. for(int j=0;j<3;j++){

14. c[i][j]=a[i][j]+b[i][j];
15. System.out.print(c[i][j]+" ");

16. }

17. System.out.println();//new line

18. }

19.

20. }}

Output:

2 6 8

6 8 10

Multiplication of 2 Matrices in Java

In the case of matrix multiplication, a one-row element of the first matrix is multiplied

by all the columns of the second matrix which can be understood by the image given

below.
 Let's see a simple example to multiply two matrices of 3 rows and 3 columns.

1. //Java Program to multiply two matrices

2. public class MatrixMultiplicationExample{

3. public static void main(String args[]){

4. //creating two matrices

5. int a[][]={{1,1,1},{2,2,2},{3,3,3}};

6. int b[][]={{1,1,1},{2,2,2},{3,3,3}};

7.

8. //creating another matrix to store the multiplication of two matrices

9. int c[][]=new int[3][3]; //3 rows and 3 columns

10.

11. //multiplying and printing multiplication of 2 matrices

12. for(int i=0;i<3;i++){

13. for(int j=0;j<3;j++){

14. c[i][j]=0;

15. for(int k=0;k<3;k++)

16. {

17. c[i][j]+=a[i][k]*b[k][j];

18. }//end of k loop

19. System.out.print(c[i][j]+" "); //printing matrix element

20. }//end of j loop

21. System.out.println();//new line

22. }
23. }}

Output:

6 6 6

12 12 12

18 18 18
Java OOPs Concepts

Simula is considered the first object-oriented programming language. The

programming paradigm where everything is represented as an object is known as a

truly object-oriented programming language.

Smalltalk is considered the first truly object-oriented programming language.

The popular object-oriented languages are Java, C#, PHP, Python, C++, etc.

The main aim of object-oriented programming is to implement real-world entities,

for example, object, classes, abstraction, inheritance, polymorphism, etc.

OOPs (Object-Oriented Programming System)

Object means a real-world entity such as a pen, chair, table, computer, watch,

etc. Object-Oriented Programming is a methodology or paradigm to design a

program using classes and objects. It simplifies software development and

maintenance by providing some concepts:

o Object

o Class

o Inheritance

o Polymorphism
 o Abstraction

o Encapsulation

Object
 • Any entity that has state and behaviour is known as an object. For example, a

chair, pen, table, keyboard, bike, etc. It can be physical or logical.

• An Object can be defined as an instance of a class.

• An object contains an address and takes up some space in memory.

• Objects can communicate without knowing the details of each other's data or

code. Example: A dog is an object because it has states like color, name,

breed, etc. as well as behaviors like wagging the tail, barking, eating, etc.

Class

• Collection of objects is called class. It is a logical entity.

• A class can also be defined as a blueprint from which you can create an

individual object. Class doesn't consume any space.

Inheritance

When one object acquires all the properties and behaviors of a parent object, it is

known as inheritance. It provides code reusability. It is used to achieve runtime

polymorphism.
Polymorphism

• If one task is performed in different ways, it is known as polymorphism.

• For example: to convince the customer differently, to draw something, for

example, shape, triangle, rectangle, etc.

• In Java, we use method overloading and method overriding to achieve

polymorphism.

• Another example can be to speak something; for example, a cat speaks meow,

dog barks woof, etc.

Abstraction

Hiding internal details and showing functionality is known as abstraction. For example

phone call, we don't know the internal processing.

In Java, we use abstract class and interface to achieve abstraction.

Encapsulation

Binding (or wrapping) code and data together into a single unit are known as

encapsulation. For example, a capsule, it is wrapped with different medicines.

A java class is the example of encapsulation. Java bean is the fully encapsulated class

because all the data members are private here.

Advantage of OOPs over Procedure-oriented

programming language

1) OOPs makes development and maintenance easier, whereas, in a procedure-

oriented programming language, it is not easy to manage if code grows as project

size increases.

2) OOPs provides data hiding, whereas, in a procedure-oriented programming

language, global data can be accessed from anywhere.

Figure: Data Representation in Procedure-Oriented Programming

Figure: Data Representation in Object-Oriented Programming

3) OOPs provides the 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.
Objects and Classes in Java

An object in Java is the physical as well as a logical entity, whereas, a class in Java is a

logical entity only.

What is an object in Java

An entity that has state and behavior is known as an object e.g., chair, bike, marker,

pen, table, car, etc. It can be physical or logical (tangible and intangible). The example

of an intangible object is the banking system.

An object has three characteristics:

o State: represents the data (value) of an object.

 o Behavior: represents the behavior (functionality) of an object such as deposit,

withdraw, etc.

o Identity: An object identity is typically implemented via a unique ID. The value

of the ID is not visible to the external user. However, it is used internally by the

JVM to identify each object uniquely.

For Example, Pen is an object. Its name is Reynolds; color is white, known as its state.

It is used to write, so writing is its behavior.

An object is an instance of a class. A class is a template or blueprint from which

objects are created. So, an object is the instance(result) of a class.

Object Definitions:

o An object is a real-world entity.

o An object is a runtime entity.

o The object is an entity which has state and behavior.

o The object is an instance of a class.

What is a class in Java

A class is a group of objects which have common properties. It is a template or

blueprint from which objects are created. It is a logical entity. It can't be physical.

A class in Java can contain:

o Fields

o Methods

o Constructors

o Blocks

o Nested class and interface

Syntax to declare a class:

1. class <class_name>{

2. field;

3. method;

4. }

Instance variable in Java

• A variable which is created inside the class but outside the method is known

as an instance variable.

• Instance variable doesn't get memory at compile time.

• It gets memory at runtime when an object or instance is created. That is why it

is known as an instance variable.

Method in Java

In Java, a method is like a function which is used to expose the behavior of an object.

Advantage of Method

o Code Reusability

o Code Optimization

new keyword in Java

The new keyword is used to allocate memory at runtime. All objects get memory in

Heap memory area.

 Object and Class Example: main within the class

In this example, we have created a Student class which has two data members id and

name. We are creating the object of the Student class by new keyword and printing

the object's value.

Here, we are creating a main() method inside the class.

File: Student.java

//Java Program to illustrate how to define a class and fields

//Defining a Student class.

class Student{

//defining fields

int id;//field or data member or instance variable

String name;

//creating main method inside the Student class

public static void main(String args[]){

//Creating an object or instance

Student s1=new Student();//creating an object of Student

//Printing values of the object

System.out.println(s1.id);//accessing member through reference variable

System.out.println(s1.name);

}
 Output:

null

Object and Class Example: main outside the class

In real time development, we create classes and use it from another class. It is a

better approach than previous one. Let's see a simple example, where we are having

main() method in another class.

We can have multiple classes in different Java files or single Java file. If you define

multiple classes in a single Java source file, it is a good idea to save the file name

with the class name which has main() method.

File: TestStudent1.java

1. //Java Program to demonstrate having the main method in

2. //another class

3. //Creating Student class.

4. class Student{

5. int id;

6. String name;

7. }
8. //Creating another class TestStudent1 which contains the main method

9. class TestStudent1{

10. public static void main(String args[]){

11. Student s1=new Student();

12. System.out.println(s1.id);

13. System.out.println(s1.name);

14. }

15. }

Output:

null

3 Ways to initialize object

There are 3 ways to initialize object in Java.

1. By reference variable

2. By method

3. By constructor

1) Object and Class Example: Initialization through reference

Initializing an object means storing data into the object. Let's see a simple example
 where we are going to initialize the object through a reference variable.

File: TestStudent2.java

1. class Student{

2. int id;

3. String name;

4. }

5. class TestStudent2{

6. public static void main(String args[]){

7. Student s1=new Student();

8. s1.id=101;

9. s1.name="Sonoo";

10. System.out.println(s1.id+" "+s1.name);//printing members with a white space

11. }

12. }

Output:

101 Sonoo

We can also create multiple objects and store information in it through reference

variable.

File: TestStudent3.java

1. class Student{
2. int id;

3. String name;

4. }

5. class TestStudent3{

6. public static void main(String args[]){

7. //Creating objects

8. Student s1=new Student();

9. Student s2=new Student();

10. //Initializing objects

11. s1.id=101;

12. s1.name="Sonoo";

13. s2.id=102;

14. s2.name="Amit";

15. //Printing data

16. System.out.println(s1.id+" "+s1.name);

17. System.out.println(s2.id+" "+s2.name);

18. }

19. }

Output:

101 Sonoo

102 Amit
 2) Object and Class Example: Initialization through method

In this example, we are creating the two objects of Student class and initializing the

value to these objects by invoking the insertRecord method. Here, we are displaying

the state (data) of the objects by invoking the displayInformation() method.

1. class Student{

2. int rollno;

3. String name;

4. void insertRecord(int r, String n){

5. rollno=r;

6. name=n;

7. }

8. void displayInformation()

9. {

10. System.out.println(rollno+" "+name);}

11. }

12. class TestStudent4{

13. public static void main(String args[]){

14. Student s1=new Student();

15. Student s2=new Student();

16. s1.insertRecord(111,"Karan");

17. s2.insertRecord(222,"Aryan");
18. s1.displayInformation();

19. s2.displayInformation();

20. }

21. }

Output:

111 Karan

222 Aryan

As you can see in the above figure, object gets the memory in heap memory area.

The 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.

3) Object and Class Example: Initialization through a

constructor

Object and Class Example: Employee

 Let's see an example where we are maintaining records of employees.

1. class Employee{

2. int id;

3. String name;

4. float salary;

5. void insert(int i, String n, float s) {

6. id=i;

7. name=n;

8. salary=s;

9. }

10. void display(){System.out.println(id+" "+name+" "+salary);}

11. }

12. public class TestEmployee {

13. public static void main(String[] args) {

14. Employee e1=new Employee();

15. Employee e2=new Employee();

16. Employee e3=new Employee();

17. e1.insert(101,"ajeet",45000);

18. e2.insert(102,"irfan",25000);

19. e3.insert(103,"nakul",55000);

20. e1.display();

21. e2.display();

22. e3.display();
23. }

24. }

Output:

101 ajeet 45000.0

102 irfan 25000.0

103 nakul 55000.0

Object and Class Example: Rectangle

There is given another example that maintains the records of Rectangle class.

File: TestRectangle1.java

1. class Rectangle{

2. int length;

3. int width;

4. void insert(int l, int w){

5. length=l;

6. width=w;

7. }

8. void calculateArea(){System.out.println(length*width);}

9. }

10. class TestRectangle1{

11. public static void main(String args[]){

12. Rectangle r1=new Rectangle();

13. Rectangle r2=new Rectangle();

14. r1.insert(11,5);

15. r2.insert(3,15);

16. r1.calculateArea();

17. r2.calculateArea();

18. }

19. }

Output:

55

45

What are the different ways to create an object in

Java?

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

o By new keyword

o By newInstance() method

o By clone() method

o By deserialization

o By factory method etc.

 Anonymous object

Anonymous simply means nameless.

An object which has no reference is known as an anonymous object.

It can be used at the time of object creation only.

If you have to use an object only once, an anonymous object is a good approach. For

example:

1. new Calculation();//anonymous object

Calling method through a reference:

1. Calculation c=new Calculation();

2. c.fact(5);
 Calling method through an anonymous object

1. new Calculation().fact(5);

Let's see the full example of an anonymous object in Java.

1. class Calculation{

2. void fact(int n){

3. int fact=1;

4. for(int i=1;i<=n;i++){

5. fact=fact*i;

6. }

7. System.out.println("factorial is "+fact);

8. }

9. public static void main(String args[]){

10. new Calculation().fact(5);//calling method with anonymous object

11. }

12. }

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.

Initialization of primitive variables:

1. int a=10, b=20;

Initialization of reference variables:

1. Rectangle r1=new Rectangle(), r2=new Rectangle();//creating two objects

Let's see the example:

1. //Java Program to illustrate the use of Rectangle class which

2. //has length and width data members

3. class Rectangle{

4. int length;

5. int width;

6. void insert(int l,int w){

7. length=l;

8. width=w;

9. }

10. void calculateArea(){System.out.println(length*width);}

11. }

12. class TestRectangle2{

13. public static void main(String args[]){

14. Rectangle r1=new Rectangle(),r2=new Rectangle();//creating two objects

15. r1.insert(11,5);

16. r2.insert(3,15);

17. r1.calculateArea();

18. r2.calculateArea();

19. }

20. }

Output:

55

45

Real World Example: Account

File: TestAccount.java

1. //Java Program to demonstrate the working of a banking-system

2. //where we deposit and withdraw amount from our account.

3. //Creating an Account class which has deposit() and withdraw() methods

4. class Account{

5. int acc_no;

6. String name;

7. float amount;

8. //Method to initialize object

9. void insert(int a,String n,float amt){

10. acc_no=a;

11. name=n;

12. amount=amt;

13. }

14. //deposit method

15. void deposit(float amt){

16. amount=amount+amt;

17. System.out.println(amt+" deposited");

18. }

19. //withdraw method

20. void withdraw(float amt){

21. if(amount<amt){

22. System.out.println("Insufficient Balance");

23. }else{

24. amount=amount-amt;

25. System.out.println(amt+" withdrawn");

26. }

27. }

28. //method to check the balance of the account

29. void checkBalance(){System.out.println("Balance is: "+amount);}

30. //method to display the values of an object

31. void display(){System.out.println(acc_no+" "+name+" "+amount);}

32. }

33. //Creating a test class to deposit and withdraw amount

34. class TestAccount{

35. public static void main(String[] args){

36. Account a1=new Account();

37. a1.insert(832345,"Ankit",1000);

38. a1.display();

39. a1.checkBalance();

40. a1.deposit(40000);

41. a1.checkBalance();

42. a1.withdraw(15000);

43. a1.checkBalance();

44. }}

Output:

832345 Ankit 1000.0

Balance is: 1000.0

40000.0 deposited

Balance is: 41000.0

15000.0 withdrawn

Balance is: 26000.0

What is a method in Java?

• A method is a block of code or collection of statements or a set of code

grouped together to perform a certain task or operation.

• It is used to achieve the reusability of code.

• We write a method once and use it many times. We do not require writing

code again and again.

• It also provides the easy modification and readability of code, just by

adding or removing a chunk of code. The method is executed only when we

call or invoke it.

• The most important method in Java is the main() method.

Method Declaration

The method declaration provides information about method attributes, such as

visibility, return-type, name, and arguments. It has six components that are known

as method header, as we have shown in the following figure.

Method Signature: Every method has a method signature. It is a part of the method

declaration. It includes the method name and parameter list.

Access Specifier: Access specifier or modifier is the access type of the method. It

specifies the visibility of the method. Java provides four types of access specifier:

o Public: The method is accessible by all classes when we use public specifier in our

application.

o Private: When we use a private access specifier, the method is accessible only in the

classes in which it is defined.

o Protected: When we use protected access specifier, the method is accessible within

the same package or subclasses in a different package.

o Default: When we do not use any access specifier in the method declaration, Java

uses default access specifier by default. It is visible only from the same package only.

Return Type: Return type is a data type that the method returns. It may have a

primitive data type, object, collection, void, etc. If the method does not return

anything, we use void keyword.

Method Name: It is a unique name that is used to define the name of a method. It

must be corresponding to the functionality of the method. Suppose, if we are

creating a method for subtraction of two numbers, the method name must

be subtraction(). A method is invoked by its name.

Parameter List: It is the list of parameters separated by a comma and enclosed in

the pair of parentheses. It contains the data type and variable name. If the method

has no parameter, left the parentheses blank.

Method Body: It is a part of the method declaration. It contains all the actions to be

performed. It is enclosed within the pair of curly braces.

Naming a Method

While defining a method, remember that the method name must be a verb and start

with a lowercase letter. If the method name has more than two words, the first name

must be a verb followed by adjective or noun. In the multi-word method name, the

first letter of each word must be in uppercase except the first word. For example:

Single-word method name: sum(), area()

Multi-word method name: areaOfCircle(), stringComparision()

It is also possible that a method has the same name as another method name in the

same class, it is known as method overloading.

Types of Method

There are two types of methods in Java:

o Predefined Method
 o User-defined Method

Predefined Method

• In Java, predefined methods are the method that is already defined in the Java

class libraries is known as predefined methods. It is also known as

the standard library method or built-in method.

• We can directly use these methods just by calling them in the program at any

point. Some pre-defined methods are length(), equals(), compareTo(),

sqrt(), etc.

• When we call any of the predefined methods in our program, a series of codes

related to the corresponding method runs in the background that is already

stored in the library.

• Each and every predefined method is defined inside a class. Such

as print() method is defined in the java.io.PrintStream class. It prints the

statement that we write inside the method. For example, print("Java"), it

prints Java on the console.

Let's see an example of the predefined method.

Demo.java

1. public class Demo

2. {
3. public static void main(String[] args)

4. {

5. // using the max() method of Math class

6. System.out.print("The maximum number is: " + Math.max(9,7));

7. }

8. }

Output:

The maximum number is: 9

In the above example, we have used three predefined methods main(),

print(), and max(). We have used these methods directly without declaration

because they are predefined. The print() method is a method of PrintStream class

that prints the result on the console. The max() method is a method of

the Math class that returns the greater of two numbers.

We can also see the method signature of any predefined method by using the

link https://docs.oracle.com/. When we go through the link and see the max()

method signature, we find the following:

In the above method signature, we see that the method signature has access

specifier public, non-access modifier static, return type int, method

name max(), parameter list (int a, int b). In the above example, instead of defining

the method, we have just invoked the method. This is the advantage of a predefined

method. It makes programming less complicated.

Similarly, we can also see the method signature of the print() method.

User-defined Method

The method written by the user or programmer is known as a user-defined method.

These methods are modified according to the requirement.

How to Create a User-defined Method

Let's create a user defined method that checks the number is even or odd. First, we
 will define the method.

1. //user defined method

2. public static void findEvenOdd(int num)

3. {

4. //method body

5. if(num%2==0)

6. System.out.println(num+" is even");

7. else

8. System.out.println(num+" is odd");

9. }

We have defined the above method named findevenodd(). It has a

parameter num of type int. The method does not return any value that's why we

have used void. The method body contains the steps to check the number is even or

odd. If the number is even, it prints the number is even, else prints the number is

odd.

How to Call or Invoke a User-defined Method

Once we have defined a method, it should be called. The calling of a method in a

program is simple. When we call or invoke a user-defined method, the program

control transfer to the called method.

 import java.util.Scanner;

1. public class EvenOdd

2. {

3. public static void main (String args[])

4. {

5. //creating Scanner class object

6. Scanner scan=new Scanner(System.in);

7. System.out.print("Enter the number: ");

8. //reading value from the user

9. int num=scan.nextInt();

10. //method calling

11. findEvenOdd(num);

12. }

In the above code snippet, as soon as the compiler reaches at

line findEvenOdd(num), the control transfer to the method and gives the output

accordingly.

Let's combine both snippets of codes in a single program and execute it.

EvenOdd.java

1. import java.util.Scanner;

2. public class EvenOdd

3. {

4. public static void main (String args[])

5. {

6. //creating Scanner class object

7. Scanner scan=new Scanner(System.in);

8. System.out.print("Enter the number: ");

9. //reading value from user

10. int num=scan.nextInt();

11. //method calling

12. findEvenOdd(num);

13. }

14. //user defined method

15. public static void findEvenOdd(int num)

16. {

17. //method body

18. if(num%2==0)

19. System.out.println(num+" is even");

20. else

21. System.out.println(num+" is odd");

22. }

23. }

Output 1:
 Enter the number: 12

12 is even

Output 2:

Enter the number: 99

99 is odd

Let's see another program that return a value to the calling method.

In the following program, we have defined a method named add() that sum up the

two numbers. It has two parameters n1 and n2 of integer type. The values of n1 and

n2 correspond to the value of a and b, respectively. Therefore, the method adds the

value of a and b and store it in the variable s and returns the sum.

Addition.java

1. public class Addition

2. {

3. public static void main(String[] args)

4. {

5. int a = 19;

6. int b = 5;

7. //method calling

8. int c = add(a, b); //a and b are actual parameters

9. System.out.println("The sum of a and b is= " + c);

10. }
11. //user defined method

12. public static int add(int n1, int n2) //n1 and n2 are formal parameters

13. {

14. int s;

15. s=n1+n2;

16. return s; //returning the sum

17. }

18. }

Output:

The sum of a and b is= 24

Static Method

• A method that has static keyword is known as static method.

• In other words, a method that belongs to a class rather than an instance of a

class is known as a static method.

• We can also create a static method by using the keyword static before the

method name.

• The main advantage of a static method is that we can call it without creating

an object.

• It can access static data members and also change the value of it. It is used to

create an instance method. It is invoked by using the class name.

 • The best example of a static method is the main() method.

Example of static method

Display.java

1. public class Display

2. {

3. public static void main(String[] args)

4. {

5. show();

6. }

7. static void show()

8. {

9. System.out.println("It is an example of static method.");

10. }

11. }

Output:

It is an example of a static method.

Instance Method

The method of the class is known as an instance method. It is a non-static method

defined in the class. Before calling or invoking the instance method, it is necessary to
 create an object of its class. Let's see an example of an instance method.

InstanceMethodExample.java

1. public class InstanceMethodExample

2. {

3. public static void main(String [] args)

4. {

5. //Creating an object of the class

6. InstanceMethodExample obj = new InstanceMethodExample();

7. //invoking instance method

8. System.out.println("The sum is: "+obj.add(12, 13));

9. }

10. int s;

11. //user-defined method because we have not used static keyword

12. public int add(int a, int b)

13. {

14. s = a+b;

15. //returning the sum

16. return s;

17. }

18. }

Output:
 The sum is: 25

There are two types of instance method:

o Accessor Method

o Mutator Method

Accessor Method: The method(s) that reads the instance variable(s) is known as the

accessor method. We can easily identify it because the method is prefixed with the

word get. It is also known as getters. It returns the value of the private field. It is

used to get the value of the private field.

Example

1. public int getId()

2. {

3. return Id;

4. }

Mutator Method: The method(s) read the instance variable(s) and also modify the

values. We can easily identify it because the method is prefixed with the word set. It

is also known as setters or modifiers. It does not return anything. It accepts a

parameter of the same data type that depends on the field. It is used to set the value

of the private field.

 Example

1. public void setRoll(int roll)

2. {

3. this.roll = roll;

4. }

Example of accessor and mutator method

Student.java

1. public class Student

2. {

3. private int roll;

4. private String name;

5. public int getRoll() //accessor method

6. {

7. return roll;

8. }

9. public void setRoll(int roll) //mutator method

10. {

11. this.roll = roll;

12. }

13. public String getName()

14. {
15. return name;

16. }

17. public void setName(String name)

18. {

19. this.name = name;

20. }

21. public void display()

22. {

23. System.out.println("Roll no.: "+roll);

24. System.out.println("Student name: "+name);

25. }

26. }

Abstract Method

• The method that does not has method body is known as abstract method. In

other words, without an implementation is known as abstract method.

• It always declares in the abstract class. It means the class itself must be

abstract if it has abstract method.

• To create an abstract method, we use the keyword abstract.

Syntax

1. abstract void method_name();

 Example of abstract method

Demo.java

1. abstract class Demo //abstract class

2. {

3. //abstract method declaration

4. abstract void display();

5. }

6. public class MyClass extends Demo

7. {

8. //method impelmentation

9. void display()

10. {

11. System.out.println("Abstract method?");

12. }

13. public static void main(String args[])

14. {

15. //creating object of abstract class

16. Demo obj = new MyClass();

17. //invoking abstract method

18. obj.display();

19. }

20. }
Output:

Abstract method...

Factory method

It is a method that returns an object to the class to which it belongs. All static

methods are factory methods. For example, NumberFormat obj =

NumberFormat.getNumberInstance();

Constructors in Java

In Java, a constructor is a block of codes similar to the method. It is called when an instance

of the class is created. At the time of calling constructor, memory for the object is allocated in

the memory.

It is a special type of method which is used to initialize the object.

Every time an object is created using the new() keyword, at least one constructor is

called.

It calls a default constructor if there is no constructor available in the class. In such

case, Java compiler provides a default constructor by default.

There are two types of constructors in Java: no-arg constructor, and parameterized

constructor.
Note: It is called constructor because it constructs the values at the time of object

creation. It is not necessary to write a constructor for a class. It is because java

compiler creates a default constructor if your class doesn't have any.

Rules for creating Java constructor

There are two rules defined for the constructor.

1. Constructor name must be the same as its class name

2. A Constructor must have no explicit return type

3. A Java constructor cannot be abstract, static, final, and synchronized

Note: We can use access modifiers

while declaring a constructor. It controls the object creation. In other words, we can have

private, protected, public or default constructor in Java.

Types of Java constructors

There are two types of constructors in Java:

1. Default constructor (no-arg constructor)

2. Parameterized constructor
 Java Default Constructor

A constructor is called "Default Constructor" when it doesn't have any parameter.

Syntax of default constructor:

1. <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.

//Java Program to create and call a default constructor

class Bike1{

//creating a default constructor

Bike1()

{
System.out.println("Bike is created");}

//main method

public static void main(String args[]){

//calling a default constructor

Bike1 b=new Bike1();

Output:

Bike is created

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

constructor.

Q) What is the purpose of a default constructor?

The default constructor is used to provide the default values to the object like 0, null,

etc., depending on the type.

 Example of default constructor that displays the default

values

//Let us see another example of default constructor

//which displays the default values

class Student3{

int id;

String name;

//method to display the value of id and name

void display(){

System.out.println(id+" "+name);}

public static void main(String args[]){

//creating objects

Student3 s1=new Student3();

Student3 s2=new Student3();

//displaying values of the object

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.

Java Parameterized Constructor

A constructor which has a specific number of parameters is called a parameterized

constructor.

Why use the parameterized constructor?

The parameterized constructor is used to provide different values to distinct objects.

However, you can provide the same values also.

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.

//Java Program to demonstrate the use of the parameterized constructor.

class Student4{

int id;

String name;

//creating a parameterized constructor

 Student4(int i,String n){

id = i;

name = n;

//method to display the values

void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

//creating objects and passing values

Student4 s1 = new Student4(111,"Karan");

Student4 s2 = new Student4(222,"Aryan");

//calling method to display the values of object

s1.display();

s2.display();

Output:

111 Karan

222 Aryan
 Constructor Overloading in Java

• In Java, a constructor is just like a method but without return type. It can also

be overloaded like Java methods.

• Constructor overloading in Java is a technique of having more than one constructor

with different parameter lists.

• They are arranged in a way that each constructor performs a different task. They are

differentiated by the compiler by the number of parameters in the list and their types.

Example of Constructor Overloading

//Java program to overload constructors

class Student5{

int id;

String name;

int age;

//creating two arg constructor

Student5(int i,String n){

id = i;

name = n;

//creating three arg constructor

Student5(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[]){

Student5 s1 = new Student5(111,"Karan");

Student5 s2 = new Student5(222,"Aryan",25);

s1.display();

s2.display();

Output:

111 Karan 0

222 Aryan 25

Difference between constructor and method in Java

There are many differences between constructors and methods. They are given

below.

Java Constructor Java Method

A constructor is used to initialize the state of an A method is used to expose the

object. behavior of an object.

A constructor must not have a return type. A method must have a return type.

The constructor is invoked implicitly. The method is invoked explicitly.

The Java compiler provides a default constructor if The method is not provided by the

you don't have any constructor in a class. compiler in any case.

The constructor name must be same as the class The method name may or may not

name. be same as the class name.

 Java Copy Constructor

There is no copy constructor in Java. However, we can copy the values from one

object to another like copy constructor in C++.

There are many ways to copy the values of one object into another in Java. They are:

o By constructor

o By assigning the values of one object into another

o By clone() method of Object class

In this example, we are going to copy the values of one object into another using

Java constructor.

//Java program to initialize the values from one object to another object.

class Student6{

int id;

String name;

//constructor to initialize integer and string

Student6(int i,String n){

id = i;

name = n;

//constructor to initialize another object

Student6(Student6 s){
 id = s.id;

name =s.name;

void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

Student6 s1 = new Student6(111,"Karan");

Student6 s2 = new Student6(s1);

s1.display();

s2.display();

Output:

111 Karan

111 Karan

Copying values 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.

class Student7{
 int id;

String name;

Student7(int i,String n){

id = i;

name = n;

Student7(){}

void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

Student7 s1 = new Student7(111,"Karan");

Student7 s2 = new Student7();

s2.id=s1.id;

s2.name=s1.name;

s1.display();

s2.display();

Output:

111 Karan

111 Karan
 Java static keyword

• The static keyword in Java is used for memory management mainly.

• We can apply static keyword with variables, methods, blocks and nested classes .

• The static keyword belongs to the class than an instance of the class.

The static can be:

1. Variable (also known as a class variable)

2. Method (also known as a class method)

3. Block

4. Nested class

1) Java static variable

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

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

Advantages of static variable

It makes your program memory efficient (i.e., it saves memory).

Understanding the 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 the object is created. All students have its unique rollno
and name, so instance data member is good in such case. Here, "college" refers to
the common property of all objects. If we make it static, this field will get the memory
only once.

Java static property is shared to all objects.

Example of static variable

//Java Program to demonstrate the use of static variable

class Student{
int rollno;//instance variable
String name;
static String college ="ITS";//static variable
//constructor
Student(int r, String n){
rollno = r;
name = n;
}
//method to display the values
void display (){
System.out.println(rollno+" "+name+" "+college);
}
}
//Test class to show the values of objects
public class TestStaticVariable1{
public static void main(String args[]){
Student s1 = new Student(111,"Karan");
Student s2 = new Student(222,"Aryan");
//we can change the college of all objects by the single line of code
//Student.college="BBDIT";
s1.display();
s2.display();
}
}
 Output:

111 Karan ITS

222 Aryan ITS

Program of the 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 other objects. So each object will have the value 1 in the
count variable.

//Java Program to demonstrate the use of an instance variable

//which get memory each time when we create an object of the class.
class Counter{
int count=0;//will get memory each time when the instance is created

Counter(){
count++;//incrementing value
System.out.println(count);
}

public static void main(String args[]){

//Creating objects
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.

//Java Program to illustrate the use of static variable which

//is shared with all objects.
class Counter2{
static int count=0;//will get memory only once and retain its value

Counter2(){
count++;//incrementing the value of static variable
System.out.println(count);
}

public static void main(String args[]){

//creating objects
Counter2 c1=new Counter2();
Counter2 c2=new Counter2();
Counter2 c3=new Counter2();
}
}

Output:

1
2
3

2) Java static method

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

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

Example of static method

//Java Program to demonstrate the use of a static method.

class Student{
int rollno;
String name;
static String college = "ITS";
//static method to change the value of static variable
static void change(){
college = "BBDIT";
}
//constructor to initialize the variable
Student(int r, String n){
rollno = r;
name = n;
}
//method to display values
void display(){System.out.println(rollno+" "+name+" "+college);}
}
//Test class to create and display the values of object
public class TestStaticMethod{
public static void main(String args[]){
Student.change();//calling change method
//creating objects
Student s1 = new Student(111,"Karan");
Student s2 = new Student(222,"Aryan");
Student s3 = new Student(333,"Sonoo");
//calling display method
s1.display();
s2.display();
s3.display();
 }
}
Output:111 Karan BBDIT
222 Aryan BBDIT
333 Sonoo BBDIT

Another example of a static method that performs a normal

calculation

//Java Program to get the cube of a given number using the 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 the 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.

class A{
int a=40;//non static

public static void main(String args[]){

System.out.println(a);
}
}
Output:Compile Time Error
 Q) Why is the Java main method static?
Ans) It is because the object is not required to call a static method. If it were a non-
static method, JVM creates an object first then call main() method that will lead the
problem of extra memory allocation.

3) Java static block

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

Example of static block

class A2{
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

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

Ans) No, one of the ways was the static block, but it was possible till JDK 1.6. Since
JDK 1.7, it is not possible to execute a Java class without the main method.

class A3{
static{
System.out.println("static block is invoked");
System.exit(0);
}
}

Output:

static block is invoked

Since JDK 1.7 and above, output would be:

Error: Main method not found in class A3, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
this keyword in Java
There can be a lot of usage of Java this keyword. In Java, this is a reference
variable that refers to the current object.

Usage of Java this keyword

Here is given the 6 usage of java this keyword.

1. this can be used to refer current class instance variable.

2. this can be used to invoke current class method (implicitly)
3. this() can be used to invoke current class constructor.
4. this can be passed as an argument in the method call.
5. this can be passed as argument in the constructor call.
6. this can be used to return the current class instance from the method.

Suggestion: If you are beginner to java, lookup only three usages of this keyword.
 1) this: to refer current class instance variable
The this keyword can be used to refer current class instance variable. If there is
ambiguity between the instance variables and parameters, this keyword resolves the
problem of ambiguity.

ncepts in Java

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 rollno;
String name;
float fee;
Student(int rollno,String name,float fee){
rollno=rollno;
name=name;
fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}
class TestThis1{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}}

Output:

0 null 0.0
0 null 0.0

In the above example, parameters (formal arguments) and instance variables are
same. So, we are using this keyword to distinguish local variable and instance
variable.

Solution of the above problem by this keyword

class Student{
int rollno;
String name;
float fee;
Student(int rollno,String name,float fee){
this.rollno=rollno;
this.name=name;
this.fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}

class TestThis2{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}}

Output:

111 ankit 5000.0

112 sumit 6000.0

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 rollno;
String name;
float fee;
Student(int r,String n,float f){
rollno=r;
name=n;
fee=f;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}

class TestThis3{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}}

Output:

111 ankit 5000.0

112 sumit 6000.0

It is better approach to use meaningful names for variables. So we use same name for
instance variables and parameters in real time, and always use this keyword.

2) this: to invoke current class method

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 A{
void m(){System.out.println("hello m");}
void n(){
System.out.println("hello n");
//m();//same as this.m()
this.m();
}
}
class TestThis4{
public static void main(String args[]){
A a=new A();
a.n();
}}

Output:

hello n
hello m

3) this() : to invoke current class constructor

The this() constructor call can be used to invoke the current class constructor. It is
used to reuse the constructor. In other words, it is used for constructor chaining.

Calling default constructor from parameterized constructor:

class A{
A(){System.out.println("hello a");}
A(int x){
this();
System.out.println(x);
}
}
class TestThis5{
public static void main(String args[]){
A a=new A(10);
}}

Output:

hello a
10

Calling parameterized constructor from default constructor:

class A{
A(){
this(5);
System.out.println("hello a");
}
A(int x){
System.out.println(x);
}
}
class TestThis6{
public static void main(String args[]){
A a=new A();
}}

Output:

5
hello a

Real usage of this() constructor call

The this() constructor call should be used to reuse the constructor from 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 rollno;
String name,course;
float fee;
Student(int rollno,String name,String course){
this.rollno=rollno;
this.name=name;
this.course=course;
}
Student(int rollno,String name,String course,float fee){
this(rollno,name,course);//reusing constructor
this.fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+course+" "+fee);}
}
class TestThis7{
public static void main(String args[]){
Student s1=new Student(111,"ankit","java");
Student s2=new Student(112,"sumit","java",6000f);
s1.display();
s2.display();
}}

Output:

111 ankit java 0.0

112 sumit java 6000.0

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

class Student{
int rollno;
String name,course;
float fee;
Student(int rollno,String name,String course){
this.rollno=rollno;
this.name=name;
this.course=course;
}
Student(int rollno,String name,String course,float fee){
this.fee=fee;
this(rollno,name,course);//C.T.Error
}
void display(){System.out.println(rollno+" "+name+" "+course+" "+fee);}
}
class TestThis8{
public static void main(String args[]){
Student s1=new Student(111,"ankit","java");
Student s2=new Student(112,"sumit","java",6000f);
s1.display();
s2.display();
}}

Output:
 Compile Time Error: Call to this must be first statement in constructor

4) this: to pass 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 S2{
void m(S2 obj){
System.out.println("method is invoked");
}
void p(){
m(this);
}
public static void main(String args[]){
S2 s1 = new S2();
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. It is used to reuse one object in many methods.

5) this: to pass 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{
A4 obj;
B(A4 obj){
this.obj=obj;
}
 void display(){
System.out.println(obj.data);//using data member of A4 class
}
}

class A4{
int data=10;
A4(){
B b=new B(this);
b.display();
}
public static void main(String args[]){
A4 a=new A4();
}
}
Output:10

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

We can return 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 Test1{
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 A5{
void m(){
System.out.println(this);//prints same reference ID
}
public static void main(String args[]){
A5 obj=new A5();
System.out.println(obj);//prints the reference ID
obj.m();
}
}

Output:

A5@22b3ea59
A5@22b3ea59

Method Overloading in Java

If a class has multiple methods having same name but different in parameters, it is known
as Method Overloading.

If we have to perform only one operation, having 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 behavior 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

In Java, Method Overloading is not possible by changing the return type of the method
only.

1) Method Overloading: changing no. of arguments

In this example, we have created two methods, first add() method performs addition
of two numbers and second add method performs addition of three numbers.

In this example, we are creating static methods so that we don't need to create
instance for calling methods.

class Adder{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}}

Output:

22
33
 2) Method Overloading: changing data type of arguments
In this example, we have created two methods that differs in data type. The first add
method receives two integer arguments and second add method receives two
double arguments.

class Adder{
static int add(int a, int b){return a+b;}
static double add(double a, double b){return a+b;}
}
class TestOverloading2{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}

Output:

22
24.9

Q) Why Method Overloading is not possible by changing the

return type of method only?
In java, method overloading is not possible by changing the return type of the
method only because of ambiguity. Let's see how ambiguity may occur:

class Adder{
static int add(int a,int b){return a+b;}
static double add(int a,int b){return a+b;}
}
class TestOverloading3{
public static void main(String[] args){
System.out.println(Adder.add(11,11));//ambiguity
}}

Output:

Compile Time Error: method add(int,int) is already defined in class Adder

 System.out.println(Adder.add(11,11)); //Here, how can java determine which sum()
method should be called?

Note: Compile Time Error is better than Run Time Error. So, java compiler renders
compiler time error if you declare the same method having same parameters.

Can we overload java main() method?

Yes, by method overloading. You can have any number of main methods in a class by
method overloading. But JVM calls main() method which receives string array as
arguments only. Let's see the simple example:

class TestOverloading4{
public static void main(String[] args){System.out.println("main with String[]");}
public static void main(String args){System.out.println("main with String");}
public static void main(){System.out.println("main without args");}
}

Output:

main with String[]

Java Garbage Collection
In java, garbage means unreferenced objects.

Garbage Collection is process of reclaiming the runtime unused memory

automatically. In other words, it is a way to destroy the unused objects.

To do so, we were using free() function in C language and delete() in C++. But, in
java it is performed automatically. So, java provides better memory management.

Advantage of Garbage Collection

o It makes java memory efficient because garbage collector removes the

unreferenced objects from heap memory.
o It is automatically done by the garbage collector(a part of JVM) so we don't
need to make extra efforts.

How can an object be unreferenced?

There are many ways:

o By nulling the reference

o By assigning a reference to another
o By anonymous object etc.
 1) By nulling a reference:

1. Employee e=new Employee();

2. e=null;

2) By assigning a reference to another:

1. Employee e1=new Employee();

2. Employee e2=new Employee();
3. e1=e2;//now the first object referred by e1 is available for garbage collection

3) By anonymous object:

finalize() method
The finalize() method is invoked each time before the object is garbage collected.
This method can be used to perform cleanup processing. This method is defined in
Object class as:

1. protected void finalize(){}

 Note: The Garbage collector of JVM collects only those objects that are created by new
keyword. So if you have created any object without new, you can use finalize method to
perform cleanup processing (destroying remaining objects).

gc() method
The gc() method is used to invoke the garbage collector to perform cleanup
processing. The gc() is found in System and Runtime classes.

1. public static void gc(){}

Note: Garbage collection is performed by a daemon thread called Garbage

Collector(GC). This thread calls the finalize() method before object is garbage collected.

Simple Example of garbage collection in java

public class TestGarbage1{
public void finalize(){System.out.println("object is garbage collected");}
public static void main(String args[]){
TestGarbage1 s1=new TestGarbage1();
TestGarbage1 s2=new TestGarbage1();
s1=null;
s2=null;
System.gc();
}
}
object is garbage collected
object is garbage collected

Note: Neither finalization nor garbage collection is guaranteed.