PPT PRESENTATION

TITLE: OBJECT-ORIENTED PROGRAMMING CONCEPTS IN JAVA

NAME: G. PREM KUMAR

 INTRODUCTION TO OOPS

DEFINITION : The way of writing the code in a proper way (or) in a structured way.

KEY BENEFITS:

 Modular
 maintainable code
 Code reusability
 Real-world modeling

FOR WRITING THE CODE IN A PROPER WAY, THEN WE SHOULD FOLLOW SOME
PRINCIPLES:

1. CLASS

2. OBJECT

3. ENCAPSULATION

4. ABSTRACTION

5. INHERITANCE

6. POLYMORPHISM
 1) WHAT IS A CLASS?

 A CLASS IS BLUEPRINT OF AN OBJECT.

 BLUEPRINT IS NOTHING BUT A PLAN OR DESIGN.
 A CLASS IS AN USER-DEFINED DATA TYPE.

2) WHAT IS AN OBJECT?

 OBJECT IS AN INSTANCE OF A CLASS WHERE,

 INSTANCE MEANS EXAMPLE, SO WE CAN CONSIDER AS OBJECT IS AN
EXAMPLE OF A CLASS.

EXAMPLE:

 PREM IS AN STUDENT.

 PREM IS AN EMPLOYEE.

 EVERYTHING IN A REAL-WORLD IS AN OBJECT.

 OBJECT IS A REAL TIME ENTITY WHICH WE CAN SEE REAL.

3) ENCAPSULATION: CODE WILL BE MODULAR (OR) SECURED

 ENCAPSULATION IS NOTHING BUT BINDING (or)WRAPPING (or)

BUNDLING THE DATA WITH RELATED FUNCTIONALITIES INTO A SINGLE
UNIT IS CALLED ENCAPSULATION.

 WHERE SINGLE UNIT CAN BE A CLASS (or) PACKAGE.

 CREATING A CLASS WITH RELATED DATA + METHODS IS KNOWN AS

ENCAPSULATION.

 ENCAPSULATION IS A COMBINATION OF DATA HIDING AND

ABSTRACTION.

1) DATA HIDING: HIDING THE DATA WITH PRIVATE KEYWORD.

 WE SHOULD STOP ACCESSING THE DATA OUTSIDE THE

CLASSES.

 AND ALSO, WE CAN DIRECTLY ACCESS WITH PRIVATE

KEYWORD.

 IT WILL GIVE PERMISSION TO READ AND MODIFY DATA BY

USING THE CONTROLLED ACCESS -SETTERS AND GETTERS.

2) ABSTRACTION: HIDING THE IMPLEMENTATION WITH ABSTRACT AND

INTERFACE.

ADVANTAGES OF ENCAPSULATION:

 SECURITY
 CODE FLEXIBILITY
 MODULARITY
 MAINTAINABILITY
3) ABSTRACTION: HIDING THE IMPLEMENTATION WITH ABSTRACT AND
INTERFACE.
 ABSTRACTION IS A FUNDAMENTAL PRINCIPLE IN OOPS THAT
FEATURES OR FOCUSES ON EXPOSING ONLY ESSENTIAL FEATURES OF
OBJECT WHILE HIDING THE COMPLEX IMPLEMENTATION DETAILS.

 IT ALLOWS DEVOLPERS TO INTERACT WITH OBJECTS AT HIGHER

LEVEL, SIMPLIFING THE USAGE AND ENHANCING CODE.


1. INTERFACE:

 INTERFACE IS A KEYWORD IN JAVA TO PROVIDE

ABSTRACTION.
 INTERFACE IS A BLUEPRINT OF A CLASS.
 INTERFACE IS A SERVICE REQUIRMENT SPECIFICATION(SRS).
 INTERFACE IS A CONTRACT BETWEEN CLIENT AND
DEVOLPERS.
 INTERFACE CONTAINS ONLY ABSTRACT METHODS AND FINAL
VARIABLES.
 ABSTRACT MEANS NO IMPLEMENTATION WHICH IS ONLY FOR
DECLARATION.
 IN INTERFACE FINAL VARIABLES WE CAN’T CHANGE UPTO 1.5
VERSION.
 FROM 1.8 VERSION INTERFACE CAN ALSO CONTAINS DEFAULT
METHODS AND STATIC METHODS.
 FROM 1.9 VERSION INTERFACE CAN ALSO CONTAINS PRIVATE
METHODS.
 WITH INTERFACE WE CAN ACHIEVE MULTIPLE INHERITANCE.

 INTERFACE ARE DIVIDED INTO 3 TYPES:

