2 Object Oriented Programming

Chapter 2
Object Oriented Programming
Prof. Amruta Deshmukh

1
What is OOP?
• Object oriented programming is a model that

provides different type of concepts, such as
inheritance, abstraction, polymorphism etc.
• These concepts implement real-world entities in
programs, and they create methods and variables
to reuse them without compromising security.
• Object oriented programming is about creating
objects that contain both data and methods.
• Object-Oriented Programming is a methodology
to design a program using classes and objects. It
simplifies the software development and
maintenance.

2
2.1 Class Fundamentals
• Class is a blue print which is containing only list of variables and
methods and no memory is allocated for them. It is a logical entity.
• A class is a group of objects that has common properties.
• A class in java contains Data Member, Methods and Constructor.
• Once a class has been defined, we can create any number of objects.
• Syntax to declare a Class
class Class_Name
{ data member;
method;
}

3
Class Rectangle
{ int length;
int width; // Variable declaration
// Method declaration
void getdata(int x, int y)
{ length=x;
width=y;
}
} // end of class

4
Object
• An object is an entity which has a well defined
structure and behavior.
• It can be physical and logical.
• Object has identity, state, Behavior and responsibility.
• An object can be conceptual.
• E.g. Air, hard disk, pen, person, sound, instrument,
bank account, contract, signal, industrial process,
transaction, training course etc.

5
State of an Object
• The state of an object includes the current values of
all its attributes.
• An attribute can be static or dynamic.
• E.g. Employee Attributes
• Static Attributes
- empid, name, gender
• Dynamic Attributes
- age, address, phone, basicsal, education, experience.

6
Behavior of the Object
• Behavior is how an object acts and reacts, in terms of
its state changes and message passing.
• The behavior of an object corresponds to its
functions. The change in the state of an object reflects
in its behavior.
• E.g. calculate salary and print details are the behaviors
of the employee. They can either help to retrieve the
information or change the state of the attributes.

7
Identity of an object
•Identity is that property of an object which
different it from all other objects.
•Every object has its own identity.
•A single or group of attributes can be identity
of an object.
•It is easier to interact with an object that has
identity.
•E.g. 1. Empid is an identity of an employee.
•2. Fan and Mobile phone would have a unique
product number as an identity.
8
Attribut State Ident Behaviour Responsibility
es ity
Empid Empid=10 Empi Swipe Card To be present in the
d=10 office on time.
name Name=”Raj” Fill Do allocated work.

Timesheet
gender Gender=”male” Wear Icard Identity with
organization.
age Age=27 Calculate Get salary

Salary
address pune Print Provide personal

Details information
phone 9862145256
Basic 9000
salary
educati
on
experie
nce

9
Create an Object
• Object is an instance of class. It is created using new
keyword in java.
• To create object of type Rectangle use statement as
Rectangle rect1 = new Rectangle();
• Every rectangle object will contain its own copies of
instance variables, length & width.
• To access these variables use Dot (.) operator.
• E.g. rect1.width=100;
• You can use dot operator to access both the instance
variables & the methods within an object.

10
• In Java, all class objects must be dynamically
allocated.

11
Simple Example of Object and Class//D
class Employee
{
int eid; // data member
String ename; // data member
eid=101;
ename="Hitesh";
public static void main(String args[])
{
Employee e=new Employee(); // Creating an object of class Employee
System.out.println("Employee ID: "+e.eid);
System.out.println("Name: "+e.ename);
}
} Prof. Amruta Deshmukh
12
class Rectangle
{
private int l,b;
public void setDimension(int x, int y)

{
l=x;
b=y;
}
public int area()

{
return l*b;
}
public void display()
{
System.out.println("Length="+l);
System.out.println("Breadth="+b);
}
public static void main(String [] args)
{
Rectangle r=new Rectangle();
r.setDimension(5,10);
r.display();
System.out.println("Area="+ r.area());
} }
13
Access Specifiers
•Access Specifiers allow to specify the scope of
class members.
•Access Specifiers are of 4 types.
1. public
2. private
3. protected
4. Default
In java, encapsulation is implemented using
access Specifier.
14
Java Access Modifiers
• Let's understand the access modifiers in Java by a simple table.
Access Modifier within class within package outside package outside package
by subclass only
Private Y N N N
Default Y Y N N
Protected Y Y Y N
Public Y Y Y Y

15
1)Public:
• The public access allows anyone to access the data or method specified
with this access.
• The public access modifier is the direct opposite of the private
access modifier. A class, method or variable can be declared as
public and it means that it is accessible from any class.
• To Compile: d//javac -d . A.java

