OOPS

CONCEPTS
MODULE-3
 SYLLABUS
• Introducing Classes: Class fundamentals, Declaration Objects, Assigning Object
Reference Variables, Introducing Methods, Constructors, this keyword, Garbage
Collection.

• Inheritance and Polymorphism: Inheritance Basics, Types of Inheritance,

Benefits, Member Access Rules, Constructor and Calling Sequence, Abstract
Classes, Super and final keywords, Method Overloading and Method Overriding.

• Interfaces: Defining an Interface, Extending Interfaces, Implementing Interface,

Accessing Interface Properties.
INTRODUCING CLASSES
PART-A
 INTRODUCING CLASSES
• The class is at the core of Java. It is the logical construct
upon which the entire Java language is built because it
defines the shape and nature of an object.

• As such, the class forms the basis for object-oriented

programming in Java.

• Any concept you wish to implement in a Java program

must be encapsulated within a class.
 CLASS FUNDAMENTALS
• The most important thing to understand about a class is that
it defines a new data type.

• Once defined, this new type can be used to create objects

of that type.

• Thus, a class is a template for an object, and an object is an

instance of a class.
 CLASS FUNDAMENTALS
The General Form of a Class
• When you define a class, you declare its exact form and
nature.

• You do this by specifying the data that it contains and the

code that operates on that data.

• While very simple classes may contain only code or only

data, most real-world classes contain both.
 CLASS FUNDAMENTALS
The General Form of a Class
• A class is declared by use of the
class keyword.

• Collectively, the methods and

variables defined within a class
are called members of the
class.
 CLASS FUNDAMENTALS
The General Form of a Class
• Variables defined within a class are called instance
variables because each instance of the class contains its
own copy of these variables.

• Thus, the data for one object is separate and unique from
the data for another.
 CLASS FUNDAMENTALS
A Simple Class
• Here is a class called Box that defines three instance
variables: width, height, and depth.

• It is important to remember that a class declaration only

creates a template; it does not create an actual object.
 CLASS FUNDAMENTALS
A Simple Class
• Thus, the preceding code does not cause any objects of type
Box to come into existence.

• To actually create a Box object, you will use a statement

like the following:

Box myBox=new Box();// create a Box object called

myBox
 CLASS FUNDAMENTALS
A Simple Class
• Every Box object will contain its own copies of the instance
variables width, height, and depth.

• To access these variables, you will use the dot (.) operator.

• The dot operator links the name of the object with the
name of an instance variable.
 DECLARING OBJECTS
Obtaining objects of a class is a two-step process

• First, you must declare a variable of the class type. This

variable does not define an object. Instead, it is simply a
variable that can refer to an object.

• Second, you must acquire an actual, physical copy of the

object and assign it to that variable. You can do this using
the new operator.
 DECLARING OBJECTS

• This statement combines the two steps just described. It can

be rewritten like this to show each step more clearly:

• The first line declares mybox as a reference to an object of

type Box.
• After the second line executes, you can use mybox as if it
were a Box object.
 ASSIGNING OBJECT REFERENCE VARIABLES

• Object reference variables act differently than you might

expect when an assignment takes place.

• For example, what do you think the following fragment

does?
 ASSIGNING OBJECT REFERENCE VARIABLES

• After this fragment executes, b1 and b2 will both refer to

the same object.

• It simply makes b2 refer to the same object as does b1.

• Thus, any changes made to the object through b2 will affect

the object to which b1 is referring, since they are the same
object.
 ASSIGNING OBJECT REFERENCE VARIABLES

• Although b1 and b2 both refer to

the same object, they are not linked
in any other way.

• For example, a subsequent

assignment to b1 will simply
unhook b1 from the original object
without affecting the object or
affecting b2.
 INTRODUCING METHODS
• Classes usually consist of two things: instance variables and
methods.
• This is the general form of a method:

• type specifies the type of data returned by the method.

• The name of the method is specified by name.
• The parameter-list is a sequence of type and identifier pairs
separated by commas.
 INTRODUCING METHODS
ADDING A METHOD TO THE BOX CLASS
• Although it is perfectly fine to create a class that contains only data,
it rarely happens.

• Most of the time, you will use methods to access the instance
variables defined by the class.

• In addition to defining methods that provide access to data, you can

