什么是设计模式
设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
为什么要学习设计模式
设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解
- 可以提高程序员的思维能力、编程能力和设计能力。
- 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
- 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。
设计模式分类
大体可以分为三种，每种加起又可以细分为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开发中的工厂设计模式
Spring IOC
- 看过Spring源码就知道，在SpringIOC容器创建bean的过程是使用了工厂设计模式。
- Spring中无论是通过xml配置还是通过配置类还是通过注解进行创建bean，大部分都是通过简单工厂来进行创建的。
- 当容器拿到了beanName和class类型后，动态的通过反射创建具体的某个对象，最后将创建的指向放到map中。
为什么Spring IOC 要使用工厂设计模式创建Bean呢？
- 在实际开发中，如果我们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(); } }- 缺点：必须是面向接口，目标业务类必须实现接口。
- 优点：不用关心代理类，只需要在运行阶段才指定代码哪一个对象。
CGLIB动态代理
CGLI动态代理原理
利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成之类来处理。
什么是CGLIB动态代理
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类型。