• To Run: d//java pp.A
//save by A.java
package pp;
public class A{
public void msg(){
System.out.println("Hello");}
}
16
2//save by B.java
To Compile :D:\>javac -d . B.java
To Run : D:\>java pack.B
package pack;
import pp.*;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
}
}

17
Private:
• The access level of a private modifier is only within the class. It cannot
be accessed from outside the class.
• Example Save D:\>javac PrivateA.java

class A{
private void msg()
System.out.println("Hello java");}
public class PrivateA{
A obj=new A();//Compile Time Error
obj.msg();
}
} 18
3)Protected
• Protected variables & methods are accessible by the
package classes and any subclasses that are in other
packages.
//save by D:\>javac -d . Ap.java
package packAp;
public class Ap{
protected void
msg(){System.out.println("Hello");}
}

19
//save by Bp.java
To Compile: D:\>javac -d . Bp.java
To Run: D:\>java mypackBp.Bp
package mypackBp;
import packAp.*;
class Bp extends Ap{

Bp obj = new Bp();
obj.msg();
}
}
20
Default
• If you don't use any modifier, it is treated as default by default.
• Data and methods declared without any access Specifiers are said to
have default access.
• The default modifier is accessible only within package.
• It cannot be accessed from outside the package.
• The default access allows all the classes within the same package to
access the data and methods.
• Example:
//save by A.java javac -d . Ad.java
package packD;
class Ad{
void msg(){System.out.println("Hello");}
}

21
//save by BD.java and
D:\>javac -d . BD.java
package mypackD;
import packD.*;
class BD{
AD obj = new AD();//Compile Time Error
obj.msg();//Compile Time Error
}
}

22
Garbage Collection
• Garbage collection in Java is the process by which Java programs
perform automatic memory management.
• Java programs compile to bytecode that can be run on a Java
Virtual Machine.
• When Java programs run on the JVM, objects are created on the
heap, which is a portion of memory allocated to the program.
• Eventually, some objects will no longer be needed. The garbage
collector finds these unused objects and deletes them to free up
memory.
• The object is subject to a garbage collection when it becomes
unreachable to the program in which it is used.
• Objects which are no longer in use. Garbage collector destroys
these objects.
• The main objective of Garbage Collector is to free heap memory
by destroying unreachable objects
23
finalize() Method
• finalize() method in Java is a method of the Object class. that
is used to perform cleanup activity before destroying any
object.
• finalize( ) method when it detects that the object has become
unreachable.
• The purpose of finalize() method is to give an unreachable object the
opportunity to perform any clean up processing before the object is
garbage collected (destroying any object).
• Inside the finalize( ) method you can specify those actions that must
be performed before an object is destroyed.
• Syntax:
• protected void finalize( ) { // code }
• finalize() method receives no parameters and returns no value.
• Finalization: Just before destroying any object, the garbage
collector always calls finalize() method to perform clean-up
activities on that object. This process is known as Finalization in
Java. Prof. Amruta Deshmukh 24
Example finalize() Method
• package amruta;
• public class TestGarbage1 {
• void h()
• {
• System.out.println("hi");
• }
• 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();
• }
• }
25
• Java System gc() Method
• The gc() method of System class runs the garbage collector.
• this method, JVM makes best effort to reuse the memory of discarded
objects for quick reuse.
• Syntax
• public static void gc() ;
• Example
• package amruta;
• public class SystemGCExample1 {

• // TODO Auto-generated method stub
• String i="amruta";
• System.out.println("before garbage collection = "+i);
• i= null; System.gc();
• System.out.println("after garbage collection = "+i);}
• }
26
Constructor
• A constructor is a special member function used to initialize the
values of the attributes of an object.
• This function is implicitly called when an object is created.
• It is not compulsory to define a constructor. In this case the
compiler provides a default constructor but the attributes are
initialized to default values. E.g. Zero for numeric type, null for
object references and false for boolean.
• A constructor in Java is a special method that is used to
initialize objects. The constructor is called when an
object of a class is created.

27
Rules to create constructor
• Constructor name is same as class name.

• No return type for constructor. Not even void.
• Constructors are implicitly called when objects are created.
• There is no return statement in the body of the constructor.
• Constructor can be overloaded.
• Overloading refers to a technique where same name is used for another

method but the signature of the methods are different.
• Constructor which does not accept any argument is called as default
constructor.

28
Types of Java constructors
• There are two types of constructors in Java:
1.Default constructor (no-arg constructor)
2.Parameterized constructor

29
Output:
Bike is created
Bik is created
Java Default Constructor

