软件设计的七大原则

在软件开发中，为了提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，程序员要尽量根据 7 条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。我来依次来总结这 7 条原则。
这 7 种设计原则是软件设计模式必须尽量遵循的原则，各种原则要求的侧重点不同。其中，

  • 开闭原则是总纲，它告诉我们要对扩展开放，对修改关闭；
  • 单一职责原则告诉我们实现类要职责单一；
  • 依赖倒置原则告诉我们要面向接口编程；
  • 接口隔离原则告诉我们在设计接口的时候要精简单一；
  • 迪米特法则告诉我们要降低耦合度；
  • 里氏替换原则告诉我们不要破坏继承体系；
  • 合成复用原则告诉我们要优先使用组合或者聚合关系复用，少用继承关系复用。

开闭原则

当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求
创建了一个汽车对象

  1. class Car {
  2.         private String band;
  3.         private String color;
  4.         private float price;
  6.         public String getBand() {
  7.             return band;
  8.         }
  10.         public void setBand(String band) {
  11.             this.band = band;
  12.         }
  14.         public String getColor() {
  15.             return color;
  16.         }
  18.         public void setColor(String color) {
  19.             this.color = color;
  20.         }
  22.         public float getPrice() {
  23.             return price;
  24.         }
  26.         public void setPrice(float price) {
  27.             this.price = price;
  28.         }
  30.         @Override
  31.         public String toString() {
  32.             return "Car{" +
  33.                     "band='" + band + '\'' +
  34.                     ", color='" + color + '\'' +
  35.                     ", price=" + price +
  36.                     '}';
  37.         }
  38.     }
  40.     public static void main(String[] args) {
  41.         Car car = new Car();
  42.         car.setBand("bm");
  43.         car.setColor("red");
  44.         car.setPrice(13.3f);
  45.         System.out.println(car.toString());
  46.     }

当变化来临时，例如汽车的价格现在需要打折（打8折），这时，我们在Car的源代码中修改，就违反了开闭原则
开发时，我们应该要去考虑变化的需求，属性会在任何时刻都有可能产生变化
进行扩展 

  1. //进行扩展  
  2. class DiscountCar extends Car{
  3.         @Override
  4.         public void setPrice(float price) {
  5.             super.setPrice(price*0.08f);
  6.         }
  7. }
  8.     public static void main(String[] args) {
  9.         //===使用向上转型时，方法的调用只和new的对象有关
  10.         Car car = new DiscountCar();
  11.         car.setBand("bm");
  12.         car.setColor("red");
  13.         car.setPrice(130000f);
  14.         System.out.println(car.toString());
  15.     }

开闭原则应该遵循应用场景去考虑，如果源代码就是你自己写的，而且需求是稳定的，那么，直接修改源代码也是一个简单的做法，但当源代码是别人的代码或架构是，我们就要去符合开闭原则，防止破坏结构的完整性！

单一职责

这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分
每个类或每个方法每个框架只做一件事
统计文本文件中有多少个单词

  1.    //==============只负责根据路径加载文件
  2.     public  String loadFile(String path) throws IOException {
  3.         Reader in = new FileReader(path);
  4.         BufferedReader br = new BufferedReader(in);
  5.         String line = null;
  6.         StringBuilder sb = new StringBuilder("");
  7.         while ((line = br.readLine()) != null) {
  8.             sb.append(line);
  9.             sb.append("");
  10.         }
  11.         br.close();
  12.         return sb.toString();
  13.     }
  14.     //=========只负责字符串根据正则分割
  15.     public  int Textlength(String sb, String regex){
  16.         String [] words = sb.split(regex);
  17.         return  words.length;
  18.     }
  19.     public static void main(String[] args) throws IOException {
  20.         String str = loadFile("F:\\1.txt");
  21.         String regex ="[^a-zA-Z]+";
  22.         System.out.println(Textlength(str,regex));
  23.     }

