JAVA PART 2

• Fundamental of oops:
Object: It is a Block of Memory which can have multiple variables
and methods in it.
*) Every Object will have reference(Address).
*) An Object represents realworld entity/object.
*) It can store Hetrogeneous type of data.
Realworld Object: Anything which has existence in real world is
known as Realworld object.
Ex: Car,laptop,Tv etc…….
*) Every object will have its own properties & behaviours.
Note: Since the states & behaviours belongs to one particular object
, If I need to store all these things we need one dedicated memory
location(Container). But we don’t have any predefined datatype
which helps to create such container.
Hence we can design our own datatype with the help of a class,
Which can be used as non-primitive datatype.

 Class:
*) Class is a keyword.
*) It is used to design a user defined non-primitive datatype to store
the details of object.
*) It can also be considered as blueprint of an object.
*) We need class for execution of program.
*) In a class we can create members like methods( to store
behaviours of an object) as well as variable(to store the states of
object).
*) Every classname can be a Non-primitive datatype.
*) The java language also comes up with lot of built-in classes
i.e, String, System etc……
Ex: class Employee
{
// design variables to store states.
// design methods to store behaviours.
}

Note:
*) The non-primitive datatype will have only default values i.e null.
*) They will not be having any default size.
*) Since the name of the class itself can be used as a non-primitive
datatype.
*) we can have any members of non-primitive datatype in java.

Members of Class: Anything which is declared within class block is

known as members of the class.
Ex: Methods, Variables, Initializers, Constructors etc….
 The members of the class cab be classified into 2 Types..
1.) Static Members of class.
 2.) Non-Static Members of class.

1.) Static Members of class:

Any members of the class which is prefixed with static modifier is
known as static member of class.
In java we have Following static members.
• Static Method
• Static Variable
• Static Initializers.

i) Static Methods: A method which is prefixed with static modifier is

known as static methods.
*) The static members will have the memory allocated inside class
static area.
*) Since the static members get the memory inside class static area,
they also known as class members.
*) A block which belongs to a static member is known as Static
Context.
*) For executing a Static Context we will have a frame getting created
inside Stack Area, which is known as Static Frame.

*) Every static frame will have a built-in reference pointing to its

class-static area.
*) The static members of the class can be used within the static
context in the following ways…
i.) Directly with the help of members name or member [Link].)
with the help of class using Access operator(.).

Access Operator(.) :
*) It is a Binary Operator.
*) It is used to access a member present in another class.

How to use a static members of one class inside static context of

another class ?
We can use static members inside another class with the help of
classname along with access operator.
ii) Static Variable: A Global Variable which is prefixed with static
modifier / keyword is known as Static Variable.
*) It should be declared inside class block. Note:
A local variable cannot be made static.

Points to be Remember:-
1.) A static variable gets its memory allocated inside class static area.
2.) Since all static variables will be present inside class static area,
they are also known as Class Variables.
3.) A static variable will be assigned with default values.
4.) A static variable can be used anywhere within the class also in a
different class.
• same class: Directly using variable name.
• diff class: With the help of classname as reference.
5.) A static variable of one class can be accessed inside another class
with the help of classname.
6.) In java we can have local variable as well as global variable with
the same name.
7.) In such situations the highest priority will be given the local
variables.
8.) Global scope variable can be used inside all the members of the
class., whereas the local variables can be used only inside the block
whereit is declared.

• Static Initializers: Initializers are the members of the class which

are used for initialization purpose.
In java we have two types of Initializers:
• Static declare & Initialization statement.
• Static block.

1.) Static declare & Initialization statement: The static Initializergets

executed during the loading process of a class.
*) The static initializers gets executed only once for class loading.
Syntax: static datatype identifier= value/exp;
2.) Static block: An Anonymous block which is prefixed with static
modifiers is known as static block.
*) It is also static Initializer.
Syntax:
 static
{

Note:

// java stmts;
}

The static block gets executed during the loading process of

class ( i.e: before the execution of main method).

*) The static block gets executed only once for the loading process ofa
class.

Characteristics of Static Block:

• It doesn’t have a name.
• It doesn’t have a return type.
• It doesn’t have a formal arguments.
• It cannot accept any inputs from the user.
• The programmer cannot call it explicitly.

Note: Inside a class we can have more than one static block & they
gets executed in top to bottom order.
2.) Non-Static Members of class:
Any member declared inside class block without prefixing static
modifier is known as Non-static member of a class.
In java we have following Non-static members
• Non-static Variable.
• Non-static Method.
• Non-static Initializers.
• Non-static Constructor.

