关于设计模式:面试题设计模式

设计模式，是一套被重复应用、少数人通晓的、通过分类编目标、代码设计教训的总结。应用设计模式是为了可重用代码、让代码更容易被别人了解、保障代码可靠性、程序的重用性。

设计模式的实质是面向对象设计准则的理论使用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充沛了解

能够进步程序员的思维能力、编程能力和设计能力。
使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

大体能够分为三种，每种加起又能够细分为 23 种。

创立型模式，共五种：工厂办法模式、形象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装璜器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板办法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

准则思维：尽量通过扩大软件实体来解决需要变动，而不是通过批改已有的代码来实现变动
形容：一个软件产品在生命周期内，都会发生变化，既然变动是一个既定的事实，咱们就应该在设计的时候尽量适应这些变动，以进步我的项目的稳定性和灵活性。
长处：繁多准则通知咱们，每个类都有本人负责的职责，里氏替换准则不能毁坏继承关系的体系。

准则思维：应用的基类能够在任何中央应用继承的子类，完满的替换基类。
大略意思是：子类能够扩大父类的性能，但不能扭转父类原有的性能。子类能够实现父类的形象办法，但不能笼罩父类的非形象办法，子类中能够减少本人特有的办法。
长处：减少程序的健壮性，即便减少了子类，原有的子类还能够持续运行，互不影响。

依赖倒置准则的核心思想是面向接口编程.
依赖倒转准则要求咱们在程序代码中传递参数时或在关联关系中，尽量援用档次高的形象层类，
这个是凋谢关闭准则的根底，具体内容是：对接口编程，依赖于形象而不依赖于具体。

这个准则的意思是：应用多个隔离的接口，比应用单个接口要好。还是一个升高类之间的耦合度的意思，从这儿咱们看出，其实设计模式就是一个软件的设计思维，从大型软件架构登程，为了降级和保护不便。所以上文中屡次呈现：升高依赖，升高耦合。
例如：领取类的接口和订单类的接口，须要把这俩个类别的接口变成俩个隔离的接口

准则思维：一个对象该当对其余对象有尽可能少地理解，简称类间解耦
大略意思就是一个类尽量减少本人对其余对象的依赖，准则是低耦合，高内聚，只有使各个模块之间的耦合尽量的低，能力进步代码的复用率。
长处：低耦合，高内聚。

准则思维：一个办法只负责一件事件。
形容：繁多职责准则很简略，一个办法一个类只负责一个职责，各个职责的程序改变，不影响其它程序。这是常识，简直所有程序员都会遵循这个准则。
长处：升高类和类的耦合，进步可读性，减少可维护性和可拓展性，升高可变性的危险。

保障一个类只有一个实例，并且提供一个拜访该全局拜访点

网站的计数器，个别也是采纳单例模式实现的，否则难以同步
应用程序的日志利用，个别也都是单例模式实现，只有一个实例去操作才好，否则内容不好最佳显示。
多线程的线程池的设计个别也是采纳单例模式，因为线程池要不便对池中的线程进行管制。
Windows 的工作管理器就是厂房典型的单例模式，他不能关上两个
Windows 的回收站也是经典的单例利用。在整个零碎运行过程中，回收站只能保护一个实例。

在单例模式中，流动的单例只有一个实例，对单例类的所有实例化失去的都是雷同的一个实例。这样就避免其余对象对本人的实例化，确保所有的对象都拜访一个实例。
单例模式具备肯定的伸缩性，类本人来管制实例化过程，类就在扭转实例化过程上有相应的伸缩性。
提供了对惟一实例的受控拜访。
因为在零碎内存中只存在一个对象，因而能够节约系统资源，当须要频繁创立和销毁的对象时单例模式无疑能够提供零碎的性能。
容许可变数目标实例。
防止对共享资源的多重占用。

不适用于变动的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的谬误，不能保留彼此的状态。
因为单例模式中没有形象层，因而单例的扩大有很大的艰难。
单例类的职责过重，在肯定程序上违反了“繁多职责准则”。
滥用单例将带来一些负面问题，如为了节俭资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而呈现连接池溢出；如果实例化的对象长时间不被利用，零碎会认为是垃圾而被回收，这将导致对象状态的失落。

