Detailed analysis of differences between java Abstract classes and interfaces

Abstractclass and interface are two mechanisms supported for the definition of abstract classes in the Java language. It is precisely because of the existence of these two mechanisms that give Java powerful object-oriented capabilities. Abstractclass and interface have great similarity in support for abstract class definitions, and can even be replaced with each other. Therefore, many developers are relatively casual in selecting abstractclass and interface when defining abstract classes. In fact, there is a big difference between the two. Their choices even reflect the understanding of the nature of the problem domain, and whether the understanding of the design intent is correct and reasonable. This article will analyze the differences between them and try to provide developers with a basis for selection between them.

Understanding abstract classes
Abstractclass and interface are used for abstract classes in Java. (The abstract classes in this article are not translated from abstractclass. They represent an abstract body, abstractclass is a method used to define abstract classes in the Java language. Be careful when defining them.) So what is an abstract class? What are the benefits of using abstract classes?

In the concept of object-oriented, we know that all objects are depicted through classes, but this is not the case. Not all classes are used to depict objects. If a class does not contain enough information to depict a specific object, such classes are abstract classes. Abstract classes are often used to represent the abstract concepts we have come up with in the analysis and design of problem domains. They are abstractions of a series of seemingly different but essentially identical specific concepts. For example, if we develop a graphic editing software, we will find that some specific concepts such as circles and triangles exist in the problematic domain. They are different, however, they all belong to the concept of shape. The concept of shape does not exist in the field of problem. It is an abstract concept. Abstract concepts cannot be instantiated because they do not have specific concepts in the problem field.

In the Object-Oriented field, abstract classes are mainly used to hide types. We can construct a fixed abstract description of a group of actions, but this group of actions can have any specific implementation method. This abstract description is an abstract class, and any possible implementations of this group are represented as all possible Derived classes. The module can operate on an abstract body. Because the module depends on a fixed abstract body, it may not be allowed to be modified. At the same time, the behavior function of this module can be extended by deriving from this abstract body. Readers who are familiar with OCP must know that abstract classes are the key to implementing the Open-ClosedPrinciple principle of object-oriented design.
View abstractclass and interface in terms of syntax definition
At the syntax level, the Java language provides different definitions for abstractclass and interface. The following describes how to define an abstract class named Demo.

The following describes how to use abstractclass to define a Demo abstract class:

Copy codeThe Code is as follows: abstractclassDemo {
Abstractvoidmethod1 ();
Abstractvoidmethod2 ();
...
}
The following method is used to define the Demo abstract class using the interface:
InterfaceDemo {
Voidmethod1 ();
Voidmethod2 ();
...
}

In the abstractclass method, the Demo can have its own data members or non-abstarct member methods. In the implementation of the interface method, demo can only have static data members that cannot be modified (that is, they must be staticfinal, but generally do not define data members in the interface). All member methods are abstract. In a sense, interface is a special form of abstractclass.

From the programming point of view, abstractclass and interface can be used to implement the idea of "designbycontract. However, there are some differences in usage.
First, abstractclass represents an inheritance relationship in Java. A class can only use an inheritance relationship once. However, a class can implement multiple interfaces. Maybe this is a compromise between Java designers and Java's support for multi-inheritance.

Secondly, in the definition of abstractclass, we can assign the default behavior of the method. However, in the interface definition, a method cannot have default behavior. to bypass this restriction, you must use a delegate. However, this increases complexity and sometimes causes great trouble.
Another serious problem still exists when the default behavior cannot be defined in the abstract class, which may cause maintenance trouble. Because if you want to modify the interface of the class (usually expressed by abstractclass or interface) to adapt to the new situation (for example, adding a new method or adding a new parameter to the used method) it will be very troublesome and may take a lot of time (especially when there are many derived classes ). However, if the interface is implemented through abstractclass, you may only need to modify the default behavior defined in abstractclass.

Similarly, if the default behavior cannot be defined in the abstract class, the same method will appear in every derived class of the abstract class. This violates the "onerule, oneplace" principle and leads to code duplication, it is not conducive to future maintenance. Therefore, be careful when selecting abstractclass and interface.

From the perspective of design concept, the difference between abstractclass and interface is mainly discussed from the perspective of syntax definition and programming. The difference between these levels is relatively low-level and non-essential. This section analyzes the differences between abstractclass and interface on the other layer. The author believes that,