Définir le modèle d'adaptateur du modèle de conception
1. Mode adaptateur
1.1 Définition et caractéristiques
La définition du modèle d'adaptateur (Adapter) est la suivante: utilisez une classe existante et son interface ne répond pas à nos besoins. A ce moment, conformément au principe d'ouverture et de fermeture, il faut créer une classe qui réponde à nos besoins (ajout de fonctions d'interface indépendantes ou incompatibles) et implémente les interfaces existantes. Le modèle d'adaptateur est divisé en deux types: un mode de structure de classe et un mode de structure d'objet. Le premier a un degré de couplage plus élevé que le second, et nécessite que le programmeur comprenne la structure interne des composants associés dans la bibliothèque de composants existante, donc il y a relativement peu d'applications Certains.
Les principaux avantages de ce modèle sont les suivants:
- Le client peut appeler en toute transparence l'interface cible via l'adaptateur.
- Les classes existantes sont réutilisées et les programmeurs n'ont pas besoin de modifier le code d'origine pour réutiliser les classes d'adaptateur existantes.
- Le découplage de la classe cible et de la classe d'adaptateur résout le problème des interfaces incohérentes entre la classe cible et la classe d'adaptateur.
L'inconvénient est que pour l'adaptateur de classe, le processus d'implémentation de remplacement de l'adaptateur est plus compliqué.
1.2 Structure du modèle
Le mode adaptateur (Adapter) contient les rôles principaux suivants.
- Interface cible (cible): l'interface attendue par l'activité système actuelle, il peut s'agir d'une classe ou d'une interface abstraite.
- Classe Adaptee (Adaptee): c'est l'interface de composant de la bibliothèque de composants existante qui est accessible et adaptée.
- Classe Adapter (Adapter): il s'agit d'un convertisseur qui convertit l'interface d'adaptateur en interface cible en héritant ou en référençant l'objet adaptateur, permettant aux clients d'accéder à l'adaptateur au format de l'interface cible.
1.3 Diagramme UML
1.4 Origine du problème
Dans la vie réelle, il y a souvent des cas où deux objets ne peuvent pas fonctionner ensemble en raison d'interfaces incompatibles. Dans ce cas, un tiers doit s'adapter. Par exemple, un ordinateur portable qui utilise l'alimentation CC a besoin d'un adaptateur secteur lorsqu'il est connecté à l'alimentation CA et d'un lecteur de carte qui doit être utilisé pour accéder à la carte mémoire SD de l'appareil photo à l'aide d'un ordinateur.
Il peut également apparaître dans la conception de logiciels: les composants avec certaines fonctions métier qui doivent être développées existent déjà dans la bibliothèque de composants existante, mais ils ne sont pas compatibles avec les spécifications d'interface système actuelles. Si le coût de redéveloppement de ces composants est très élevé, cela Le mode adaptateur peut bien résoudre ces problèmes
1.5 Solution
Il existe deux façons de le résoudre. La première est le modèle d'adaptateur de classe. L'idée principale est d'implémenter l'adaptation par héritage, c'est-à-dire d'hériter de nouvelles classes de fonctions métier basées sur les composants d'origine. La seconde est le modèle d'adaptateur d'objet. L'idée principale est de Les objets de la nouvelle classe de fonction métier sont injectés dans les composants d'origine, puis remplissent le rôle d'adaptation
1.6 Solution
1. Mode adaptateur de classe
/**
* @author 26530
* HDMI接口
*/
public interface HDMIPort
{
void useHDMIPort();
}
/**
* @author 26530
* 数据转换线
*/
public class DataConversionLine
{
public void vgaToHdmi()
{
System.out.println("将VGA数据传输转为HDMI");
}
}
/**
* @author 26530
* 笔记本电脑
*/
public class LaptopComputer extends DataConversionLine implements HDMIPort
{
@Override
public void useHDMIPort()
{
System.out.println("使用的HDMI接口");
}
}
/**
* @author 26530
* 投影仪
*/
public class Projector
{
public void dataLine()
{
System.out.println("投影仪使用的是VGA接口的数据线");
}
}
public class Test
{
public static void main(String[] args)
{
//笔记本想连接投影仪,但是笔记本自身的接口是HDMI，投影仪的接口是VGA的。
//为解决这个问题，我们需要一个适配器，把vga的接口转为hdmi，通过这个适配器就可以实现笔记本电脑和投影仪连接了
Projector projector = new Projector();
projector.dataLine();
LaptopComputer laptopComputer = new LaptopComputer();
laptopComputer.vgaToHdmi();
laptopComputer.useHDMIPort();
/*
投影仪使用的是VGA接口的数据线
将VGA数据传输转为HDMI
使用的HDMI接口
*/
//这样就实现了笔记本和投影仪相连接
}
}
2. Modèle d'adaptateur d'objet
/**
* @author 26530
* HDMI接口
*/
public interface HDMIPort
{
void useHDMIPort();
}
/**
* @author 26530
* 数据转换线
*/
public class DataConversionLine
{
public void vgaToHdmi()
{
System.out.println("将VGA数据传输转为HDMI");
}
}
/**
* @author 26530
* 笔记本电脑
*/
public class LaptopComputer implements HDMIPort
{
private DataConversionLine dataConversionLine;
public LaptopComputer(DataConversionLine dataConversionLine) {
super();
this.dataConversionLine = dataConversionLine;
}
public LaptopComputer() {
super();
// TODO Auto-generated constructor stub
}
@Override
public void useHDMIPort()
{
System.out.println("使用的HDMI接口");
}
public DataConversionLine getDataConversionLine() {
return dataConversionLine;
}
public void setDataConversionLine(DataConversionLine dataConversionLine) {
this.dataConversionLine = dataConversionLine;
}
}
/**
* @author 26530
* 投影仪
*/
public class Projector
{
public void dataLine()
{
System.out.println("投影仪使用的是VGA接口的数据线");
}
}
public class Test
{
public static void main(String[] args)
{
//笔记本想连接投影仪,但是笔记本自身的接口是HDMI，投影仪的接口是VGA的。
//为解决这个问题，我们需要一个适配器，把vga的接口转为hdmi，通过这个适配器就可以实现笔记本电脑和投影仪连接了
Projector projector = new Projector();
projector.dataLine();
DataConversionLine dataConversionLine = new DataConversionLine();
LaptopComputer laptopComputer = new LaptopComputer(dataConversionLine);
laptopComputer.getDataConversionLine().vgaToHdmi();
laptopComputer.useHDMIPort();
/*
投影仪使用的是VGA接口的数据线
将VGA数据传输转为HDMI
使用的HDMI接口
*/
//这样就实现了笔记本和投影仪相连接
}
}
