Qu'est-ce que le modèle d'adaptateur (Adapter) en Java ? Modèle d'adaptateur (explication détaillée)

Ce que cet article vous apporte, c'est qu'est-ce que le modèle d'adaptateur (Adapter) en Java ? Modèle d'adaptateur (explication détaillée). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Objectif : Adapter le type source au type cible pour répondre aux besoins du client (Client) ici nous considérons l'appelant de l'interface cible comme le client

Scénarios d'utilisation : Dans les scénarios où le type doit être converti du type source en type cible

Conditions préalables  : Client existant

//Client 一个调用目标接口的方法
Class ClientInvoking {

    static void invoke(TargetInterface target) {
        String value = target.getMark();
        System.out.println(value);
    }

}

Plusieurs modes couramment utilisés

Mode 1 : Il existe une interface cible et des méthodes existantes

//目标接口
public interface TargetInterface {
    
    public String getMark();

    public String getInfo();

}

//已有类及方法
public class ExistClass {

    public String sayHello() {
        return "Hello";
    }
      
    public String sayWorld() {
        return "World";
    }
}

Nous supposons que la chaîne renvoyée par ExistClass est exactement ce que notre client doit utiliser, mais quel est le Le besoin du client est de l'obtenir via un objet de type TargetInterface, il faut donc trouver un moyen d'adapter la classe existante pour qu'elle puisse répondre aux besoins du client il existe deux solutions applicatives dans ce mode :

Solution 1. Modèle d'adaptateur de classe

//适配器
public class ClassAdapter extends ExistClass implements TargetInterface {
    
    public int getMark() {
        String value = this.sayHello();
        return value;
    }
    
    public int getInfo() {
        String value = this.sayWorld();
        return value;
    }
    
}

//客户端调用
TargetInterface target = new ClassAdapter();
ClientInvoking.invoke(target);

Du concept d'interface Java, on peut voir que ClassAdapter, en tant que classe d'implémentation de TargetInterface, peut être transformé vers le haut en le type TargetInterface et s’adapter aux besoins du Client.

Solution 2. Modèle d'adaptateur d'objet

//适配器
public class ClassAdapter implements TargetInterface {
    
    private ExistClass exist;
    
    public ClassAdapter(ExistClass existClass) {
        this.exist = existClass;
    }
    
    public int getMark() {
        String value = exist.sayHello();
        return value;
    }
    
    public int getInfo() {
        String value = exist.sayWorld();
        return value;
    }
    
}

//客户端调用
TargetInterface target = new ClassAdapter(new ExistClass());
ClientInvoking.invoke(target);

Cette solution est similaire au modèle d'adaptateur de classe, sauf qu'elle le fait ne pas utiliser l'héritage. La manière de conserver les objets est plus flexible et plus évolutive.

Mode 2 : Il n'y a pas d'interface cible, mais il existe une classe cible, et il existe des méthodes existantes

Vérifions d'abord les conditions préalables Le client est modifié comme suit :

Class ClientInvoking {

    static void invoke(TargetClass target) {
        String value = target.getMark();
        System.out.println(value);
    }

}

Après la modification, la méthode d'invocation nécessite un objet de la classe TargetClass en paramètre ; voici la classe cible et les classes existantes

//目标类
public class Class {
    
    public String getMark() {
        return "yes";
    }

    public String getInfo() {
        return "no";
    }

}

//已有类及方法
public class ExistClass {

    public String sayHello() {
        return "Hello";
    }
      
    public String sayWorld() {
        return "World";
    }
}

Nous supposons que la chaîne renvoyée par ExistClass est exactement ce que notre client doit utiliser, et que le contenu de l'objet TargetClass requis dans le client est obsolète, nous besoin de gérer ExistClass en conséquence S'adapter pour répondre aux besoins du client

//适配器
public class ClassAdapter extends TargetClass {
    
    private ExistClass exist;
    
    public ClassAdapter(ExistClass existClass) {
        this.exist = existClass;
    }
    
    public int getMark() {
        String value = exist.sayHello();
        return value;
    }
    
    public int getInfo() {
        String value = exist.sayWorld();
        return value;
    }
    
}

//客户端调用
TargetClass target = new ClassAdapter(new ExistClass());
ClientInvoking.invoke(target);

Dans ce mode, deux classes sont conçues, et finalement une transformation vers le haut est nécessaire en fonction. à Java Avec le mécanisme d'héritage unique, nous ne pouvons utiliser que la forme de détention d'objets, c'est-à-dire le modèle d'adaptateur d'objet.

Mode 3 : Mode adaptateur par défaut

Dans ce mode, il n'y a pas de type de cible explicite, mais seulement le type de source ; pour l'utiliser, souvent parce que le type source fournit trop de choses dont nous n'avons pas besoin et que nous devons le personnaliser via le mode adaptateur. Prenons WindowListener comme exemple pour expliquer :

//WindowListener源码
public interface WindowListener extends EventListener {
    public void windowOpened(WindowEvent e);
    public void windowClosing(WindowEvent e);
    public void windowClosed(WindowEvent e);
    ...
}

//添加监听器的例子
Frame frame = new Frame();
frame.addWindowListener(new WindowListener() {
    @Override    
    public void windowOpened(WindowEvent e) {
            
    }

    @Override    
    public void windowClosing(WindowEvent e) {

    }

    @Override    
    public void windowClosed(WindowEvent e) {

    }
    ...
})

Un tel code semble très fastidieux, par exemple, j'ai seulement besoin d'écouter l'événement de clôture, mais je génère beaucoup de messages ; ce code de modèle non pertinent réduit la lisibilité du code. Compte tenu de cela, nous allons le personnaliser et n'écouter qu'une seule interface

Nous fournissons d'abord une classe abstraite pour implémenter l'interface, Et fournissez des implémentations vides pour tous les auditeurs ; puis utilisez une sous-classe de la classe abstraite pour réécrire l'implémentation de l'écouteur là où la fenêtre se ferme :

//适配器
public abstract ListenerAdapter implements WindowListener {
    public void windowOpened(WindowEvent e) {}
    public void windowClosing(WindowEvent e) {}
    public void windowClosed(WindowEvent e) {}
    ...
}

.

//重写方法
public class OverrideWindowClosing extends ListenerAdapter {
    
    @Override    
    public void windowClosing(WindowEvent e) {        
       //TODO    
    }
    
}

//客户端调用
frame.addWindowListener(new OverrideWindowClosing());

Cette méthode simplifie l'interface et améliore la lisibilité du code. Le plus important est que nous avons réalisé la personnalisation de l'interface et que nous ne pouvons faire que les choses qui nous tiennent à cœur.

Résumé : Ce qui précède représente l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'étude de chacun. Pour plus de didacticiels connexes, veuillez visiter le

Tutoriel vidéo Java

, le Tutoriel graphique de développement Java, le Tutoriel vidéo bootstrap !

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!