Abstraction

Abstract class in Java

A class that is declared with abstract keyword is known as abstract class. Before learning abstract class, let's understand the abstraction first.

Abstraction

1.      Abstraction is a process of hiding the implementation details and showing only functionality to the user.

2.      Another way, it shows only important things to the user and hides the internal details for example sending sms, you just type the text and send the message. You don't know the internal processing about the message delivery.

3.      Abstraction lets you focus on what the object does instead of how it does it.

 

Ways to achieve Abstaction

There are two ways to achieve abstraction in java

1.      Abstract class (0 to 100%)

2.      Interface (100%)

 

Abstract class

A class that is declared as abstract is known as abstract class. It needs to be extended and its method implemented. It cannot be instantiated.

Syntax to declare the abstract class

1.      abstract class <class_name>{}  

abstract method:- A method that is declared as abstract and does not have implementation is known as abstract method.

 

Syntax to define the abstract method

1.      abstract return_type <method_name>();//no braces{}  

Example of abstract class that have abstract method

In this example, Bike the abstract class that contains only one abstract method run. It implementation is provided by the Honda class.

1.      abstract class Bike{  

2.        abstract void run();  

3.      }  

4.        

5.      class Honda extends Bike{  

6.      void run(){System.out.println("running safely..");}  

7.        

8.      public static void main(String args[]){  

9.       Bike obj = new Honda();  

10.   obj.run();  

11.  }  

12.  }  

Output:running safely..

Understanding the real scenario of abstract class

In this example, Shape is the abstract class, its implementation is provided by the Rectangle and Circle classes. Mostly, we don't know about the implementation class (i.e. hidden to the end user) and object of the implementation class is provided by the factory method.

A factory method is the method that returns the instance of the class. We will learn about the factory method later.

In this example, if you create the instance of Rectangle class, draw method of Rectangle class will be invoked.

1.       abstract class Shape{  

2.      abstract void draw();  

3.      }  

4.        

5.      class Rectangle extends Shape{  

6.      void draw(){System.out.println("drawing rectangle");}  

7.      }  

8.        

9.      class Circle extends Shape{  

10.  void draw(){System.out.println("drawing circle");}  

11.  }  

12.    

13.  class Test{  

14.  public static void main(String args[]){  

15.  Shape s=new Circle();  

16.  //In real scenario, Object is provided through factory method  

17.  s.draw();  

18.  }  

19.  }  

Output:drawing circle

 

Abstract class having constructor, data member, methods etc.

Note: An abstract class can have data member, abstract method, method body, constructor and even main() method.

 

1.      //example of abstract class that have method body  

2.       abstract class Bike{  

3.         abstract void run();  

4.         void changeGear(){System.out.println("gear changed");}  

5.       }  

6.        

7.       class Honda extends Bike{  

8.       void run(){System.out.println("running safely..");}  

9.        

10.   public static void main(String args[]){  

11.    Bike obj = new Honda();  

12.    obj.run();  

13.    obj.changeGear();  

14.   }  

15.  }  

Output:running safely..

       gear changed

1.      //example of abstract class having constructor, field and method  

2.      abstract class Bike  

3.      {  

4.       int limit=30;  

5.       Bike(){System.out.println("constructor is invoked");}  

6.       void getDetails(){System.out.println("it has two wheels");}  

7.       abstract void run();  

8.      }  

9.        

10.  class Honda extends Bike{  

11.   void run(){System.out.println("running safely..");}  

12.    

13.   public static void main(String args[]){  

14.    Bike obj = new Honda();  

15.    obj.run();  

16.    obj.getDetails();  

17.    System.out.println(obj.limit);  

18.   }  

19.  }  

Output:constructor is invoked

running safely..

it has two wheels

30

 

Rule: If there is any abstract method in a class, that class must be abstract.

1.      class Bike{  

2.      abstract void run();  

3.      }  

Output:compile time error

 

Rule: If you are extending any abstact class that have abstract method, you must either provide the implementation of the method or make this class abstract.

 

Another real scenario of abstract class

The abstract class can also be used to provide some implementation of the interface. In such case, the end user may not be forced to override all the methods of the interface.

Note: If you are beginner to java, learn interface first and skip this example.

1.      interface A{  

2.      void a();  

3.      void b();  

4.      void c();  

5.      void d();  

6.      }  

7.        

8.      abstract class B implements A{  

9.      public void c(){System.out.println("I am C");}  

10.  }  

11.    

12.  class M extends B{  

13.  public void a(){System.out.println("I am a");}  

14.  public void b(){System.out.println("I am b");}  

15.  public void d(){System.out.println("I am d");}  

16.  }  

17.    

18.  class Test{  

19.  public static void main(String args[]){  

20.  A a=new M();  

21.  a.a();  

22.  a.b();  

23.  a.c();  

24.  a.d();  

25.  }}  

Output:I am a           I am b          I am c          I am d

Inheritance in Java

1.      Inheritance

2.      Types of Inheritance

3.      Why multiple inheritance is not possible in java in case of class?

Inheritance is a mechanism in which one object acquires all the properties and behaviours of parent object.

The idea behind inheritance is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you reuse (or inherit) methods and fields, and you add new methods and fields to adapt your new class to new situations.

Inheritance represents the IS-A relationship.

 

Why use Inheritance?