应用时不能用反射模式创立单例，否则会实例一个新的对象。
应用懒单例模式时留神线程平安问题。
饿单例模式和懒单例模式构造方法都是公有的，因而是不能被继承的，有些单例模式能够被继承（如注销式模式）

private static boolean flag = false;

private Singleton() {if (flag == flase) {flag = !flag;} eLse {thrown new RuntimeException("单例模式被进犯！");
    }
}

如果不须要提早加载单例，能够应用枚举或者饿汉式，相对来说枚举性好于饿汉式。如果须要提早加载，能够应用动态外部类或者懒汉式，相对来说动态外部类好于懒汉式。

饿汉式：类初始化时，会立刻加载该对象，线程天生平安，调用效率高。
懒汉式：类初始化时，不会初始化该对象，真正须要应用的时候才会创立该对象，具备懒加载性能。
动态外部形式：联合了懒汉式和饿汉式格子的长处，真正须要对象的时候才会加载，加载相似线程平安的。
枚举单例：应用枚举实现单例模式
- 长处：实现简略、调用效率高，枚举自身就是单例，因为 JVM 从根本上提供保障！防止通过反射和反序列化的破绽
- 毛病：没有提早加载
双重检测锁形式：因为 JVM 实质重排序的起因，可能会初始化屡次，不举荐应用

类初始化时，会立刻加载该对象，线程天生平安，调用效率高。

public class Demo1 {private static Demo1 demo1 = new Demo1();

    private Demo1() {System.out.println("公有 Demo1 结构参数初始化");
    }

    public static Demo1 getInstance() {return demo1;}

    public static void main(String[] args) {Demo1 s1 = Demo1.getInstance();
        Demo1 s2 = Demo1.getInstance();
        System.out.println(s1 == s2);
    }
}

类初始化时，不会初始化该对象，真正须要应用的时候才会创立该对象，具备懒加载性能。

public class Demo2 {
    private static Demo2 demo2;

    private Demo2() {System.out.println("公有 Demo2 结构参数初始化");
    }

    public synchronized static Demo2 getInstance () {if (demo2 == null) {demo2 = new Demo2();
        }
        return demo2;
    }

    public static void main(String[] args) {Demo2 s1 = Demo2.getInstance();
        Demo2 s2 = Demo2.getInstance();
        System.out.println(s1 == s2);
    }
}

动态外部类形式：联合了懒汉式和饿汉式格子的长处，真正须要对象的时候才会加载，加载类是线程平安的。

public class Demo3 {private Demo3() {System.out.println("Demo 的公有结构参数办法");
    }

    public static class SingletonClassInstance{private static final Demo3 DEMO_3 = new Demo3();
    }

    public static Demo3 getInstance() {return SingletonClassInstance.DEMO_3;}

    public static void main(String[] args) {Demo3 s1 = Demo3.getInstance();
        Demo3 s2 = Demo3.getInstance();
        System.out.println(s1 == s2);
    }
}

应用枚举实现单例模式
长处：实现简略，调用效率高，枚举自身就是单例，由 JVM 从根本上提供保障！防止通过反射和反序列化的破绽
毛病：没有提早加载

它提供了一种创建对象的最佳形式。在工厂模式中，咱们创建对象时不会对客户端裸露创立逻辑，并且是通过应用一个独特的接口来指向新创建的对象。实现了创建者和调用者拆散，工厂模式分为简略工厂、工厂办法、形象工程模式

工厂模式时咱们最罕用的实例化对象模式了，是用工厂办法代替 new 操作的一种模式。
利用工厂模式能够升高程序的耦合性，为前期的保护批改提供了很大的便当。
将抉择实现类、创建对象对立治理和管制。从而将调用者跟我妈的实现类解耦。

Spring IOC
- 看过 Spring 源码就晓得，在 SpringIOC 容器创立 bean 的过程是应用了工厂设计模式。
- Spring 中无论是通过 xml 配置还是通过配置类还是通过注解进行创立 bean，大部分都是通过简略工厂来进行创立的。
- 当容器拿到了 beanName 和 class 类型后，动静的通过反射创立具体的某个对象，最初将创立的指向放到 map 中。