1) NORMAL INTERFACE: NORMAL INTERFACE CONTAINS ANY NUMBER

OF ABSTRACT METHODS, DEFAULT METHODS, STATIC METHODS,
PRIVATE METHODS THEN WE WILL CONSIDER AS NORMAL
INTERFACE.

2) FUNTIONAL INTERFACE: IN INTERFACE WHICH CONTAINS ONLY

SINGLE ABSTRACT METHODS (SAM) AND ANY NUMBER OF STATIC
METHODS, DEFAULT METHODS BUT THE ABSTRACT METHODS
SHOULD BE ONLY ONE.FUNCTIONAL INTERFACE PURPOSE IS TO
WORK WITH LAMBDA EXPRESSIONS.

3) MARKER INTERFACE: IN ANY INTERFACE DOESN’T CONTAIN ANY

METHODS THEN WE WILL CONSIDER AS MARKER INTERFACE .
 2 . ABSTRACT:
 AN ABSTRACT CLASS IS A CLASS DECLARED WITH ABSTRACT
KEYWORD.IT CAN’T BE INSTANTIATED DIRECTLY AND MAY
CONTAIN BOTH ABSTRACT METHODS (WITHOUT
IMPLEMENTATION) AND CONCRETE METHODS (WITH
IMPLEMENTATION).

 ABSTRACT KEYWORD WE USE FOR METHODS AND CLASSES.

 IF WE GIVE ABSTRACT FOR METHODS THERE WILL BE NO

IMPLEMENTATION.

 IF WE GIVE ABSTRACT FOR CLASSES, WE CAN’T CREATE AN

OBJECT FOR THOSE CLASSES.SO WHENEVER WE DON’T WANT
TO CREATE AN OBJECT FOR CLASSES THEN WE WILL GO FOR
ABSTRACT FOR CLASSES.

 IF A CLASS CONTAIN ABSTRACT METHOD, THAT CLASS MUST

BE ABSTRACT.

 ABSTRACTION WITH ABSTRACT CLASS IS SOMETHING LIKE

PARTIAL ABSTRACTION.

ADVANTAGES OF ABSTRACTION:

1. REDUCE COMPLEXITY.

2. AVOID CODE DUPLICATION.

3. SECURITY.
3. INHERITANCE:

 INHERITANCE IS NOTHING BUT GETTING THE PARENT CLASS

FUNCTIONALITIES INTO CHILD CLASS USING EXTENDS KEYWORD TO
ACHIEVE CODE REUSEABILITY.

 INHERITANCE WILL CONSIDER AS:

1. HAS-A RELATIONSHIP

2. IS-A RELATIONSHIP

 INHERITANCE WILL USE WHENEVER THERE IS A RELATIONSHIP

BETWEEN TWO CLASSES THEN ONLY, WE WILL USE INHERITANCE.

 EVERY CLASS OBJECT IS A ROOT OF THE CLASSS HIERARCHY.

 EVERY CLASS HAS A OBJECT AS SUPERCLASS.

METHODS IN INHERITANCE:

 CLONE : CREATES AND RETURN THE OBJECT CLASS.

 EQUALS : INDICATES WHETHER SOME OTHER OBJECT IS EQUALS ARE

NOT.

 FINALIZE : CALLED BY THE GARBAGE COLLECTION ON A OBJECT .

 GET CLASS (): RETURNS RUN TIME CLASS OF AN OBJECT.

 HASHCODE (): RETURNS THE HASCODE VALUE OF THE OBJECT .

 TOSTRING () :RETURNS A STRING REPRESENTATION OF THE OBJECT .

TYPES OF INHERITANCE:

1. SINGLE INHERITANCE: ONE CLASS EXTENDS

ANOTHER CLASS IS CALLED SINGLE
INHERITANCE.

2. MULTI-LEVEL INHERITANCE: A CLASS IS DERIVED

FROM ANOTHER CLASS, FORMING A CHAIN OF
INHERITANCE.

3. MULTIPLE INHERITANCE: JAVA DOESN’T

SUPPORT MULTIPLE INHERITANCE WITH
CLASSES DUE TO ABIGUITY.HOWEVER IT WILL
BE ACHIEVED THROUGH INTERFACES.
 4. HIRARCHIAL INHERITANCE : MULTIPLE
SUBCLASSES INHERIT FROM A SINGLE
SUPERCLASS.

5. HYBRID INHERITANCE : A COMBINATION OF TWO

OR MORE TYPES OF INHERITANCE.

