开闭原则：实现热插拔，提高扩展性。

里氏代换原则：实现抽象的规范，实现子父类互相替换；

依赖倒转原则：针对接口编程，实现开闭原则的基础；

接口隔离原则：降低耦合度，接口单独设计，互相隔离；

迪米特法则，又称不知道原则：功能模块尽量独立；

合成复用原则：尽量使用聚合，组合，而不是继承；

在面向对象设计模式中存在的是五大原则和一个法则。

五大原则:

• 单一职责 SRP(Single Responsibilities Principle)
• 开闭原则 OCP(Open Close Principle)
• 里氏代换 LSK(Liskov Substitution Principle)
• 倒转依赖 DIP(Dependence Inversion Principle)
• 接口隔离 ISP(Interface Segregation Principle)

个法则是：迪米特 DP (Demeter Principle)

迪米特法则是管理中涉及的一个术语，被引用到面向对象术语体系中，又称知识最少原则。Least Knowledge Principle正儿八经的翻译是就是知识最少原则，不知道哪个英文水平不济的把knowledge翻译成了知道，汗语中知道是动词没有名词的意思，而knowledge译成见闻也比相对好一点。虽然现在都知道“知道”的意思。另外，在一些台系的书中迪米特法则也被翻译成“德默特尔法则”，当你看到这个时不要奇怪——音译本就会出现多个译法的。

其实在清华出版社中软件设计师书中，迪米特虽然被称为法则，但其与其他五大原则是同样的重要的，所以有些人会混称为面向对象六大原则，事实上在软件设计师考试中经常使用的面向对象五大原则。按清华出版社软件设计师体系来说，面向对象五大原则和一个法则（迪法特法则）。其他时候程序员也称为六大原则。

在MSDN类库设计原则中提到“尽量少使用继承，而使用组合与聚合“，但其并没有说明原因。微软的惯例就是如此，只告诉你应该如何，不应该如何，尽量如何或尽量不如何，从来不会告诉你原则。在面向对象设计中（清华出版社软件设计师一书中）讲到五大原则与法则共同的目标就是高内聚低耦合的代码。

其中高内聚指的是类内成员之间的关系，而低耦合则是类关系。要求就是类内各成员的关系尽量高，并按照一定的方式对内聚性进行排序。而讲到耦合关系，按照一定的方式也进行了排序；也就是内聚度与耦合度对这种关系进行了一定程度上量化。所以此处提到了继承——继承是耦合度最高的一种关系。所以提示了一句话是尽量使用组合或聚合的方式来代替继承，或者使用最简单的继承树关系，当然也提示了继承应该继承于抽象类，避免继承实现类。这个是对高内聚低耦合的一个补充说明，而且没有绝对的定义。所以并不是几大原则之中的事。而且有前提前条件，只是避免继承普通类！所以合成复用原则完全是某个人背完了原则忘记了而瞎编出来的（只是会背不会用或不理解，当然容易忘记了）！

当然，单一职责原则其实就是为了提高内聚性一个说明，它的目的就保证了内聚性，只有一个引起变化的原因，说明类内成员之间的关系较高，内聚性不强的就不要写到一个类中。这就是单一职责的真正用意。事实上很多程序员爱写大类超多成员或爱用静态成员，都是对内聚性的一种破坏——所以这些人很难想起来还有一个单一职责的原则！慢慢的这个原则就是被忘记了！

使用反射机制可以解决每次增加一个产品时，都需要增加一个对象实现工厂的缺点

public class ShapeFactory {
    public static Object getClass(Class<?extends Shape> clazz) {
        Object obj = null;

        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return obj;
    }
}

使用的使用采用强制转换

Rectangle rect = (Rectangle) ShapeFactory.getClass(Rectangle.class);
rect.draw();
Square square = (Square) ShapeFactory.getClass(Square.class);
square.draw();

这样就只需要一个对象实现工厂

在上面的基础上进一步扩展，针对多个接口实现一个公共的工厂类：

