Liste complète des interfaces Java courantes : fonctions d'interface communes principales

Aperçu des interfaces courantes en Java : Pour comprendre les interfaces courantes et leurs fonctions, des exemples de code spécifiques sont nécessaires

Introduction :
Dans le langage de programmation Java, les interfaces sont un concept très important. Une interface définit un ensemble de méthodes qui représentent les comportements qu'une classe peut implémenter. L'utilisation d'interfaces peut permettre la réutilisation et la modularisation du code, et améliorer la maintenabilité et l'évolutivité du code.

Cet article présentera les interfaces couramment utilisées en Java et leurs fonctions. Pour chaque interface, nous illustrerons son utilisation avec des exemples de code spécifiques.

1. Interface Iterable :
L'interface Iterable est l'interface racine du framework de collection Java. Elle définit un ensemble de méthodes pour parcourir les éléments de la collection. Les classes qui implémentent l'interface Iterable peuvent utiliser l'instruction foreach pour parcourir les éléments de la collection.

Exemple de code :

public class MyCollection implements Iterable<String> {
    private List<String> data;

    public MyCollection() {
        data = new ArrayList<String>();
        data.add("Apple");
        data.add("Banana");
        data.add("Orange");
    }

    @Override
    public Iterator<String> iterator() {
        return data.iterator();
    }
}

public class Main {
    public static void main(String[] args) {
        MyCollection collection = new MyCollection();
        for (String item : collection) {
            System.out.println(item);
        }
    }
}

2. Interface comparable :
L'interface comparable est une interface générique qui définit une méthode de comparaison d'objets. Les classes qui implémentent l'interface Comparable peuvent effectuer des comparaisons d'objets personnalisées pour les opérations de tri ou de recherche.

Exemple de code :

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        Collections.sort(people);
        for (Person person : people) {
            System.out.println(person.getName() + ", " + person.getAge());
        }
    }
}

3. Interface Runnable :
L'interface Runnable est une interface fonctionnelle qui définit une méthode pour décrire les tâches exécutables. Les classes qui implémentent l'interface Runnable peuvent être exécutées en tant que tâches de thread.

Exemple de code :

public class MyTask implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyTask());
        Thread t2 = new Thread(new MyTask());

        t1.start();
        t2.start();
    }
}

4. Interface fermable :
L'interface fermable est une interface qui implémente des ressources fermables. Les classes qui implémentent l'interface Closeable peuvent utiliser l'instruction try-with-resources pour fermer automatiquement les ressources.

Exemples de code :

public class MyResource implements Closeable {
    public MyResource() {
        System.out.println("Resource opened");
    }

    public void doSomething() {
        System.out.println("Doing something");
    }

    @Override
    public void close() throws IOException {
        System.out.println("Resource closed");
    }
}

public class Main {
    public static void main(String[] args) {
        try (MyResource resource = new MyResource()) {
            resource.doSomething();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Conclusion :
Cet article présente les interfaces couramment utilisées en Java : interface itérable, interface comparable, interface exécutable et interface fermée, et fournit des exemples de code correspondants. En comprenant les fonctions et l'utilisation de ces interfaces, vous pouvez utiliser les interfaces de manière plus flexible pour organiser et réutiliser le code dans le développement Java quotidien. Dans le même temps, grâce à des exemples de code spécifiques, les lecteurs peuvent mieux comprendre l'utilisation et les effets de fonctionnement de l'interface.

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!