什么是设计模式
设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
为什么要学习设计模式
设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解
- 可以提高程序员的思维能力、编程能力和设计能力。
- 使程序设计更加标准化、代码编制更加工程化,使软件开发效率大大提高,从而缩短软件的开发周期。
- 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。
设计模式分类
大体可以分为三种,每种加起又可以细分为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类型。