• A constructor is called "Default Constructor" when it doesn't
have any parameter.
• Syntax of default constructor:
<class_name>(){}
Example: D:\>javac ACD.java
class ACD{
ACD()
{
System.out.println("Default constructor");
}
public static void main(String args[])
{
ACD b=new ACD();
} Prof. Amruta Deshmukh
} 30
Java Parameterized Constructor
• A constructor which has a specific number of

parameters is called a parameterized constructor.

31
1.//Java Program to demonstrate the use of the parameterized constructor.
2.D:\>javac Student4.java
class Student4{
int id;
String name;
Student4(int i,String n)
{
id = i;
name = n;
}
void display()
{
System.out.println(id+" "+name);
}
Student4 s1 = new Student4(11,"Kunal");

Student4 s2 = new Student4(22,"Amol");
s1.display();
s2.display(); Prof. Amruta Deshmukh
}
32
}
2.7 Nested and Inner Classes
• Inner Class
• Definition of one class within the definition of another class.
• Inner class is a member of the enclosing class just like another class
member.
• Syntax of Inner class
class Outer_class {
// details of outer class
class Inner_class {
// details of inner class
}
// more details of outer class
}

33
// Example of member inner class that is invoked inside a class
package deshmukh;
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class
class Inner {
void display() {
System.out.println("display: outer_x = " + outer_x);
} }
}
class InnerClassDemo {
public static void main(String args []) {
Outer outer = new Outer();
outer.test();
} }
Output : display: outer_x = 100 Prof. Amruta Deshmukh
34
// member inner class that is invoked outside a class
Example 1
• package deshmukh;
• class Outer1 {
• private int data=30;
• class Inner
• {
• void msg()
• {
• System.out.println("data is"+ data);
• }
• }
• }
• public class TestMemberInner {
• Outer1 obj=new Outer1();

• Outer1.Inner in=obj.new Inner();
• in.msg();
• }
• } Prof. Amruta Deshmukh

Output: data is 30
35
• //member inner class that is invoked outside a class
• Example 2
• class A
• {
• class B
• {
• void show()
• {
• System.out.println("Class B");
• }
• }
• }
• class MainC
• {
• public static void main(String argc[])
• {
• A a1=new A();
• A.B b2=a1.new B();
• b2.show();
• }
• }
36
Types of Inner Classes
1.Nested Inner Class/Member Inner Class
2.Static Inner Classes
3.Method Local Inner Classes
4. Anonymous Inner Classes

37
1Nested Inner Class/Member Inner Class
• In Java, you can define a class within another class. Such class is known as nested inner
class.
• Example
• class Outer {
• int outerx = 100;
• void test() {
• Inner inner = new Inner();
• inner.display();
• }
• class Inner {
• void display() {
• System.out.println("display: outerx = " + outerx);
• }
• }
• }
• public class InnerClassDemo {

• Outer outer = new Outer();
• outer.test();
• }
• } 38
• 2) Static Nested Classes:
• In Java, we can also define a Static class inside another class. Such class
is known as Static nested class.
• Example.
• class MotherBoard {
• // static nested class

• static class USB{
• int usb2 = 2;
• int usb3 = 1;
• int getTotalPorts(){
• return usb2 + usb3;
• }
• }
• }
• public class staticinnerclass {
• MotherBoard.USB usb = new MotherBoard.USB();

• System.out.println("Total Ports = " + usb.getTotalPorts());
• }
• }
39
1Nested Inner Class/Member Inner Class
• In Java, you can define a class within another class. Such class
is known as nested inner class.
• 2) Static Nested Classes:
• In Java, we can also define a Static class inside another class.
Such class is known as Static nested class.

• Inner class can be declared within a method of an outer class.

40
• Inner class can be declared within a method of an outer class.
• Example 1: Method Local Inner Classes
• class OuterM {
•
• void outerMethod()
• {
• System.out.println("inside outerMethod");
•
• class Inner {
•
• void innerMethod()
• {
• System.out.println("inside innerMethod");
• }
• }
• //inner object
• Inner y = new Inner();
• y.innerMethod();
• }
41
• public class Localinner {

• OuterM x = new OuterM();
• x.outerMethod();
•}
•}

42
• //Example 2 Method Local Inner Classes
• class A
• {
• void methodA()
• {
• class B
• {
• void show()
• {
• System.out.println("Class B");
• }
• }
• B b1=new B();
• b1.show();
• }
• }
• class MCA
• {
• {
• A a1=new A();
•
• a1.methodA();
• }
• }
43
4 Anonymous Classes
• Anonymous inner classes are declared without any name at all.
• They are created in two ways.
1.As a subclass of the specified type
2.As an implementer of the specified interface
• An inner class with no name is called anonymous inner class.

