Objectif des interfaces en Java et classification des scénarios d'application

Classification et scénarios d'utilisation des interfaces en Java

1. Classification des interfaces
En Java, une interface est une définition standardisée utilisée pour définir les méthodes qu'une classe doit implémenter. Les interfaces peuvent être divisées dans les types suivants :

1. Interface régulière : l'interface régulière est le type d'interface le plus courant, qui définit les méthodes qu'une classe doit implémenter. Par exemple :

public interface Shape {
    double calculateArea(); // 计算面积的方法
    double calculatePerimeter(); // 计算周长的方法
}

L'interface Shape ci-dessus définit une méthode de calcul de la surface et du périmètre.

2. Interface de rappel : L'interface de rappel est un type d'interface spécial utilisé pour implémenter le traitement des événements. Lorsqu'un événement se produit, la méthode de la classe qui implémente l'interface de rappel est appelée. Par exemple :

public interface OnButtonClickListener {
    void onButtonClick(); // 按钮点击时调用的方法
}

L'interface OnButtonClickListener mentionnée ci-dessus est utilisée pour gérer les événements de clic sur un bouton.

3. Interface fonctionnelle : L'interface fonctionnelle est une nouvelle fonctionnalité introduite dans Java 8. Elle ne contient qu'une seule méthode abstraite. Cette interface peut être implémentée à l'aide d'expressions Lambda, ce qui facilite l'écriture de code de programmation fonctionnel. Par exemple :

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b); // 计算两个数的方法
}

L'interface Calculatrice ci-dessus définit une méthode pour calculer deux nombres.

2. Scénarios d'utilisation des interfaces
Les interfaces ont un large éventail de scénarios d'application en Java. Voici plusieurs scénarios d'utilisation courants :

1. Polymorphisme : les interfaces peuvent être utilisées pour réaliser un polymorphisme et fonctionner via des références d'interface. Par exemple :

public class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Rectangle implements Shape {
    private double height;
    private double width;
    
    public Rectangle(double height, double width) {
        this.height = height;
        this.width = width;
    }
    
    public double calculateArea() {
        return height * width;
    }
    
    public double calculatePerimeter() {
        return 2 * (height + width);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(3, 4);
        
        System.out.println("Circle area: " + circle.calculateArea());
        System.out.println("Circle perimeter: " + circle.calculatePerimeter());
        
        System.out.println("Rectangle area: " + rectangle.calculateArea());
        System.out.println("Rectangle perimeter: " + rectangle.calculatePerimeter());
    }
}

Dans l'exemple ci-dessus, le polymorphisme est obtenu via l'interface Shape. Vous pouvez utiliser la référence de l'interface Shape pour faire fonctionner respectivement les objets Circle et Rectangle.

2. Traitement des événements : les interfaces peuvent être utilisées pour implémenter des mécanismes de traitement d'événements. Lorsqu'un événement se produit, la méthode de la classe qui implémente l'interface est appelée. Par exemple :

public class Button {
    private OnButtonClickListener listener;
    
    public void setOnButtonClickListener(OnButtonClickListener listener) {
        this.listener = listener;
    }
    
    public void click() {
        if (listener != null) {
            listener.onButtonClick();
        }
    }
}

public class ViewController implements OnButtonClickListener {
    private Button button;
    
    public ViewController() {
        button = new Button();
        button.setOnButtonClickListener(this);
    }
    
    public void onButtonClick() {
        // 处理按钮点击事件
        System.out.println("Button clicked");
    }
    
    public static void main(String[] args) {
        ViewController viewController = new ViewController();
        viewController.button.click();
    }
}

Dans l'exemple ci-dessus, la classe Button implémente le traitement des événements de clic sur un bouton via l'interface de rappel OnButtonClickListener. La classe ViewController implémente l'interface OnButtonClickListener et transmet son instance à l'objet Button Lorsque l'on clique sur le bouton, la méthode onButtonClick de la classe ViewController est appelée.

3. Programmation fonctionnelle : les interfaces fonctionnelles peuvent être utilisées pour écrire du code de programmation fonctionnel, particulièrement adapté au traitement des opérations de classe de collection. Par exemple :

import java.util.Arrays;
import java.util.List;

public class CalculatorDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        Calculator add = (a, b) -> a + b;
        Calculator multiply = (a, b) -> a * b;
        
        int sum = numbers.stream().reduce(0, add::calculate);
        int product = numbers.stream().reduce(1, multiply::calculate);
        
        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Dans l'exemple ci-dessus, l'interface fonctionnelle Calculatrice permet de définir une méthode de calcul de deux nombres. Les objets de calculatrice pour l'addition et la multiplication sont implémentés via des expressions Lambda, et les classes de collection sont exploitées via l'API Stream.

Résumé :
Les interfaces ont de nombreuses classifications en Java, notamment les interfaces normales, les interfaces de rappel et les interfaces fonctionnelles. Les interfaces ont un large éventail de scénarios d'utilisation et peuvent être utilisées pour implémenter le polymorphisme, la gestion des événements, la programmation fonctionnelle, etc. Grâce à la référence de l'interface, des opérations unifiées sur différentes classes d'implémentation peuvent être réalisées. À l'aide d'interfaces, nous pouvons écrire du code plus flexible et extensible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!