结构型模式

奔走的蚂蚁~

于 2024-05-01 10:47:13 发布

阅读量595

点赞数 9

分类专栏：设计模式文章标签： java

本文链接：https://blog.csdn.net/qq_34901859/article/details/138367695

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

系列文章目录

结构型模式关注类和对象的组合

继承的概念被用来组合接口和定义组合对象获得新功能的方式

包括

1、适配器模式（AdapterPattern）；
2、桥接模式（BridgePattern）；
3、过滤器模式（Filter、CriteriaPattern）；
4、组合模式（CompositePattern）；
5、装饰器模式（DecoratorPattern）；
6、外观模式（FacadePattern）；
7、享元模式（FlyweightPattern）；
8、代理模式（ProxyPattern）；

适配器模式 ( Adapter Pattern )

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁

适配器模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能

举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡

适配器模式属于结构型模式，它结合了两个独立接口的功能

摘要
1、意图：

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

2、主要解决：

主要解决在软件系统中，常常要将一些”现存的对象”放到新的环境中，而新环境要求的接口是现对象不能满足的

3、何时使用：

1、系统需要使用现有的类，而此类的接口不符合系统的需要；
2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口；
3、通过接口转换，将一个类插入另一个类系中（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口）；

4、如何解决：

继承或依赖（推荐）

5、关键代码：

适配器继承或依赖已有的对象，实现想要的目标接口

6、应用实例：

1、美国电器110V，中国220V，就要有一个适配器将110V转化为220V；
2、 JAVAJDK1.1提供了Enumeration接口，而在1.2中提供了Iterator接口，想要使用1.2的JDK，则要将以前系统的Enumeration接口转化为Iterator接口，这时就需要适配器模式；
3、在LINUX上运行WINDOWS程序；
4、 JAVA中的jdbc；

7、优点：

1、可以让任何两个没有关联的类一起运行；
2、提高了类的复用；
3、增加了类的透明度；
4、灵活性好；

8、缺点：

1、过多地使用适配器，会让系统非常零乱，不易整体进行把握；

比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难

因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构

2、由于JAVA至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类；

9、使用场景：

有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。

10、注意事项：

适配器不是在详细设计时添加的，而是解决正在服役的项目的问题

实现
1、 MediaPlayer接口和一个实现了MediaPlayer接口的实体类AudioPlayer默认情况下，AudioPlayer可以播放mp3格式的音频文件；
2、接口AdvancedMediaPlayer和实现了AdvancedMediaPlayer接口的实体类该类可以播放vlc和mp4格式的文件；
3、让AudioPlayer播放其他格式的音频文件为了实现这个功能，我们需要创建一个实现了MediaPlayer接口的适配器类MediaAdapter，并使用AdvancedMediaPlayer对象来播放所需的格式；
4、 AudioPlayer使用适配器类MediaAdapter传递所需的音频类型，不需要知道能播放所需格式音频的实际类；
5、 AdapterPatternDemo使用AudioPlayer类来播放各种格式；

范例
1、为媒体播放器和更高级的媒体播放器创建接口；

MediaPlayer.java

public interface MediaPlayer {
   public void play(String audioType, String fileName);
}

AdvancedMediaPlayer.java

public interface AdvancedMediaPlayer {  
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}

创建实现了 AdvancedMediaPlayer 接口的实体类
VlcPlayer.java

public class VlcPlayer implements AdvancedMediaPlayer{
   @Override
   public void playVlc(String fileName) {
      System.out.println("Playing vlc file. Name: "+ fileName);     
   }

   @Override
   public void playMp4(String fileName) {
      //什么也不做
   }
}

Mp4Player.java

public class Mp4Player implements AdvancedMediaPlayer{

   @Override
   public void playVlc(String fileName) {
      //什么也不做
   }

   @Override
   public void playMp4(String fileName) {
      System.out.println("Playing mp4 file. Name: "+ fileName);     
   }
}

创建实现了 MediaPlayer 接口的适配器类
MediaAdapter.java

public class MediaAdapter implements MediaPlayer {

   AdvancedMediaPlayer advancedMusicPlayer;