• Anonymous classes enables you to define and create object of class at
the same time.
• Generally, they are used whenever you need to override the method of
a class or an interface.
• An Anonymous class has access to the members of its enclosing class.
• An Anonymous class can have final variables.
• Anonymous classes are often used in GUI applications.
44
Syntax
AnonymousInner an_inner = new AnonymousInner() {
public void my_method()
{ ........ ........
}
};

45
• Anonymous Classes
• class Demo {
• void show()
• {
• System.out.println(
• "i am in show method of super class");
• }
• }
• public class Anonymous {
• static Demo d = new Demo() {
•
• void show()
• {
• System.out.println("i am in Flavor1Demo class");
• }
• };
• d.show();
• }
• }

46
• Example 2 Anonymous Classes
• class A
• {
• void show()
• {
• System.out.println("Class A");
• }
• }
• class M1
• {
• static A a1=new A()
• {
• void show()
• {
• System.out.println("Class New");
• }
• };
•
• {
• a1.show();
• }
• }
47
Abstract class in Java
• A class which is declared as abstract is known as an abstract class.
• It can have abstract and non-abstract methods.
• An abstract is a java modifier applicable for classes and methods in
java but not for Variables.
• It cannot be instantiated.
• Abstract class: is a restricted class that cannot be used to create
objects (to access it, it must be inherited from another class).
• Java Abstraction
• The major use of abstract classes and methods is to achieve
abstraction in Java.
• Abstraction is an important concept of object-oriented programming
that allows us to hide unnecessary details and only show the needed
information.
•

48
Key Points to Remember
• We use the abstract keyword to create abstract
classes.
• We cannot create objects of an abstract class.
• It can have abstract and non-abstract methods.
• Abstract class must be inherited from another class.
• A subclass must override all abstract methods of an
abstract class.
• We can define static methods in an abstract class

49
The Syntax for Abstract Class
• To declare an abstract class, we use the access modifier first, then the
"abstract" keyword, and the class name shown below.
• //Syntax:
• <Access_Modifier> abstract class <Class_Name> {
• //Data_Members;
• //Methods;
•}

50
Example Abstract Class With Non Abstract Method
• abstract class AbstractSimple
• {
• void show()
• {
• System.out.println("Abstract class");
• }
• }
• public class ATclass extends AbstractSimple {

• ATclass obj=new ATclass();
• obj.show();
• }
• }
51
Example Abstract Class With Non Abstract Method and
Abstract Method
• abstract class Book {
• public abstract void show();
• // method of abstract class
• public void display() {
• System.out.println("This is Java Programming");
• }
• }
• public class abstractclass extends Book {
• public void show()
• {
• System.out.println("abstract method");
• }
• abstractclass obj=new abstractclass();
• obj.show();
• obj.display();
• }
• }
52
Abstract method:
• A method declared using the abstract keyword within an abstract
class and does not have a definition (implementation) is called an
abstract method.
• can only be used in an abstract class, and it does not have a body.
The body is provided by the subclass (inherited from).
• An abstract method must be declared with an abstract keyword.
• Syntax for abstract method:

• abstract return_type method_name( [ argument-list ] );

53
Example: Abstract Class With Abstract Method and non Abstract
Method
• abstract class Multiply {
• public abstract int MultiplyTwo (int n1, int n2);
• public abstract int MultiplyThree (int n1, int n2,
int n3);
•
• // regular method with body
• public void show() {
• System.out.println ("Method of abstract class
Multiply");
• }
•}

54
• public class AbstractMethod extends Multiply {
public int MultiplyTwo (int num1, int num2) {
• return num1 * num2;
• }
• public int MultiplyThree (int num1, int num2, int num3) {
• return num1 * num2 * num3;
• }
• AbstractMethod obj=new AbstractMethod();
• System.out.println("Method two="+obj.MultiplyTwo(5,6));
• obj.show();
• System.out.println("Method
three="+obj.MultiplyThree(2,3,4));
• obj.show();
•}
}
55
Example : Abstract Class With Inheritance Concept
• abstract class Fruit
• {
• abstract void show();
• }
• class Apple extends Fruit
• {
• {
• System.out.println("Apple");
• }
• }
• class Mango extends Fruit
• {
• void show()
• {
• System.out.println("Mango");
• }
• }
56
• public class abstractC1 {

• Apple a1=new Apple();
• a1.show();
• Mango m1= new Mango();
• m1.show();
•
•}
•}