在理论开发中，如果咱们 A 对象调用 B，B 调用 C，C 调用 D 的话咱们程序的耦合性就会变高。
在很久以前的三层架构编程时，都是管制层调用业务层，业务层调用数据拜访层时，都是间接 new 对象，耦合性大大晋升，代码反复量很高，对象满天飞。
为了防止这种状况，Spring 应用工厂模式编程，写一个工厂，由工厂创立 Bean，当前咱们如果要对象就间接管工厂要就能够了，剩下的事件不归咱们管了.Spring IOC 容器的工厂中有个动态的 Map 汇合，是为了让工厂合乎单例设计模式，即每个对象只生产一次，生产出对象后就存入到 Map 汇合中，保障了实例不会反复影响程序效率。

简略工厂：用来生产同一等级构造中的任意产品
工厂办法：用来生产同一等级构造中的固定产品
形象工厂：用来生产不同产品组族的全副产品。

简略工厂模式相等于是一个工厂中有各种产品，创立在一个类中，客户无需晓得具体产品的名称，只须要晓得产品类说对应失去参数即可。然而工厂的职责过重，而且当类型过多时不利于零碎的扩大保护。

代码演示：

创立工厂

public interface Car {public void run();
}

创立工厂的产品（如果为宝马）

public class Bmw implements Car {
@Override
public void run() {System.out.println("我是宝马汽车......");
    }
}

创立工厂中的另外一种产品（如果为奥迪）

public class AoDi implements Car{
@Override
public void run() {System.out.println("我是奥迪汽车......");
    }
}

创立外围工厂类，有他决定具体调用哪个产品

public class CarFactory {public static Car createCar(String name) {if ("".equals(name)) {return null;}
    if (name.equals("奥迪")) {return new AoDi();
    }
    if (name.equals("宝马")) {return new Bmw();
    }
    return null;
    }
}

演示创立工厂的具体实例
```
public class Client01 {public static void main(String[] args) {Car aoDi = CarFactory.createCar("奥迪");
    Car bmw = CarFactory.createCar("宝马");
    aoDi.run();
    bmw.run();;}
}
```
单工厂的长处 / 毛病：
长处：简略工厂模式可能依据外界给定的信息，决定到底应该创立哪个具体类的对象。明确辨别了各自的职责和势力，有利于整个软件体系结构的优化。
毛病：很显著工厂类集中了所有实例的创立逻辑，容易违反高汇集的责任分配原则。

工厂办法模式，又称为多态性工厂模式。在工厂办法模式中，外围的工厂类不在负责所有的产品的创立，而是将具体创立的工作交给子类去做。该外围类成为一个形象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类该当被实例化的这种细节。

代码演示：

创立工厂：

public interface Car {public void run();
}

创立工厂办法调用接口（所有的产品须要 new 进去必须继承他来实现办法）
```
public interface CarFactory {Car createCar();
}
```

创立工厂的第一种产品（假如为奥迪）

public class AoDi implements Car{
@Override
public void run() {System.out.println("我是奥迪汽车......");
    }
}

创立工厂中的另外一个产品（假如为宝马）

public class Bmw implements Car{
@Override
public void run() {System.out.println("我是宝马汽车......");
    }
}

创立工厂办法调用接口的实例（奥迪）

public class AoDiFactory implements CarFactory{
@Override
public Car createCar() {return new AoDi();
    }
}

创立工厂办法调用接口的实例（宝马）

public class BmwFactory implements CarFactory{
@Override
public Car createCar() {return new Bmw();
    }
}

演示创立工厂的具体实例

public class Client {public static void main(String[] args) {Car aodi = new AoDiFactory().createCar();
    Car bmw = new BmwFactory().createCar();
    aodi.run();
    bmw.run();}
}

形象工厂简略地说是工厂的工厂，形象工厂能够创立具体工厂，由具体工厂来产品具体产品。

代码演示：

创立第一个子工厂，及实现类

public interface Car {void run();
}

class CarA implements Car {

    @Override
    public void run() {System.out.println("宝马");
    }
}

