设计模式

设计模式7大原则

$\color{red}开闭原则$
一个软件实体如类、模块和函数应该对扩展开放，对修改关闭，带来的好处是可维护、可扩展、可复用、灵活性好。

$\color{red}里氏代换原则$
就是子类型必须能够替换掉它们的父类型，子类可以扩展父类的功能，但不能改变父类原有的功能
1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
2.子类中可以增加自己特有的方法。
3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松
4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格

$\color{red}依赖倒转原则$
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。即针对接口编程，不要针对实现编程，依赖倒置原则的中心思想是面向接口编程，
传递依赖关系有三种方式：接口传递，构造方法传递和setter方法传递。
低层模块尽量都要有抽象类或接口，或者两者都有。
变量的声明类型尽量是抽象类或接口。
使用继承时遵循里氏替换原则。

$\color{red}接口隔离原则$
建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少

$\color{red}组合/聚合复用原则$
就是说要尽量的使用合成和聚合，而不是继承关系达到复用的目的
该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。

$\color{red}迪米特法则$
一个对象应该对其他对象保持最少的了解

$\color{red}单一职责法则$
不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责，应该仅有一个引起它变化的原因

设计模式分类

构建型设计模式 工单构原抽
结构型设计模式 外组适代桥状元
行为型设计模式 命令职责观察备忘录中介解释器迭代器模板访问者状态策略

简单工厂模式

不属于23中设计模式缺点，违反了开闭原则，无法扩展

public class FactoryDemo {
    
    
  public static void main(String[] args) {
    
    
    Car c1 = CarFactory.getCar("奥迪");
    Car c2 = CarFactory.getCar("奔驰");
    assert c1 != null;
    c1.run();
    assert c2 != null;
    c2.run();
  }
}

interface Car {
    
    
  void run();
}

class bench implements Car {
    
    

  @Override
  public void run() {
    
    
    System.out.println("奔驰在跑");
  }
}

class audi implements Car {
    
    

  @Override
  public void run() {
    
    
    System.out.println("奥迪在跑");
  }
}

class CarFactory {
    
    
  static Car getCar(String name){
    
    
    if("奔驰".equals(name)){
    
    
      return new bench();
    }
    if("奥迪".equals(name)){
    
    
      return new audi();
    }
    return null;
  }
}

工厂模式

public class FactoryDemo {
    
    
  public static void main(String[] args) {
    
    
    Car c1 = new FactoryAudi().getCar();
    c1.run();
  }
}

interface Car {
    
    
  void run();
}

interface CarFactory {
    
    
  Car getCar();
}

class bench implements Car {
    
    

  @Override
  public void run() {
    
    
    System.out.println("奔驰在跑");
  }
}

class audi implements Car {
    
    

  @Override
  public void run() {
    
    
    System.out.println("奥迪在跑");
  }
}

class FactoryBench implements CarFactory {
    
    
  @Override
  public Car getCar() {
    
    
    return new bench();
  }
}

class FactoryAudi implements CarFactory {
    
    

  @Override
  public Car getCar() {
    
    
    return new audi();
  }
}

抽象工厂

能够创建多个产品族的产品对象。

public class FactoryDemo2 {
    
    
  public static void main(String[] args) {
    
    
    GoodCarFactory car = new GoodCarFactory();
    Engine en = car.getEngine();
    en.fire();
  }
}

interface Wheel {
    
    
  void run();
}

class GoodWheel implements Wheel {
    
    
  @Override
  public void run() {
    
    
    System.out.println("好轮子 磨损慢");
  }
}

class NormalWheel implements Wheel {
    
    
  @Override
  public void run() {
    
    
    System.out.println("一般轮子 磨损块");
  }
}

interface Engine {
    
    
  void fire();
}

class GoodEngine implements Engine {
    
    

  @Override
  public void fire() {
    
    
    System.out.println("好发动机 跑得快");
  }
}

class NormalEngine implements Engine {
    
    

  @Override
  public void fire() {
    
    
    System.out.println("一般发动机 跑得慢");
  }
}

interface FactoryCar {
    
    
  Engine getEngine();
  Wheel getWheel();
}

class GoodCarFactory implements FactoryCar {
    
    

  @Override
  public Engine getEngine() {
    
    
    return new GoodEngine();
  }

  @Override
  public Wheel getWheel() {
    
    
    return new GoodWheel();
  }
}

java学习基础-5