57
Interfaces
• An interface is basically a kind of class.
• Like classes, interfaces contain methods and variables.
• But interfaces define only abstract methods and final variables. i.e.
• interface can be only abstract methods in the Java interface, not the
method body.
• Data fields contain only constants.
• It is used to achieve abstraction and multiple inheritance in Java.
• Therefore, it is the responsibility of the class that implements an
interface to define the code for implementation of these methods.

58
Characteristics of an Interface
• An interface can have only abstract methods.
• Methods in an interface are always public.
• Variables in an interface are always static & final.
• An interface can extend other interfaces, just as a class can extend
another class. However, while a class can only extend one another class
an interface can extend any number of interfaces.
• Interface do not have constructor.
• It is used to achieve abstraction and multiple inheritance in Java.
• The interface in Java is a mechanism to achieve abstraction.

59
The relationship between classes and interfaces
• As shown in the figure given below, a class extends another class, an
interface extends another interface, but a class implements an
interface.
•

60
• Valid combinations
a. class extends class
b. class implements interface
c. interface extends interface

61
Syntax:-
interface InterfaceName
{
variable declaration;
method declaration;
}
Here, interface is keyword and InterfaceName is any
valid java identifier.
Variables are declared as –

static final type variableName=value;
62
Remember
• An interface can’t extend classes.

• Implementing Interfaces
• Using implements Keyword
class class_name implements interface_name
{ // body of class_name
}

63
• Methods declaration will contain only a list of methods without any
body statement.
retun_type methodname1(parameterlist);
e.g. interface Item

{
static final int code=1001;
static final String name=“Raj”;
void display();
}

64
Remember
• The code for method is not included in the interface.
• Interface is used only when we wish to implement multiple inheritance
feature in the program.
• Interfaces defines only abstract methods and final fields.
e.g. interface Area

{ final static float pi=3.14;
float compute(float x, float y);
void show();
}

65
Example: Interface
• interface A2p
•{
• void printA2();
•}
• class InterfaceD implements A2p{
• public void printA2(){
• System.out.println("Hello");
•}
• InterfaceD obj=new InterfaceD();

• obj.printA2();
•}
•}
66
• Example 2 interface
• interface xyz
• {
• void show();
• }
• class abcd implements xyz

• {
• {
• System.out.println("xyz");
• }
• public static void main(String args[])
• {
• abcd obj= new abcd();

• obj.show();
• }
• }
67
Extending Interfaces
• Like classes, interfaces can also be extended i.e. an interface can be sub
interfaced from another interfaces. The new sub interface will inherit all
the members of the super interface in the manner similar to subclasses.
• This is achieved using keyword extends.
interface name2 extends name1

{ body of name2
}

68
• We can put all constants in one interface and the methods in the other.
This will enable us to use the constants in classes where the methods
are not required.
interface Itemconstants
{
int code=1001;
String name=“Fan”;
}
interface Item extends Itemconstants
{
void display();
}

69
Example: Interface with Single Level Inheritance
• interface interfaceX1
• {
• void show();
• }
• interface interfaceY1 extends interfaceX1
• {
• void print1();
• }
• public class classInterface implements interfaceY1
• {
• {
• System.out.println("Base interface in interfaceX1");
• }
• public void print1()
• {
• System.out.println("Derived interface in interfaceY1");
• }
70
• classInterface obj=new classInterface();
• obj.show();
• obj.print1();
•}
•}

71
Multiple inheritance in Java by interface
• If a class implements multiple interfaces, or an interface extends
multiple interfaces, it is known as multiple inheritance.

72
Example : Class implements multiple interfaces (Different
Methods Name)
• interface interface1
•{
• void show1();
•}
• interface interface2
•{
• void show2();
•}

73
• public class MultipleInterface implements
interface1,interface2 {
• public void show1() {
• System.out.println("First Interface");
• }
• public void show2()
• {
• System.out.println("Second Interface");
• }
• MultipleInterface obj=new MultipleInterface();
• obj.show1();
• obj.show2();
•}
•} Prof. Amruta Deshmukh
74
Example : Class implements multiple interfaces (Same Method)
• interface interfaceAa
• {
• void show();
• }
• interface interfaceBb
• {
• void show();
• }
• public class MI implements interfaceAa , interfaceBb {
• public void show() {
• System.out.println("2 Base Interface method is same ");
• }
•
• MI obj=new MI();
• obj.show();
• }
• }
75
Interface extends multiple interfaces
• interface interfaceA1
• {
• void show1();
• }
• interface interfaceK1
• {
• void show2();
• }
• interface interfaceC extends interfaceA1,interfaceK1
• {
• void show3();
•}