also define methods that are used internally by the class itself.
 INTRODUCING METHODS
RETURNING A VALUE
• For example, what if another part of your program wanted to
know the volume of a box, but not display its value?

• A better way to implement volume( ) is to have it compute

the volume of the box and return the result to the caller.
 INTRODUCING METHODS
ADDING A METHOD THAT TAKES PARAMETERS
• While some methods don’t need parameters, most do.
Parameters allow a method to be generalized.

• That is, a parameterized method can operate on a variety of

data and/or be used in a number of slightly different
situations.
 INTRODUCING METHODS
ADDING A METHOD THAT TAKES PARAMETERS

• square( ) is now a general-purpose method that can compute

the square of any integer value, rather than just 10.
 INTRODUCING METHODS
ADDING A METHOD THAT TAKES PARAMETERS
• It is important to keep the two terms parameter and argument
straight.

• A parameter is a variable defined by a method that receives a

value when the method is called.

• An argument is a value that is passed to a method when it is

invoked.
 CONSTRUCTORS
• Even when you add convenience functions like setDim( ), it
would be simpler and more concise to have all of the setup
done at the time the object is first created.

• The requirement for initialization is so common, Java

allows objects to initialize themselves when they are created.

• This automatic initialization is performed through the use of

a constructor.
 CONSTRUCTORS
• A constructor initializes an object immediately upon
creation.

• It has the same name as the class in which it resides and is

syntactically similar to a method.

• Once defined, the constructor is automatically called when

the object is created, before the new operator completes.
 CONSTRUCTORS
• Let’s reexamine the new operator. As you know, when you
allocate an object, you use the following general form:

• When you do not explicitly define a constructor for a class,

then Java creates a default constructor for the class.

• The default constructor automatically initializes all instance

variables to their default values.
 CONSTRUCTORS
• PARAMETERIZED CONSTRUCTORS
 THE this KEYWORD
• Sometimes a method will need to refer to the object that
invoked it. To allow this, Java defines the this keyword.

• this can be used inside any method to refer to the current

object.

• That is, this is always a reference to the object on which the

method was invoked.
 THE this KEYWORD
• You can use this anywhere a reference to an object of the
current class’ type is permitted.

• To better understand what this refers to, consider the

following version of Box( ):

• Inside Box( ), this will always refer to the invoking object.

 THE this KEYWORD

INSTANCE VARIABLE HIDING

• As you know, it is illegal in Java to declare two local
variables with the same name inside the same or enclosing
scopes.

• Interestingly, you can have local variables, including

formal parameters to methods, which overlap with the
names of the class’ instance variables.
 THE this KEYWORD

INSTANCE VARIABLE HIDING

• However, when a local variable has the same name as an
instance variable, the local variable hides the instance
variable.

• This is why width, height, and depth were not used as the
names of the parameters to the Box( ) constructor inside the
Box class.
 GARBAGE COLLECTION
• In some languages, such as C++, dynamically allocated
objects must be manually released by use of a delete
operator.

• Java takes a different approach; it handles deallocation for

you automatically.

• The technique that accomplishes this is called garbage

collection.
 GARBAGE COLLECTION
• When no references to an object exist, that object is assumed to be
no longer needed, and the memory occupied by the object can be
reclaimed.

• The garbage collector in Java can be called explicitly using the

following method:
System.gc();

• Garbage collection only occurs sporadically during the execution

of your program.
 GARBAGE COLLECTION

THE finalize() METHOD

• Sometimes an object will need to perform some action
when it is destroyed.

• For example, if an object is holding some non-Java resource

such as a file handle or character font, then you might want
to make sure these resources are freed before an object is
destroyed.
 GARBAGE COLLECTION
THE finalize() METHOD
• To handle such situations, Java provides a mechanism called
finalization.

• By using finalization, you can define specific actions that

will occur when an object is just about to be reclaimed by
the garbage collector.
 GARBAGE COLLECTION
THE finalize() METHOD
• To add a finalizer to a class, you simply define the finalize( )
method.

• The finalize( ) method has this general form:

 INHERITANCE
AND POLYMORPHISM
PART-B
 INHERITANCE BASICS
• Inheritance is one of the key features of OOP.

• The idea behind inheritance in Java is that you can create