6. CYCLIC INHERITANCE: CYCLIC INHERITANCE IS

NOT POSSIBLE IN JAVA.

ADVANTAGES OF INHERITANCE:

1. CODE REUSABILITY

2. MODULARITY

3. POLYMORPHISM
 4. POLYMORPHISM: POLYMORPHISM MEANS “MANY FORMS”. THE
SPECIFICATION SHOULD NOT CHANGE BUT YOU CAN CHANGE THE
BEHAVIOUR IN CHILD CLASS.

TYPES OF POLYMORPHISM:

1. COMPILE-TIME POLYMORPHISM: IT IS ACHIEVED

THROUGH METHOD OVERLOADING.

2. RUN-TIME POLYMORPHISM: IT IS ACHIEVED

THROUGH METHOD OVERRIDING.

1. METHOD OVERLOADING:

 WITHIN THE CLASS IF TWO OR MORE METHODS WITH SAME

NAME AND DIFFERENT ARGUMENTS THEN WILL CONSIDER AS
METHOD OVERLOADING.

 IT WILL HELPFUL FOR LOSE COUPLING AND FLEXIBILITY.

RULES FOR METHODOVERLOADING :

 METHOD SIGNATURE MUST NOT BE SAME.

 RETURN TYPE OR ACCESS MODIFIERS IS NOT CONSIDERABLE.

 WHENEVER THE SPECIFICATION IS SAME AND ACTIONS SHOULD BE

DIFFERENT WITH DIFFERENT VALUES THEN WE WILL GO FOR METHOD
OVERLOADING.

EXAMPLE: PRINTLN IS A METHOD FROM PRINTSTREAM CLASS IS THE

EXAMPLE FOR METHODOVERLOADING.
 2. METHOD OVERRIDING: WHENEVER WE AREN’T SATISFY WITH
PARENT CLASS FUNCTIONALITIES THEN WE NEED TO GO FOR METHOD
OVERRIDING IN CHILD CLASS.

METHOD OVERRIDING RULES:

 METHOD SIGNATURE MUST BE SAME FROM PARENT TO CHILD.

 METHOD SIGNATURE MEANS METHODS+ARGUMENTS.

 METHOD RETURN TYPE MUST BE SAME UPTO 1.5 VERSION FOR OBJECT
TYPE.
 IF PARENT RETURN TYPE IS PRIMITIVE IN CHILD METHOD
RETURN TYPE MUST BE SAME RETURN TYPE.

 IF PARENT RETURN TYPE IS OBJECT TYPE IN CHILD

METHOD NO NEED TO BE SAME RETURN TYPE, WE CAN USE
CO-VARIENT RETURN TYPE.

 CO-VARIENT MEANS IF PARENT CLASS METHOD RETURN

TYPE IN CHILD CLASS METHOD TYPE MUST BE SAME OR
ITS SUB CLASSES.

 METHOD SCOPE OR ACCESS MODIFIERS SHOULDN’T BE REDUCED.

 IF PARENT CLASS METHODS ARE PRIVATE METHODS WE CAN’T

OVERRIDE, BECAUSE THE SCOPE IS WITHIN THE CLASS .AND IF WE
SAME METHOD AS PARENT IN CHILD, WE WILL NOT GET ANY ERROR.

 UNTIL IF WE KEEP @OVERRIDE ANNOTATION AND IT IS WORKING

INDIVIDUALLY BUT NOT OVERRIDE METHOD.

 IF WE KEEP OVERRIDE ANNOTATION WE WILL GET COMPILE TIME

ERROR.

 FINAL METHODS WE CAN’T OVERRIDE -IF PARENT CLASS METHODS

ARE FINAL, WE CAN’T OVERRIDE FINAL CLASS METHODS TO CHILD
CLASS.

 IF PARENT CLASS IS ITSELF FINAL, WE CAN’T EVEN OVERRIDE.

 IF PARENT CLASS METHODS ARE STATIC, WE CAN’T OVERRIDE BUT WE

CAN CALL IT IS OVERHIDING OR METHODHIDING.
 IF PARENT CLASS METHOD THROWS ANY EXCEPTION YOUR CHILD
CLASS METHOD NO NEED TO THROUGH THAT EXCEPTION.

 IF CHILD CLASS METHOD THROWS ANY EXCEPTION MUST AND SHOULD

PARENT CLASS ALSO MUST THROW THAT EXCEPTION.

 IF PARENT ABSTRACT CLASS METHOD IS ABSTRACT THEN ABSTRACT

METHOD MUST OVERRIDE IN CHILD CLASS .