In Java, both abstract classes and interfaces are used to define abstract types that can be used to specify the behavior that classes must implement. However, they have different features and purposes. Here are the key differences between them:
Abstract Class
- Definition: An abstract class is a class that cannot be instantiated on its own and can have abstract methods (methods without a body) as well as concrete methods (methods with a body).
- Usage: Abstract classes are used when you want to share code among several closely related classes.
- Constructors: An abstract class can have constructors.
- Access Modifiers: Methods and fields in an abstract class can have any access modifier (public, protected, private).
- Fields: An abstract class can have instance variables (fields).
- Inheritance: A class can extend only one abstract class (single inheritance).
- Implementation: Abstract classes can provide default implementation for some of the methods.
- Static Methods: Abstract classes can have static methods.
- State Management: Abstract classes can maintain state (instance variables).
Interface
- Definition: An interface is a reference type in Java, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods.
- Usage: Interfaces are used to define a contract that other classes must adhere to. They are suited for declaring methods that one or more classes are expected to implement.
- Constructors: Interfaces cannot have constructors.
- Access Modifiers: All methods in an interface are implicitly public and abstract (except default and static methods, which are explicitly defined).
- Fields: Interfaces can only have static and final fields (constants).
- Inheritance: A class can implement multiple interfaces (multiple inheritance).
- Implementation: Interfaces cannot provide any method implementations except for default and static methods.
- Static Methods: Interfaces can have static methods.
- State Management: Interfaces cannot maintain state, as they cannot have instance variables.
Example:
Abstract Class Example
abstract class Animal {
String name;
Animal(String name) {
this.name = name;
}
abstract void makeSound();
void sleep() {
System.out.println(name + " is sleeping.");
}
}
class Dog extends Animal {
Dog(String name) {
super(name);
}
@Override
void makeSound() {
System.out.println(name + " says: Woof Woof");
}
}
Interface Example
interface Animal {
void makeSound();
default void sleep() {
System.out.println("Animal is sleeping.");
}
}
class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Dog says: Woof Woof");
}
}
When to Use What?
- Abstract Class: Use when you have a base class that should not be instantiated and contains some common code that can be shared among derived classes.
- Interface: Use when you want to define a contract for what a class can do, without dictating how it should do it. Interfaces are especially useful for defining capabilities that can be added to any class regardless of where it sits in the class hierarchy.
No comments:
Write comments