   public MediaAdapter(String audioType){
      if(audioType.equalsIgnoreCase("vlc") ){
         advancedMusicPlayer = new VlcPlayer();         
      } else if (audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer = new Mp4Player();
      } 
   }

   @Override
   public void play(String audioType, String fileName) {
      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer.playVlc(fileName);
      }else if(audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

创建实现了 MediaPlayer 接口的实体类
AudioPlayer.java

public class AudioPlayer implements MediaPlayer {
   MediaAdapter mediaAdapter; 

   @Override
   public void play(String audioType, String fileName) {        

      //播放 mp3 音乐文件的内置支持
      if(audioType.equalsIgnoreCase("mp3")){
         System.out.println("Playing mp3 file. Name: "+ fileName);          
      } 
      //mediaAdapter 提供了播放其他文件格式的支持
      else if(audioType.equalsIgnoreCase("vlc") 
         || audioType.equalsIgnoreCase("mp4")){
         mediaAdapter = new MediaAdapter(audioType);
         mediaAdapter.play(audioType, fileName);
      }
      else{
         System.out.println("Invalid media. "+
            audioType + " format not supported");
      }
   }   
}

使用 AudioPlayer 来播放不同类型的音频格式
AdapterPatternDemo.java

public class AdapterPatternDemo {
   public static void main(String[] args) {
      AudioPlayer audioPlayer = new AudioPlayer();

      audioPlayer.play("mp3", "beyond the horizon.mp3");
      audioPlayer.play("mp4", "alone.mp4");
      audioPlayer.play("vlc", "far far away.vlc");
      audioPlayer.play("avi", "mind me.avi");
   }
}

编译运行以上 Java 范例，输出结果如下

Playing mp3 file. Name: beyond the horizon.mp3
Playing mp4 file. Name: alone.mp4
Playing vlc file. Name: far far away.vlc
Invalid media. avi format not supported

桥接模式 ( Bridge Pattern )

桥接模式（Bridge Pattern）是用于把抽象化与实现化解耦，使得二者可以独立变化

桥接模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类，这两种类型的类可被结构化改变而互不影响

桥接模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦

摘要
1、意图：

将抽象部分与实现部分分离，使它们都可以独立的变化

2、主要解决：

在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活

3、何时使用：

实现系统可能有多个角度分类，每一种角度都可能变化

4、如何解决：

把这种多角度分类分离出来，让它们独立变化，减少它们之间耦合

5、关键代码：

抽象类依赖实现类

6、应用实例：

1、猪八戒从天蓬元帅转世投胎到猪，转世投胎的机制将尘世划分为两个等级，即：灵魂和肉体，前者相当于抽象化，后者相当于实现化；

生灵通过功能的委派，调用肉体对象的功能，使得生灵可以动态地选择
2、墙上的开关，可以看到的开关是抽象的，不用管里面具体怎么实现的；

7、优点：

1、抽象和实现的分离；
2、优秀的扩展能力；
3、实现细节对客户透明；

8、缺点：

桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程

9、使用场景：

1、如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系；
2、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用；
3、一个类存在两个独立变化的维度，且这两个维度都需要进行扩展；

10、注意事项：

对于两个独立变化的维度，使用桥接模式再适合不过了

实现
1、创建一个作为桥接实现的DrawAPI接口和实现了DrawAPI接口的实体类RedCircle、GreenCircle；
2、 Shape是一个抽象类，将使用DrawAPI的对象；
3、 BridgePatternDemo使用Shape类来画出不同颜色的圆；

范例
我们通过下面的实例来演示桥接模式（Bridge Pattern）的用法: 可以使用相同的抽象类方法但是不同的桥接实现类，来画出不同颜色的圆

创建桥接实现接口
DrawAPI.java

public interface DrawAPI {
   public void drawCircle(int radius, int x, int y);
}

创建实现了 DrawAPI 接口的实体桥接实现类
RedCircle.java

public class RedCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: red, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

GreenCircle.java

public class GreenCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: green, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

使用 DrawAPI 接口创建抽象类 Shape
Shape.java

public abstract class Shape {
   protected DrawAPI drawAPI;
   protected Shape(DrawAPI drawAPI){
      this.drawAPI = drawAPI;
   }
   public abstract void draw(); 
}

创建实现了 Shape 接口的实体类
Circle.java

public class Circle extends Shape {
   private int x, y, radius;

   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
      super(drawAPI);
      this.x = x;  
      this.y = y;  
      this.radius = radius;
   }

   public void draw() {
      drawAPI.drawCircle(radius,x,y);
   }
}

使用 Shape 和 DrawAPI 类画出不同颜色的圆
BridgePatternDemo.java

public class BridgePatternDemo {
   public static void main(String[] args) {
      Shape redCircle = new Circle(100,100, 10, new RedCircle());
      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());