class CarB implements Car {
    @Override
    public void run() {System.out.println("摩拜");
    }
}

创立第二个子工厂，及实现类

public interface Engine {void run();
}

class EngineA implements Engine {
    @Override
    public void run() {System.out.println("转的很快!");
    }
}

class EngineB implements Engine {
    @Override
    public void run() {System.out.println("转的慢!");
    }
}

创立一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）

public interface TotalFactory {
// 创立汽车
Car createChair();

// 创立发动机
Engine createEngine();}

class TotalFactoryReally implements TotalFactory {public Engine createEngine() {return new EngineA();
    }

    public Car createChair() {return new CarA();
    }
}

运行测试

public class Client {public static void main(String[] args) {TotalFactory totalFactory = new TotalFactoryReally();
    Car car = totalFactory.createChair();
    car.run();

    TotalFactory factoryReally = new TotalFactoryReally();
    Engine engine = factoryReally.createEngine();
    engine.run();}
}

通过代理管制对象的拜访，能够在这个对象调用办法之前、调用办法之后去解决 / 增加新的性能。（也就是 AOP 的微实现）
代理在原有代码乃至原业务流程都不批改的状况下，间接在业务流程中切入行新代码，减少新性能，这也和 Spring（面向切面编程）很类似。

Spring AOP、日志打印、异样解决、事务管制、权限管制等等

动态代理（动态定义代理类）
动静代理（动静生成代理类，也称为 JDK 自带动静代理）
Cglib、javaassist（字节码操作库）

动态代理：简略代理模式，是动静代理的实践根底。常见应用在代理模式。
JDK 动静代理：应用反射实现代理。须要有顶层接口能力应用，常见是 myabtis 的 mapper 文件是代理。
cglib 动静代理：也是应用反射实现代理，能够间接代理类（jdk 动静代理不行），应用字节码技术，不能对 final 类进行继承。（须要导入 jar 包）

什么是动态代理

由程序员创立或工具生成代理类的源码，再编译代理类。所谓动态也就是程序运行前就曾经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

我有一段这样的代码：（如何能在不批改 UserDao 接口类的状况下开事务和敞开事务呢）

public class UserDao {public void save() {System.out.println("保留数据办法");
    }
}

public class Test {public static void main(String[] args) {UserDao userDao = new UserDao();
        userDao.save();}
}

批改代码，增加代理类

public class UserDaoProxy extends UserDao{
    private UserDao userDao;

    public UserDaoProxy(UserDao userDao) {this.userDao = userDao;}

    public void save() {System.out.println("开启事务...");
        userDao.save();
        System.out.println("敞开事务...");
    }
}

public class ProxyTest {public static void main(String[] args) {UserDao userDao = new UserDao();
        UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
        userDaoProxy.save();}
}

长处：能够面相理论对象或者是接口的形式实现代理
毛病：每个须要代理的对象都须要本人反复编写代理，很不难受。

动静代理也叫做，JDK 代理、接口代理。

动静代理的对象，是利用 JDK 的 API，动静的在内存中构建代理对象（是依据被代理的接口来动静生成代理类的 class 文件，并加载运行的过程），这就叫动静代理。
源代码：

public interface UserDao {void save();
}

public class UserDaoImpl implements UserDao{
  @Override
  public void save() {System.out.println("保留数据办法");
  }
}

上面是代理类，可重复使用，不像动态代理那样要本人反复编写代理。

/**
 * 每次生成动静代理类对象，实现了 InvocationHandler 接口的调用处理器对象
 */
public class InvocationHandlerImpl implements InvocationHandler {

  /**
   * 这位业务实现类对象，用来调用具体的业务办法
   */
  private Object target;

  /**
   * 通过构造函数传入指标对象
   */
  public InvocationHandlerImpl(Object target) {this.target = target;}

