Interfaces in Java

Java 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.

Interfaces are similar to classes:

• 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.

The difference between an interface and a 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.

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.

The difference between an abstract class and an interface

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

Declaration of the interface

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.

 Public Interface nameofinterface{   // any type final, static field    // abstract method }

The interface has the following characteristics:

• Interfaces are implicitly abstract, and it is not necessary to use the abstract keyword when declaring an interface.
• Each method in the interface is implicitly abstract, and the declaration does not require the abstract keyword.
• The methods in the interface are public.

Instance

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

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:

... implements interface name [, other interface name, other interface name ..., ...] ...

Instance

 Public classMammalintImplementsanimal{ Public voideat () {System.out.println ("Mammal Eats"); }     Public voidTravel () {System.out.println ("Mammal Travels"); }      Public intNooflegs () {return0; }     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:

• A class cannot throw a mandatory exception when implementing the method of an interface, but only in an interface, or an abstract class that inherits an interface.
• class to maintain a consistent method name when overriding a method, and should maintain the same or compatible return value type.
• If the class that implements 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:

• A class can implement multiple interfaces at the same time.
• A class can inherit only one class, but it can implement multiple interfaces.
• An interface can inherit another interface, which is similar to the inheritance between classes.

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 interfaces are inherited by the hockey and football interfaces:

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

 

The hockey interface itself declares four methods, inheriting two methods from the sports interface, so that the class implementing 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.

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 extends Sports, Event

The above program fragment is a legally defined sub-interface, and unlike a class, the interface allows multiple inheritance, while sports and Event may define or inherit the same method

Tag interface

The most common inherited interface is an interface that does not contain any methods.

The markup interface is an interface that does not have any methods and properties. It merely indicates that its class belongs to a particular type, and that other code is allowed to do some things for testing.

Tag 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:

• To create a common parent interface:

  As with 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.

• To add a data type to a class:

  This situation is the initial purpose of the markup interface, the class that implements the tag interface does not need to define any interface methods (because the markup interface has no method at all), but the class becomes an interface type through polymorphism.

Interfaces in Java