      redCircle.draw();
      greenCircle.draw();
   }
}

编译运行以上 Java 范例，输出结果如下

Drawing Circle[ color: red, radius: 10, x: 100, 100]
Drawing Circle[  color: green, radius: 10, x: 100, 100]

过滤器模式 ( Filter Pattern )

过滤器模式（Filter Pattern）或允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来

过滤器模式（Filter Pattern）又称标准模式（Criteria Pattern）

过滤器模式属于结构型模式，它结合多个标准来获得单一标准

实现
1、创建一个Person对象、Criteria接口和实现了该接口的实体类，来过滤Person对象的列表；
2、 CriteriaPatternDemo使用Criteria对象，基于各种标准和它们的结合来过滤Person对象的列表；

范例

创建一个类，在该类上应用标准
Person.java

public class Person {

   private String name;
   private String gender;
   private String maritalStatus;

   public Person(String name,String gender,String maritalStatus){
      this.name = name;
      this.gender = gender;
      this.maritalStatus = maritalStatus;       
   }

   public String getName() {
      return name;
   }
   public String getGender() {
      return gender;
   }
   public String getMaritalStatus() {
      return maritalStatus;
   }    
}

为标准（Criteria）创建一个接口
Criteria.java

public interface Criteria {
   public List<Person> meetCriteria(List<Person> persons);
}

创建实现了 Criteria 接口的实体类
CriteriaMale.java

public class CriteriaMale implements Criteria {

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> malePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getGender().equalsIgnoreCase("MALE")){
            malePersons.add(person);
         }
      }
      return malePersons;
   }
}

CriteriaFemale.java

public class CriteriaFemale implements Criteria {

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> femalePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getGender().equalsIgnoreCase("FEMALE")){
            femalePersons.add(person);
         }
      }
      return femalePersons;
   }
}

CriteriaSingle.java

public class CriteriaSingle implements Criteria {

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> singlePersons = new ArrayList<Person>(); 
      for (Person person : persons) {
         if(person.getMaritalStatus().equalsIgnoreCase("SINGLE")){
            singlePersons.add(person);
         }
      }
      return singlePersons;
   }
}

AndCriteria.java

public class AndCriteria implements Criteria {

   private Criteria criteria;
   private Criteria otherCriteria;

   public AndCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria; 
   }

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);       
      return otherCriteria.meetCriteria(firstCriteriaPersons);
   }
}

OrCriteria.java

public class OrCriteria implements Criteria {

   private Criteria criteria;
   private Criteria otherCriteria;

   public OrCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria; 
   }

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
      List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);

      for (Person person : otherCriteriaItems) {
         if(!firstCriteriaItems.contains(person)){
            firstCriteriaItems.add(person);
         }
      } 
      return firstCriteriaItems;
   }
}

使用不同的标准（Criteria）和它们的结合来过滤 Person 对象的列表
CriteriaPatternDemo.java

public class CriteriaPatternDemo {
   public static void main(String[] args) {
      List<Person> persons = new ArrayList<Person>();

      persons.add(new Person("Robert","Male", "Single"));
      persons.add(new Person("John","Male", "Married"));
      persons.add(new Person("Laura","Female", "Married"));
      persons.add(new Person("Diana","Female", "Single"));
      persons.add(new Person("Mike","Male", "Single"));
      persons.add(new Person("Bobby","Male", "Single"));

      Criteria male = new CriteriaMale();
      Criteria female = new CriteriaFemale();
      Criteria single = new CriteriaSingle();
      Criteria singleMale = new AndCriteria(single, male);
      Criteria singleOrFemale = new OrCriteria(single, female);

      System.out.println("Males: ");
      printPersons(male.meetCriteria(persons));

      System.out.println("\nFemales: ");
      printPersons(female.meetCriteria(persons));

      System.out.println("\nSingle Males: ");
      printPersons(singleMale.meetCriteria(persons));

      System.out.println("\nSingle Or Females: ");
      printPersons(singleOrFemale.meetCriteria(persons));
   }