  /**
   * 动静代理理论运行的代理办法
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("调用开始解决");
      // 上面 invoke()办法是以反射的形式来创建对象，第一个参数是要创立的对象，第二个是形成办法的参数，由第二个参数决定创立指向应用哪个构造方法
      Object result = method.invoke(target, args);
      System.out.println("调用完结解决");
      return result;
  }
}

public class Test {public static void main(String[] args) {
      // 被代理对象
      UserDao userDao = new UserDaoImpl();
      InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(userDao);
      // 类加载器
      ClassLoader loader = userDao.getClass().getClassLoader();
      Class<?>[] interfaces = userDao.getClass().getInterfaces();
      // 次要装载器、一组接口及调用解决动静代理实例
      UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandler);
      newProxyInstance.save();}
}

毛病：必须是面向接口，指标业务类必须实现接口。
长处：不必关怀代理类，只须要在运行阶段才指定代码哪一个对象。

利用 asm 开源包，对代理对象类的 class 文件加载进来，通过批改其字节码生成之类来解决。

CGLIB 动静代理和 jdk 代理一样，应用反射实现代理，不同的是他能够间接代理类（jdk 代理不行，他必须指标业务类必须实现接口），CGLIB 动静代理底层应用字节码技术，CGLIB 动静代理通能对 final 类进行继承。（CGLIB 动静代理须要导入 jar 包）

源代码：

public interface UserDao {void save();
}

public class UserDaoImpl implements UserDao{
    @Override
    public void save() {System.out.println("保留数据的办法");
    }
}

退出代理类：

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理次要类
 */
public class CglibProxy implements MethodInterceptor {

    private Object targetObject;

    /**
     * 这里的指标类型为 Object，则能够承受任意一种参数作为被代理类，实现了动静代理
     */
    public Object getInstance(Object target) {
        // 设置须要创立子类的类
        this.targetObject = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();}

    /**
     * 代理的理论办法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("开启事务");
        Object result = methodProxy.invoke(targetObject, objects);
        System.out.println("敞开事务");
        return result;
    }
}

public class Test {public static void main(String[] args) {CglibProxy cglibProxy = new CglibProxy();
        UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
        userDao.save();}
}

建造者模式：是将一个简单的对象的构建与它的示意拆散，使得同样的构建过程能够创立不同的形式进行创立。
工厂类模式提供的是创立单个类的产品，而建造者模式这是将各种产品集中起来进行治理，用来具备不同的属性的产品。

Builder：给出一个形象接口，以标准产品对象的各个组成成分的建造。这个接口规定要实现简单对象的哪些局部的创立，并不波及具体的对象部件的创立。
ConcreteBuilder：实现 Builder 接口，针对不同的商业逻辑，具体化简单对象的各局部的创立。在建造过程实现后，提供产品的实例。
Director：调用具体建造者来创立简单对象的各个局部，在指导者中不波及具体产品的信息，只负责保障对象各局部残缺创立或按某种程序创立。
Product：要创立的简单对象

须要生成的对象具备简单的内部结构。
须要生成的对象外部属性自身相互依赖。

与工厂模式的区别是：建造者模式更加关注与整机拆卸的程序。
Java 中的 StringBuilder 就是建造者模式创立的，他吧一个单个只剩的 char 数组组合起来。
Spring 不是建造者模式，他提供的操作应该是对于字符串自身的一些操作，而不是创立或扭转一个字符串。

建设一个配备对象 Arms

import lombok.Data;

/**
 * 配备类
 */
@Data
public class Arms {
    // 头盔
    private String helmet;
    // 铠甲
    private String armor;
    // 武器
    private String weapon;
}

创立 Builder 接口（给出一个形象接口，以标准产品对象的各个组成成分的建造，这个接口只是标准）

public interface PersonBuilder {void builderHelmetMurder();
void builderArmorMurder();
void builderWeaponMurder();
void builderHelmetYanLong();
void builderArmorYanLong();
void builderWeaponYanLong();
// 组装
Arms builderArms();}

创立 Builder 实现类（这个类次要实现简单对象创立的哪些局部须要什么属性）

public class ArmsBuilder implements PersonBuilder{

    private Arms arms;

    public ArmsBuilder() {arms = new Arms();
    }

    @Override
    public void builderHelmetMurder() {arms.setHelmet("夺命头盔");
    }

    @Override
    public void builderArmorMurder() {arms.setArmor("夺命盔甲");
    }