Note:
*) The non-static members gets their memory allocated insideobject.
*) If we need to access any non-static members…. The first thing we
must do id create an object.

What is Object?
*) An object is a block of memory created during in runtime inside
heap area.
*) The object also known as Instance Of A Class.
*) The process of creating an object is known as INSTANCIATION.
Syntax to create an object:
new constructor of the class;

Syntax for Constructor of the class:

Classname();
 Therefore the actual syntax of object creation is:
new classname();

new:
*) new is a keyword.
*) It is a unary operator.
*) It is used to create an object along with constructor of the class.
*) new will create a block of memory inside heap area and it will
return the address of it after the loading process is completed.
*) The type of address generated for the object will always be specific
to its class. The address of object generated will always be inthe
below format:
classname@hexadecimal value

Constructor:
Constructor are used to load the non-static members into the object.

Note:
1.) We can have multiple objects created for one single class.
2.) Everytime we create a new object, it will create a new block of
memory with different address.
3.) Everytime we create an object , the non-static members will be
loaded into an object.
Non-Primitive Datatypes:
*) They are user defined datatypes which are used to store the
following things:
• The default values of non-primitive datatypes i.e null.
• Address of an object.
*) The variables which are created using non-primitive datatypes is
known as Non-primitive variables / Reference Variables.

 Reference Variable: A variable which is created for the non-

primitive datatypes is known as Reference variables.
*) The Reference Variables are used to store address of object.
Syntax to create reference variable: classname identifier;

Note:
Inside static context we can access static members in 3 ways:
• Directly with the help of member name.
• With the help of classname & access Operator.
• With the help of address of the object.
Inside a static context we can access non-static members in
following ways:
i) Only with the help of Address of the object.

• Non-static Variable: A variable which is not prefixed with static

modifier is known as non-static variable.
*) They gets their memory allocated inside object created in heap
area.
*) Non static variable can be accessed with the help of object
reference or address.
*) Non static variables will be allocated in every object of the class
created.
*) Non static variables initialized with the default values.

• Non-static Method: A method which is not prefixed with static

modifier is known as non-static method.
*) Non-static method gets their memory allocated inside object
created in heap area.
*) A block which belongs to non-static method is called as non-static
context.
*) Non-static methods can be accessed inside static context of same
class using Object address/ reference.
*) Non static Methods will be allocated in every object of the class
created.
*) Inside Non-static context, we can use both static & Non-static
members of the same class directly without any reference.

Non-Static Context:
Any block or Any instruction which belongs to Non-static member of
a class is known as Non-static Context.
Note:
1.) We can use the Non-static members of the class inside Non-static
Context directly.
2.) We can use static members of the class inside non-static context
directly.

Constructor:
Constructor is a special non-static members which is used to load all
the non-static members of a class into the object.
Note:
1.) The name of the constructor must be same as that of classname.
2.) The constructor is just similar to a method except the returntype.
3.) Constructor doesn’t return anything after the execution, hence
constructor has no returntype.
4.) In java every class created must and should have a constructor.
5.) Therefore, the compiler will always check whether a programmer
has created atleast one constructor inside the class or not.
6.) If it is not created , then compiler will add a constructor into the
class file such constructors are known as Default Constructor.

Types of Constructors
1.) Default Constructor
2.) User-Defined Constructor.
i.) No-Argument Constructor.
ii.) Parameterized Constructor.
1.) Default Constructor: A No-argument constructor added by the
compiler during the compilation is known as Default Constructor.
*) It will be added only when the user forgets to create even a single
constructor inside the class.

2.) User-Defined Constructor: The constructor created by the users

or programmers are known as user-defined constructor.
Syntax to create Constructor:
[modifier] classname ([Formal Arguments])
{
//java stmts;
}
• No-Arguments Constructor: A constructor which doesn’t
have a formal arguments declared is known as No-
arguments
• Constructor.

Note: Whenever we create an object using No-Argument

Constructor, we need to initialize the states using extra-instructions
which is the main disadvantage of No-argument Constructor ,i.e we
will not be able to initialize the states of the object during object
creation itself.

*) To Overcome this Problem ,java Provides us one more member

known as parameterized constructor.
ii) Parameterized Constructor: A constructor which has a formal
arguments created during declaration is known as Parameterized
Constructor.
*) The Parameterized Constructor are used for initializing states of
object.