·         For Method Overriding (So Runtime Polymorphism).

·         For Code Reusability.

 

Syntax of Inheritance

1.      class Subclass-name extends Superclass-name  

2.      {  

3.         //methods and fields  

4.      }  

The keyword extends indicates that you are making a new class that derives from an existing class. In the terminology of Java, a class that is inherited is called a superclass. The new class is called a subclass.

Understanding the simple example of inheritance

As displayed in the above figure, Programmer is the subclass and Employee is the superclass. Relationship between two classes is Programmer IS-A Employee.It means that Programmer is a type of Employee.

1.      class Employee{  

2.       float salary=40000;  

3.      }  

4.        

5.      class Programmer extends Employee{  

6.       int bonus=10000;  

7.          

8.       public static void main(String args[]){  

9.         Programmer p=new Programmer();  

10.     System.out.println("Programmer salary is:"+p.salary);  

11.     System.out.println("Bonus of Programmer is:"+p.bonus);  

12.  }  

13.  }  

Output:Programmer salary is:40000.0

       Bonus of programmer is:10000

In the above example,Programmer object can access the field of own class as well as of Employee class i.e. code reusability.

 

Types of Inheritance

On the basis of class, there can be three types of inheritance: single, multilevel and hierarchical.

Multiple and Hybrid is supported through interface only. We will learn about interfaces later.

Multiple inheritance is not supported in java in case of class.

When a class extends multiple classes i.e. known as multiple inheritance. For Example

Que) Why multiple inheritance is not supported in java?

·         To reduce the complexity and simplify the language, multiple inheritance is not supported in java. For example:

1.      class A{  

2.      void msg(){System.out.println("Hello");}  

3.      }  

4.        

5.      class B{  

6.      void msg(){System.out.println("Welcome");}  

7.      }  

8.        

9.      class C extends A,B{//suppose if it were  

10.     

11.   Public Static void main(String args[]){  

12.     C obj=new C();  

13.     obj.msg();//Now which msg() method would be invoked?  

14.  }  

15.  }  

Interface in Java

1.      Interface

2.      Example of Interface

3.      Multiple inheritance by Interface

4.      Why multiple inheritance is supported in Interface while it is not supported in case of class.

5.      Marker Interface

6.      Nested Interface

An interface is a blueprint of a class. It has static constants and abstract methods.

The interface is a mechanism to achieve fully abstraction in java. There can be only abstract methods in the interface. It is used to achieve fully abstraction and multiple inheritance in Java.

Interface also represents IS-A relationship.

It cannot be instantiated just like abstract class.

Why use Interface?

There are mainly three reasons to use interface. They are given below.

·         It is used to achieve fully abstraction.

·         By interface, we can support the functionality of multiple inheritance.

·         It can be used to achieve loose coupling.

 

The java compiler adds public and abstract keywords before the interface method and public, static and final keywords before data members.

In other words, Interface fields are public, static and final bydefault, and methods are public and abstract.

Understanding 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.

Simple example of Interface

In this example, Printable interface have only one method, its implementation is provided in the A class

1.      interface printable{  

2.      void print();  

3.      }  

4.        

5.      class A implements printable{  

6.      public void print(){System.out.println("Hello");}  

7.        

8.      public static void main(String args[]){  

9.      A obj = new A();  

10.  obj.print();  

11.   }  

12.  }  

Output:Hello

Multiple inheritance in Java by interface

If a class implements multiple interfaces, or an interface extends multiple interfaces i.e. known as multiple inheritance.

1.      interface Printable{  

2.      void print();  

3.      }  

4.        

5.      interface Showable{  

6.      void show();  

7.      }  

8.        

9.      class A implements Printable,Showable{  

10.    

11.  public void print(){System.out.println("Hello");}  

12.  public void show(){System.out.println("Welcome");}  

13.    

14.  public static void main(String args[]){  

15.  A obj = new A();  

16.  obj.print();  

17.  obj.show();  

18.   }  

19.  }  

Output:Hello

       Welcome

Q) Multiple inheritance is not supported in case of class but it is supported in case of interface, why?

As we have explained in the inheritance chapter, multiple inheritance is not supported in case of class. But it is supported in case of interface because there is no ambiguity as implementation is provided by the implementation class. For example:

1.      interface Printable{  

2.      void print();  

3.      }  

4.        

5.      interface Showable{  

6.      void print();  

7.      }  

8.        

9.      class A implements Printable,Showable{  

10.    

11.  public void print(){System.out.println("Hello");}  

12.    

13.  public static void main(String args[]){  

14.  A obj = new A();  

15.  obj.print();  

16.   }  

17.  }  

Output:Hello

As you can see in the above example, Printable and Showable interface have same methods but its implementation is provided by class A, so there is no ambiguity.

Note: A class implements interface but One interface extends another interface .

1.      interface Printable{  

2.      void print();  

3.      }  

4.        

5.      interface Showable extends Printable{  

6.      void show();  

7.      }  

8.        

9.      class A implements Showable{  

10.    

11.  public void print(){System.out.println("Hello");}  

12.  public void show(){System.out.println("Welcome");}  

13.    

14.  public static void main(String args[]){  

15.  A obj = new A();  

16.  obj.print();     obj.show();  

17.   }  

18.  }  

Output:Hello

       Welcome