76
• public class interfaceE implements interfaceC {
• public void show1() {
• System.out.println("Base First Interface");
• }
• {
• System.out.println("Base Second Interface");
• }
• {
• System.out.println("Child Second Interface");
•
• }
• interfaceE obj=new interfaceE();
• obj.show1();
• obj.show2();
• obj.show3();
• }
}

77
Differences between abstract class and interface
Abstract class Interface
Abstract class can have abstract and Interface can have only
non-abstract methods. abstract methods.
2) Abstract class doesn't support Interface supports multiple

multiple inheritance. inheritance.
3) Abstract class can have final, non- Interface has only static and final
final, static and non-static variables.
variables.
4) Abstract class can provide the Interface can't provide the
implementation of interface. implementation of abstract class.
5) The abstract keyword is used to The interface keyword is used to

declare abstract class. declare interface.
78
Abstract class Interface
6) An abstract class can extend An interface can extend another

another Java class and implement Java interface only.
multiple Java interfaces.
7) An abstract class can be An interface can be implemented
extended using keyword "extends". using keyword "implements".
8) A Java abstract class can have Members of a Java interface are

class members like private, public by default.
protected, etc.
9)Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }
79
2.8Method in Java
• a method is a way to perform some task.
• Similarly, the method in Java is a collection of instructions that
performs a specific task.
• It provides the reusability of code.
• We can also easily modify code using methods.
• A method is a block of code or collection of statements or a set of
code grouped together to perform a operation.
• We write a method once and use it many times
• . We do not require to write code again and again.
• It also provides the easy modification of code,
• . The method is executed only when we call or invoke it.

80
• A simple Java method requires a minimum of three items:
• 1. Visibility : public, private, protected
• 2. Return Type: void, int, double, (etc.)
• 3. name: whatever you want to call the method

81
Return Values
• The void keyword, used in method should not return a value.
• If you want the method to return a value, you can use a primitive
data type (such as int, char, etc.) :

82
Java Method Parameters and Arguments
• You can pass data, known as parameters, into a method.
• Information can be passed to methods as parameter. Parameters act
as variables inside the method.
• Parameters are specified after the method name, inside the
parentheses. You can add as many parameters as you want, just
separate them with a comma.

83
Method Overloading,
• 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
• . Method overloading is one of the ways that java implements
polymorphism.
• The methods calls are resolved at compile time using method
signature. i.e. When java encounters a call to an overloaded method,
it simply executes the version of the method whose parameters
match the arguments used in the call.

84
Method Overloading…
• Compile time error occurs if compiler can not match the arguments or if
more than one match is possible.
• In addition to overloading normal methods, constructors can also be
overloaded.
• Method Signature consists of-
1. Number of arguments passed to a function.
2. Data types of arguments
3. Sequence in which they are passed.
• e.g. TestOverloading.java

85
Example : Method Overloading
• class Calculator
•{
•
• int addition(int var1, int var2)
• {
• return var1+var2;
• }
• int addition(int var1, int var2, int var3)
• {
• return var1+var2+var3;
• }
•
•}

86
• public class Additionoverloading {

•
• Calculator obj = new Calculator();
• "Addition of two operands is"+obj.addition(10, 20));
• "Addition of three operands is "+obj.addition(10, 20,
30));
•
•}
•}

87
Recursion
• Recursion is a process in which a method calls itself continuously.
• A method in java that calls itself is called recursive method.
Syntax: returntype methodname()

{
//code to be executed
methodname();//calling same method
}

88
Java Recursion Example 1: Unlimited times
• public class RE1 {

• static void p(){
• System.out.println("hello");
• p();
• }
• p();
• }
•}
89
Java Recursion Example 2: Limited times
• public class RE2 {

• static int count=0;
• static void p(){
• count++;
• if(count<=5){
• System.out.println("hello "+count);
• p();
• }
• }
• p();
• }
• }
90
Static
• The main purpose of using the static keyword is to manage the
memory so that we can use the memory efficiently
• The static keyword in Java is mainly used for memory management.
• We can apply static keyword with variables, methods, blocks
and nested classes.
• The static keyword in Java is used to share the same variable or
method of a given class.
• The static keyword is used for a constant variable or a method that is
the same for every object of a class.

91
1) Java static variable
• If you declare any variable as static, it is known as a static variable.

• The static variable can be used to refer to the common property of all
objects.
• Change in static variable value affects all objects.
• E.g. static int count;
• Static variable is shared by all the objects of the class.
• Static variables are, essentially, global variables.