   public static void printPersons(List<Person> persons){
      for (Person person : persons) {
         System.out.println("Person : [ Name : " + person.getName() 
            +", Gender : " + person.getGender() 
            +", Marital Status : " + person.getMaritalStatus()
            +" ]");
      }
   }      
}

编译运行以上 Java 范例，输出结果如下

Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : John, Gender : Male, Marital Status : Married ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Females: 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]

Single Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Single Or Females: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]

组合模式 ( Composite Pattern )

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象

组合模式依据树形结构来组合对象，用来表示部分以及整体层次

组合模式创建了一个包含自己对象组的类，该类提供了修改相同对象组的方式。

组合模式属于结构型模式，它创建了对象组的树形结构

摘要
1、意图：

将对象组合成树形结构以表示”部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性

2、主要解决：

它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦

3、何时使用：

1、您想表示对象的部分-整体层次结构（树形结构）；
2、希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象；

4、如何解决：

树枝和叶子实现统一接口，树枝内部组合该接口

5、关键代码：

树枝内部组合该接口，并且含有内部属性 List，里面放 Component

6、应用实例：

1、算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作树、操作符和另一个操作数；
2、在JAVAAWT和SWING中，对于Button和Checkbox是树叶，Container是树枝；

7、优点：

1、高层模块调用简单；
2、节点自由增加；

8、缺点：

在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则

9、使用场景：

部分、整体场景，如树形菜单，文件、文件夹的管理

10、注意事项：

定义时为具体类

实现

1、类Employee，该类被当作组合模型类；
2、 CompositePatternDemo类使用Employee类来添加部门层次结构，并打印所有员工；

范例

创建 Employee 类，该类带有 Employee 对象的列表
Employee.java

public class Employee {
   private String name;
   private String dept;
   private int salary;
   private List<Employee> subordinates;

   //构造函数
   public Employee(String name,String dept, int sal) {
      this.name = name;
      this.dept = dept;
      this.salary = sal;
      subordinates = new ArrayList<Employee>();
   }

   public void add(Employee e) {
      subordinates.add(e);
   }

   public void remove(Employee e) {
      subordinates.remove(e);
   }

   public List<Employee> getSubordinates(){
     return subordinates;
   }

   public String toString(){
      return ("Employee :[ Name : "+ name 
      +", dept : "+ dept + ", salary :"
      + salary+" ]");
   }   
}

使用 Employee 类来创建和打印员工的层次结构
CompositePatternDemo.java

public class CompositePatternDemo {
   public static void main(String[] args) {
      Employee CEO = new Employee("John","CEO", 30000);

      Employee headSales = new Employee("Robert","Head Sales", 20000);

      Employee headMarketing = new Employee("Michel","Head Marketing", 20000);

      Employee clerk1 = new Employee("Laura","Marketing", 10000);
      Employee clerk2 = new Employee("Bob","Marketing", 10000);

      Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
      Employee salesExecutive2 = new Employee("Rob","Sales", 10000);

      CEO.add(headSales);
      CEO.add(headMarketing);

      headSales.add(salesExecutive1);
      headSales.add(salesExecutive2);

      headMarketing.add(clerk1);
      headMarketing.add(clerk2);

      //打印该组织的所有员工
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }     
   }
}

编译运行以上 Java 范例，输出结果如下

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]

装饰器模式 ( Decorator Pattern )

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构

装饰器模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能

装饰器模式属于结构型模式，它是作为现有的类的一个包装

摘要
1、意图：

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活

2、主要解决：

一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀

3、何时使用：

在不想增加很多子类的情况下扩展类

4、如何解决：

将具体功能职责划分，同时继承装饰者模式

5、关键代码：

