🕸️Abstraction

Hide the Details, Show the Essence ✨

Abstraction in Java is about hiding implementation details 🙈 and only exposing essential functionality to users. 💡

It helps reduce complexity 😅 and allows focusing on what an object does rather than how it does it. 🔍

Ways to Achieve Abstraction

// Abstract Class 
public abstract class Animal {
  public abstract void makeSound(); // Abstract method
}

// Interface 
public interface Flyable {
  public void fly(); // Interface method
}

• Abstract Classes 🏫

  • 0-100% abstraction

  • Can have concrete methods 👍

• Interfaces ⛓️

  • 100% abstraction

  • Cannot have concrete methods ❌

Benefits 🎁

• Isolates impact of changes 💪

• Promotes reusability 🙌

• Enables focus on essentials 🎯

Abstraction is key to managing complexity in large systems! 🚀

📚 Rules for Abstraction in Java 📚

Abstraction refers to hiding implementation details and only exposing functionality to users. In Java, abstraction is achieved through abstract classes and interfaces.

🖼️ Rules for Abstract Classes 🖼️

Abstract classes have the following rules:

• An abstract class cannot be instantiated directly

• An abstract class may or may not contain abstract methods

• Abstract methods only declare the method signature and do not provide an implementation

• Subclasses must override all abstract methods by providing implementations

For example:

public abstract class Shape {

  public abstract void draw();

}

public class Circle extends Shape {

  @Override
  public void draw() {
    // code to draw a circle
  }

} 

Shape is an abstract class with an abstract draw() method. Circle overrides draw() to provide an implementation.

📑 Rules for Interfaces 📑

Some key rules for interfaces are:

• An interface cannot be instantiated directly

• An interface can only contain abstract methods and static constants

• Methods in an interface are implicitly abstract and public

• Classes must override all interface methods when implementing an interface

For example:

public interface Drawable {
  
  void draw();

}

public class Square implements Drawable {

  @Override
  public void draw() {
    // code to draw a square
  }

}

The Drawable interface enforces a draw() contract. Square implements Drawable and overrides draw().

So these are the key rules around using abstraction in Java through abstract classes and interfaces.

Difference between abstract class and interface

Abstract class and interface both are used to achieve abstraction where we can declare the abstract methods. Abstract class and interface both can't be instantiated.

But there are many differences between abstract class and interface that are given below.

Abstract class	Interface
1) Abstract class can have abstract and non-abstract methods.	Interface can have only abstract methods. Since Java 8, it can have default and static methods also.
2) Abstract class doesn't support multiple inheritance.	Interface supports multiple inheritance.
3) Abstract class can have final, non-final, static and non-static variables.	Interface has only static and final variables.
4) Abstract class can provide the implementation of interface.	Interface can't provide the implementation of abstract class.
5) The abstract keyword is used to declare abstract class.	The interface keyword is used to declare interface.
6) An abstract class can extend another Java class and implement multiple Java interfaces.	An interface can extend another Java interface only.
7) An abstract class can be extended using keyword "extends".	An interface can be implemented using keyword "implements".
8) A Java abstract class can have class members like private, protected, etc.	Members of a Java interface are public by default.
9)Example: public abstract class Shape{ public abstract void draw(); }	Example: public interface Drawable{ void draw(); }

Simply, abstract class achieves partial abstraction (0 to 100%) whereas interface achieves fully abstraction (100%).