this:
*) “this” is a keyword.
*) It is a non-static variable which can be used only inside non-static
context.
*) “this” keyword will always have the address of the current object.

Purpose of this keyword:

*) It is used to access non-static members of the class.
*)Whenever we are in a situation where global variable & local
variable are having the same name.. to access the global variable we
can use “this” keyword

Non-Static –Initializer

 In java we have following non-static-initializers.

i.) Non-static declare & initialization statement. ii.)
Non-static block.
i.) Non-static declare & initialization statement:
Syntax: Datatype identifier=value/Expression;
ii) Non-static block: An Anonymous block which is not prefixed with
static modifier is known as Non-static block.
*) The non-static blocks gets executed during loading process of
object i.e, it gets executed for each & every object created.
*) If we have more than one non-static block inside the class, they
gets executed in top to bottom order.

Purpose of Non-static block:

1.) The Non-static block is use to count the number of objects
created.
2.) Usage of non-static block in the realtime , The Non-static blocks
are used to generate the Id’s automatically to the object.

ENCAPSULATION
The process of binding both states and behaviours of an object
together is known as Encapsulation.
*) We can achieve Encapsulation with the help of class.

Data Hiding: The Process of restricting the direct access to the statesof
the class but providing controlled access with the help of behaviours of
the same class is known as Data Hiding.
*) Data Hiding is possible only inside encapsulated class.
Steps to achieve DataHiding:
1.)Prefix the data member with the help of private access
modifier.
2.) Define the getter & setter method based on Requirement.

Private:
*) It is a Keyword.
*) It is a access modifier.
*) Any members which is prefixed with private access modifier canbe
accessed only within the same class.

1.) Getter Method: It is a Method which is used to print the private

members data from different class.
*) It returns the data of members which has to be read.
Syntax: Datatype of private_Mem getPrivateMemName()
{
Return Private_Mem_name;
}

2.) Setter Method: It is a Method which is used to modify the data of

private member of different class.
*) Setter method must always accept an input , it must have formal
arguments.
Syntax: void setPrivateMemName ( DatatypeofprivateMem ident)
 {
[Link]=identifier;
}
NOTE: we can achieve the flexibility of accessing the private
members data in following ways:
1.)Readable
2.)Readable & Modify3.)Only
Modify
4.)Not Readable & Not Modifiable

RELATIONSHIP
Relationship means some Connection or some type of bond
between two Objects.
The relationship between objects can be achieved with the help of
following way:
Is-A-relationship

Is-A-Relationship: It is just similar to a relationship between parent

and child where the child aquires all the states & behavioursof
parent.
Eg: Cardiologist is a doctor.
Student is a Person
Car is a Vehicle
Saving Account is a Account.
*) The main purpose of using Is-A-Relationship is to achieve
Generalization , where Parent object behaves like a generalized
object and Child more is Specialized Object.
*) Whatever belongs to parent ,it also belongs to child.
*) But Whatever Created by the child , it doesn’t belongs to parent.
*) Basically such relation is called as Is-a-relationship.

Note: we can achieve Is-a-relationship with the help of very

interesting concept called as Inheritance.

Inheritance: Inheritance is a design principle which is used to achieve

Is-a relationship between two Objects, where one object will aquire
all the states & behaviours of another object.
Parent Object/Class: A Class which provides states & behaviours to
another Class is known as Parent Object/Class.
*) Parent object is also known Super Object/BaseObject/Generalized
Object.

Child Object/Class: A Class which recieves states & behaviours

from another Class is known as Child Object/Class.
*) Child class is also known as Sub / Derived /Specialized class/Object

Note: In java we can achieve Inheritance using following keywords.

• extends
• implements

• extends: extends keyword can be used between 2 class or 2

Interface.
• implements: implements keyword is used when I want to achieve
a inheritance between Interface & Class.
( will understand about Interface & implements keyword in
Abstraction ).

Types of Inheritance
1.) Single-level Inheritance
2.) Multi-level Inheritance
3.) Hierarchical Inheritance
4.) Multiple Inheritance
5.) Hybrid Inheritance

1.) Single-level Inheritance: An Inheritance of one level is known as

Single-level Inheritance.
Or
Inheritance between one child and one parent is known as
Single-level Inheritance.

2.) Multi-level Inheritance: An Inheritance of more than one level is

known as Multi-level Inheritance.
3.) Hierarchical Inheritance: An Inheritance where one parent will
have more than one child at the same level is known as hierarchical
Inheritance.

