Le rôle des interfaces et des classes abstraites dans les génériques Java

Les interfaces sont utilisées pour définir le comportement qu'une classe doit implémenter, permettant le sous-typage. Les classes abstraites contiennent des méthodes abstraites, permettant au polymorphisme de ne pas être instancié.

Le rôle des interfaces et des classes abstraites dans Java Generics

Introduction
Les génériques sont une technique de programmation puissante qui nous permet de créer du code réutilisable sans spécifier de types concrets. Les interfaces et les classes abstraites jouent un rôle crucial dans les génériques, fournissant des mécanismes permettant d'obtenir le polymorphisme et l'abstraction dans les systèmes typés.

Interface
Une interface est un type abstrait qui contient uniquement des déclarations de méthode. Il définit un ensemble de méthodes qui doivent être implémentées par toute classe implémentant l'interface. Une interface ne peut contenir aucun champ ou constructeur.

Sous-typage
L'interface peut être utilisée pour établir des relations de sous-typage. Lorsqu'une classe implémente une interface, elle devient un sous-type de cette interface. Cela signifie qu'un objet de cette classe peut être affecté à cette variable de type d'interface, tout comme un objet de classe enfant peut être affecté à sa variable de type de classe parent.

Exemple pratique

public interface Comparable<T> {
    int compareTo(T other);
}

public class Person implements Comparable<Person> {

    private String name;
    private int age;

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
}

// 使用示例
List<Person> people = new ArrayList<>();
people.add(new Person("John", 30));
people.add(new Person("Mary", 25));

Collections.sort(people);  // 使用接口实现按年龄排序

Dans cet exemple, la classe Person implémente l'interface Comparable, permettant de la comparer par âge. Cela signifie que nous pouvons trier une collection d'objets Person en utilisant la méthode Collections.sort(). Person 类实现了 Comparable 接口，使其可以按年龄进行比较。这意味着我们可以使用 Collections.sort() 方法对 Person 对象集合进行排序。

抽象类
抽象类是一种不能被实例化的类。它可以包含抽象方法（没有实现的方法），以及普通方法和字段。

多态性
抽象类允许以多态的方式使用对象。当创建一个引用抽象类类型的变量时，它可以引用该类或其任何子类的对象。

实用示例

public abstract class Shape {

    private String color;

    public abstract double getArea();
}

public class Rectangle extends Shape {

    private double width;
    private double height;

    @Override
    public double getArea() {
        return width * height;
    }
}

public class Circle extends Shape {

    private double radius;

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

// 使用示例
List<Shape> shapes = new ArrayList<>();
shapes.add(new Rectangle(5, 10));
shapes.add(new Circle(5));

for (Shape shape : shapes) {
    System.out.println(shape.getArea());
}

在这个示例中，Shape 是一个抽象类，它定义了一个 getArea() 方法，该方法由其子类 Rectangle 和 Circle

🎜Classe abstraite🎜🎜Une classe abstraite est une classe qui ne peut pas être instanciée. Il peut contenir des méthodes abstraites (méthodes sans implémentation), ainsi que des méthodes et champs ordinaires. 🎜🎜🎜Polymorphisme🎜🎜Les classes abstraites permettent d'utiliser des objets de manière polymorphe. Lorsque vous créez une variable qui fait référence à un type de classe abstraite, elle peut faire référence à un objet de cette classe ou à l'une de ses sous-classes. 🎜🎜🎜Exemple pratique🎜🎜rrreee🎜Dans cet exemple, Shape est une classe abstraite qui définit une méthode getArea(), qui est définie par ses sous-classesRectangle et Circle sont implémentés. Cela nous permet de créer des objets de formes variées, de les stocker dans une collection et de les utiliser de manière polymorphe. 🎜

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!