Quick implementation and calling method of Java interface

Get started quickly with Java interface creation: implementation code and calling methods

Introduction:
Java interface is a very important feature that allows us to define a set of methods, and let different classes implement these methods. The interface provides a data type that enables polymorphism between different classes, and provides a specification that makes the code more flexible and easier to maintain. This article will demonstrate how to quickly get started creating Java interfaces, including code examples for implementing interfaces and methods for calling interface methods.

1. Create an interface:
In Java, an interface is defined by using the interface keyword. The following is the code of a sample interface:

public interface Animal {
    void eat();
    void sleep();
}

The interface Animal defines two methods: eat() and sleep(). We can define any number of methods in the interface, and these methods are abstract methods, which are public and abstract by default.

2. Implement the interface:
To implement an interface, we need to write a class and use the implements keyword to indicate that this class implements the interface. The following is the code for an example class that implements the interface Animal:

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}

Class Dog implements the interface Animal and overrides two methods in the interface: eat() and sleep(). In these two methods, we can write logic according to specific needs.

3. Calling the interface method:
To call a method of a class that implements the interface, we can first create a reference to the interface, and then initialize the reference with an object that implements the interface. The following is a sample code for calling the interface method:

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        animal.sleep();
    }
}

In the main method, first create a reference to the interface Animal, and initialize this reference with an object of class Dog that implements the interface. Then, we can call the methods defined in the interface by referencing animal: eat() and sleep(). Since the actual object is an instance of the Dog class, the methods in the Dog class are actually executed.

4. Summary:
Through the above examples, we can see that the creation, implementation and calling of Java interfaces are relatively simple. By using interfaces, we can achieve code reuse and polymorphism, thereby improving code maintainability and flexibility.

It should be noted that the interface cannot be instantiated, that is, an object of the interface cannot be directly created. We can only call methods of classes that implement the interface through a reference to the interface.

In actual development, the interface is a powerful design tool. It can help us optimize the code structure and improve the scalability and testability of the code. Therefore, I hope that everyone can be good at using the interface feature when writing Java code to improve their programming skills.

In short, through the introduction of this article, I believe that everyone has a preliminary understanding of the creation, implementation and calling of Java interfaces, and can quickly get started through specific code examples. I hope this article will be helpful to everyone in learning and using Java interfaces.

The above is the detailed content of Quick implementation and calling method of Java interface. For more information, please follow other related articles on the PHP Chinese website!