# 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** ```java // 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: ```java 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: ```java 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 classInterface
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%). --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://qatesting.gitbook.io/qa/java/oops/abstraction.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.