92
Example Static Variable
• package amruta;
• class sv
• {
• static int c=1;
• void a1()
• {
• c=c+4;
• System.out.println("method a1 value of c="+c);
• }
• void a2()
• {
• c=c+10;
• System.out.println("method a1 value of c="+c);
• }
• }
• public class Svariable {

• sv obj= new sv();
• sv obj1= new sv();
• obj.a1();
• obj1.a2();
• }
93
Static Method
• The JVM runs the static method first
• It can be called without an Objects.
• Static method can access static members only.
• Static method is invoked using class name.
• <class name>.<method name> ( )
• Reference ‘this’ is never passed to a static method.
• main() method is a static method. It is an entry point method that is
called automatically.

94
• Syntax:
• [access specifier] static [return type] [function name] (parameter list)
•{
• //body of the function
•}
• Calling Static Function
• In Java, we cannot call the static function by using the object. It is
invoked by using the class name.
• [class name].[method name]

95
Example Static Method Call Same Class
• public class StaticMethod2 {

• static int add(int a,int b)
• {
• return a+b;
• }

• System.out.println("Addition="+add(10,20));
• }
• }
96
Example Static Method Call Another Class
• class Adder{
• static int add(int a,int b)
• {
• return a+b;
• }
• }
• public class StaticMethod {

• System.out.println(Adder.add(11,11));
• }
• }

97
static initialization blocks
• Sometimes initialization is required before main application starts, like
database connections.
• Executed before main( ) when class is loaded.
• Used for initializing static variables.
• A class can have more than one static blocks.
• If more than one static blocks exits in a program then called in the order
they appear in the source code.
static {
// manipulation of static variables
}

98
Example Static Block
• public class StaticBlock {
• static
• {
• // Print statement
• System.out.println("Static Block ");
•
• }
• System.out.println("Main Method ");
• }
• }
99
Execution Order:
• There is an order in which static block/method/variable gets

initialized.
1.Static Block
2.Static Variable
3.Static Method

100
Example :Execution Order:
• public class SBVM {

• SBVM obj=new SBVM();
• System.out.println("Static Variable=" +count);

• System.out.println("Static Method");
• }
• static int count = 3;
•
• // Called even before Main Method
• static {
• System.out.println("Static Block");
•
• }
• }
101
Use of “this” reference
• ‘this’ is a keyword in java.
• ‘this’ points to the current object.
• ‘this’ always holds address of an object which invokes the member
function.
• The keyword this can be used inside any method to refer to the current
object.
• Box(double w, double h, double d) {
this.width=w; this.height=h;
this.depth=d; }
Inside Box(), ‘this’ always refers to the invoking object.

102
• “this” can also be used to:
1. Invoke current class constructor
2. Invoke current class method
3. Return the current class object
4. Pass an argument in the method call
5. Pass an argument in the constructor call
The most common use of the this keyword is to eliminate the confusion
between class attributes and parameters with the same name .

103
Example 2:this Keyword
public class Main {
int x;
// Constructor with a parameter
public Main(int x) {
this.x = x;
}
// Call the constructor
public static void main(String[] args) {
Main myObj = new Main(5);
System.out.println("Value of x = " + myObj.x);
}
}
o/p- Value of x = 5
104
Example 2:this Keyword
• class Tk
• {
• int p;
• Tk(int p)
• {
• this.p=p;
• }
• void show()
• {
• System.out.println("p="+p);
• }
• }
• public class thiskeyword {

• Tk obj=new Tk(2);
• obj.show();
• }

105
Native Method
• The native keyword is applied to a method to show that the method is
implemented in Native Code (c,c++) using JNI(Java Native Interface).
• The ‘native’ keyword is used before a method to indicate that it is
implemented in other language.
• Native methods allow you to use code from other languages
such as C or C++ in your java code. You use them when java
doesn't provide the functionality that you need.
• A method marked as native cannot have a body and should end with a
semicolon:
• [ public | protected | private] native [return_type] method ();
• Its used to improve the performance.
Its used for Machine level communication.

106
Native Method
• We can use them to:
• implement an interface with system calls or libraries written in other
programming languages
• access system or hardware resources that are only reachable from the
other language
• integrate already existing legacy code written in C/C++ into a Java
application
• call a compiled dynamically loaded library with arbitrary code from Java

107
Class Native
{
Static
{
System.LoadLibrary(“Native library path”);
}
public native void m();
}
Class Test
{
public static void main(String[] args)
{
Native n = new Native();
n.m();
}
}
108
Important points about native Method
• For native methods implementation is already available in old languages
like C, C++ and we are not responsible to provide implementation.
Hence native method declaration should end with ; (semi-colon).
• We can’t declare native method as abstract.
• The main advantage of native keyword is improvement in performance
but the main disadvantage of native keyword is that it breaks platform
independent nature of java.

