Interfaces and abstract classes in java

Abstraction is one of the major features of object-oriented design, and its embodiment in Java is abstract classes and interfaces. The two are very similar. I think many beginners have even come into contact with it. Abstraction is one of the major features of object-oriented design, and its manifestation in Java is abstract classes and interfaces. The two are very similar, and it is difficult for many beginners and even people who have been exposed to Java for several years to distinguish them. Today, when I was looking at the code related to the collection class, I found that some of them are interfaces such as List, Map, etc., and some are abstract classes such as AbstractList, AbstractSet, etc. Since I am not very clear about the two, I am confused. So today the author in this article mainly introduces the difference between the two.

Abstract class

Abstract method

Using abstract to modify a method that only declares but does not implement it is called an abstract method. For example:

abstract void fun();

Abstract class

A class modified with abstract is called an abstract class. For example:

abstract class ClassA{}

A class with abstract methods must be an abstract class. An abstract class can have no abstract methods. Abstract classes, like ordinary classes, can have member variables and ordinary member methods.

Because abstract classes contain methods without concrete implementation, you cannot use abstract classes to create instance objects! Of course, it is possible that a class is only modified with abstract, but does not have an abstract method. This is also an abstract class and cannot be instantiated. But if there is no abstract method, why design it as an abstract class? So there is no need to go into details.

Function

So it can be seen that abstract classes exist for inheritance. If you define an abstract class but do not inherit it, it is of no use. Of course, after inheritance, the class must implement all unimplemented methods in the parent class, otherwise it is not allowed (unless it is an abstract class inherited from an abstract class, in which case it does not need to be implemented).

The difference between

and ordinary classes

Abstract methods must be public or protected (because if they are private, they cannot be inherited by subclasses, and subclasses cannot implement the method). By default, it is public.

Abstract classes cannot be used to create objects;

If a subclass inherits an abstract class, the subclass must implement the abstract method of the parent class. Otherwise the subclass must also be defined as an abstract class.
In other aspects, there is no difference between abstract classes and ordinary classes.

Interface

Interface is an extremely abstract type, it is more abstract than abstract class. Interfaces can have variables and methods. However, the variables in the interface will be implicitly designated as public static final variables (defined as other types, such as private, an error will be reported), which also means that the variables must be initialized. Methods in the interface will be implicitly designated as public abstract methods (using other keywords, such as private, protected, static, final, etc., will result in an error).

And all methods in the interface cannot have specific implementations, and the methods in the interface must be abstract methods.

Similarly, when a non-abstract class implements an interface, all methods must be implemented. Otherwise the class must be an abstract class, or interface.

Comparison between abstract classes and interfaces

Differences at the syntax level

Interfaces can only have public abstract methods, abstract classes have more method types and can have ordinary methods;
Member variables in interfaces can only be of public static final type Yes, abstract classes have more variable types and can have ordinary variables;
Interfaces cannot contain static code blocks and static methods, while abstract classes can have static code blocks and static methods;
A class can only inherit one abstract class, and A class can implement multiple interfaces.
Differences at the design level

1) Abstract classes are the abstraction of things (abstraction of classes), and interfaces are the abstraction of behavior.

For example, Bird is defined as an abstract class, and various birds implement it. Define an interface called fly, and various birds can implement this interface. In layman's terms: inheritance is a "is it" relationship, while interface implementation is a "is it is" relationship. If a bird inherits Bird, its type is determined. As for whether to implement the fly interface, it only depends on whether it has this feature (behavior).

2) Abstract classes are a template design, and interfaces are a behavioral specification and a radial design.

For example, for the same method, after using the abstract class template design, when modifying the method, you only need to modify it in the template, and all subclasses can be updated; after using the interface radial design, when modifying the method, Modifications need to be made in all implementation classes before they can be updated, independently of each other.

The connection between the two uses

1. If the interface is inherited, the interface must be inherited. Can't be achieved. Cannot inherit abstract classes

2. Abstract classes can implement interfaces, can inherit abstract classes, but cannot inherit interfaces