依赖倒置原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象其核心思想是：要面向接口编程，不要面向实现编程。

人喂养动物

  1. static class Person{
  2.     public void feed(Dog dog){
  3.         dog.eat();
  4.     }
  5. }
  6. static class Dog{
  7.     public void eat() {
  8.         System.out.println("狗啃骨头");
  9.     }
  10. }
  11. public static void main(String[] args) {
  12.     Person p = new Person();
  13.     Dog d = new Dog();
  14.     p.feed(d);
  15. }

在上面的代码中，人要喂狗，依赖于有一条狗，人作为上层依赖于下层，这样有什么坏处呢？
坏处是，当变化来临时，比如，人又养了一只猫，那么上层人这个类当中，就必须在添加喂猫的方法，每当下层变动时，上层也会跟着变动，而我们希望下层变动时，上层不会跟着改变(上层直接依赖了下层)
image.png
他们都应该依赖于抽象

  1. interface Animal{
  2.     void eat();
  3. }
  4. static class Person{
  5.     public void feed(Animal animal){
  6.         animal.eat();
  7.     }
  8. }
  9. static class Dog implements Animal{
  10.     public void eat() {
  11.         System.out.println("狗啃骨头");
  12.     }
  13. }
  14. public static void main(String[] args) {
  15.     Person p = new Person();
  16.     Dog d = new Dog();
  17.     p.feed(d);
  18. }

依赖倒转原则就是指：代码要依赖于抽象的类，而不要依赖于具体的类；要针对接口或抽象类编程，而不是针对具体类编程。通过面向接口编程，抽象不应该依赖于细节，细节应该依赖于抽象(倒过来了)。
image.png

接口隔离原则


接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。
设计接口时，接口的抽象应该是有意义的
反例: 动物接口中定义的方法并不是被所有动物需要的

  1. interface  Animal{
  2.         void eat();
  3.         void fly();
  4.         void swim();
  5.     }
  6. class Bird implements Animal{
  7.     @Override
  8.     public void eat() {
  9.         System.out.println("吃");
  10.     }
  11.     @Override
  12.     public void fly() {
  13.         System.out.println("飞");
  14.     }
  15.     //======鸟不会游泳，并不需要实现
  16.     @Override
  17.     public void swim() {
  18.         System.out.println("游泳");
  19.     }
  20. }

正例：接口抽象出有意义的层级，供需要的类去实现

  1. interface  Flyable{
  2.         void fly();
  3.     }
  4. interface  Swimable{
  5.         void swim();
  6.     }
  7. interface  Eatable{
  8.         void eat();
  9.     }
  10. class Bird implements Flyable,Eatable{
  11.     .....
  12. }
  13. class Dog implements Swimable,Eatable{
  14.     .....
  15. }

客户端不应该依赖那些它不需要的接口。
一旦一个接口太大，则需要将它分割成一些更细小的接口，使用该接口的客户端仅需知道与之相关的方法即可

迪米特法则

只与你的直接朋友交谈，不跟“陌生人”说话。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
（最少知道原则）封装，只和朋友通信
什么是朋友？
1.类中的字段
2.方法的返回值
3.方法的参数
4.方法中的实例对象
5.对象本身
6.集合中的泛型

反例：关闭电脑的流程

  1. class Computers{
  2.     public  void  closeFile(){
  3.         System.out.println("关闭文件");
  4.     }
  5.     public  void  closeScreen(){
  6.         System.out.println("关闭屏幕");
  7.     }
  8.     public  void  powerOff(){
  9.         System.out.println("断电");
  10.     }
  11. }
  12. class Person{
  13.     private Computers computers;
  14.     public void offComputers(){
  15.         computers.closeFile();
  16.         computers.closeScreen();
  17.         computers.powerOff();
  18.     }
  19. }

