How to use interface functions to implement interfaces and polymorphic programming in Java

How to use interface functions to implement interfaces and polymorphic programming in Java

Introduction:
In Java, interface functions (Functional Interface) are new in Java 8 A new feature that allows us to define an abstract method and one or more default methods in the interface. An interface function can only have one abstract method in the interface, and this method is called the functional method of the interface function. Interface functions can implement polymorphic programming of interfaces, making the code more concise, flexible and maintainable. This article will introduce how to use interface functions to implement interfaces and polymorphic programming in Java, and give specific code examples.

Implementing interface functions:

To implement interface functions in Java, the following conditions need to be met:

1. Only one abstract method can exist in the interface;
2. This method cannot have any implementation;
3. can have multiple default methods.

The following is a simple example to illustrate how to implement the interface function:

// 定义一个接口函数
interface Greeting {
    void sayHello(); // 接口函数的抽象方法
}

public class Main {

    public static void main(String[] args) {
        // 使用Lambda表达式实现接口函数
        Greeting greeting = () -> System.out.println("Hello, World!");
        greeting.sayHello();
    }
}

In the above example, we first define an interface function Greeting, It has only one abstract method sayHello(). Then in the main method of the Main class, we use Lambda expressions to implement this interface function. Lambda expression() -> System.out.println("Hello, World!") represents a function body without parameters. There is only one statement in the function body, which is to output "Hello, World!" . Finally, this interface function is executed by calling the sayHello() method.

Implementing interfaces and polymorphic programming:

Another important feature of interface functions is that they can implement interfaces and polymorphic programming. The following is a simple example to illustrate how to implement interfaces and polymorphic programming:

interface Vehicle {
    void drive();
}

class Car implements Vehicle {
    public void drive() {
        System.out.println("Drive a car");
    }
}

class Truck implements Vehicle {
    public void drive() {
        System.out.println("Drive a truck");
    }
}

public class Main {

    public static void main(String[] args) {
        // 使用接口函数实现多态编程
        Vehicle vehicle1 = new Car();
        Vehicle vehicle2 = new Truck();

        vehicle1.drive();
        vehicle2.drive();
    }
}

In the above example, we define a Vehicle interface, which has only one abstract method drive(). Then we implemented two classes, Car and Truck respectively, and they both implemented the Vehicle interface. In the main method, we implement polymorphic programming through the interface function Vehicle. First, a Car object is created through new Car(), and then it is assigned to the Vehicle type variable vehicle1. Then create a Truck object through new Truck(), and then assign it to the Vehicle type variable vehicle2. Finally, different vehicle driving behaviors are performed by calling the drive() method.

Summary:
Interface function is an important feature of implementing interfaces and polymorphic programming in Java. It can make our code more concise, flexible and maintainable. By using Lambda expressions to implement interface functions, we can directly define the function body in the interface, avoiding the trouble of creating an implementation class. By implementing polymorphic programming through interface functions, we can pass different implementation objects as needed to achieve the same behavior of different objects. This makes the code more scalable and maintainable. We hope that the introduction and examples in this article can help readers better understand and apply interface functions.

The above is the detailed content of How to use interface functions to implement interfaces and polymorphic programming in Java. For more information, please follow other related articles on the PHP Chinese website!