Explication détaillée du mode pont dans les modèles de conception Java-javaDidacticiel-php.cn

Cet article présente principalement le mode pont du modèle de conception Java. Il analyse en détail le concept, la fonction, la méthode d'implémentation Java et les précautions associées sous forme d'exemples. Les amis dans le besoin peuvent se référer à

<.>Cet article L'exemple décrit le mode pont du modèle de conception Java. Partagez-le avec tout le monde pour votre référence, comme suit :

Concept :

Modèle de pont : Séparez la partie abstraite de sa partie d'implémentation afin qu'elles soient toutes les deux. Peut être varié indépendamment.

Le mode pont convertit les relations d'héritage en relations d'association, réduisant ainsi le couplage entre les classes et réduisant la quantité d'écriture de code.

Quand utiliseriez-vous le mode pont ?

Pour faire simple, lorsque nous faisons abstraction des caractéristiques d'un objet, les attributs caractéristiques de l'objet sont très abstraits, et nous devons à nouveau abstraire les attributs.

Sinon, le nombre de sous-classes spécifiques augmentera de façon exponentielle et sera difficile à développer. Il n'y a aucun moyen de conserver le code existant.

Par exemple, lorsque l'on fait abstraction des deux objets du téléphone mobile, plusieurs de ses attributs, comme le système d'exploitation, le CPU, l'écran, le réseau de l'opérateur, etc. sont très complexes. Nous ne pouvons pas simplement définir ces attributs directement, ils doivent être à nouveau abstraits. Un objet de téléphone mobile spécifique est une combinaison de ces attributs, mais ce n'est pas une simple combinaison. Les attributs doivent réaliser leurs propres fonctions en tant qu'attributs. Dans une telle conception, la maintenance et l’expansion du code seront plus faciles.

Remarque : Quand je parle de ce modèle, je ne peux pas garantir que les exemples que je dis et écris sont corrects. Après tout, je suis nouveau dans ce domaine et tous les exemples sont basés sur une compréhension personnelle. .

Ce que je pense de l'illustration du mode pont :

Ce qui suit est un exemple :

1. Définissez d'abord les classes abstraites, abstraites. et description des caractéristiques des objets.

Divisez les dimensions selon les propriétés de l'objet pour de futurs ponts et expansions.

package test.design.bridge;
public abstract class CellPhone {
  private String cellPhoneName;
  public CellPhoneSystem cellPhoneSystem;
  public CellPhoneCPU cellPhoneCPU;
  public void works(){
    System.out.println("---------------------");
    System.out.println("This cellphone is:"+this.getCellPhoneName()+",welcome to use. ");
    System.out.println("This cellphone detail infomation:");
    System.out.println("系统类型："+this.getCellPhoneSystem().getSystemName());
    System.out.println("cpu型号："+this.getCellPhoneCPU().getCpuName());
    System.out.println("---------------------");
  }
  public String getCellPhoneName() {
    return cellPhoneName;
  }
  public void setCellPhoneName(String cellPhoneName) {
    this.cellPhoneName = cellPhoneName;
  }
  public CellPhoneSystem getCellPhoneSystem() {
    return cellPhoneSystem;
  }
  public void setCellPhoneSystem(CellPhoneSystem cellPhoneSystem) {
    this.cellPhoneSystem = cellPhoneSystem;
  }
  public CellPhoneCPU getCellPhoneCPU() {
    return cellPhoneCPU;
  }
  public void setCellPhoneCPU(CellPhoneCPU cellPhoneCPU) {
    this.cellPhoneCPU = cellPhoneCPU;
  }
}

Copier après la connexion

2. Abstraction des dimensions d'attribut. (Vous pouvez utiliser la définition de l'interface, la clé dépend de votre fonction spécifique)

package test.design.bridge;
/**
 * 属性cpu被抽象成一个维度，为了以后扩展
 * @author lushuaiyin
 *
 */
public abstract class CellPhoneCPU {
  public CellPhone cellPhone;
  public String cpuName;
  public void cpuWorks(){
    System.out.println("I am cpu. My pattern is："+this.getCpuName());
    System.out.println("I am working for this cellphone："+this.getCellPhone().getCellPhoneName());
  }
  public CellPhone getCellPhone() {
    return cellPhone;
  }
  public void setCellPhone(CellPhone cellPhone) {
    this.cellPhone = cellPhone;
    this.getCellPhone().setCellPhoneCPU(this);// 装配(桥接，或者可以认为对象类与其属性类的传递)
  }
  public String getCpuName() {
    return cpuName;
  }
  public void setCpuName(String cpuName) {
    this.cpuName = cpuName;
  }
}

Copier après la connexion

package test.design.bridge;
/**
 * 属性操作系统被抽象成一个维度，为了以后扩展
 * @author lushuaiyin
 *
 */