当用户关闭电脑时，需要调用计算机的各个方法，但是这些方法的细节太多了，会出现用户流程出错，遗漏调用等等，对于用户来言，他只需要知道关机按钮就够了
正例：封装细节，提供接口

  1. class Computers{
  2.     public  void  closeFile(){
  3.         System.out.println("关闭文件"); 
  4.     }
  5.     public  void  closeScreen(){
  6.         System.out.println("关闭屏幕");
  7.     }
  8.     public  void  powerOff(){
  9.         System.out.println("断电");
  10.     }
  11.     public void offComputers(){
  12.         closeFile();
  13.         closeScreen();
  14.         powerOff();
  15.     }
  16. }
  17. class Person{
  18.     private Computers computers;
  19.     public void offComputers(){
  20.         computers.offComputers();
  21.     }
  22. }

里氏替换原则

子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。关于里氏替换原则的例子，最有名的是“正方形不是长方形”。
在任何使用父类对象的地方,替换为子类对象以后,程序不会有问题出现.
里氏替换原则在“几维鸟不是鸟”实例中的应用
设计模式 - 图3

  1. package principle;
  2. public class LSPtest
  3. {
  4.     public static void main(String[] args)
  5.     {
  6.         Bird bird1=new Swallow();
  7.         Bird bird2=new BrownKiwi();
  8.         bird1.setSpeed(120);
  9.         bird2.setSpeed(120);
  10.         System.out.println("如果飞行300公里：");
  11.         try
  12.         {
  13.             System.out.println("燕子将飞行"+bird1.getFlyTime(300)+"小时.");
  14.             System.out.println("几维鸟将飞行"+bird2.getFlyTime(300)+"小时。");
  15.         }
  16.         catch(Exception err)
  17.         {
  18.             System.out.println("发生错误了!");
  19.         }
  20.     }
  21. }
  22. //鸟类
  23. class Bird
  24. {
  25.     double flySpeed;
  26.     public void setSpeed(double speed)
  27.     {
  28.         flySpeed=speed;
  29.     }
  30.     public double getFlyTime(double distance)
  31.     {
  32.         return(distance/flySpeed);
  33.     }
  34. }
  35. //燕子类
  36. class Swallow extends Bird{}
  37. //几维鸟类
  38. class BrownKiwi extends Bird
  39. {
  40.     public void setSpeed(double speed)
  41.     {
  42.            flySpeed=0;
  43.     }
  44. }

合成复用原则

合成复用原则（Composite Reuse Principle，CRP）又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

统计集合添加元素的次数
反例：继承hashset，重写父类add方法，每次add元素时count+1；

  1. class Counter extends HashSet {
  2.     private int count =0;
  3.     public boolean add(int i) {
  4.         count++;
  5.         return super.add(i);
  6.     }
  7.     public int getCount(){
  8.         return count;
  9.     }
  10. }
  12. public static void main(String[] args) {
  13.     Counter c = new Counter();
  14.     c.add(1);
  15.     c.add(2);
  16.     c.add(3);
  17.     System.out.println(c.getCount());
  18. }

这样写会出现在hashset方法中，不只是add可以添加元素的问题，还有其他方式可以添加，如果是其他方式添加的，count就不会累加，这样是有问题的

  1. @Override
  2. public boolean addAll(Collection c) {
  3.     count=count+c.size();
  4.     return super.addAll(c);
  5. }

假如我们继续重写addAll方法添加相应的判断时，又会出现新的问题，我们的count并没有正确的累计，因为在HashSet的源码addAll方法中，回调了add方法，并没有解决需求
那我们不重写addAll，反正它会回调add，完成计数，就没有问题了吗？
其实并不能解决问题，hashset的源码我们不能保证永远不会更改，假如在下一个版本中，hashset的作者更改了addAll方法，那么我们的功能也会不能正常实现了！
当继承的父类作者不是我们自己的时候，我们没有办法保证父类代码不会变更，假如我们继承了这个父类，那么我们最好是只去复用父类的代码，避免去重写或新建方法，防止源码结构变更带来的打击
也就是说，在我们需要重用代码，并且重用的代码作者并不是我们自己的时候，我们要采用组合的方式。

