设计模式-结构型模式总结实例（三）

装饰模式

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

 

 

Component（被装饰对象基类）： 定义对象的接口，可以给这些对象动态增加职责。

ConcreteComponent（具体被装饰对象）：定义具体的对象，Decorator可以给它增加额外的职责。

Decorator（装饰者抽象类）：维护一个指向Component实例的引用，并且定义了与Component一致的接口。

ConcreteDecorator（具体装饰者） ：具体的装饰对象，给内部持有的具体被装饰对象增加具体的职责。

 

package com.ruishenh.designPatter.structure.decorator;
 
public class DecoratorClient {
   public static void main(String[] args) {
     
      //定义一个卧室
      House house =new BedRoom();
      //定义一个装饰者可以随时往卧室中添加新东西
      House upfitter=new DoubleControlDecorator(new ConcreteDecorator(house));
      //装修
      upfitter.fitting();
   }
}
 
//抽象要装修房子--被装饰对象基类
abstract class House{
   abstract void fitting();
}
//卧室--具体被装饰对象
class BedRoom extends House{
   @Override
   void fitting() {
      System.out.println("房子正在装修:");
      System.out.println("房子安装了灯");
   }
  
}
//装修工头，--装饰者抽象类
class Decorator extends House{
   House house;
    public Decorator(House house) {
      super();
      this.house = house;
   }
   void fitting() {
       house.fitting();
   }
   public House getHouse() {
      return house;
   }
   public void setHouse(House house) {
      this.house = house;
   }
}
//具体装饰者，--装饰者抽象类
class ConcreteDecorator extends Decorator{
   public ConcreteDecorator(House house) {
      super(house);
   }
   @Override
   void fitting() {
      super.fitting();
      addMural();
   }
   void addMural(){
      System.out.println("墙壁上上安装了一个壁画");
   }
}
//房子又要修改，增加一个开关 
class DoubleControlDecorator extends Decorator{
   public DoubleControlDecorator(House house) {
      super(house);
   }
   @Override
   void fitting() {
      super.fitting();
      addDoubleControlSwitch();
   }
   void addDoubleControlSwitch(){
      System.out.println("房间安装了一个双控开关");
   }
}
 

 

Decorator模式与继承关系的目的都是要扩展对象的功能，但是Decorator可以提供比继承更多的灵活性
通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。非常方便扩展。

桥接模式

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

在软件系统中，有些类型由于自身的逻辑，它具有两个或多个维度的变化。桥接模式可以很好的解决这种多维度变化，又不引入复杂度

 

 

Abstraction ：定义抽象接口，该接口中包含实现具体行为、具体特征的Implementor接口。

RefinedAbstraction：继承自Abstraction的子类，扩充Abstraction定义的接口。

Implementor ：定义具体行为应用接口。

ConcreteImplementor：实现Implementor。

 

package com.ruishenh.designPatter.structure.bridge;
 
 
public class BridgeClient {
   public static void main(String[] args) {
      Noodle noodle =new Thick();
      noodle.setTaste(new Tomato());
      System.out.println(noodle);
   }
}
//Implementor  味道
interface Taste{
   String getTaste();
}
//ConcreteImplementor 香辣味
class SpicyAndHot implements Taste{
   @Override
   public String getTaste() {
      return "香辣的";
   }
}
//ConcreteImplementor 西红柿味
class  Tomato implements Taste{
   @Override
   public String getTaste() {
      return "西红柿的";
   }
}
//Abstraction  抽象面条
abstract class  Noodle{
   Taste taste;
   public void setTaste(Taste taste) {
      this.taste = taste;
   }
   abstract String getNoddole();
   @Override
   public String toString() {
      return "这是一碗 ["+taste.getTaste()+"],["+getNoddole()+"]牛肉面";
   }
}
//RefinedAbstraction 宽面条
class Thick extends Noodle {
   @Override
   public String getNoddole() {
      return "宽大的";
   }
}
//RefinedAbstraction 细面条
class Thin extends Noodle {
   @Override
   public String getNoddole() {
      return "细小的";
   }
}

桥接模式的核心任务就是多维度的对一个对象进行操作管理降低复杂度。 

 

享元模式

 

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

 

 

Flyweight(抽象享元角色)： 产品的抽象类

ConcreteFlyWeight(具体享元角色)： 具体的一个产品

UnsharedConcreteFlyweight(非共享角色)：对于不能够实用共享技术的对象

FlyweightFactory（享元工厂）：构造池容器，并且提供容器中的对象。

 

 

 

package com.ruishenh.designPatter.structure.flyweight;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class FlyweightClient {
 
   public static void main(String[] args) {
      // 客户下的订单
      List<Order> orders = new ArrayList<Order>();
      // 订单生成工厂
      Order order = MealFactory.getOrder("西红柿鸡蛋");
      orders.add(order);
      order = MealFactory.getOrder("宫保鸡丁");
      orders.add(order);
      order = MealFactory.getOrder("西红柿鸡蛋");
      orders.add(order);
      for (Order or : orders) {
        or.createOrder();
      }
   }
}
 
//抽象享元角色
abstract class Order {
   final String  foodName;
   public Order(String foodName) {
      super();
      this.foodName = foodName;
   }
   public String getFoodName() {
      return foodName;
   }
   public abstract void createOrder();
}
//具体享元角色
class Meal extends Order {
   public Meal(String foodName) {
      super(foodName);
   }
 
   @Override
   public void createOrder() {
      System.out.println("恭喜您下单成功，您所订购的饭菜为："+foodName);
   }
}
//享元工厂
class MealFactory {
   private static Map<String, Order> orderPool =null;
 
   //返回单个对象实例如果存在直接返回如果不存在创建一个放入订单池中
   public static Order getOrder(String foodName) {
      if (orderPool==null) {
        orderPool=new HashMap<String, Order>();
      }
      Order order = null;
      if (!orderPool.containsKey(foodName)) {
        order = new Meal(foodName);
        orderPool.put(foodName, order);
      } else {
        order = orderPool.get(foodName);
      }
      return order;
   }
}
 

 

 

享元模式就是在单例模式池容器上取业务定义的相关对象然后执行相关操作。可以减少程序内存的占用。但是为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化