Java Fundamentals (11): Interfaces

First, interface:

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

Interfaces are not classes, and the way they are written is similar to classes, but they are different concepts. Class describes the properties and methods of an object. The interface contains the methods to be implemented by the class. Unless the class that implements the interface is an abstract class, the class defines all the methods in the interface.

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

1, interface and similar points of the class:

• An interface can have multiple methods.
• The interface file is saved in a file that ends in. java, and the filename uses the interface name.
• The bytecode file for the interface is saved in a file that ends in a. class.
• The corresponding bytecode file for the interface must be in the directory structure that matches the package name.

2, the difference between the interface and the class:

• An interface cannot be used to instantiate an object.
• Interface has no constructor method.
• All methods in an interface must be abstract methods.
• An interface cannot contain member variables, except static and final variables.
• Interfaces are not inherited by classes, but are implemented by classes.
• The interface supports multiple inheritance.

3. Interface Features:

• Each method in the interface is implicitly abstract, and the methods in the interface are implicitly specified as public abstract(only public abstract, and other modifiers will be error-marked).
• The interface can contain variables, but the variables in the interface are implicitly specified as public static final variables (and can only be public, with the private modifier reporting compilation errors).
• The method in the interface is not implemented in the interface, only the class implementing the interface can implement the method in the interface.

4. The difference between abstract classes and interfaces:

• A method in an abstract class can have a method body, which is a specific function that can implement a method, but the method in an interface is not.
• member variables in an abstract class can be of various types, whereas member variables in an interface are only public static final types.
• Interfaces cannot contain static blocks of code and static methods (methods that are decorated with static), whereas abstract classes can have static code blocks and static methods.
• A class can inherit only one abstract class, while a class may implement multiple interfaces.

Second, the Declaration of the interface:

The declaration syntax format for the interface is as follows:

Interface Interface Name [extends other class name]        {//  declare variable         //  abstract method }

The interface keyword is used to declare an interface. Here is a simple example of an interface declaration.

Import java.lang.*;      // Introduction Package  Public Interface nameofinterface{   // any type final, static field    // abstract method }

The interface has the following characteristics:

(1) An interface is implicitly abstract, and it is not necessary to use the abstract keyword when declaring an interface.

(2) Each method in an interface is implicitly abstract, and the declaration does not require an abstract key.

(3) The methods in the interface are public. Like what:

Interface Animal {   publicvoid  eat ();     Public void Travel ();}

Third, the implementation of the interface:

　　when a class implements an interface, the class implements all the methods in the interface . Otherwise, the class must be declared as an abstract class.

class implements the interface using the implements keyword. In a class declaration, the Implements keyword is placed after the class declaration.

To implement the syntax of an interface, you can use this formula: Modifier class ClassName implements Interface Name 1[, other interfaces, other interfaces ... ]

 Public classMammalint implements animal{ Public voideat () {System. out. println ("mammal Eats"); }    Public voidTravel () {System. out. println ("Mammal Travels"); }     Public intNooflegs () {return 0; }    Public Static voidMain (String args[]) {mammalint m=NewMammalint ();      M.eat ();   M.travel (); }}

When overriding a method declared in an interface, you need to be aware of the following rules:

(1) When implementing a method of an interface, the class cannot throw a mandatory exception, only in an interface, or in an abstract class that inherits an interface.

(2) class to maintain a consistent method name when overriding a method, and should maintain the same or compatible return value type.

(3) If the class implementing the interface is an abstract class, then there is no need to implement the method of the interface.

There are some rules to be aware of when implementing an interface:

(1) A class can implement more than one interface at a time.

(2) A class can inherit only one class, but it can implement multiple interfaces.

(3) An interface can inherit another interface, which is similar to the inheritance between classes.

Iv. Inheritance of interfaces:

An interface can inherit another interface, and the inheritance between classes is more similar. The inheritance of an interface uses the extends keyword, which inherits the method of the parent interface.

The following sports interface is inherited by the hockey and football interfaces: The Hockey interface declares four methods, inherits two methods from the sports interface, so that the class that implements the hockey interface needs to implement six methods. Similarly, a class that implements the football interface needs to implement five methods, two of which are from the sports interface.

//file name: Sports.java Public Interfacesports{ Public voidSethometeam (String name);  Public voidSetvisitingteam (String name);}//file name: Football.java Public InterfaceFootball extends sports{ Public voidHometeamscored (intpoints);  Public voidVisitingteamscored (intpoints);  Public voidEndofquarter (intquarter);}//file name: Hockey.java Public InterfaceHockey extends sports{ Public voidhomegoalscored ();  Public voidvisitinggoalscored ();  Public voidEndofperiod (intperiod);  Public voidOvertimeperiod (intot);}

V. Multiple Inheritance of interfaces:

In Java, multiple inheritance of a class is illegal, but the interface allows multiple inheritance. In multiple inheritance of interfaces, the extends keyword needs to be used only once, followed by an inherited interface. As shown below:

 Public Interface Hockey extends Sports, Event

Six, marking interface:

The most common inherited interface is an interface that does not contain any methods. The identity interface is an interface that does not have any methods and properties. It simply indicates that its class belongs to a particular type, and that other code is allowed to do something for testing.

Identity interface function: The simple image is to give an object a mark (a stamp), so that the object has some or some of the privileges.

For example: The Java.util.EventListener interface that inherits from the MouseListener interface in the Java.awt.event package is defined as follows:

Package Java.util;  Public Interface eventlistener{
}

Interfaces that do not have any methods are called labeled interfaces. The tag interface is mainly used for the following two purposes:

(1) Establish a common parent interface: Just like the EventListener interface, which is a Java API that is extended by dozens of other interfaces, you can use a markup interface to create a parent interface for a set of interfaces. For example: When an interface inherits the EventListener interface, the Java Virtual Machine (JVM) knows that the interface will be used for an event's proxy scenario.

(2) Adding a data type to a class: this is the initial purpose of the markup interface, and the class that implements the tag interface does not need to define any interface methods (because the markup interface has no methods at all), but the class becomes an interface type through polymorphism.

Java Fundamentals (11): Interfaces