Abstraction - Notes by Shariq SP - Notes by Shariq SP

Understanding Abstraction in Java

Abstraction is one of the key concepts in object-oriented programming (OOP) and refers to the process of hiding the complex implementation details and showing only the essential features of an object. It allows programmers to focus on the functionality of an object rather than its implementation details.

What is Abstraction?

In Java, abstraction is achieved through abstract classes and interfaces. An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body) and concrete methods (methods with a body). Abstract methods define the signature of a method without providing its implementation. Concrete methods provide the implementation details.

An interface is a reference type similar to a class but only contains abstract methods, constants, and default methods. It defines a contract for classes that implement it, specifying a set of methods that the implementing class must override.

Benefits of Abstraction

  • Encapsulation of Complexity: Abstraction helps in encapsulating the complex implementation details within classes and interfaces, making the code easier to understand and maintain.
  • Modularity: It promotes modularity by breaking down a system into smaller, manageable components with well-defined interfaces.
  • Code Reusability: Abstraction allows for code reuse through inheritance and interface implementation, as classes can inherit from abstract classes and implement interfaces to inherit their functionality.
  • Flexibility and Extensibility: It provides flexibility and extensibility by allowing new classes to be added without modifying existing code, as long as they adhere to the contract specified by abstract classes and interfaces.

Understanding Abstract Classes in Java

In Java, an abstract class is a class that cannot be instantiated on its own and may contain abstract methods. Abstract classes are used to define a common interface for a group of subclasses while allowing some methods to be implemented by subclasses.

Key Characteristics of Abstract Classes:

  • An abstract class cannot be instantiated directly; it can only be used as a superclass for other classes.
  • Abstract classes may contain both abstract and concrete methods.
  • Abstract methods are declared without implementation and must be implemented by concrete subclasses.
  • If a class contains one or more abstract methods, it must be declared as abstract.
  • An abstract class can have constructors, fields, and normal methods just like any other class.
  • Abstract classes can also contain non-abstract methods that provide a default behavior.

Example of an Abstract Class:

Consider the following example of an abstract class named Shape:


            abstract class Shape {
                private String color;
                
                public Shape(String color) {
                    this.color = color;
                }
                
                // Abstract method to calculate area
                public abstract double calculateArea();
                
                // Concrete method to get color
                public String getColor() {
                    return color;
                }
            }

In this example, Shape is an abstract class with a constructor and two methods: calculateArea() (abstract) and getColor() (concrete). Subclasses of Shape such as Circle and Rectangle can provide their own implementations of calculateArea() while inheriting getColor() method from the abstract class.

Benefits of Abstract Classes:

  • Provides a common interface for related classes.
  • Enforces method implementation in subclasses, ensuring consistency.
  • Supports code reusability and promotes modularity.

Conclusion

Abstraction is a powerful concept in Java that allows for the creation of high-level, modular, and reusable code. By hiding implementation details and exposing only essential features, abstraction promotes better code organization, maintainability, and flexibility in software development.

Understanding Interfaces in Java

In Java, an interface is a reference type that defines a set of abstract methods. Interfaces are similar to abstract classes but differ in their purpose and usage. Unlike abstract classes, interfaces cannot contain concrete methods or constructors and are used to define contracts for classes that implement them.

Key Characteristics of Interfaces:

  • An interface cannot be instantiated directly; it can only be implemented by classes.
  • Interfaces can contain only abstract methods, which are declared without implementation.
  • Interfaces can also contain constants (static final variables).
  • Classes can implement multiple interfaces, but they can extend only one class.
  • Interfaces provide a way to achieve multiple inheritance in Java.

Example of an Interface:

Consider the following example of an interface named Shape:


            interface Shape {
                double calculateArea(); // Abstract method
                
                String getColor(); // Abstract method
                
                // Constant
                String UNIT = "cm";
            }

In this example, Shape is an interface containing two abstract methods: calculateArea() and getColor(). It also defines a constant UNIT. Classes that implement the Shape interface must provide implementations for these methods.