public abstract class CellPhoneSystem {
  public CellPhone cellPhone;
  public String SystemName;
  public void systemWorks(){
    System.out.println("I am "+this.getSystemName()+" system.");
    System.out.println("I am working for this cellphone："+this.getCellPhone().getCellPhoneName());
  }
  public CellPhone getCellPhone() {
    return cellPhone;
  }
  public void setCellPhone(CellPhone cellPhone) {
    this.cellPhone = cellPhone;
    this.getCellPhone().setCellPhoneSystem(this);// 装配(桥接，或者可以认为对象类与其属性类的传递)
  }
  public String getSystemName() {
    return SystemName;
  }
  public void setSystemName(String systemName) {
    SystemName = systemName;
  }
}

Copier après la connexion

3. objets .

Ici, nous définissons 2 objets spécifiques chacun dans les attributs du système d'exploitation et les attributs du processeur,

package test.design.bridge;
public class AndroidSystem extends CellPhoneSystem{
}

Copier après la connexion

package test.design.bridge;
public class IOSSystem extends CellPhoneSystem{
}

Copier après la connexion

package test.design.bridge;
/**
 * 双核cpu
 * @author Administrator
 *
 */
public class TwoCore extends CellPhoneCPU{
}

Copier après la connexion

package test.design.bridge;
/**
 * 四核cpu
 * @author Administrator
 *
 */
public class FourCore extends CellPhoneCPU{
}

Copier après la connexion

4. Testez le code.

Il explique comment agrandir la dimension si cela est nécessaire.

Définir un objet téléphone mobile

package test.design.bridge;
public class Phone1 extends CellPhone{
  //具体对象的属性与逻辑
}

Copier après la connexion

Tester la fonction principale

package test.design.bridge;
public class TestMain {
  /**
   * @param args
   */
  public static void main(String[] args) {
    //任何一种具体的对象都是复杂多种属性的集合，在此可以看出桥接模式在构建对象时的灵活性
    //产生一个具体对象1
    CellPhone p1=new Phone1();
    p1.setCellPhoneName(" IPhone 6 ");
    CellPhoneSystem system1=new IOSSystem();//操作系统属性维度
    system1.setSystemName("ios7");
    system1.setCellPhone(p1);//装配
    system1.systemWorks();//工作
    /*装配说的简单点就是传值。因为我们把一个对象的属性按维度分开来了，
     那么桥接的时候就必须相互传递对象。即对象类可以调用子属相类对象，
     子属性类对象也可以调用该对象类.
     关于这样的传值方式有多种，你可以在构造函数中传递，也可以在
    调用具体逻辑方法时传递。这里我直接用set方法传递，只是为了更清楚.
    如果某个属性维度是必须出现的，那就可以在抽象类的构造函数中传入*/
    CellPhoneCPU cpu1=new TwoCore();//cpu属性维度
    cpu1.setCpuName("A6");
    cpu1.setCellPhone(p1);
    cpu1.cpuWorks();
    p1.works();//最终整体对象功能
    /*
    桥接模式就是为了应对属性的扩展，在此说的属性必须是在维度确定的情况下。
    比如，这里我们在定义手机对象时，确定两个属性维度：操作系统和cpu型号。
    以后再这两个属性中，需要扩展时，就可以使用该模式。比如，一种新的cpu
    型号出现了，那么我不用重新设计现在的代码，只要增添一个cpu类即可。
    如果出现了新的维度属性，比如手机对象必须考虑屏幕大小。那桥接模式
    在此就需要从根本上修改代码来了。
    */
    System.out.println("-----------分割---------------------------");
    //在cpu维度上扩展。比如出现新型cpu：8核三星Exynos 5 Octa芯片".
    //三星手机推出了GALAXY Note Ⅲ就是使用这种新型cpu. 写一个新类EightCore扩展cpu维度.
    //同时定义这个手机对象GALAXY Note Ⅲ为PhoneGalaxyNote3
    CellPhone note3=new PhoneGalaxyNote3();
    note3.setCellPhoneName("GALAXY Note Ⅲ");
    CellPhoneSystem system2=new AndroidSystem();
    system2.setSystemName("android4");
    system2.setCellPhone(note3);//装配
    system2.systemWorks();//工作
    CellPhoneCPU cpu2=new EightCore();//最新8核cpu
    cpu2.setCpuName("三星Exynos 5 Octa芯片");
    cpu2.setCellPhone(note3);
    cpu2.cpuWorks();
    note3.works();//三星GALAXY Note Ⅲ新体验
  }
}

Copier après la connexion

Si nécessaire, définissez de nouveaux attributs de dimension

package test.design.bridge;
public class EightCore extends CellPhoneCPU {
}

Copier après la connexion

package test.design.bridge;
public class PhoneGalaxyNote3 extends CellPhone{
  //具体对象的属性与逻辑
}

Copier après la connexion

Test d'impression ;

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!