Abstraction in Java
- Ways to achieve Abstraction
- 1. Abstract Classes and Abstract Methods
- 2. Interface
- Advantage of Abstraction
Topic – 1 : Abstraction
Abstraction is a process of hiding the implementation details and showing only functionality to the user.
Another way, it shows only essential things to the user and hides the internal details, for example, sending SMS where you type the text and send the message. You don’t know the internal processing about the message
An Abstraction is a process of exposing all the necessary details and hiding the rest. In Java, Data Abstraction is defined as the process of reducing the object to its essence so that only the necessary characteristics are exposed to the users.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
- Abstract class (0 to 100%)
- Interface (100%)
In Java, we can achieve Data Abstraction using Abstract classes and interfaces.
- Interfaces allow 100% abstraction (complete abstraction). Interfaces allow you to abstract the implementation completely.
- Abstract classes allow 0 to 100% abstraction (partial to complete abstraction) because abstract classes can contain concrete methods that have the implementation which results in a partial abstraction.
Abstract Class
- A class which is declared as abstract is known as an abstract class.
- An Abstract class is created through the use of the abstract keyword.
- It is used to represent a
- Object Can not be created of an Abstract
- Does not Support multiple inheritance.
Points to Remember
- An abstract class must be declared with an abstract
- It can have abstract and non-abstract methods.
- The class has to be declared as abstract if it contains at least one abstract
- It can have constructors, static methods and final methods.
- It can have any type of variables (Static, non-static, final, non-final etc)
Syntax of declaring an abstract class:
- To declare an abstract class we use the keyword The syntax is given below:
access-specifier abstract class ClassName
{
//class body
}
Abstract Methods in Java
• A method which is declared as abstract and does not have implementation is known as an abstract method.
- The declaration of an abstract method must end with a semicolon ;
• The child classes which inherit the abstract class must provide the implementation of these inherited abstract methods.
- Syntax of declaring abstract methods:
access-specifier abstract return-type method_name();
- Example:
public abstract void printStatus();
Example – 1
|
|
|
An abstract class that has abstract method
| Example – 2 | |||
| An abstract class that has abstract , non-abstract methods and Constructor | |||
| public abstract class Vehicle { | public class Car extends Vehicle { | ||
| public Vehicle()
{ System.out.println(“Vehicle is Created.”); } |
public void move()
{ System.out.println(“Car moves faster.”); } |
||
| public abstract void move();
public void carry() { System.out.println(“All Vehicle carry loads”); } |
public static void main(String[] args) { Car c1 = new Car();
c1.move(); c1.carry(); } } |
||
| } | // Outputs:
Vehicle is Created. Car moves faster. All Vehicle carry loads |
||
Interface in Java
- An interface is a blueprint or template of a class.
- It is much similar to the class but the only difference is that it has abstract methods and
static constants.
- Object can not be created of an
- All the methods in an interface are by default abstract.
- All variables are declared as both static and
- An interface does not contain any constructors.
- An interface can not be extended or inherited by a class; it is implemented by a
- Multiple-Inheritance supported.
Internal addition by the compiler
Syntax of declaring an Interface
interface <interface_name>{
// declare constant fields
// declare methods that abstract
//by default.
}
The 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
Example – 1
|
|
|
|
Multiple inheritance in Java by interface
If a class implements multiple interfaces, or an interface extends multiple interfaces, it is known as
multiple inheritance
Example – 2
|
class DemoClass implements FirstInterface, SecondInterface {
public void myMethod() {
System.out.println(“Some text..”);
}
|
Thank you!