Benefits of Interfaces:

  • Defines a contract that classes must adhere to.
  • Supports multiple inheritance, allowing classes to implement multiple interfaces.
  • Promotes code flexibility and modularity by separating implementation details.
  • Facilitates code reuse and promotes consistency.

Using Extends and Implements in Java

In Java, the extends keyword is used to create a subclass (child class) that inherits the properties and methods of another class (superclass or parent class). On the other hand, the implements keyword is used to indicate that a class is implementing an interface, thereby agreeing to provide implementations for all the methods defined in the interface.

Using extends for Class Inheritance:

When a class extends another class, it inherits all the non-private properties and methods of the superclass. Here's how you can use extends in Java:


            class Animal {
                void eat() {
                    System.out.println("Animal is eating...");
                }
            }
        
            class Dog extends Animal {
                void bark() {
                    System.out.println("Dog is barking...");
                }
            }

In this example, the Dog class extends the Animal class, inheriting its eat() method.

Using implements for Interface Implementation:

When a class implements an interface, it agrees to provide implementations for all the abstract methods defined in the interface. Here's how you can use implements in Java:


            interface Shape {
                double calculateArea();
            }
        
            class Circle implements Shape {
                private double radius;
        
                Circle(double radius) {
                    this.radius = radius;
                }
        
                public double calculateArea() {
                    return Math.PI * radius * radius;
                }
            }

In this example, the Circle class implements the Shape interface and provides an implementation for the calculateArea() method.

Using extends for Interface Inheritance:

Interfaces can also extend other interfaces, allowing for the creation of hierarchies of interfaces. When an interface extends another interface, it inherits the abstract methods of the parent interface. Here's how you can use extends for interface inheritance:


            interface Vehicle {
                void start();
                void stop();
            }
        
            interface Car extends Vehicle {
                void accelerate();
                void brake();
            }

In this example, the Car interface extends the Vehicle interface, inheriting its start() and stop() methods. The Car interface then adds its own methods accelerate() and brake().

Key Points to Remember:

  • Use extends to create a subclass that inherits from a superclass.
  • Use implements to indicate that a class is implementing an interface.
  • A class can extend only one superclass but can implement multiple interfaces.
  • Interfaces can extend other interfaces to create interface hierarchies.

Abstraction with Interfaces in Java

In Java, interfaces are commonly used to achieve abstraction by defining a set of abstract methods that represent a contract for classes that implement them. By using interfaces, you can define what needs to be done without specifying how it should be done.

Example: Vehicle Interface

Consider the following example of an interface named Vehicle that defines methods representing common functionalities of vehicles:


            interface Vehicle {
                void start(); // Abstract method for starting the vehicle
                void stop();  // Abstract method for stopping the vehicle
            }

In this example, the Vehicle interface defines two abstract methods: start() and stop(). Any class that implements the Vehicle interface must provide concrete implementations for these methods.

Implementing the Vehicle Interface

Now, let's create a class named Car that implements the Vehicle interface:


            class Car implements Vehicle {
                public void start() {
                    System.out.println("Car started.");
                }
                
                public void stop() {
                    System.out.println("Car stopped.");
                }
            }

In this example, the Car class implements the start() and stop() methods defined in the Vehicle interface. It provides concrete implementations for these methods based on the behavior of a car.

Using Abstraction with Interfaces

By defining the Vehicle interface, we have achieved abstraction by specifying what methods a vehicle should have without concerning ourselves with the specific implementation details. Classes like Car, Truck, etc., can implement the Vehicle interface and provide their own implementations for the abstract methods, thus adhering to the contract defined by the interface.

Type Casting with Interfaces

Since interfaces provide a common contract for classes, you can use type casting to treat objects of implementing classes as instances of the interface. For example:


            Vehicle myCar = new Car(); // Upcasting: Car object treated as a Vehicle
            myCar.start(); // Calls start() method of Car
            
            // Downcasting: Vehicle object treated as a Car
            Car myNewCar = (Car) myCar;
            myNewCar.stop(); // Calls stop() method of Car

In this example, myCar is treated as a Vehicle object, but it refers to a Car object. With type casting, you can access both the methods of the Vehicle interface and the specific methods of the Car class.

