Data Hiding

Hiding of data, so that outside person can't access data directly, by using private modifier we can implement data hiding.

class Account {

private double bal = 1000;

}

the main advantage of data hiding is we can achieve security.

Abstraction

Hiding internal implementation details and highlight the necessary set of service to users is called Abstraction, by using interfaces and abstract classes we can achieve abstraction. the main advantage of abstraction are -

• we can achieve security as no one is allowed to know internal implementation
• without effecting outside services we can change our internal implementation so enhancement will become very easy
• the main disadvantage is it increases the length of code and slow down execution

Encapsulation

Wrapping up data and corresponding method (behavior) into a single unit is known as encapsulation. if any java class follows data hiding and abstraction such type of class is said to encapsulated class. (Encapsulation = Data Hiding + Abstraction)

class Account {

private double bal;

public double getBal() {

return bal;

}

public void setBal(double bal) {

this.bal = bal;

}}

Hiding data behind method is the central concept of encapsulation, the main advantage of using encapsulation are -

• We can achieve security
• Enhancement will become very easy
• Improves modularity of the application

Note: If parent class is not tightly encapsulated then no child class is tightly encapsulated

Tightly Encapsulated class

A class is tightly encapsulated, when every data member declared as private, it improves the modularity of application.

IS-A Relationship

It also know as inheritance, by using extends keyword we can implement inheritance concept, In inheritance child class acquires all the properties of super class, and this is the main advantage so that we can achieve code re-usability.

• whatever the super class holds these all available to child class also, hence child class reference can call both super and child class.
• Parent class reference can be used to hold child class objects, by using that reference we can call only parent class methods
• we can't use child class reference to hold parent class object

Note: Java don't provide multiple inheritance concept but through interface it is possible

Has-A Relationship

It also known as composition or aggregation, there is no specific keyword to implement Has-A Relationship, mostly we use 'new' keyword, main advantage to use this concept is code re-usability but it increases dependency between the class and creates maintenance problem.

Composition vs Aggregation

In the case of composition, whenever object container destroys then all objects gets destroy automatically. there is no chance of exists of object without existing object container, Container and contained object having strong association.

In the case of aggregation, whenever object container destroys, there is no guarantee of destruction of contained objects. without existing object container there may be chance to exists objects. object container just maintains reference of contained objects, this is called weak association which is nothing but aggregation.

Overloading

If methods names are same but arguments are different then it is known as overloading. having overloading concept simplifies the programming

In overloading, method resolution always take care by compiler based on reference type. hence overloading is also considered as compile time polymorphism, static polymorphism or early binding reference type plays very important role and runtime object will become dummy overriding

In overriding, method names and arguments must be same, i.e method signature must be same until 1.4 version return type must be match but from 1.5 version onward co-variant return types are applicable, co-variant return type concept is applicable only for object type but not for primitive types.

It is also known as run time polymorphism, dynamic polymorphism or late binding, overriding method resolution is also known as dynamic method dispatch

We can't override final method, private method.

Method Hiding

All rules of method hiding are same as overriding except these following difference -

Method Hiding

• Both methods should be static
• Method resolution take care by compiler based on reference type
• It is considered as compile time polymorphism, static polymorphism or early binding.

Overriding

• Both methods should be non static
• Method resolution always take care by JVM based on run time object
• It is considered as runtime polymorphism, dynamic polymorphism or late binding.

Difference between overloading and overriding

Overloading

• Arguments must be different (at least order)
• Method signature must be different
• For return type no restriction
• For access modifiers no restriction
• private, static and final method can be overloaded
• For throws class no restriction
• Method resolution always take care by compiler based on reference type
• Also known as compile time polymorphism, static polymorphism or early binding

Overriding

• Arguments must be same (including order)
• Method signature must be same
• Return type must be same till 1.4 version, but from 1.5 version onward co-variant return types are allowed
• private, static and final method can't be override
• Size and level of checked exception we can't increase but we decrease, no restriction for unchecked exception
• Method resolution always take care by JVM based on runtime object
• Also known as run time polymorphism, dynamic polymorphism or late binding