109
Cloning Objects
• The object cloning is a way to create exact copy of an object. The 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
generates CloneNotSupportedException.
• The clone() method is defined in the Object class. Syntax of the clone()
method is as follows:
• protected Object clone() throws CloneNotSupportedException

110
Creating Copy of Java Object
• We can create a replica or copy of java object by
1. Creating a copy of object in a different memory location. This is called a
Deep copy.
2. Creating a new reference that points to the same memory location. This
is also called a Shallow copy.

111
• Shallow copy
• This basically creates a new instance of the object and copies all the data
from the original data set to the newly created instance.
• This object will have an exact copy of all the fields of source object
including the primitive type and object references.
• If we make changes in shallow copy then changes will get reflected in
the source object.
• Example:
When we do a copy of some entity to create two or more than two
entities such that changes in one entity are reflected in the other
entities as well, then we can say we have done a shallow copy.
In shallow copy, new memory allocation never required for the
other entities, and the only reference is copied to the other entities.
The following example demonstrates the same.
• Both instances are not independent.
• it will copy the reference, not value

112
Example :Shallow copy
• class ABCD
•{
• int x = 30;
•}
• public class ShallowCopyExample {

•
• ABCD obj1 = new ABCD();
• ABCD obj2 = obj1;
• obj2.x = 6;
• System.out.println("The value of x is: " + obj1.x);
•}
•}
113
• Deep Copy
• When we do a copy of some entity to create two or more than two
entities such that changes in one entity are not reflected in the
other entities, then we can say we have done a deep copy.
• In the deep copy, a new memory allocation happens for the other
entities, and reference is not copied to the other entities. Each
entity has its own independent reference.
• This means that both source and destination objects are independent of
each other. Any change made in the cloned object will not impact the
source object.
• it will copy the reference, not value

114
Example: Deep Copy
• class ABC
• {
• int x = 30;
• }
• public class DeepCopyExample1 {

• ABC obj1 = new ABC();
• ABC obj2 = new ABC();
•
• obj2.x = 6;
• System.out.println("The value of x is: " + obj1.x);
• }
• }
115
Differences Between Shallow Copy and Deep Copy
Shallow Copy Deep Copy
It is fast as no new memory is It is slow as new memory is

allocated. allocated.
Changes in one entity is reflected Changes in one entity are not

in other entity. reflected in changes in another
identity.
The default version of the clone() In order to make the clone()

method supports shallow copy. method support the deep copy,
one has to override the clone()
method.
A shallow copy is less expensive. Deep copy is highly expensive.
Cloned object and the original Cloned object and the original
object are not disjoint. object are disjoint.
116
Advantage of OOPs over Procedure-oriented
programming language
1) OOPs make 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 provide data hiding whereas in Procedure-oriented
programming language a global data can be accessed from anywhere.
3) OOPs provide 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.

117

2 Object Oriented Programming

Uploaded by

Copyright:

Available Formats

2 Object Oriented Programming

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

2 Object Oriented Programming

Uploaded by

Copyright:

Available Formats

Chapter 2

Object Oriented Programming

Prof. Amruta Deshmukh

• Object oriented programming is a model that

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

name Name=”Raj” Fill Do allocated work.

age Age=27 Calculate Get salary

address pune Print Provide personal

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

public void setDimension(int x, int y)

public int area()

Prof. Amruta Deshmukh

• To Compile: d//javac -d . A.java

Prof. Amruta Deshmukh

• Example Save D:\>javac PrivateA.java

private void msg()

public class PrivateA{

public static void main(String args[]){

A obj=new A();//Compile Time Error

Prof. Amruta Deshmukh

class Bp extends Ap{

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

• TestGarbage1 s1=new TestGarbage1();

• public static void main(String[] args) {

Prof. Amruta Deshmukh

• Constructor name is same as class name.

• Overloading refers to a technique where same name is used for another

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Java Default Constructor

• A constructor which has a specific number of

Prof. Amruta Deshmukh

Student4 s1 = new Student4(11,"Kunal");

Prof. Amruta Deshmukh

• public class TestMemberInner {

• public static void main(String[] args) {

• Outer1 obj=new Outer1();

• } Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

• public static void main(String[] args) {

• // static nested class

• public static void main(String[] args) {

• MotherBoard.USB usb = new MotherBoard.USB();

3.Method Local Inner Classes

Prof. Amruta Deshmukh

• public static void main(String[] args) {

Prof. Amruta Deshmukh

• An inner class with no name is called anonymous inner class.

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh

Prof. Amruta Deshmukh