Marker Interface in Java

A marker interface in Java is an interface that does not declare any methods. It is used to mark or tag classes so that they can be identified by certain behavior or capabilities at runtime. The presence of a marker interface indicates that a class possesses some specific characteristic or behavior.

Characteristics of Marker Interfaces:

  • Marker interfaces do not contain any methods.
  • They are used for identification or categorization purposes.
  • Classes that implement marker interfaces inherit the marker's behavior or capabilities.
  • They serve as a form of metadata for classes.

Common Examples of Marker Interfaces:

  • Serializable: Indicates that a class can be serialized, allowing its objects to be converted into a byte stream for storage or transmission.
  • Cloneable: Indicates that a class can create a copy of its objects, typically used for object cloning.
  • Remote: Used in Java Remote Method Invocation (RMI) to indicate that a class can be invoked remotely.
  • SingleThreadModel: Used in Java Servlets to indicate that a servlet can handle only one request at a time.

Usage Example:

Suppose we have a framework that processes objects and performs some action based on their capabilities. We can define marker interfaces such as Processable to mark classes that can be processed by the framework:


          // Marker Interface
          interface Processable {}
          
          // Implementing class
          class MyClass implements Processable {
            // Class definition
          }
          
          // Framework method
          public void process(Object obj) {
            if (obj instanceof Processable) {
              // Perform processing based on capability
            }
          }

Marker interfaces provide a way to convey additional information about classes without adding methods or fields, allowing for runtime identification of class capabilities.

Interview Questions on Abstraction, Abstract Classes, and Interfaces in Java

  1. What is abstraction in Java?
  2. How do you achieve abstraction in Java?
  3. What is an abstract class? How is it different from a concrete class?
  4. When should you use an abstract class?
  5. Can an abstract class have constructors?
  6. What is an interface in Java?
  7. How do interfaces promote abstraction in Java?
  8. Can an interface contain concrete methods?
  9. Can a class implement multiple interfaces?
  10. What is the difference between an abstract class and an interface?
  11. When would you use an abstract class over an interface, and vice versa?
  12. Can an abstract class implement an interface?
  13. Can an interface extend another interface? If yes, how?
  14. Can an abstract class extend another class? If yes, how?
  15. What is the purpose of default methods in interfaces?
  16. How do you achieve multiple inheritance in Java using interfaces?
  17. Can you instantiate an interface?
  18. How do you use type casting with interfaces?
  19. What is the significance of marker interfaces in Java?
  20. Explain the concept of functional interfaces and how they relate to abstraction.
  21. Explain the concept of abstraction with an example.
  22. What are the benefits of abstraction in Java?
  23. Can you create an instance of an abstract class? Why or why not?
  24. How do you declare an abstract method in Java?
  25. What happens if a class fails to implement all abstract methods of an interface it claims to implement?
  26. Can an abstract class have non-abstract methods?
  27. How do you achieve abstraction using interfaces?
  28. What are the access modifiers allowed for methods in an interface?
  29. What is the purpose of static methods in interfaces?
  30. Explain the concept of method overriding in interfaces.
  31. What are functional interfaces? Provide an example.
  32. Can an interface extend a class? Why or why not?
  33. Can you have variables in an interface? If yes, what types of variables are allowed?
  34. How do you achieve abstraction when implementing multiple interfaces?
  35. What is the diamond problem? How does Java address it?
  36. What are the rules for method overriding in Java interfaces?
  37. What is the difference between abstract classes and interfaces in terms of member variables?
  38. Explain the concept of default methods in interfaces.
  39. How do you achieve encapsulation along with abstraction in Java?
  40. What are the design principles associated with using abstract classes and interfaces?
  41. How do you create a hierarchy of interfaces in Java?
  42. What is the difference between an abstract class and a concrete class?
  43. Explain the role of interfaces in Java collections framework.
  44. Can you provide an example where you would prefer using an abstract class over an interface?
  45. How do you handle versioning and compatibility issues when modifying interfaces in Java?
  46. What is the purpose of the Object class in Java interfaces?
  47. How do you handle exceptions in interfaces?
  48. Explain the concept of marker interfaces and provide examples from the Java standard library.
  49. How do you implement callback functionality using interfaces in Java?
  50. What are the best practices for naming interfaces and abstract classes?