1、 Component类充当抽象角色，不应该具体实现；
2、修饰类引用和继承Component类，具体扩展类重写父类方法；

6、应用实例：

1、孙悟空有72变，当他变成”庙宇”后，他的根本还是一只猴子，但是他又有了庙宇的功能；
2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体；

7、优点：

装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能

8、缺点：

多层装饰比较复杂

9、使用场景：

1、扩展一个类的功能；
2、动态增加功能，动态撤销；

10、注意事项：

可代替继承

实现
1、创建一个Shape接口和实现了Shape接口的实体类；
2、创建一个实现了Shape接口的抽象装饰类ShapeDecorator，并把Shape对象作为它的实例变量；
3、创建类RedShapeDecorator实现了ShapeDecorator实体类；
4、创建类DecoratorPatternDemo使用RedShapeDecorator来装饰Shape对象；

范例
我们通过下面的范例来演示装饰器模式的用法，其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类

创建一个接口
Shape.java

public interface Shape {
   void draw();
}

创建实现接口的实体类
Rectangle.java

public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Shape: Rectangle");
   }
}

Circle.java

public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Shape: Circle");
   }
}

创建实现了 Shape 接口的抽象装饰类
ShapeDecorator.java

public abstract class ShapeDecorator implements Shape {
   protected Shape decoratedShape;

   public ShapeDecorator(Shape decoratedShape){
      this.decoratedShape = decoratedShape;
   }

   public void draw(){
      decoratedShape.draw();
   }    
}

创建扩展了 ShapeDecorator 类的实体装饰类
RedShapeDecorator.java

public class RedShapeDecorator extends ShapeDecorator {

   public RedShapeDecorator(Shape decoratedShape) {
      super(decoratedShape);        
   }

   @Override
   public void draw() {
      decoratedShape.draw();           
      setRedBorder(decoratedShape);
   }

   private void setRedBorder(Shape decoratedShape){
      System.out.println("Border Color: Red");
   }
}

使用 RedShapeDecorator 来装饰 Shape 对象
DecoratorPatternDemo.java

public class DecoratorPatternDemo {
   public static void main(String[] args) {

      Shape circle = new Circle();

      Shape redCircle = new RedShapeDecorator(new Circle());

      Shape redRectangle = new RedShapeDecorator(new Rectangle());
      System.out.println("Circle with normal border");
      circle.draw();

      System.out.println("\nCircle of red border");
      redCircle.draw();

      System.out.println("\nRectangle of red border");
      redRectangle.draw();
   }
}

编译运行以上 Java 范例，输出结果如下

Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red

外观模式 ( Facade Pattern )

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口

外观模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用

外观模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性

摘要
1、意图：

为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用

2、主要解决：

降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口

3、何时使用：

1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个”接待员”即可；
2、定义系统的入口；

4、如何解决：

客户端不与系统耦合，外观类与系统耦合

5、关键代码：

在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好

6、应用实例：

1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便；
2、 JAVA的三层开发模式；

7、优点：

1、减少系统相互依赖；
2、提高灵活性；
3、提高了安全性；

8、缺点：

不符合开闭原则，如果要改东西很麻烦，继承重写都不合适

9、使用场景：

1、为复杂的模块或子系统提供外界访问的模块；
2、子系统相对独立；
3、预防低水平人员带来的风险；

10、注意事项：

在层次化结构中，可以使用外观模式定义系统中每一层的入口

实现
1、创建一个Shape接口和实现了Shape接口的实体类；
2、定义一个外观类ShapeMaker；
3、定义类ShapeMaker使用实体类来代表用户对这些类的调用；
4、定义类FacadePatternDemo使用ShapeMaker类来显示结果；

范例

创建一个接口
Shape.java

public interface Shape {
   void draw();
}

创建实现接口的实体类
Rectangle.java

public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Rectangle::draw()");
   }
}

Square.java

public class Square implements Shape {

   @Override
   public void draw() {
      System.out.println("Square::draw()");
   }
}

Circle.java

public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Circle::draw()");
   }
}

创建一个外观类
ShapeMaker.java

public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
   private Shape square;

   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }

   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }
   public void drawSquare(){
      square.draw();
   }
}