4.) Multiple Inheritance: An inheritance where one child will have

more than one parent in the same level is known as Multiple
Inheritance.
NOTE: Multiple Inheritance is not possible in java with the help of
only class.
*) It can be achieved with the help of Inheritance.
Diamond Problem: The ambiguity in multiple Inheritance , which
arises when a super class member is tried to call from a subclass is
known as diamond problem.

5.) Hybrid Inheritance: It is a Combination of two or more

Inheritance.

*) Non-Primitive TypeCasting: The Process of converting one Non-

primitive type to Another Non-primitive type, we call it as Non-
primitive typecasting.
*) We can achieve Non-primitive typecasting only when there is Is-a-
relationship.
 Types of Non-primitive Typecasting
• Upcasting
• Downcasting

• Upcasting: The Process of Converting Subclass reference type into

Super class reference type is known as Upcasting.

*) Creating an Object of Subclass, and storing it’s address into a

reference of type superclass.
*) With Upcasted reference we can access only superclass
members/properties.
*) In order to achieve Upcasting , Is-a relationship is mandatory.
*) Upcasting will be done implicitly, hence it is also known as Auto
Upcasting.
Disadvantages of Upcasting:
• Whenever we upcast one reference type to its parent type,
we will not be able to access subclass members with the
help of superclass reference.
Note: To overcome the problem of Upcasting we will go for
Downcasting.
 Advantages of Upcasting:
• Upcasting helps us to create a generalized Container inside
which we can store any of the subclass reference.
• Downcasting: The process converting Super class reference type
into sub class reference type is known as Downcasting.
*) Downcasting will not be done implicitly, we must do it Explicitly
with the help of Typecast Operator.
*) In order to achieve Downcasting , Upcasting is Mandatory.
 Advantages of Downcasting:
The Main advantage of Downcasting is we will be able to access the
members of subclass now.

POLYMORPHISM
*)Polymorphism is a Greek word.
*) Where Poly means Many, & Morphism means Forms..
(Many Forms).
*) Polymorphism is nothing but having multiple behaviours withsame
name is known as Polymorphism.
Or
*) It is the ability of members to exhibits more than one forms is
known as polymorphism.
In java we can achieve Polymorphism in two ways:
• Compile Time Polymorphism.
• Runtime Polymorphism.

• Compile Time Polymorphism: If the Implementation of the

member has to be used is decided by the compiler during
compilation, then we call it as Compile Time Polymorphism.
*) The decision is taken by the Compiler.
In java , we have following Compile time polymorphisms.
1.)Method Overloading.
2.)Constructor Overloading.

1.) Method Overloading: A class having methods with same name

but different formal arguments is known as Method Overloading.
*) Method Overloading is an example of compile time polymorphism
as the compiler decides which implements to be executed based on
the actual arguments passed hence it is known as compile time
Polymorphism.
2.) Constructor Overloading: A class having constructors with same
name but different formal arguments is known as Constructor
Overloading.
*) Constructor Overloading is an example of compile time
polymorphism as the compiler decides which implements to be
executed based on the actual arguments passed hence it is known as
compile time Polymorphism.

Method Shadowing is also example of compile time

polymorphism, as the compiler who decides which method to be
used based on:
1.)Place of usage.
2.)Type of reference variable created.
ii) Run Time Polymorphism: In the Runtime Polymorphism , the
binding between method call stmt & method Implementation to be
executed.. happens during Runtime. Hence it is known as Runtime
Polymorphism.
Note: In Runtime Polymorphism Whatever compiler will see may not
get executed.
*) We can achieve Runtime Polymorphism with the help of
Method Overriding.

1.) Method Overriding: The process of providing new

Implementation to the Super class methods from subclass is known
as Method Overriding.
Note: Rule of Method Overriding is just similar to rules of method
shadowing, but here we have “Non-static Methods” instead of
“static methods”.
*) Method Overriding is an Example for Runtime Polymorphism Since
which implementation to be executed is decided during Runtime
based on type of Object created.
Note: static methods cannot be overridden.

ABSTRACTION
Abstraction is used to provide only the necessary details or essential
features of the object & hide the implementation of it from the user.
In java we can achieve Abstraction with the help of :-
• Class
• Interface
• Abstraction with the help of Class:-
1.) With the help of class we can achieve Abstraction from 0 to 100%2.)

Abstraction class can have two types of Methods

w.r.t. Abstraction:
a.) Concrete Method