Multiple Choice Questions on Abstraction, Abstract Classes, and Interfaces in Java

  1. What is the purpose of abstraction in Java?
    1. To hide implementation details and show only essential features.
    2. To make the code run faster.
    3. To increase memory consumption.
    4. To improve code readability.
  2. Which keyword is used to declare an abstract method in Java?
    1. abstracted
    2. method
    3. void
    4. abstract
  3. Can an abstract class be instantiated?
    1. Yes, always.
    2. No, never.
    3. It depends on the constructor.
    4. It depends on the visibility of the abstract methods.
  4. Which of the following statements about interfaces is true?
    1. Interfaces can have constructors.
    2. Interfaces can extend multiple classes.
    3. Interfaces can contain concrete methods.
    4. Interfaces can have member variables.
  5. How do you achieve multiple inheritance in Java?
    1. By using the extends keyword.
    2. By using the implements keyword.
    3. Java does not support multiple inheritance.
    4. By using abstract classes only.
  6. Which keyword is used to declare an interface in Java?
    1. interface
    2. class
    3. abstract
    4. implements
  7. What is the purpose of default methods in interfaces?
    1. To provide a default implementation for abstract methods.
    2. To restrict access to interface methods.
    3. To make interfaces non-instantiable.
    4. To define constants.
  8. How do you achieve abstraction in Java interfaces?
    1. By implementing multiple interfaces.
    2. By providing concrete implementations for all methods.
    3. By declaring only abstract methods.
    4. By using the abstract keyword.
  9. Which of the following can an interface contain?
    1. Static methods
    2. Member variables
    3. Private methods
    4. Public constructors
  10. How do you instantiate an object of an interface type?
    1. By using the new keyword.
    2. By calling the interface's constructor.
    3. Interfaces cannot be instantiated.
    4. By using the instanceof keyword.
  11. What is the difference between an abstract class and an interface?
    1. Abstract classes can have constructors, while interfaces cannot.
    2. Interfaces can have member variables, while abstract classes cannot.
    3. Abstract classes can implement multiple interfaces, while interfaces cannot extend classes.
    4. Interfaces can contain concrete methods, while abstract classes cannot.
  12. What happens if a class fails to implement all abstract methods of an interface?
    1. The class will compile successfully.
    2. The class will throw a runtime exception.
    3. The class will be marked as abstract.
    4. The class will be marked as final.
  13. Which of the following is not a valid access specifier for interface members?
    1. public
    2. protected
    3. private
    4. default
  14. How do you implement multiple inheritance in Java?
    1. By extending multiple classes.
    2. By implementing multiple interfaces.
    3. By using the extends keyword only.
    4. By using abstract classes only.
  15. What is the purpose of marker interfaces in Java?
    1. To provide a default implementation for interface methods.
    2. To declare methods as abstract.
    3. To provide a way to identify classes with special behavior.
    4. To restrict access to interface methods.
  16. Which of the following statements is true about functional interfaces?
    1. They can have multiple abstract methods.
    2. They can have only one abstract method.
    3. They cannot have any abstract methods.
    4. They must have a default implementation for all methods.
  17. Can an interface extend another interface?
    1. Yes, always.
    2. No, never.
    3. It depends on the visibility of the interface.
    4. It depends on the number of methods in the interface.
  18. Which keyword is used to declare a method as default in an interface?
    1. default
    2. public
    3. abstract
    4. final
  19. What is the purpose of abstract methods in Java interfaces?
    1. To provide a default implementation.
    2. To define methods without implementation details.
    3. To restrict access to the methods.
    4. To declare methods as final.
  20. What happens if you try to access a private method of an interface?
    1. The code will compile successfully.
    2. The compiler will throw an error.
    3. The code will run successfully.
    4. The method will be accessible only within the interface.
☰