设计模式概述

reify实现；concrete realization 具体实现；instantiated 实例化;implementation实现；

设计模式分类：

创造型：Factory Method工厂模式；Abstract Factory抽象工厂；Builder建造者；Prototype原型模式；Singleton单例模式；

结构型：Adapter适配器；Bridge桥接；Composite组合模式，Decorator装饰者；Facade门面/外观模式；Flyweight享元模式；

Proxy代理模式；

行为型：

Interpreter解释器模式；Template Method模板方法模式；Chain of Responsibility责任链模式；Command命令模式；Iterator迭代器模式；Mediator中介者模式；Memento备忘录模式；Observer观察者模式；State状态模式；Strategy策略模式；Visitor访问者模式

类模式：需要extends继承；Factory Method工厂模式；Class Adapter适配器；Interpreter解释器模式；Template Method模板方法模式；

对象模式：接口继承；除了类模式外都是对象模式；

 

使用接口和创建型模式编程

接口实现implement代替继承；建议不使用extend是

多态：使用派生类的重写来重新定义基类的行为，implements是某种形式的继承。

耦合：是程序的一个部分对另一部分有依赖。如：全局变量。

降低耦合，对象的实现必须对其使用者完全隐藏。

而访问器get和修改器set都是对域为对外公开的，这样不好；有耦合性。

组合：多使用实现接口，采用对象组合功能；在类中使用另一个类；

 

模板模式

基类的代码调用占位方法，该占位方法可被重写，其真正的实现是有派生类提供。

工厂方法模式：其实就是一个模板方法，该模板方法创建对象时，具体的类对基类来说是未知。

继承：is-a关系

 

工厂模式：

抽象工厂模式是避免"必须修改所有new 调用"。

抽象供的所有具体化有一个共同的主题：使用工厂创建类型尚不知道的对象。

 

单例模式：

私有构造器，只能创建一个对象；

全局访问：

Class.forName("MyClass")

double check：

if (instance == null){

   synchronized(lock)

}

 

设计模式类型

1.创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式

2.结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

3.行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式

 

1.单例设计模式

保证某个类只能存在一个对象实例，并且该类只能提供一个取得其对象实例的方法（静态方法）

八种方式：

1.饿汉式（静态常量）

2.饿汉式（静态代码块）

3.懒汉式（线程不安全）

4.懒汉式（线程安全，同步方法）

5.懒汉式（线程安全，同步代码块）

6.双重检查

7.静态内部类

8.枚举

 

步骤：

1.构造器私有化（防止new）

2.类的内部创建对象；

3.向外部暴露一个静态的公共方法，getInstance；

 

双重检查：解决线程安全问题，同时解决懒加载问题，同时保证了效率，推荐使用

public static synchronized Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
}

JVM的classloder机制避免多线程的同步问题，

 

静态内部类：

// 静态内部类完成， 推荐使用
class Singleton {
    private static volatile Singleton instance;
    
    //构造器私有化
    private Singleton() {}
    
    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton(); 
    }
    
    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {        
        return SingletonInstance.INSTANCE;
    }
}

这种方式：

静态内部类在类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingleetonInstance类；从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以JVM保证了线程的安全；

总结：

1.单例模式，保证内存中该类只存在一个对象，对于需要频繁创建销毁的对象，单例模式会提高系统性能；

2.获得单例对象时，是使用获取对象的方法，而不是使用new；

3.单例使用场景：工具类对象，访问数据库或文件的对象；

 

2.简单工厂模式

需求：

1.披萨的种类很多；

2.披萨的制作方法；

3.披萨店订购功能；

思路：

把创建Pizza对象封装到一个类中，这样在有新的Pizza种类时，只需修改该类就可以-->简单工厂模式；

 

简单工厂定义：

1.属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品实例。

2.简单工厂模式，定义一个创建对象的类，由这个类来封装实例化对象的行为。

3.应用场景，在用到创建某种、某类批量对象时。

public static Pizza createPizza2(String orderType)  //静态工厂模式

 

工厂方法模式

1.将对象实例化功能抽象成抽象方法，在子类中具体实现。

2.定义一个创建对象的抽象方法，由子类决定要实例化的类。

工厂方法就是讲对象的实例化推迟到子类

OrderPizza抽象类

public abstract class OrderPizza {

    //定义一个抽象方法，createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);
    
    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); //抽象方法，由工厂子类完成
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            
        } while (true);
    }

}

继承抽象类，实现createPizza方法

public class BJOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) { 
        Pizza pizza = null;
        if(orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
      
        return pizza;
    }

}

//将Pizza 类做成抽象
public abstract class Pizza {

     //准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
    public abstract void prepare();

}

多个披萨子类

public class BJCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println(" 北京的奶酪pizza 准备原材料");
    }

}

抽象工厂

1.抽象工厂：定义了一个interface用于创建相关或有依赖关系的对象组，无需指明具体的类。

2.抽象工厂模式将简单工厂模式和工厂方法模式进行整合。

3.抽象工厂模式是对简单工厂模式的改进；

4.将工厂抽象成两层，AbsFactory抽象工厂和具体实现的工厂子类；可根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂族，便于代码的维护和扩展。

 

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来 具体实现
    public Pizza createPizza(String orderType);
}

 

public class OrderPizza {

    AbsFactory factory;

    // 构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = ""; // 用户输入
        this.factory = factory;
        do {
            orderType = getType();
            // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) { // 订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }
}

public static void main(String[] args) {
        //new OrderPizza(new BJFactory());
        new OrderPizza(new LDFactory());
}

总结：

1.工厂模式意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。

2.设计模式依赖抽象原则；

 

创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。

变量不要直接持有具体类的引用。

不要让类继承具体类，而是继承抽象类或者是实现interface接口；

不要覆盖基类已经实现的方法；