Maison > Article > Java > Introduction au modèle d'adaptateur et au modèle de pont dans les modèles de conception Java (exemple de code)

Introduction au modèle d'adaptateur et au modèle de pont dans les modèles de conception Java (exemple de code)

不言original: 2018-09-12 16:02:391739parcourir

Cet article vous présente une introduction au mode adaptateur et au mode pont dans les modèles de conception Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Préface

Dans l'article précédent, nous avons découvert le modèle de constructeur et le modèle de prototype du modèle créatif. Dans cet article, nous découvrirons le mode adaptateur et le mode pont du mode structurel.

Modèle d'adaptateur

Introduction

Le modèle d'adaptateur sert de pont entre deux interfaces incompatibles. Ce type de modèle de conception est un modèle structurel qui combine les fonctionnalités de deux interfaces indépendantes.

Pour faire simple, deux classes incompatibles sont rendues compatibles via une interface, communément appelée convertisseur.
Un exemple typique dans la vie est la tension des appareils électriques. La tension aux États-Unis est d'environ 110 V, tandis que la tension en Chine est généralement de 220 V. Si nous voulons utiliser des appareils électriques américains ou japonais, nous avons besoin d'un convertisseur pour. convertir 110V en 220V. Un autre exemple typique est l’ancien chargeur universel, qui permettait essentiellement de charger les batteries de différents téléphones portables.

Ici, nous utilisons un exemple simple pour illustrer.
Un certain lecteur vidéo ne peut lire que des vidéos au format MP4, mais en plus du MP4, les formats vidéo courants incluent également AVI, RVMB, etc. À l'heure actuelle, il existe un logiciel, Format Factory, qui est utilisé pour convertir formats vidéo (adaptateur) pour lire la vidéo. À ce stade, nous pouvons utiliser le modèle d'adaptateur pour terminer l'écriture du code.

Il existe deux principaux types de modèles d'adaptateur. L'un est le modèle d'adaptateur de classe, qui implémente principalement les fonctions d'adaptateur par héritage ; l'autre est le modèle d'adaptateur d'objet, qui implémente les fonctions d'adaptateur par combinaison.

Le premier est le mode adaptateur de classe, qui doit suivre les étapes suivantes :

Établir une interface pour les vidéos MP4, AVI, RVMB formats ;
Créer une classe de lecteur vidéo pour implémenter la classe de format vidéo MP4
Écrire une classe d'usine de format pour convertir les fichiers vidéo en AVI ; , RVMB et autres formats Convertir en fichiers au format MP4.
Lisez ces vidéos.

Ensuite, le code est le suivant :

Exemple de code :

    interface Mp4{
        void playMp4();
    }
    
    interface Avi{
        void playAvi();
    }
    
    
    interface Rvmb{
        void playRvmb();
    }
    
    class VideoPlayer implements Mp4{
    
        @Override
        public void playMp4() {
            System.out.println("播放Mp4格式的视频文件.");
        }
    }
    
    
    class FormatFactory extends VideoPlayer  implements Avi{    
        @Override
        public void playAvi() {
            //转换成MP4格式的视频
            playMp4();
        }
    }
    
    
    public static void main(String[] args) {        
            Mp4 mp4=new VideoPlayer();
            mp4.playMp4();
            Avi avi=new FormatFactory();
            avi.playAvi();
    }

Exécuter le résultat :

    播放Mp4格式的视频文件.
    播放Mp4格式的视频文件.

Grâce au code ci-dessus et aux résultats d'exécution, nous pouvons obtenir les résultats souhaités. S'il existe de nouveaux formats vidéo et que nous devons utiliser ce lecteur vidéo pour les lire, il nous suffit d'en ajouter un. l'interface et la classe d'usine de format feront l'affaire.

Modèle d'adaptateur d'objet
La fonction d'adaptateur est implémentée par combinaison.
Il suffit donc ici de modifier l'héritage dans la fabrique de formats pour créer un objet.
Le code après le changement est le suivant :
Exemple de code

class FormatFactory2  implements Rvmb{
        private Mp4 mp4;
        
         public FormatFactory2(Mp4 mp4) {
            this.mp4=mp4;
        }
        
        @Override
        public void playRvmb() {
            mp4.playMp4();
        }   
    }


    public static void main(String[] args) {
    
            Rvmb rvmb=new FormatFactory2(new VideoPlayer());
            rvmb.playRvmb();
            
    }