Polymorphism

Poly represents 'many' and morphs represents 'forms', we can use same name to represent multiple forms in polymorphism. There are two types of polymorphism

Compiler Time - Overloading, Method Hiding

Run Time - Overriding

Note: Three pillar of OOPs concept is Inheritance for code re-usability, Encapsulation for security, Polymorphism for flexibility

Static control flow

At the time of class loading if we want to perform any activity, we have to define that activity inside static block because static block will be executed at the time of class loading. within a class we can take any number of static block but all these static block will be executed from top to bottom

Constructor

Object creation is not enough, we have to perform initialization then only object can provide response properly. whenever we are creating an object some piece of code execute automatically to perform initialization, this piece of code is nothing but constructor, hence the main objective of constructor is to perform initialization for the newly created object.

• Class name and constructor name must be same
• Return type concept is not applicable for constructor even void also, by mistake if we declare return type for the constructor then we won't get any error because compiler treats it as method
• The only applicable modifiers for constructor are public, private, protected, <default>

Singleton Class

For any java class if we are allowed to create only one object such type of class is called singleton class. eg. Runtime, ActionServlelt (Structs), BusinessDeligate (EJB), ServiceLocation(EJB)

The main advantage of singleton class is instead of creating a separate object for every requirement we can create single object and reuse the same object for every requirement this approach improves memory initialization and performance of the system.

Runtime r1 = Runtime.getRuntime();

Runtime r2 = Runtime.getRuntime();

Runtime r100 = Runtime.getRuntime();

Runtime is a class and getRuntime is a method

Creation of our own Singleton class

we can create our own singleton class also for this we have to use private constructor and factory method.

factory method

By using class name if we call any method and return same class object, then that method consider as factory method.

Default Constructor

• If we don't write any constructor then compiler will always generate default constructor
• If we write at least one constructor then compiler won't generate default constructor
• Hence a class can contain either programmer constructor or compiler generated constructor but not both simultaneously
• It is always no argument constructor
• The access modifier of default constructor is same as calss modifier but this rule is applicable for public and <default>
• It has no argument to call super class constructor

Instance block vs Constructor

• At the time of object creation if we want to perform initialization of instance variable then we have to go for constructor
• If we want to perform any other activity at the time of object creation then we have to go for instance block
• We can't replace constructor with instance block because constructor can take argument but instance block can't

Super( ) & this( )

The first line inside a constructor should be either super() or this(), with the constructor we can use any of them

this() - To call current class constructor

super() - To call parent class constructor

compiler provides super() as default

super(), this() vs super, this

• super( ), this( ) are constructor call, we can use only in constructor
• super, this are keywords to refer super and current class instance member, we can use anywhere except static area

Constructor Overloading

A class can contain more than one constructor with same name with different arguments, these constructor are consider as overloaded constructor, Inheritance and overriding concepts are not applicable for constructor, every class including abstract class can contain constructor but interface can't have constructor

Note: If the parent class contain some constructor then while writing child class we have to give special care to constructor, if parent class throws some checked exception then compulsory child class constructor should throw same checked exception or its parent otherwise the code will not be compile

Type Casting

Parent class reference can be used to hold child class object eg. Parent p = new child(); similarly, interface reference can be used to hold implemented class object eg. Runnable r = new thread();

syntax A b = (C) d; A and C is class or interface, b is reference variable and d is object reference or object

C and type of d must have some relationship (either parent to child or child to parent or any other) otherwise we will get compile time error 'inConvertable types found d type but required C TYPE', in type casting we are just converting only type of object not object itself.

Coupling

The degree of dependency between the components is called coupling, it reduces maintainability and doesn't promote re-usability

Cohesion

For every component a clear well defined functionality is defined such type of component is called high cohesion, without effecting remaining components we can modify any component hence enhancement will become very easy, it improves maintainability of the application and promotes re-usability of the code

Note: Loose coupling and high cohesion is good for application.