b.) Abstract Method

a.) Concrete Method: A Method which has Method implementation
is known as Concrete Method.
Syntax: [modifiers] returntype Methodname([formal Arguments])
{
// java stmts;
}
Ex: public int test() {
[Link](“From Test”);
return 10;
}

b.) Abstract Method: A method which is incomplete, which doesn’t

have a body is called as Abstract method.
Or
A method which doesn’t have Method implementation is known as
Abstract Method.
*) It is mandatory abstract method starts with abstract & ends with
semicolon.
Syntax: abstract [Access modifier] returntype Methodname([F A]);
Ex: abstract public void add(int a, int b);

With Respect to Abstraction we can classify classes into two types:

1.)Abstract Class

2.)Concrete Class
1.) Abstract Class: A class which is prefixed with abstract modifier is
known as abstract class.
Ex: abstract class A1
{
// java stmts;
}
When Should we make a class Abstract ?
1.) If we have an Abstract method declared inside the class.
2.) If we have an Abstract method Inherited but not overridden.

Important Points To Be Remembered About Abstract Class:

1.) Abstract classes have Constructors.
2.) Abstract classes can have both Concrete Method & Abstract
Method.
3.) We can make class Abstract even if it is not having the Abstract
Method.
4.) Variable Cannot be Abstracted.
5.) We cannot Instantiate for abstract class i.e, We can’t create
object for Abstract Classes.
6.) Static Members can’t be abstracted.
7.) We cannot make Static Method Abstract.
8.) The concept of Abstraction is Valid only for Non-static Members.
9.) Private members can’t be prefixed with a Abstract Modifier.
10.) final members can’t be Abstracted.

2.) Concrete Class: A class which is not prefixed with Abstract

modifier is known as Concrete class.
*) A concrete class cannot have any Abstract Method.
Concrete Implementing Class:-
A class inside which we provide implementation to all the abstract
methods using Method Overriding is Known as Concrete
Implementing class.
 Steps to create a concrete implementing class:-Step1:
Create a Subclass for the Abstract class.
Step2: Provide Implementation to all the methods which is present
inside Abstract class.

• Interface:
*) It is a Keyword.
*) Interface is a user defined Non-primitive datatype which is used to
achieve multiple Inheritance & 100% Abstraction.
Syntax to create Interface:
Interface InterfaceName
{
// java stmts;
}

Note:
*) By default interface is an abstract member.
*) we cannot create an Object for interface.
*) we can compile an interface & generate a class file for that.
*) we cannot make an interface either private or protected, It can be
either default or public.
*) we cannot make an interface as final member.

Members we can have inside Interface:

1.)Inside interface we can have static methods.
2.)Inside interface we can have public abstract method.
3.)Public static final variable is allowed.

Note:
*) Methods inside interface will have public & abstract by default, so
we cannot have body for abstract method.
*) We cannot update or reinitialize the variable bcz by default
variable will be prefixed with public static & final modifiers.
*) Without initializing we cannot use final variable , so it ismandatory
to initialize variables inside interface.

Members we cannot have inside Interface:

1.) Non-static variable Not allowed.
2.)Non-public abstract methods Not allowed.
3.)Non-public static methods not allowed.
4.) Final abstract methods.
5.) Static block & Non-static block.6.)
Constructors & Initializers.
7.) Private & Protected members.
8.) Non-final static variables.

Inheritance w.r.t. Interfaces:

*) Inheritance between interface & interface can be achieved with
the help of extends keyword.
*) Inheritance between class & interface can be achieved with the
help of implements keyword.
Note:
1.) The static methods of interfaces are not inherited.
2.) The Abstract methods & the public static final variables will be
inherited.

Case1: Interface Inheriting Interface.

*)An Interface can inherit more than one interfaces with the help of
extends keyword.
 Case2: A class inherits interface.
• A class can inherit Interface using implements keyword.
*) implements is represented using dotted line.
Ex: interface A1
{

}
Class B implements A1
{
}
• A class can inherit any number of interfaces.
Ex: interface A1{ interface A2{
} }

Class B implements A1,A2{

}

3.) A class can inherit one class & any no. of interfaces. Ex:
interface A1{} interface A2{} class A3{}
Class B extends A3 implements A1,A2{}

Note: Whenever a class is inheriting from both the types of members

i.e. A class as well as interfaces, we must always make sure we use
extends keyword first & then implements, else we get CTE.
4.) Interface cannot inherit class, it is not possible in java.