Résultats en cours d'exécution :

    播放Mp4格式的视频文件.

Ces deux fonctions sont implémentées dans le modèle d'adaptateur, mais il est recommandé d'utiliser le Modèle d'adaptateur d'objet Par rapport au Modèle d'adaptateur de classe, il est plus flexible et conforme à la synthèse. et réutilisation dans le principe de conception :

Essayez d'utiliser la composition/agrégation au lieu de l'héritage.

Avantages du modèle d'adaptateur :

Améliore la réutilisation et la flexibilité des classes.

Inconvénients du mode adaptateur : Si

est trop utilisé, le système sera désordonné et difficile à maîtriser.

Remarque :

L'adaptateur n'est pas ajouté lors de la conception détaillée, mais pour résoudre le problème du projet en service.

Mode Bridge

Introduction

Bridge est utilisé pour découpler l'abstraction et la mise en œuvre afin que les deux puissent changer indépendamment. Ce type de modèle de conception est un modèle structurel qui dissocie l'abstraction et la mise en œuvre en fournissant une structure de pont entre elles.

L'interprétation littérale est de relier les choses des deux côtés par un pont au milieu, mais les deux choses liées ne s'affectent pas. Ce qui m'a le plus impressionné, ce sont les marques de téléphones mobiles et les logiciels mobiles en 12db3c63aeaac454b7e6113240c6531e. Il existe de nombreuses marques de téléphones mobiles, et il existe de nombreux logiciels sur le marché. Les logiciels installés sur chaque téléphone mobile sont différents. , mais le logiciel n'est pas la partie téléphone mobile, ce sont des relations d'agrégation. Si le téléphone mobile de marque A est installé avec les logiciels a et b, et que le téléphone mobile de marque B est installé avec les logiciels b et c, si le téléphone mobile de marque A doit installer un nouveau logiciel c, il lui suffit alors d'ajouter le logiciel sans savoir comment le logiciel est produit. De même, si un nouveau téléphone mobile de marque C est ajouté, il lui suffit alors d'installer le logiciel a, b ou c requis.

D’accord, fini les bêtises, prenons un exemple pour illustrer.
Il existe de nombreux types de stylos sur le marché, tels que des crayons, des stylos à bille noirs, des stylos à bille rouges, etc. Il existe également de nombreux types de papier, tels que du papier pour les épreuves d'examen, du papier journal, etc. D'une manière générale, la couleur des mots sur le journal est noire. Ici, nous utilisons un stylo à bille noir pour écrire. La couleur des mots marqués sur la feuille d'examen est rouge. Les stylos et le papier sont indépendants les uns des autres, mais l'écriture sur papier les associe ici.

实现步骤如下:

定义一个笔类的接口，有写的这个方法；
定义红笔和黑笔的类，实现笔类的接口；
定义一个纸类的抽象类，设置笔的种类，并需要实现被写的方法；
定义卷子纸和新闻纸类，继承纸类并实现该方法；
进行书写。

代码示例

interface Pen{
    void write();
}

class RedPen implements Pen{
    @Override
    public void write() {
        System.out.println("红色的字");
    }
}

class BlackPen implements Pen{
    @Override
    public void write() {
        System.out.println("黑色的字");
    }
}


abstract class  Paper{
    protected  Pen pen;
    
    void setPen(Pen pen){
        this.pen=pen;
    }   
    abstract void writing();
}

class ExaminationPaper extends Paper{
    @Override
    void writing() {
        pen.write();
    }
}

class NewsPaper extends Paper{
    @Override
    void writing() {
        pen.write();
    }
}

public static void main(String[] args) {
        Paper paper=new ExaminationPaper();
        paper.setPen(new RedPen());
        paper.writing();
        
        Paper paper2=new NewsPaper();
        paper2.setPen(new BlackPen());
        paper2.writing();
    }

运行结果

红色的字
黑色的字

从上述结果中我们可以得出我们想要的结果。如果新增一个笔类或者一个纸类，那么只需新增相应的接口和实现即可，并不会因为结构化改变而相互直接影响。

桥接模式的优点:

1、抽象和实现的分离，实现了解耦；
2、提升的扩展能力。

桥接模式的缺点:

会使系统看起复杂，对新手不友好，没有一定的抽象进行设计能力难以理解。

使用场景:

一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

Articles Liés

Voir plus