设计模式之结构型设计模式

设计模式之结构型设计模式

1. 最少知识原则 ：我知道很少其他类的事情，不触及其他类的领域

2. 依赖倒置原则：从依赖具体，变成我提供出要求，让别的类实现

3. 单一职责原则：只做自己领域的事情

4. 里氏替换原则：针对继承,不重写父类的实现,如果要实现多态度使用抽象

5. 接口隔离原则：接口应该尽量的少，做的事情尽量的耦合低

6. 开闭原则:对扩展开放,对修改关闭

适配器模式

// 我们需要实现这样一个接口 interface A
public void execute();


// 但是我们的实现类是这样的 Class:B
public void run(){
  // run......
}

// 这时候 B肯定不能直接 impl呀就需要一个适配器了

class Adapter impl A{
  B b;
  public void execute(){
    b.run();
  }
}

//这样不就是通过另外一个类实现这个接口调用的还是B的方法

装饰者模式

// 咖啡 -> 加咖啡 -> 加摩卡 -> 加糖    // 加的东西不确定数目,如果具体实现类爆炸
// 抽象出一个基类抽象类  
abstract class beverage{
  public abstract int cost();
}

class coffe extend beverage{
  public int cost(){
    return 16;
  }
}

// 调料类 调料类 引入组合
class moka extend beverage{
  private beverage;
  public int cost(){
    if(beverage!=null){
      return beverage.cost() + 2;
		}
    return 2;
  }
}

class milk extend beverage{
  private beverage;
  public int cost(){
    if(beverage!=null){
      return beverage.cost() + 2;
		}
    return 2;
  }
}
// 计算总共花了多少钱
new moka(new milk(new coffe())).cost()

桥接模式

// 将实现和抽象处理出来
public interface color{
 	String getColor(); 
}

class red impl color{
  public String getColor(){
    return "red";
  }
}

class blue impl color{
  public String getColor(){
    return "blue";
  }
}

public void brransh{
  private color color;
  public void draw(){
    Color color = color.getColor()
  }
}

门面模式

// 门面模式，提供简单完备的api去使用
public class Car{
  private Key key;
  private Door door;
  private Enigine enigine;
  
  public void start(){
    if(key.hasKey){
      door.open();
      enigine.run();
      door.close();
    }
  }
}

// 用户只要了解到我用这个Car直接start就好了
new Car().start();

享元模式

// 量特别大的类数据，但是种类可以预计到数量的,类的池化技术。
public class Person{
  // 种类特别多的数据
  private String name;
  private String addres;
  //基本没几类的数据
  private Normal data;
  
  public Person(String name,String address,String age,String Sex){
    this.name = name;
    this.age = age;
    this.data = Normal.valueOf(age+Sex);
  }
}

class Normal{
  public static Map<String,Normal> map = Map.newsHashMap();
 	private String age;
  private String sex;
  
  public static valueOf(String ageSex){
    if(map.containKey(ageSex)){
      return map.get(ageSex);
    }
    Normal  normal = new Normal(ageSex);
    map.put(ageSex,normal);
    return normal;
  }
}

组合模式

// 特点:树形结构,解决部分和层级的关系
// 董事长 -> 技术总监 -> 经理 -> 职员

public abstract corp{
 	priave String name;
  private String location;
  
  public void  getInfo();
}

public class leaf extend corp{
  public void  getInfo(){
    System.out.println(this.name + "-" + this.location);
  }
}

public class branch extend corp{
  List<Corp> corps = Lists.newArrayList();
  
  publi void addCorps(Corp corps){
    corps.add(corp);
  }
  
 public void getInfo(){
   super.info();
   if(corps.size != 0){
      corps.foreache(Branch:getInfo);
   }
 }
}