The Four Pillars of Java - Part 3 - Abstraction

Abstraction is one of the fundamental concepts in object-oriented programming (OOP) and is particularly important in the Java programming language. Abstraction allows you to model real-world entities in a simplified way, focusing on the essential characteristics while hiding the unnecessary details.

In Java, abstraction is primarily achieved through the use of abstract classes and interfaces.

1. Abstract Class:
   - An abstract class is a class that cannot be instantiated on its own; it is meant to be subclassed.
   - You can declare methods within an abstract class without providing their implementation. These are called abstract methods, and they are meant to be implemented by subclasses.
   - Abstract classes can also have concrete (fully implemented) methods.
   - To create an abstract class in Java, you use the `abstract` keyword in the class declaration.
 

   abstract class Animal {
       abstract void makeSound(); // Abstract method
       void eat() {
           System.out.println("Eating...");
       }
   }

2. Interface:
   - An interface is a way to achieve full abstraction in Java. It defines a contract of methods that implementing classes must adhere to.
   - All methods declared in an interface are implicitly abstract and public. Fields declared in an interface are implicitly public, static, and final.
   - A class can implement one or more interfaces, and it must provide implementations for all the methods declared in those interfaces.
   
   ```java
   interface Drawable {
       void draw();
   }
   ```

**Example of Using Abstraction in Java:**

```java
class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark!");
    }
}

class Circle implements Drawable {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}


In the example above, `Animal` is an abstract class with an abstract method `makeSound()`, and `Drawable` is an interface with an abstract method `draw()`. The `Dog` class extends `Animal` and provides an implementation for `makeSound()`, while the `Circle` class implements the `Drawable` interface and provides an implementation for `draw()`.

Abstraction is essential for building flexible and maintainable software systems because it allows you to define clear contracts and separate the interface from the implementation. It also enables polymorphism, which allows you to treat objects of different classes in a uniform way based on their shared abstract types (e.g., interfaces or base abstract classes).