public class ObjectFactory {
    public <T> Object getObject(Class<T> clazz) {
       if (clazz == null ) {
           return null;
    }    
        Object obj  = null;
        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

创建的这个工厂，这个创建函数，没能看出有什么特别的，还特别繁琐，如果IShape类太多，那么if else语句也将增加太多，不好维护，与其这样写，还不如改成如下：

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
  public Shape getShape(Class<?> clazz){
        try {
            return (IShape) clazz.getConstructor().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
}

这样写在创建时也不用知道具体的类别，易于管理维护。

使用枚举优化

public enum Factory {
    CIRCLE(new Circle(),"CIRCLE"),
    RECTANGLE(new Rectangle(),"RECTANGLE"),
    SQUARE(new Square(),"SQUARE");
    
    // 成员变量  
    private Shape shape;  
    private String name;  
    
    // 普通方法  
    public static Shape getShape(String name) {  
        for (Factory c : Factory.values()) {  
            if (c.name == name) {  
                return c.shape;  
            }  
        }  
        return null;  
    } 
    // 构造方法  
    private Factory(Shape shape, String name) {  
        this.shape = shape;  
        this.name = name;  
    } 
    public String getName() {
        return name;
    }
    public Shape getShape() {
        return shape;
    }


    public void setShape(Shape shape) {
        this.shape = shape;
    }


    public void setName(String name) {
        this.name = name;
    } 
    
}


/*使用枚举类*/
Factory.getShape("CIRCLE").draw();
Factory.getShape("RECTANGLE").draw();
Factory.getShape("SQUARE").draw();

@kusirp21 讲得很好，使用枚举类优化。

增加枚举类

public enum ShapeType{
    CIRCLE,
    RECTANGLE,
    SQUARE
}

修改工厂类的工厂方法，个人建议工厂方法应该是静态方法或者采用单例模式：

public class ShapeFactory{
    public static Shape getShape(ShapeType type){
        switch(type){
            case CIRCLE:
                return new Circle();
            case RECTANGLE:
                return new Rectangle();
            case SQUARE:
                return new Square();
            default:
                throw new UnknownTypeException();
        }
    }
}

上面用到的类和接口与课程中的一样。

最后是使用示例：

public class FactoryPatternDemo {
    public static void main(String[] args) {
        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = ShapeFactory.getShape(ShapeType.CIRCLE);

        //调用 Circle 的 draw 方法
        shape1.draw();

        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = ShapeFactory.getShape(ShapeType.RECTANGLE);

        //调用 Rectangle 的 draw 方法
        shape2.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = ShapeFactory.getShape(ShapeType.SQUARE);

        //调用 Square 的 draw 方法
        shape3.draw();
    }
}

工厂模式实例：

package 工厂设计模式;

public class Factory_pattern {
    public static void main(String[] args) {
        Factory facortoy = new Factory();
        Person zgr = facortoy.getInstance("zgr");
        zgr.eat();
    }
}

//人类都具有吃方法
interface  Person{
    public void eat();
}

//中国人
class zgr implements Person{

    @Override
        public void eat() {
        System.out.println("中国人吃饭用筷子");
    }
}

//印度人
class ydr implements Person{

    @Override
    public void eat() {
        System.out.println("印度人用手吃饭");
    }
}

//美国人
class mgr implements Person{

    @Override
    public void eat() {
        System.out.println("美国人用刀和叉子吃饭");
    }
}

interface Instance{
    public Person getInstance(String str);
}

class Factory implements Instance{
    @Override
    public Person getInstance(String str) {
        if(str.equals("zgr")) {
            return new zgr();
        }else if(str.equals("ydr")) {
            return new ydr();
        }else if(str.equals("mgr")) {
            return new mgr();
        }else {
            return null;
        }
    }
}

接口定义实现类的规范，通过反射工厂类进行生产，完整的一个过程就是。

接口类：

public interface Shape {
   void draw();
}

实现类：

public class Rectangle implements Shape{
   @Override   public void draw() {
      System.out.println("Rectangle");  
   }
}

public class Square implements Shape{
   @Override   public void draw() {
      System.out.println("Square");  
   }
}

工厂类:

public class ShapeFactory{
   public static Shape getClass(Class<?extends Shape> clazz) {
       Shape o = null;     
        try {
          o = (Shape) Class.forName(clazz.getName()).newInstance();       
        } catch (InstantiationException e) {
          e.printStackTrace();       
        } catch (IllegalAccessException e) {
          e.printStackTrace();       
        } catch (ClassNotFoundException e) {
          e.printStackTrace();       
        }
       return o;    
     }
  }
}

给定条件产出：

public class FactoryModeImpl {
   public static void main(String[] args) {
      Shape shape = ShapeFactory.getClass(Square.class);      
      shape.draw();  
   }
}

python 代码实现示例：

class Shape(object):
    def draw(self):
        pass
    
class RectangleImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Rectangle::draw() method.")
        
class SquareImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Square::draw() method.")
        
        
class CircleImplementsShape(Shape):
    def __init__(self):
        print("this relalize Interface")
    def draw(self):
        print("Inside Circle::draw() method.")
        
class ShapeFactory(object):
    def __init__(self):
        print("ShapeFactory init")
    def getShape(self,method):
        if method.lower() == 'rectangle':
            return RectangleImplementsShape()
        if method.lower() == 'square':
            return SquareImplementsShape()
        if method.lower() == 'circle':
            return CircleImplementsShape()

            
        
shapeFactory = ShapeFactory()        
        
shap1 = shapeFactory.getShape('Rectangle')
shap2 = shapeFactory.getShape('Square')
shap3 = shapeFactory.getShape('Circle')

shap1.draw()
shap2.draw()
shap3.draw()

下面例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂。

简单工厂模式

简单工厂模式不是 23 种里的一种，简而言之，就是有一个专门生产某个产品的类。

比如下图中的鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。

工厂模式

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。

戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。

生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。

后续直接调用鼠标工厂.生产鼠标()即可

抽象工厂模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。

也就是 PC 厂商是个父类，有生产鼠标，生产键盘两个接口。

戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。

创建工厂时，由戴尔工厂创建。

后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

在抽象工厂模式中，假设我们需要增加一个工厂

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。

之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。

之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。 以上。

Python 实现：

# Python原生默认不支持接口，默认多继承，所有的方法都必须不能实现
from abc import  abstractmethod,ABCMeta

# 创建一个接口Shape
class Shape(metaclass=ABCMeta):
    @abstractmethod
    def draw(self):
        pass
#创建Shape的实体类
class Rectangle(Shape):
    def draw(self):
        print("Inside Rectangel:draw() method.")
class Square(Shape):
    def draw(self):
        print("Inside Square:draw() method.")
class Circle(Shape):
    def draw(self):
        print("Inside Circle:draw() method.")

# 创建一个接口Color
class Color(metaclass=ABCMeta):
    @abstractmethod
    def fill(self):
        pass
# 创建Color的实体类
class Red(Color):
    def fill(self):
        print("Inside Red.fill() method.")
class Green(Color):
    def fill(self):
        print("Inside Green.fill() method.")
class Blue(Color):
    def fill(self):
        print("Inside Blue.fill() method.")

#创建抽象工厂
class AbstractFactory(metaclass=ABCMeta):
    @abstractmethod
    def getColor(self,color):
        pass
    @abstractmethod
    def getShape(self,shape):
        pass
#创建抽象工厂实例 ShapeFactory,ColorFactory
class ShapeFactory(AbstractFactory):
    def getShape(self,shapeType):
        if shapeType == None :
            return None
        elif shapeType.upper() == "CIRCLE":
            return Circle()
        elif shapeType.upper() == "RECTANGLE":
            return Rectangle()
        elif shapeType.upper() == "SQUARE":
            return Square()
        return None
    def getColor(self,colorType):
        pass
class ColorFactory(AbstractFactory):
    def getShape(self,shapeType):
        pass
    def getColor(self,colorType):
        if colorType == None:
            return None
        elif colorType.upper() == "RED":
            return Red()
        elif colorType.upper() == "GREEN":
            return Green()
        elif colorType.upper() == "BLUE":
            return Blue()
        return None

# 创建工厂创造器/生产器类
class FactoryProducer():
    @staticmethod
    # 这里不能写成 def getFactory(self,choiceType): 否则会报错
    # 因为是静态方法，被直接调用，所以不能带self参数
    # 如果不是静态方法，必须加self参数，且需要先实例化对象，再用实例化的对象调用方法
    def getFactory(choiceType):
        if choiceType.upper() == "SHAPE":
            return ShapeFactory()
        elif choiceType.upper() == "COLOR":
            return ColorFactory()
        return None

# 调用输出
if __name__ == '__main__':
    shapeFactory = FactoryProducer.getFactory('SHAPE')
    shape1 = shapeFactory.getShape("CIRCLE")
    shape1.draw()
    shape2 = shapeFactory.getShape("RECTANGLE")
    shape2.draw()
    shape3 = shapeFactory.getShape("SQUARE")
    shape3.draw()

    colorFactory = FactoryProducer.getFactory("COLOR")
    color1 = colorFactory.getColor("RED")
    color1.fill()
    color2 = colorFactory.getColor("Green")
    color2.fill()
    color3 = colorFactory.getColor("BLUE")
    color3.fill()

懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。

并且声明对象都需要私有化，构造方法都要私有化，这样外部才不能通过 new 对象的方式来访问。

饿汉式的话是声明并创建对象(因为他饿)，懒汉式的话只是声明对象，在调用该类的 getinstance() 方法时才会进行 new 对象。

反射机制破解单例模式（枚举除外）：

public class BreakSingleton{
    public static void main(String[] args) throw Exception{
        Class clazz = Class.forName("Singleton");
        Constructor c = clazz.getDeclaredConstructor(null);

        c.setAccessible(true);

        Singleton s1 = c.newInstance();
        Singleton s2 = c.newInstance();
        //通过反射，得到的两个不同对象
        System.out.println(s1);
        System.out.println(s2);
    }
}

如何避免以上的漏洞：

class Singleton{
    private static final Singleton singleton = new Singleton(); 
        private Singleton() {
        //在构造器中加个逻辑判断,多次调用抛出异常
        if(instance!= null){
            throw new RuntimeException()
        }
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

登记式单例模式是对一组单例模式进行的维护, 保证 map 中的对象是同一份 Spring 中使用的就是类似的模式:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class RegisterSingleton {
    /** * 登记式单例模式, 保证map中的对象是同一份 */
    private static Map<String, Object> map;

    static {
        map = new ConcurrentHashMap<>();
        map.put(RegisterSingleton.class.getName(), new RegisterSingleton());
    }

    private RegisterSingleton() {
        System.out.println("this Constructor is called");
    }

    public static Object getInstance(String name) {
        if (name == null) {
            name = RegisterSingleton.class.getName();
        }
        if (map.get(name) == null) {
            try {
                map.put(name, Class.forName(name).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}

其实还有一种饿汉模式的变种：

public class LazyModel {
    public final static LazyModel INSTANCE = new LazyModel();
    int age ;
    String name;
    private LazyModel(){}
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

在准备阶段 LazyModel 就已经完成创建，所以可以直接使用。

建造者模式举例：去肯德基点餐，我们可以认为点餐就属于一个建造订单的过程。我们点餐的顺序是无关的，点什么东西也是没有要求的，可以单点，也可以点套餐，也可以套餐加单点，但是最后一定要点确认来完成订单。

public class OrderBuilder{
    private Burger mBurger;
    private Suit mSuit;

    //单点汉堡,num为数量
    public OrderBuilder burger(Burger burger， int num){
        mBurger = burger;
    }

    //点套餐，实际中套餐也可以点多份
    public OrderBuilder suit(Suit suit, int num){
    mSuit = suit;
    }

    //完成订单
    public Order build(){
        Order order = new Order();
        order.setBurger(mBurger);
        order.setSuit(mSuit);
        return order;
    }
}

另外适用于快速失败，在 build 时可以做校验，如果不满足必要条件，则可以直接抛出创建异常，在 OkHttp3 中的 Request.Builder 中就是这样用的。

public Request build() {  
    if (url == null) throw new IllegalStateException("url == null");  
    return new Request(this);
}

例如订单要求价格至少达到 30 块:

//完成订单
public Order build(){
    Order order = new Order();
    order.setBurger(mBurger);
    order.setSuit(mSuit);
    if(order.getPrice() < 30){
        throw new BuildException("订单金额未达到30元");
    }
    return order;
}

另外，在构建时如果有必传参数和可选参数，可以为 Builder 类添加构造函数来保证必传参数不会遗漏，例如在构建一个 http 请求时, url 是必传的:

public class RequestBuilder{
    private final String mUrl;
    private Map<String, String> mHeaders = new HashMap<String, String>();

    private RequestBuilder(String url){
        mUrl = url;
    }

    public static RequestBuilder newBuilder(String url){
        return new RequestBuilder(url);
    }

    public RequestBuilder addHeader(String key, String value){
        mHeaders.put(key, value);
    }

    public Request build(){
        Request request = new Request();
        request.setUrl(mUrl);
        request.setHeaders(mHeaders);
        return request;
    }
}

步骤 7可以拆开吧？

抽象建造者 1

public  class Builder {    
    public Meal meal = new Meal();    
    public void prepareVegMeal(){};    
    public void prepareNonVegMeal(){};    
    public Meal getMeal(){return null;
};

指挥者 2

public class Director {    
    public void Constuct(Builder builder){        
        builder.prepareVegMeal();        
        builder.prepareNonVegMeal();    
    }
}

具体的建造者

public class VegMealBuilder extends Builder{    
    public void prepareVegMeal() {        
        meal.addItem(new VegBurger());        
        meal.addItem(new Coke());
    }    
    public void prepareNonVegMeal() {    }    
    public Meal getMeal() {        
        return meal;    
    }
}

具体建造者

public class NonVegMealBuilder extends Builder {    
    @Override    
    public void prepareVegMeal() {    }    
    @Override    
    public void prepareNonVegMeal() {        
        meal.addItem(new ChickenBurger());        
        meal.addItem(new Pepsi());    
    }    
    @Override   
    public Meal getMeal() {        
        return meal;    
    }
}

调用

public class Test {    
    @Test    
    public void BuilderPatternDemo() {        
        Director director = new Director();        
        VegMealBuilder b1 = new VegMealBuilder();        
        NonVegMealBuilder b2 = new NonVegMealBuilder();        
        director.Constuct(b1);        
        director.Constuct(b2);        
        Meal vegMeal = b1.getMeal();        
        System.out.println("Veg Meal");        
        vegMeal.showItems();        
        System.out.println("Total Cost: " +vegMeal.getCost());        
        Meal nonVegMeal = b2.getMeal();        
        System.out.println("\n\nNon-Veg Meal");        
        nonVegMeal.showItems();       
        System.out.println("Total Cost: " +nonVegMeal.getCost());    
    }
}

最后应该是优化成 list（含有多参数）传入，上层组装meal套餐或者单点，这种灵活性更强吧。