    @Override
    public void builderWeaponMurder() {arms.setWeapon("夺命宝刀");
    }

    @Override
    public void builderHelmetYanLong() {arms.setHelmet("炎龙头盔");
    }

    @Override
    public void builderArmorYanLong() {arms.setArmor("炎龙铠甲");
    }

    @Override
    public void builderWeaponYanLong() {arms.setWeapon("炎龙宝刀");
    }

    @Override
    public Arms builderArms() {return arms;}
}

Director（调用具体建造者来创立简单对象的各个局部，在指导者中不波及具体产品的信息，只负责保障对象各局部残缺创立或按某种程序创立）

public class PersonDirector {
/**
 * 组装
 */
public Arms constructPerson(PersonBuilder pb) {pb.builderHelmetYanLong();
    pb.builderArmorMurder();
    pb.builderWeaponMurder();
    return pb.builderArms();}

/**
 * 开始进行测试
 */
public static void main(String[] args) {PersonDirector personDirector = new PersonDirector();
    Arms arms = personDirector.constructPerson(new ArmsBuilder());
    System.out.println(arms.getHelmet());
    System.out.println(arms.getArmor());
    System.out.println(arms.getWeapon());
}

模板办法模式：定义一个操作中的算法骨架（父类），而将一些步骤提早到子类中。模板办法是得子类能够不扭转一个算法的构造来重定义该算法的。

实现一些操作时，整体步骤很固定，然而呢。就是其中一小部分须要扭转，这时候能够应用模板办法模式，将容易变的局部形象进去，供子类实现。

其实很多框架中都有用到了模板办法模式
例如：数据库拜访的封装、Junit 单元测试、servlet 中对于 doGet/doPost 办法的调用等等

例如：去餐厅吃饭，餐厅给咱们提供了一个模板就是：看菜单、点菜、吃饭、付款、走人（这里“点菜和付款”是不确定的由子类来实现的，其余的则是一个模板）

先定义一个模板，把模板中的点菜和付款，让子类来实现。

/**
 * 模板办法
 */
public abstract class RestaurantTemplate {
    /**
     * 看菜单
     */
    public void menu() {System.out.println("看菜单");
    }

    /**
     * 点菜业务
     */
    abstract void spotMenu();

    /**
     * 吃饭业务
     */
    public void havingDinner() {System.out.println("吃饭");
    }

    /**
     * 付款业务
     */
    abstract void payment();

    /**
     * 走人
     */
    public void GoR() {System.out.println("走人");
    }

    /**
     * 模板通用构造
     */
    public void process() {menu();
        spotMenu();
        havingDinner();
        payment();
        GoR();}
}

具体的模板办法子类 one

public class RestaurantLobsterImpl extends RestaurantTemplate{
    /**
     * 点菜业务
     */
    @Override
    void spotMenu() {System.out.println("龙虾");
    }

    /**
     * 付款业务
     */
    @Override
    void payment() {System.out.println("50 块");
    }
}

具体的模板办法子类 two

public class RestaurantGinsengImpl extends RestaurantTemplate{
    /**
     * 点菜业务
     */
    @Override
    void spotMenu() {System.out.println("人参");
    }

    /**
     * 付款业务
     */
    @Override
    void payment() {System.out.println("5 块");
    }
}

客户端测试

public class Client {public static void main(String[] args) {RestaurantLobsterImpl restaurantLobster = new RestaurantLobsterImpl();
        restaurantLobster.process();}
}

外观模式：也叫门面模式，暗藏零碎的复杂性，并向客户端提供了一个客户端能够拜访零碎的接口。
它向现有的零碎增加一个接口，用这一个接口来暗藏理论的零碎的复杂性。
应用外观模式，他内部看起来就是一个接口，其实他的外部有很多简单的接口曾经被实现。

用户注册完之后，须要调用阿里短信接口、邮件接口、微信推送接口。

创立阿里短信接口

/**
 * 阿里短信音讯
 */
public interface AliSmsService {void sendSms();
}

public class AliSmsServiceImpl implements AliSmsService{
    @Override
    public void sendSms() {System.out.println("阿里短信音讯");
    }
}

创立邮件接口

/**
 * 发送邮件音讯
 */
public interface EamilSmsService {void sendSms();
}

public class EamilSmsServiceImpl implements EamilSmsService{
    @Override
    public void sendSms() {System.out.println("发送邮件音讯");
    }
}

创立微信推送接口

/**
 * 微信音讯推送
 */
public interface WeixinSmsService {void sendSms();
}

public class WeiXinSmsServiceImpl implements WeixinSmsService{
    @Override
    public void sendSms() {System.out.println("发送微信音讯推送");
    }
}

创立门面（门面看起来很简略，简单的货色以及被门面给封装好了）

public class Computer {
    AliSmsService aliSmsService;
    EamilSmsService eamilSmsService;
    WeixinSmsService weixinSmsService;