new classes that are built upon existing classes.

• When you inherit from an existing class, you can reuse

methods and fields of the parent class. Moreover, you can
add new methods and fields in your current class also.
 INHERITANCE BASICS
• Inheritance represents the IS-A relationship which is also known
as a parent-child relationship.

• Sub Class/Child/ Derived Class: Subclass is a class which

inherits the other class. It is also called a derived class, extended
class, or child class.

• Super Class/Parent/ Base Class: Superclass is the class from

where a subclass inherits the features. It is also called a base class
or a parent class.
 INHERITANCE BASICS
• To inherit a class, you simply incorporate the definition of
one class into another by using the extends keyword.

• The general form of a class declaration that inherits a

superclass is shown
 TYPES OF INHERITANCE
Java supports different types of inheritance. These are:

• Single Inheritance

• Multilevel Inheritance

• Hierarchical Inheritance

• Multiple Inheritance

• Hybrid Inheritance
 TYPES OF INHERITANCE

SINGLE INHERITANCE
• When a single class gets derived from its base class, then this
type of inheritance is termed as single inheritance.

• class A as the base class, and class B gets

derived from that base class.
 TYPES OF INHERITANCE

MULTILEVEL INHERITANCE
• In multilevel inheritance, a subclass
extends from a superclass and then the
same subclass acts as a superclass for
another class.
 TYPES OF INHERITANCE

HIERARCHIAL INHERITANCE
• In hierarchical inheritance, multiple subclasses extend from a
single superclass.
 TYPES OF INHERITANCE

MULTIPLE INHERITANCE
• In multiple inheritance, a single subclass extends from
multiple superclasses.
 TYPES OF INHERITANCE

HYBRID
INHERITANCE
• Hybrid inheritance is a
combination of two or
more types of
inheritance.
 BENEFITS OF INHERITANCE

Code Reusability
• Inheritance allows for code reuse and reduces the amount of
code that needs to be written.

• The subclass can reuse the properties and methods of the

superclass, reducing duplication of code.
 BENEFITS OF INHERITANCE

Abstraction
• Inheritance allows for the creation of abstract classes that
define a common interface for a group of related classes.

• This promotes abstraction and encapsulation, making the

code easier to maintain and extend.
 BENEFITS OF INHERITANCE
Class Hierarchy

• Inheritance allows for the creation of a class hierarchy, which

can be used to model real-world objects and their
relationships.
 BENEFITS OF INHERITANCE
Polymorphism
• Inheritance allows for polymorphism, which is the ability of
an object to take on multiple forms.

• Subclasses can override the methods of the superclass,

which allows them to change their behavior in different
ways.
 MEMBER ACCESS RULES
• The member access rules determines whether a sub class can
use a property of it's super class or it can only access or it can
neither access nor access.

• There are two level of access control:

• At the top level: public or package-private

• At the member level: public, private, protected

 MEMBER ACCESS RULES

• A class may be declared with the 'public' modifier, in that

case that class is visible to all classes everywhere.

• At the member level, there are three different access

modifiers are there:
• Private
• Protected
• Public
 MEMBER ACCESS RULES
• If private access modifier is applied to an instance variable,
method or with a constructor in side a class then they will be
accessed inside that class only not out side of the class.
 MEMBER ACCESS RULES
• In Java, if a class includes protected fields and methods,
then these fields and methods are accessible from the
subclass of the class.
 CONSTRUCTOR AND CALLING SEQUENCE

• While implementing inheritance in a Java program, every

class has its own constructor.

• Therefore the execution of the constructors starts after the

object initialization.

• It follows a certain sequence according to the class

hierarchy.
 CONSTRUCTOR AND CALLING SEQUENCE
• In single level inheritance, the constructor of the base class
is executed first.

• In multilevel inheritance, all the upper class constructors

are executed when an instance of bottom most child class is
created.

• A child class constructor or method can access the base

class constructor or method using the super keyword.
 ABSTRACT CLASSES
• There are situations in which you will want to define a
superclass that declares the structure of a given abstraction
without providing a complete implementation of every
method.
• That is, you want to create a superclass that only defines a
generalized form that will be shared by all of its subclasses,
leaving it to each subclass to fill in the details.
• Such a class determines the nature of the methods that the
subclasses must implement.