使用该外观类画出各种类型的形状
FacadePatternDemo.java

public class FacadePatternDemo {
   public static void main(String[] args) {
      ShapeMaker shapeMaker = new ShapeMaker();

      shapeMaker.drawCircle();
      shapeMaker.drawRectangle();
      shapeMaker.drawSquare();      
   }
}

编译运行以上 Java 范例，输出结果如下

Circle::draw()
Rectangle::draw()
Square::draw()

享元模式 ( Flyweight Pattern )

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能

享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象

这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式

摘要
1、意图：

运用共享技术有效地支持大量细粒度的对象

2、主要解决：

在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建

3、何时使用：

1、系统中有大量对象；
2、这些对象消耗大量内存；
3、这些对象的状态大部分可以外部化；
4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替；
5、系统不依赖于这些对象身份，这些对象是不可分辨的；

4、如何解决：

用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象

5、关键代码：

用HashMap 存储这些对象

6、应用实例：

1、 JAVA中的String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面；
2、数据库的数据池；

7、优点：

大大减少对象的创建，降低系统的内存，使效率提高

8、缺点：

提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱

9、使用场景：

1、系统有大量相似对象；
2、需要缓冲池的场景；

10、注意事项：

1、注意划分外部状态和内部状态，否则可能会引起线程安全问题；
2、这些类必须有一个工厂对象加以控制；

实现
1、定义一个Shape接口和实现了Shape接口的实体类Circle；
2、定义工厂类ShapeFactory；

*ShapeFactory* 有一个 *Circle* 的 *HashMap* ，其中键名为 *Circle* 对象的颜色

无论何时接收到请求，都会创建一个特定颜色的圆

*ShapeFactory* 检查它的 *HashMap* 中的 circle 对象，如果找到 *Circle* 对象，则返回该对象，否则将创建一个存储在 hashmap 中以备后续使用的新对象，并把该对象返回到客户端

3、定义类FlyWeightPatternDemo使用ShapeFactory来获取Shape对象；

它将向 *ShapeFactory* 传递信息（ *red / green / blue/ black / white* ），以便获取它所需对象的颜色

范例
我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式

由于只有 5 种可用的颜色，所以 color 属性被用来检查现有的 Circle 对象

定义一个接口
Shape.java

public interface Shape
{
   void draw();
}

创建实现接口的实体类
Circle.java

public class Circle implements Shape {
   private String color;
   private int x;
   private int y;
   private int radius;

   public Circle(String color){
      this.color = color;       
   }

   public void setX(int x) {
      this.x = x;
   }

   public void setY(int y) {
      this.y = y;
   }

   public void setRadius(int radius) {
      this.radius = radius;
   }

   @Override
   public void draw() {
      System.out.println("Circle: Draw() [Color : " + color 
         +", x : " + x +", y :" + y +", radius :" + radius);
   }
}

创建一个工厂，生成基于给定信息的实体类的对象
ShapeFactory.java

public class ShapeFactory {
   private static final HashMap<String, Shape> circleMap = new HashMap();

   public static Shape getCircle(String color) {
      Circle circle = (Circle)circleMap.get(color);

      if(circle == null) {
         circle = new Circle(color);
         circleMap.put(color, circle);
         System.out.println("Creating circle of color : " + color);
      }
      return circle;
   }
}

使用该工厂，通过传递颜色信息来获取实体类的对象
FlyweightPatternDemo.java

public class FlyweightPatternDemo {
   private static final String colors[] = 
      { "Red", "Green", "Blue", "White", "Black" };
   public static void main(String[] args) {

      for(int i=0; i < 20; ++i) {
         Circle circle = 
            (Circle)ShapeFactory.getCircle(getRandomColor());
         circle.setX(getRandomX());
         circle.setY(getRandomY());
         circle.setRadius(100);
         circle.draw();
      }
   }
   private static String getRandomColor() {
      return colors[(int)(Math.random()*colors.length)];
   }
   private static int getRandomX() {
      return (int)(Math.random()*100 );
   }
   private static int getRandomY() {
      return (int)(Math.random()*100);
   }
}

编译运行以上 Java 范例，输出结果如下

