Exemple d'analyse de l'implémentation Java de la méthode de rappel d'interface

Le contenu principal de cet article est de vous montrer l'utilisation générale des rappels d'interface dans la programmation Java à travers le code réel. Il a une certaine valeur de référence. Les amis qui en ont besoin peuvent en apprendre davantage

Le rappel d'interface signifie : vous pouvez utiliser un certain Si la référence de l'objet créé par la classe d'une interface est affectée à la variable d'interface déclarée par l'interface, alors la variable d'interface peut appeler la méthode de l'interface implémentée par la classe. En effet, lorsqu'une variable d'interface appelle une méthode dans l'interface implémentée par la classe, elle notifie à l'objet correspondant d'appeler la méthode de l'interface. Ce processus est appelé le rappel d'interface de la fonction objet.

Utilisation générale des rappels d'interface Java : l'implémentation d'interfaces est en fait similaire à l'héritage de classes abstraites, sauf que l'héritage fonctionne au niveau de la classe, tandis que les interfaces fonctionnent au niveau des méthodes et des collections constantes. Les interfaces sont plus flexibles que les interfaces abstraites. cours abstraits et plus simples. L'implémentation d'une interface peut être considérée comme l'héritage d'une ou plusieurs méthodes spécifiques et de certaines constantes. Les règles spécifiques de l'interface ne seront pas décrites ici.

Pourquoi utiliser des interfaces et des classes abstraites ? Car à bien des égards, cela correspond aux idées de conception orientées objet, comme par exemple le principe d'ouverture et de fermeture.

D'un point de vue pratique du développement, Java ne prend pas en charge l'héritage multiple. Pour compenser cela, l'existence d'interfaces est extrêmement importante. Contrairement à l'héritage, une classe peut implémenter plusieurs interfaces.

Une fonction majeure de l'interface est d'implémenter les rappels. Les rappels sont divisés en rappels synchrones et rappels asynchrones. La différence est que les rappels asynchrones utilisent la technologie multi-threading. les rappels, des rappels asynchrones doivent être utilisés.

Ce qui suit utilise tous le rappel asynchrone comme exemple. Ce qui suit utilise l'écriture Java comme exemple, et il en va de même pour Android.

1. Utilisation générale

Créez une nouvelle classe d'entrée Main et créez une nouvelle interface InterfaceExample

public class Main implements InterfaceExample{
  public static void main(String[] args) {
    System.out.println("------接口使用测试--------");
    InterfaceTest test = new InterfaceTest();
    //调用InterfaceTest的handleThings方法，并传递Main的实例
    test.handleThings(new Main());
    System.out.println("------异步回调测试--------");
  }
  @Override  //重写接口方法
  public void sendMessage(String string) {
    System.out.println("接口回调成功，利用 " + string + " 做一些事");
  }
}
 
//接口也可以写在一个独立的.java文件里
interface InterfaceExample {
  void sendMessage(String string);
}

Ce qui suit crée une nouvelle classe InterfaceTest

public class InterfaceTest {
  //注意这里Main实例向上转型，接口变量引用了Main实例
  public void handleThings(InterfaceExample example) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("-----做一些事------");
        try {
          Thread.sleep(3000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        //回调接口方法
        example.sendMessage("接口传的参数");
      }
    }).start();
  }
}

La sortie finale de l'exécution :

------接口使用测试--------
------异步回调测试--------
-----做一些事------
接口回调成功，利用 接口传的参数 做一些事

Un traitement asynchrone peut également être effectué lorsque handleThings est appelé dans Main.

2. Combinez des classes internes anonymes pour implémenter des rappels d'interface

La deuxième méthode n'a besoin que de modifier la classe Main en fonction de la première méthode

public class Main {
  public static void main(String[] args) {
    System.out.println("------接口使用测试--------");
    InterfaceTest test = new InterfaceTest();
    //调用InterfaceTest的handleThings方法，并使用实现了InterfaceExample接口的匿名内部类
    //在该匿名内部类中重写接口方法
    test.handleThings(new InterfaceExample() {
      @Override  //重写接口方法
      public void sendMessage(String string) {
        System.out.println("接口回调成功，利用 " + string + " 做一些事");
      }
    });
    System.out.println("------异步回调测试--------");
  }
}
interface InterfaceExample {
  void sendMessage(String string);
}

Comme vous pouvez le constater, l'utilisation de classes internes anonymes peut simplifier le code et rendre la structure du programme plus claire. Cet usage est donc très courant. Par exemple, l'événement click de la vue fournie par le système Android utilise cette forme de rappel.

Le résultat est le même :

------接口使用测试--------
------异步回调测试--------
-----做一些事------
接口回调成功，利用 接口传的参数 做一些事。

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!