正例：组合优于继承

  1.   static class Counter  {
  2.         HashSet hashSet = new HashSet();
  3.         private int count =0;
  4.         public boolean add(int i) {
  5.             count++;
  6.             return hashSet.add(i);
  7.         }
  8.         public boolean addAll(Collection c) {
  9.             count=count+c.size();
  10.             return hashSet.addAll(c);
  11.         }
  12.         public int getCount(){
  13.             return count;
  14.         }
  15.     }
  17.     public static void main(String[] args) {
  18.         Counter c = new Counter();
  19.         c.add(1);
  20.         c.add(2);
  21.         c.add(3);
  22.         System.out.println(c.getCount());
  23.     }

这样来写，我们类中的add和addAll方法跟HashSet中的add和addAll方法的不在有关系，也能解决这个问题

设计模式

工厂模式

提供了一种创建对象的最佳方式

简单工厂模式

正例：创建产品接口，具体产品实现，工厂类负责生产，使用时找到工厂类拿到对应产品

  1. class Test {
  2.     interface Food {
  3.         void eat();
  4.     }
  5.     static class Bun implements Food {
  6.         @Override
  7.         public void eat() {
  8.             System.out.println("包子");
  9.         }
  10.     }
  11.     static class SteameDread implements Food {
  12.         @Override
  13.         public void eat() {
  14.             System.out.println("馒头");
  15.         }
  16.     }
  17.     static class FoodFactory {
  18.         public static Food getFood(int n) {
  19.             Food food = null;
  20.             switch (n) {
  21.                 case 1:
  22.                     food = new Bun();
  23.                     break;
  24.                 case 2:
  25.                     food = new SteameDread();
  26.                     break;
  27.             }
  28.             return food;
  29.         }
  30.     }
  31.     public static void main(String[] args) {
  32.         FoodFactory.getFood(1).eat();;
  34.     }
  35. }

优点
1．把具体产品的类型，从客户端代码中，解耦出来。
2．服务器端，如果修改了具体产品的类名，客户端也不知道!这便符合了“面向接口编程的思想
缺点
1．客户端不得不死记硬背那些常量与具体产品的映射关系，比如:1—汉堡包，2—馒头
2．如何具体产品特别多，则简单工厂，就会变得十分臃肿。比如有100个具体产品，则需要在简单工厂的switch写出100个case!3．最重要的是，变化来了:客户端需要扩展具体产品的时候，势必要修改简单工厂中的代码，这样便违反了”开闭原则

工厂方法模式

  1. class Test {
  2.     interface Food {
  3.         void eat();
  4.     }
  5.     static class Bun implements Food {
  6.         @Override
  7.         public void eat() {
  8.             System.out.println("包子");
  9.         }
  10.     }
  11.     static class SteameDread implements Food {
  12.         @Override
  13.         public void eat() {
  14.             System.out.println("馒头");
  15.         }
  16.     }
  18.     //工厂
  19.     static interface FoodFactory{
  20.         Food getFood();
  21.     }
  22.     static class BunFactory implements FoodFactory{
  23.         @Override
  24.         public Food getFood() {
  25.             return new Bun();
  26.         }
  27.     }
  28.     static class SteameDreadFactory implements FoodFactory{
  29.         @Override
  30.         public Food getFood() {
  31.             return new SteameDread();
  32.         }
  33.     }
  35.     static class Business {
  36.         public static void test(FoodFactory foodFactory){
  37.             Food food = foodFactory.getFood();
  38.             food.eat();
  39.         }
  40.     }
  41.     public static void main(String[] args) {
  43.         FoodFactory ff = new BunFactory();
  44.         ff.getFood();
  45.         //Business.test(new SteameDreadFactory());
  47.     }
  48. }

