开闭原则：一个软件的实体应当对扩展开放，对修改关闭
依赖倒转原则：要针对接口编程，不要针对实现编程
迪米特法则：只与你直接的朋友通信，而避免和陌生人通信
作用：实现了创建者和调用者的分离
核心本质：
实例化对象不使用new，用工厂方法代替
将选择实现类，创建对象统一管理和控制。从而将调用者跟实现类解耦。
详细分类：
简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要覆盖已有代码）
工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂
1 /** 2 * 接口Car 3 */ 4 public interface Car { 5 void name(); 6 } 7 8 class wuling implements Car { 9 @Override 10 public void name() { 11 System.out.println("五菱宏光"); 12 } 13 } 14 15 class TeSiLa implements Car { 16 @Override 17 public void name() { 18 System.out.println("特斯拉"); 19 } 20 } 21 22 class CatPlant { 23 24 //简单工厂 25 public static Car getCar(String name){ 26 if(name.equals("五菱")){ 27 return new wuling(); 28 }else if(name.equals("特斯拉")){ 29 return new TeSiLa(); 30 }else { 31 return null; 32 } 33 } 34 } 35 36 /** 37 * 主类，消费者类 38 * 简单工厂模式（静态工厂模式） 如果需要增加新的产品，必须修改代码，不符合开闭原则 39 */ 40 public class Consumer { 41 public static void main(String[] args) { 42 //通过工厂new对象， 43 Car car1 = CatPlant.getCar("五菱"); 44 Car car2 = CatPlant.getCar("特斯拉"); 45 46 car1.name(); 47 car2.name(); 48 } 49 }
相比简单工厂模式，符合开闭原则
实现：创建两个接口，一个是对象接口，一个工厂接口，通过new工厂接口实例化对象，
这样做的好处是，增加新类型对象，不需要修改代码，可以随时扩展了
1 /** 2 * 接口Car 3 */ 4 public interface Car { 5 void name(); 6 } 7 8 9 //汽车工厂接口 10 public interface CarPlant { 11 12 //方法工厂 13 Car getCar(); 14 } 15 16 17 //五菱汽车实现类 18 public class wuling implements Car { 19 @Override 20 public void name() { 21 System.out.println("五菱宏光"); 22 } 23 } 24 25 26 //特斯拉汽车实现类 27 public class TeSiLa implements Car { 28 @Override 29 public void name() { 30 System.out.println("特斯拉"); 31 } 32 } 33 34 35 //五菱工厂 36 public class wulingPlant implements CarPlant{ 37 @Override 38 public Car getCar() { 39 return new wuling(); 40 } 41 } 42 43 44 //特斯拉工厂 45 public class TeSiLaPlant implements CarPlant{ 46 @Override 47 public Car getCar() { 48 return new TeSiLa(); 49 } 50 } 51 52 53 /** 54 * 主类，消费者类 55 * 简单工厂模式（静态工厂模式） 如果需要增加新的产品，必须修改代码，不符合开闭原则 56 */ 57 public class Consumer { 58 public static void main(String[] args) { 59 //通过具体的车辆工厂 60 Car car1 = new TeSiLaPlant().getCar(); 61 Car car2 = new wulingPlant().getCar(); 62 63 car1.name(); 64 car2.name(); 65 //优点：添加车辆不需要修改代码直接新建实现类继承接口，符合开闭原则 66 // （注意新建两个类，一个实现车接口，作为对象，一个实现工厂接口，作为工厂。直接new工厂） 67 68 //缺点：代码量增大 69 } 70 }
定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类
适用场景：
客户端（应用层）不依赖于产品实例如何被创建、实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现
优点：
具体产品在应用层的代码隔离，无需关心创建的细节
将一个系列的产品统一到一起创建
缺点：
规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难
增加了系统的抽象性和理解难度
1 //抽象类：手机，拥有手机的基本功能 2 public interface Phone { 3 void note(); //发短信 4 void callUp(); //打电话 5 } 6 7 8 //游戏机 接口 9 public interface GameMachine { 10 void playGame(); //打游戏 11 void music(); //听音乐 12 } 13 14 15 //抽象接口：新建对象方法 16 public interface AbstractPlant { 17 Phone getPhone(); //新建手机 18 GameMachine getGame(); //新建游戏机 19 } 20 21 22 // 手机实现类：小米手机 23 public class XiaomiPhone implements Phone { 24 @Override 25 public void note() { 26 System.out.println("小米手机发短信"); 27 } 28 29 @Override 30 public void callUp() { 31 System.out.println("小米手机打电话"); 32 } 33 } 34 35 36 //游戏机实现类：小米游戏机 37 public class XiaomiGame implements GameMachine { 38 @Override 39 public void playGame() { 40 System.out.println("小米游戏机打游戏"); 41 } 42 43 @Override 44 public void music() { 45 System.out.println("小米游戏机听音乐"); 46 } 47 } 48 49 50 //小米工厂：生产游戏机，手机 51 public class XiaomiPlant implements AbstractPlant{ 52 53 @Override 54 public Phone getPhone() { 55 return new XiaomiPhone(); 56 } 57 58 @Override 59 public GameMachine getGame() { 60 return new XiaomiGame(); 61 } 62 } 63 64 65 //手机实现类：华为手机 66 public class HuaweiPhone implements Phone { 67 @Override 68 public void note() { 69 System.out.println("华为手机发短信"); 70 } 71 72 @Override 73 public void callUp() { 74 System.out.println("华为手机打电话"); 75 } 76 } 77 78 79 //游戏机实现类：华为游戏机 80 public class HuaweiGame implements GameMachine{ 81 @Override 82 public void playGame() { 83 System.out.println("华为游戏机打游戏"); 84 } 85 86 @Override 87 public void music() { 88 System.out.println("华为游戏机听音乐"); 89 } 90 } 91 92 93 //华为工厂：生产华为手机，华为游戏机 94 public class HuaweiPlant implements AbstractPlant { 95 @Override 96 public Phone getPhone() { 97 return new HuaweiPhone(); 98 } 99 100 @Override 101 public GameMachine getGame() { 102 return new HuaweiGame(); 103 } 104 } 105 106 107 // 测试类。主方法 108 public class Test { 109 public static void main(String[] args) { 110 //抽象工厂 引用指向 实现类工厂 111 AbstractPlant abs1 = new XiaomiPlant(); //小米工厂 112 AbstractPlant abs2 = new HuaweiPlant(); //华为工厂 113 114 System.out.println("=========xioami======="); 115 abs1.getGame().music(); //小米游戏机听音乐 116 abs1.getGame().playGame(); //小米游戏机打游戏 117 abs1.getPhone().callUp(); //小米手机打电话 118 abs1.getPhone().note(); //小米手机发短信 119 120 System.out.println("=========huawei======="); 121 abs2.getGame().music(); //华为游戏机听音乐 122 abs2.getGame().playGame(); //华为游戏机打游戏 123 abs2.getPhone().callUp(); //华为手机打电话 124 abs2.getPhone().note(); //华为手机发短信 125 } 126 }
原文：https://www.cnblogs.com/liuwenchuang/p/14730428.html