    public Computer() {aliSmsService = new AliSmsServiceImpl();
        eamilSmsService = new EamilSmsServiceImpl();
        weixinSmsService = new WeiXinSmsServiceImpl();}

    /**
     * 只须要调用它
     */
    public void sendMsg() {aliSmsService.sendSms();
        eamilSmsService.sendSms();
        weixinSmsService.sendSms();}
}

进行测试

public class Client {public static void main(String[] args) {new Computer().sendMsg();}
}

原型设计模式简略来说就是克隆
原型表明了有一个样板实例，这个原型是可定制的。原型模型多用于创立简单的或者结构耗时的实例，因为这种状况下，复制一个曾经存在的实例可使程序运行更高效。

类初始化须要消化十分多的资源，这个资源包含数据、硬件资源等。这时咱们就能够通过原型拷贝防止这些耗费。
通过 new 产生的一个对象须要十分繁琐的数据筹备或者权限，这时能够应用原型模式。
一个对象须要提供给其余对象拜访，而且各个调用者可能都须要批改其值时，能够思考应用原型模式拷贝多个对象供调用者应用，即保护性拷贝。

实现 Cloneable 接口。在 java 语言有一个 Cloneable 接口，它的作用只有一个，就是在运行时告诉虚拟机能够平安地在实现了此接口的类上应用 clone 办法。在 java 虚拟机中，只有实现了这个接口的类才能够被拷贝，否则在运行时会抛出 CloneNotSupportedException 异样。
重写 Object 类中的 clone 办法。Java 中，所有类的父类都是 Object 类，Object 类中有一个 clone 办法，作用是返回对象的一个拷贝，然而其作用域 protected 类型的，个别的类无奈调用，因而 Prototype 类须要将 clone 办法的作用域批改为 public 类型。

什么是设计模式

为什么要学习设计模式

设计模式分类

设计模式的六大准则

凋谢关闭准则

里氏代换准则

依赖倒转准则

接口隔离准则

迪米特法令（起码晓得准则）

繁多职责准则

单例模式

什么是单例

那些中央用到了单例模式

单例模式的优缺点

长处

毛病

单例模式应用注意事项

单例避免反射破绽攻打

如何抉择单例创立形式

单例创立形式

饿汉式

懒汉式

动态外部类

枚举单例式

工厂模式

什么是工厂模式

工厂模式益处

Spring 开发中的工厂设计模式

为什么 Spring IOC 要应用工厂设计模式创立 Bean 呢？

工厂模式分类

简略工厂模式

什么是简略工厂模式

工厂办法模式

什么是工厂办法模式

形象工厂模式

什么是形象工厂模式

代理模式

什么是代理模式

代理模式利用场景

代理的分类

三种代理的区别

用代码演示三种代理

动态代理

什么是动态代理

动静代理

什么是动静代理

CGLIB 动静代理

CGLI 动静代理原理

什么是 CGLIB 动静代理

代码演示：

建造者模式

什么是建造者模式

建造者模式通常包含上面几个角色

建造者模式的应用场景

应用场景

代码演示：

模板办法模式

什么是模板办法

什么时候应用模板办法

理论开发中利用场景哪里用到了模板办法

现实生活中的模板办法

代码演示：

外观模式

什么是外观模式

代码演示：

原型模式

什么原型模式

原型模式的利用场景

原型模式的应用形式