优点:
1．仍然具有简单工厂的忧点，赈务器端修改了具体产品的类名以后，客户端不知道!
2．当客户端需要扩展一个新的产品时，不需要修改作者原来的代码，只是扩展一个新的工厂而已!
缺点:
如果有多个品等级，那么工厂类的数量，就会爆炸式增长!

抽象工厂模式

和抽象方法差不多，不过工厂中会依赖多个产品
image.png
6mm工厂只能生产6mm螺丝6mm螺母

  1. class Test {
  2.     interface Food {
  3.         void eat();
  4.     }
  6.     interface Drink {
  7.         void drink();
  8.     }
  10.     static class DoughSticks implements Food {
  11.         @Override
  12.         public void eat() {
  13.             System.out.println("油条");
  14.         }
  15.     }
  17.     static class SteamedBuns implements Food {
  18.         @Override
  19.         public void eat() {
  20.             System.out.println("馒头");
  21.         }
  22.     }
  24.     static class SoybeanMilk implements Drink {
  25.         @Override
  26.         public void drink() {
  27.             System.out.println("豆浆");
  28.         }
  29.     }
  31.     static class Milk implements Drink {
  32.         @Override
  33.         public void drink() {
  34.             System.out.println("牛奶");
  35.         }
  36.     }
  38.      interface Factory {
  39.         Food getFood();
  41.         Drink getDrink();
  42.     }
  44.     static class DoughSticksFactory implements Factory {
  46.         @Override
  47.         public Food getFood() {
  48.             return new DoughSticks();
  49.         }
  51.         @Override
  52.         public Drink getDrink() {
  53.             return new SoybeanMilk();
  54.         }
  55.     }
  57.     static class SteamedBunsFactory implements Factory {
  59.         @Override
  60.         public Food getFood() {
  61.             return new SteamedBuns();
  62.         }
  64.         @Override
  65.         public Drink getDrink() {
  66.             return new Milk();
  67.         }
  68.     }
  70.     static class Business {
  71.         public void test(Factory factory) {
  72.             Food food = factory.getFood();
  73.             food.eat();
  74.             Drink drink = factory.getDrink();
  75.             drink.drink();
  76.         }
  77.     }
  79.     public static void main(String[] args) {
  80.         Business business = new Business();
  81.         business.test(new DoughSticksFactory());
  82.         System.out.println();
  83.         business.test(new SteamedBunsFactory());
  84.     }
  85. }
  87. /**
  89. 油条
  90. 豆浆
  92. 馒头
  93. 牛奶
  95. */

优点：
1、仍然有简单工厂和工厂方法的优点
2．更重要的是，抽象工厂把工厂类的数量减少了!无论有多少个产品等级，工厂就一套。
解释：
抽象工厂中，可以生产多个产品,这多个产品之间．必须有内在联系。
同一个工厂中的产品都属于同一个产品簇!!不能把不同产品簇中的产品混合到一个象工厂的实现类中。

image.png
产品簇和产品等级多看看，容易搞混，如果增加个京东工厂（工厂类）叫多了个产品簇，如果增加个电器-空调（工厂类中的方法）叫多了个产品等级

