what is interface in java

Interface (English: Interface), in the JAVA programming language, is an abstract type and a collection of abstract methods. The interface is usually declared with interface. A class inherits the abstract methods of the interface by inheriting the interface.

Interfaces are not classes. The way to write interfaces is very similar to classes, but they belong to different concepts. Classes describe the properties and methods of an object. The interface contains the methods that the class implements.

Unless the class that implements the interface is an abstract class, the class must define all methods in the interface.

Interface cannot be instantiated, but it can be implemented. A class that implements an interface must implement all methods described in the interface, otherwise it must be declared as an abstract class. In addition, in Java, interface types can be used to declare a variable, they can be a null pointer, or be bound to an object that implements this interface.

The declaration syntax format of the interface is as follows:

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法}

Function

In the Java language specification, the characteristics of a method are only Including the name of the method, the number and type of parameters, but not the return type of the method, the names of the parameters and the exceptions thrown. When the Java compiler checks the overloading of methods, it will determine whether the two methods are overloaded methods based on these conditions. But when the Java compiler checks the substitution of the method, it will further check whether the return type and exception thrown by the two methods (supertype and subtype) are the same.

The rules for interface implementation and class inheritance are different. For data security, a class has only one direct parent class during inheritance, that is, single inheritance. However, a class can implement multiple interfaces, and interfaces make up for the inability of classes. Disadvantages of multiple inheritance: The dual design of inheritance and interface not only maintains the data security of the class but also implements multiple inheritance in disguise.

The Java interface itself does not have any implementation, because the Java interface does not involve representation, but only describes public behavior, so the Java interface is more abstract than the Java abstract class. But interfaces are not classes, and you cannot use the new operator to instantiate an interface. Such as x=new comparable(...);//This is an error. But the interface variable Comparable x can be declared; //This is allowed.

Methods of Java interfaces can only be abstract and public. Java interfaces cannot have constructors. Java interfaces can have public, static and final attributes. That is, the properties in the interface can be defined as public static final int value=5; [1]

The interface separates the characteristics of the method and the implementation of the method. This separation is reflected in the fact that an interface often represents a role, which packages the operations and properties related to that role, and the class that implements this interface is the actor who plays this role. A role is played by different actors, and different actors do not require anything else in common except playing a common role.

Use two similar functions in two classes, call their classes to dynamically determine an implementation, then they provide an abstract parent class, child Classes implement the methods defined by the parent class respectively.

The emergence of the problem: Java is a single-inheritance language. Under normal circumstances, which specific class may already have a superclass. The solution is to add a parent class to its parent class, or to give it a parent class. The parent class plus the parent class until it moves to the top of the class hierarchy. In this way, designing the pluggability of a specific class becomes a modification of all classes in the entire hierarchy.

Pluggability

Any class in a hierarchical structure can implement an interface. This interface will affect all subclasses of this class, but not Will affect any superclasses of this class. This class will have to implement the methods specified by this interface, and its subclasses can automatically inherit these methods from this class. Of course, you can also choose to replace all these methods, or some of them. At this time, these subclasses have Pluggability (and can be loaded with this interface type, passing all subclasses that implement it).

What we care about is not that specific class, but whether this class implements the interface we need.

Interfaces provide pluggability in association and method calls. The larger the scale of the software system, the longer the life cycle. Interfaces ensure the flexibility and scalability of the software system, and pluggability is guaranteed.

Type

Use Java interfaces to couple software units internally and externally. Use Java interfaces instead of concrete classes to declare variable types, return type declarations for methods, type declarations for parameters, and convert data types.

In an ideal situation, a concrete Java class should only implement the Java interface and the methods declared in the abstract Java class, and should not give extra methods.

Hierarchical structure

Java interfaces (and abstract classes) are generally used as the starting point for a type's hierarchical structure.

If a class already has a primary supertype (parent class), then by implementing an interface, the class can have another secondary supertype. This secondary supertype is called a mixed type .

Related learning recommendations:

java basic tutorial

The above is the detailed content of what is interface in java. For more information, please follow other related articles on the PHP Chinese website!