Creating circle of color : Black
Circle: Draw() [Color : Black, x : 36, y :71, radius :100
Creating circle of color : Green
Circle: Draw() [Color : Green, x : 27, y :27, radius :100
Creating circle of color : White
Circle: Draw() [Color : White, x : 64, y :10, radius :100
Creating circle of color : Red
Circle: Draw() [Color : Red, x : 15, y :44, radius :100
Circle: Draw() [Color : Green, x : 19, y :10, radius :100
Circle: Draw() [Color : Green, x : 94, y :32, radius :100
Circle: Draw() [Color : White, x : 69, y :98, radius :100
Creating circle of color : Blue
Circle: Draw() [Color : Blue, x : 13, y :4, radius :100
Circle: Draw() [Color : Green, x : 21, y :21, radius :100
Circle: Draw() [Color : Blue, x : 55, y :86, radius :100
Circle: Draw() [Color : White, x : 90, y :70, radius :100
Circle: Draw() [Color : Green, x : 78, y :3, radius :100
Circle: Draw() [Color : Green, x : 64, y :89, radius :100
Circle: Draw() [Color : Blue, x : 3, y :91, radius :100
Circle: Draw() [Color : Blue, x : 62, y :82, radius :100
Circle: Draw() [Color : Green, x : 97, y :61, radius :100
Circle: Draw() [Color : Green, x : 86, y :12, radius :100
Circle: Draw() [Color : Green, x : 38, y :93, radius :100
Circle: Draw() [Color : Red, x : 76, y :82, radius :100
Circle: Draw() [Color : Blue, x : 95, y :82, radius :100

代理模式 ( Proxy Pattern )

代理模式（Proxy Pattern）使用一个类代表另一个类的功能

代理模式创建具有现有对象的对象，以便向外界提供功能接口

代理模式属于结构型模式

摘要
1、意图：

为其他对象提供一种代理以控制对这个对象的访问

2、主要解决：

在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上

在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层

3、何时使用：

想在访问一个类时做一些控制

4、如何解决：增加中间层；

5、关键代码：实现与被代理类组合；

6、应用实例：

1、买火车票不一定在火车站买，也可以去代售点；
2、一张支票或银行存单是账户中资金的代理，支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制；
3、 springaop；

7、优点：

1、职责清晰；
2、高扩展性；
3、智能化；

8、缺点：

1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢；
2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂；

9、使用场景：

1、远程代理；
2、虚拟代理；
3、 Copy-on-Write代理；
4、保护（ProtectorAccess）代理；
5、 Cache代理；
6、防火墙（Firewall）代理；
7、同步化（Synchronization）代理；
8、智能引用（SmartReference）代理；

10、注意事项：

1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口；
2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制；

实现
1、定义一个Image接口和实现了Image接口的实体类；
2、定义代理类ProxyImage，减少RealImage对象加载的内存占用；
3、定义类ProxyPatternDemo使用ProxyImage来获取要加载的Image对象，并按照需求进行显示；

范例

创建一个接口
Image.java

public interface Image {
   void display();
}

创建实现接口的实体类
RealImage.java

public class RealImage implements Image {

   private String fileName;

   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }

   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }

   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

ProxyImage.java

public class ProxyImage implements Image{

   private RealImage realImage;
   private String fileName;

   public ProxyImage(String fileName){
      this.fileName = fileName;
   }

   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

当被请求时，使用 ProxyImage 来获取 RealImage 类的对象
ProxyPatternDemo.java

public class ProxyPatternDemo {

   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");

      //图像将从磁盘加载
      image.display(); 
      System.out.println("");
      //图像将无法从磁盘加载
      image.display();  
   }
}

编译运行以上 Java 范例，输出结果如下

Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

奔走的蚂蚁~

关注

9
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
结构型模式

结构型模式关注类和对象的组合继承的概念被用来组合接口和定义组合对象获得新功能的方式包括1、适配器模式（AdapterPattern）；2、桥接模式（BridgePattern）；3、过滤器模式（Filter、CriteriaPattern）；4、组合模式（CompositePattern）；5、装饰器模式（DecoratorPattern）；6、外观模式（FacadePattern）；7、享元模式（FlyweightPattern）；
复制链接

扫一扫