缺点:
1．当，产品等级发生变化时(增如产品等价、删除产品等价〕，都要引起所有以前工厂代码的修改，这就违反了””开闭原则!

结论:
当产品等级比较固定时，可以考虑使用抽象工厂,|如果产品等级经常变化，则不建议使用抽象工厂。

策略模式

一个类的行为可以在运行时更改

  1. public class ZhaoYun {
  3.     public static  interface IStrategy {
  4.         //每个锦囊妙计都是一个可执行的算法
  5.         public void operate();
  6.     }
  8.     public static class BackDoor implements IStrategy {
  9.         public void operate() {
  10.             System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
  11.         }
  12.     }
  13.     public  static class GivenGreenLight implements IStrategy {
  14.         public void operate() {
  15.             System.out.println("求吴国太开个绿灯,放行！");
  16.         }
  17.     }
  18.     public static class BlockEnemy implements IStrategy {
  19.         public void operate() {
  20.             System.out.println("孙夫人断后，挡住追兵");
  21.         }
  22.     }
  24.     public static class Context {
  25.         //构造函数，你要使用那个妙计
  26.         private IStrategy strategy;
  28.         public void setStrategy(IStrategy strategy) {
  29.             this.strategy = strategy;
  30.         }
  32.         //使用计谋了，看我出招了
  33.         public void operate() {
  34.             this.strategy.operate();
  35.         }
  37.     }
  38.     public static void main(String[] args) {
  39.        ;
  41.         System.out.println("-----------刚刚到吴国的时候拆第一个-------------");
  42.         Context context = new Context();
  43.         context.setStrategy(new BackDoor());//拿到妙计
  44.         context.operate(); //拆开执行
  46.         System.out.println("-----------刘备乐不思蜀了，拆第二个了-------------");
  47.         context.setStrategy(new GivenGreenLight());//拿到妙计
  48.         context.operate(); //执行了第二个锦囊了
  51.         System.out.println("-----------孙权的小兵追了，咋办？拆第三个------------ - ");
  52.         context.setStrategy(new BlockEnemy());//拿到妙计
  53.         context.operate(); //孙夫人退兵
  54.  /*
  55.  *问题来了：赵云实际不知道是那个策略呀，他只知道拆第一个锦囊，
  56.  *而不知道是BackDoor这个妙计，咋办？ 似乎这个策略模式已经把计谋名称写出来了
  57.  *
  58.  * 错！BackDoor、GivenGreenLight、BlockEnemy只是一个代码，你写成first、second、
  59. third，没人会说你错!
  60.  *
  61.  * 策略模式的好处就是：体现了高内聚低耦合的特性呀，缺点嘛，这个那个，我回去再查查
  62.  */
  63.     }
  64. }

image.png

静态代理

一个接口,多个实现类,代理类要需要实现接口(通过构造器接受实现类),在代理类方法中调用具体的实现类方法

什么是代理模式呢？我很忙，忙的没空理你，那你要找我呢就先找我的代理人吧，那代理人总要知道 被代理人能做哪些事情不能做哪些事情吧，那就是两个人具备同一个接口，代理人虽然不能干活，但是被 代理的人能干活呀。

image.png

KindWomen

  1. public interface KindWomen {
  2.     //这种类型的女人能做什么事情呢？
  3.      void makeEyesWithMan(); //抛媚眼
  5.      void happyWithMan(); //happy what? You know that!
  7. }

PanJinLian

  1. public class PanJinLian implements KindWomen{
  2.     @Override
  3.     public void makeEyesWithMan() {
  5.         System.out.println("潘金莲抛媚眼");
  6.     }
  8.     @Override
  9.     public void happyWithMan() {
  10.         System.out.println("潘金莲在和男人做那个.....");
  11.     }
  12. }

JiaShi

  1. public class JiaShi implements KindWomen{
  2.     @Override
  3.     public void makeEyesWithMan() {
  4.         System.out.println("贾氏抛媚眼");
  5.     }
  7.     @Override
  8.     public void happyWithMan() {
  9.         System.out.println("贾氏正在Happy中......");
  10.     }
  11. }

WangPo(代理类)

  1. public class WangPo implements KindWomen {
  2.     private KindWomen kindWomen;
  4.     public WangPo(){ //默认的话，是潘金莲的代理
  5.         this.kindWomen = new PanJinLian();
  6.     }
  8.     //她可以是KindWomen的任何一个女人的代理，只要你是这一类型
  9.     public WangPo(KindWomen kindWomen){
  10.         this.kindWomen = kindWomen;
  11.     }
  13.     public void happyWithMan() {
  14.         this.kindWomen.happyWithMan(); //自己老了，干不了，可以让年轻的代替
  15.     }
  16.     public void makeEyesWithMan() {
  17.         this.kindWomen.makeEyesWithMan(); //王婆这么大年龄了，谁看她抛媚眼？！
  18.     }
  19. }

XiMenQing(测试类)

  1. public class XiMenQing {
  3.     /*
  4.      * 水浒里是这样写的：西门庆被潘金莲用竹竿敲了一下难道，痴迷了，
  5.      * 被王婆看到了, 就开始撮合两人好事，王婆作为潘金莲的代理人
  6.      * 收了不少好处费，那我们假设一下：
  7.      * 如果没有王婆在中间牵线，这两个不要脸的能成吗？难说的很！
  8.      */
  9.     public static void main(String[] args) {
  10.         //把王婆叫出来
  11.         WangPo wangPo = new WangPo();
  13.         //然后西门庆就说，我要和潘金莲happy，然后王婆就安排了西门庆丢筷子的那出戏:
  14.         wangPo.makeEyesWithMan(); //看到没，虽然表面上时王婆在做，实际上爽的是潘金莲
  15.         wangPo.happyWithMan();
  17.         System.out.println("\n");
  19.         wangPo =  new WangPo(new JiaShi());
  21.        // 改编一下历史，贾氏被西门庆勾走：
  22.         wangPo.makeEyesWithMan(); //让王婆作为贾氏的代理人
  23.         wangPo.happyWithMan();
  24.     }
  25. }

模板方法模式

将不会改变的地方变为模板，而会发生改变的部分代码变成抽象的，这样调用它的人负责实现，来实现它需要的效果

  1. abstract class Test {
  2.     public void templent() {
  3.         long start = System.currentTimeMillis();
  4.         code();
  5.         long end = System.currentTimeMillis();
  6.         System.out.println(end - start);
  7.     }
  9.     abstract void code();
  10. }
  12. class ArrayTest extends Test {
  13.     @Override
  14.     void code() {
  15.         List<Integer> list = new ArrayList<>();
  16.         for (int i = 0; i < 10000; i++) {
  17.             list.add(0, 1);
  18.         }
  19.     }
  20. }
  22. class AppTest {
  23.     public static void main(String[] args) {
  24.         Test test = new ArrayTest();
  25.         test.templent();
  26.     }
  27. }

建造者模式

image.png

  1. // 电脑
  2. @Data
  3. class Computer {
  4.     private String cpu;
  5.     private String gpu;
  6.     private String hd;
  7.     private String memory;
  8. }
  10. // 电脑构建者
  11. interface ComputerBuilder {
  12.     void buildCpu();
  14.     void buildGpu();
  16.     void buildMemory();
  18.     void buildHd();
  20.     Computer build();
  21. }
  23. class AdvanceComputerBuilder implements ComputerBuilder {
  24.     Computer c = new Computer();
  27.     @Override
  28.     public void buildCpu() {
  29.         c.setCpu("i9-9700K");
  31.     }
  33.     @Override
  34.     public void buildGpu() {
  35.         c.setGpu("3090");
  36.     }
  38.     @Override
  39.     public void buildMemory() {
  40.         c.setMemory("32G");
  41.     }
  43.     @Override
  44.     public void buildHd() {
  45.         c.setHd("2T固态");
  46.     }
  48.     @Override
  49.     public Computer build() {
  50.         return c;
  51.     }
  52. }
  53. class MiddleComputerBuilder implements ComputerBuilder {
  54.     Computer c = new Computer();
  57.     @Override
  58.     public void buildCpu() {
  59.         c.setCpu("i7-5700HQ");
  61.     }
  63.     @Override
  64.     public void buildGpu() {
  65.         c.setGpu("1080");
  66.     }
  68.     @Override
  69.     public void buildMemory() {
  70.         c.setMemory("32G");
  71.     }
  73.     @Override
  74.     public void buildHd() {
  75.         c.setHd("1T固态");
  76.     }
  78.     @Override
  79.     public Computer build() {
  80.         return c;
  81.     }
  82. }
  84. class LowComputerBuilder implements ComputerBuilder {
  85.     Computer c = new Computer();
  86.     @Override
  87.     public void buildCpu() {
  88.         c.setCpu("i5-5400u");
  89.     }
  91.     @Override
  92.     public void buildGpu() {
  93.         c.setGpu("950M");
  94.     }
  96.     @Override
  97.     public void buildMemory() {
  98.         c.setMemory("4G");
  99.     }
  101.     @Override
  102.     public void buildHd() {
  103.         c.setHd("1T机械");
  104.     }
  106.     @Override
  107.     public Computer build() {
  108.         return c;
  109.     }
  110. }
  112. //指挥者
  113. class Direct{
  114.     public static Computer  build(ComputerBuilder builder){
  115.         builder.buildCpu();
  116.         builder.buildGpu();
  117.         builder.buildHd();
  118.         builder.buildMemory();
  119.         return builder.build();
  120.     }
  121. }
  122. public class Client {
  124.     public static void main(String[] args) {
  125.         Computer c1 = Direct.build(new AdvanceComputerBuilder());
  126.         System.out.println(c1);
  127.         Computer c2 = Direct.build(new MiddleComputerBuilder());
  128.         System.out.println(c2);
  129.         Computer c3 = Direct.build(new LowComputerBuilder());
  130.         System.out.println(c3);
  131.     }
  132. }

输出

  1. Computer(cpu=i9-9700K, gpu=3090, hd=2T固态, memory=32G)
  2. Computer(cpu=i7-5700HQ, gpu=1080, hd=1T固态, memory=32G)
  3. Computer(cpu=i5-5400u, gpu=950M, hd=1T机械, memory=4G)

优点:
1，创建对象的过程稳定不变的（因为有ComputerBuilder接口来稳定过程）
2．创建对象的过程只写了一次，没有重复代码（指挥者完成〕
3．当需要扩展指挥者的时候,不用修改之前的代码。这符合了开团原则
建造者与工厂模式的区别。
工厂模式只需一个简单的new. new出产品即可。
建造者更注重，在new出产品之后的。为产品属性赋值的过程! ! l

观察者模式

  1. interface Observer {
  2.     void update();
  3. }
  5. abstract class Subject {
  6.     private List<Observer> observerList = new ArrayList<>();
  8.     public void attach(Observer observer) {
  9.         observerList.add(observer);
  10.     }
  12.     public void detach(Observer observer) {
  13.         observerList.remove(observer);
  14.     }
  16.     public void notifyAllObserver() {
  17.         for (Observer observer : observerList) {
  18.             observer.update();
  19.         }
  20.     }
  22.     public abstract void doSomething();
  23. }
  25. //矩形血条
  26. class RectangleBlood implements Observer {
  28.     @Override
  29.     public void update() {
  30.         System.out.println("收到消息----矩形血条");
  32.     }
  33. }
  35. //圆形血条
  36. class CircleBlood implements Observer {
  38.     @Override
  39.     public void update() {
  40.         System.out.println("收到消息----圆形血条");
  41.     }
  42. }
  44. class HeroSubject extends Subject {
  46.     @Override
  47.     public void doSomething() {
  48.         System.out.println("Hero做事情");
  49.         super.notifyAllObserver();
  50.     }
  51. }
  53. public class Client {
  55.     public static void main(String[] args) {
  56.         HeroSubject hero = new HeroSubject();
  57.         RectangleBlood rectangleBlood = new RectangleBlood();
  58.         CircleBlood circleBlood = new CircleBlood();
  60.         hero.attach(rectangleBlood);
  61.         hero.attach(circleBlood);
  63.         hero.doSomething();
  64.     }
  65. }