单例模式:
- 可以用双检索、枚举、匿名内部类实现。
- 分为懒汉式(延迟加载,需要再创建)和饿汉式(一开始就创建好)。
- 由JVM保证static修饰的内容,堆中只有一份
- 枚举:避免通过反序列化来创建多个对象
- JVM保证枚举实例的唯一性
- 反编译可以看出来枚举其实就是一个集成了Enum的类
- 枚举序列化是由jvm保证的,每一个枚举类型和定义的枚举变量在JVM中都是唯一的
代理模式:
为一个对象提供一个替身,以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增强额外的功能能操作,即扩展目标对象的功能。
实现方式:
- Cglib代理:实际上是生成一个被代理对象的子类,所以被代理对象不能被final修饰
- jdk代理:被代理对象需要实现一个接口
动态代理(jdk代理)
主要方法:newProxyInstance
/**
* 说明:
* public static Object newProxyInstance(ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h)
* 1. ClassLoader loader:
* 指定当前目标对象使用的类加载器,获取加载器的方法固定
* 2. Class<?>[] interfaces
* 目标对象实现的接口类型,使用泛型方法确认类型
* 3. InvocationHandler h
* 事情处理,执行目标对象的方法时,会触发事情处理器方法,会把当前执行的目标对象方法作为参数传入
*
*/
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new InvocationHandler() {
Cglib代理:
需要实现MethodInterceptor 接口,并重写其中intercept方法。
public class CglibProxyFactory implements MethodInterceptor {
// 维护一个目标对象
private Object target;
// 构造器,传入一个被代理对象
public CglibProxyFactory (Object target) {
this.target = target;
}
// 返回一个代理对象,是target对象的代理对象
public Object getProxyInstance() {
// 1.创建一个工具类
Enhancer enhancer = new Enhancer();
// 2. 设置父类
enhancer.setSuperclass(target.getClass());
// 3.设置回调函数
enhancer.setCallback(this);
// 4.创建子类对象,即代理对象
return enhancer.create();
}
// 重写intercept犯法,会调用目标对象的方法
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("Cglib代理对象模式开始。。。。。。。");
Object res = method.invoke(target, objects);
System.out.println("Cglib代理对象模式结束。。。。。。。");
return res;
}
}
装饰模式:
动态的将新功能附加到对象上。
装饰模式的实现方式:装饰者中存放一个被装饰对象的引用(属性)。
- 接口A,
- 被装饰对象:一个实现类B,即被装饰对象。
- 装饰者抽象类:装饰者抽象类C实现A,并在其中存放一个A的引用。
- 具体装饰类:具体的装饰者实现类D继承C,完成对被装饰对象的装饰。
在IO中被广泛使用:
- InputStream是抽象类
- ByteArrayInputStream、FileInputStream、ObjectInputStream、PipedInputStream都是具体构建角色,是InputStream的子类是被装饰对象
如FileInputStream的声明
public
class FileInputStream extends InputStream
{
- FilterInputStream无疑就是一个装饰角色,因为FilterInputStream实现了InputStream内的所有抽象方法并且持有一个InputStream的引用
public
class FilterInputStream extends InputStream {
/**
* The input stream to be filtered.
*/
protected volatile InputStream in;
protected FilterInputStream(InputStream in) {
this.in = in;
}
- 具体装饰角色就是InflaterInputStream、BufferedInputStream、DataInputStream;
享元模式:
简单点说,其实就是共享对象,避免资源的浪费。
经典使用场景就是stirng常量池,数据库连接池、缓冲池等
策略模式:
策略模式是对算法的包装,是把使用算法的责任和算法本身分开。策略模式通常是把一系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。
策略模式涉及到三个角色:
- 环境角色(使用者Context):持有一个策略Strategy的引用
- 抽象策略角色:这是一个抽象角色,通常由一个接口或抽象类实现,此角色给出所有具体策略类所需的接口
- 具体策略角色:实现了抽象策略角色,包装了相关算法或行为
策略模式的使用:
举一个实际例子吧。假如有一个购物系统,在用户付款的时候,会产生很多场景,根据用户的不同情况算出不同用户要付款的金额,这时候最直观的一种做法是:
在付款的里面写N多的if…else if…else,判断用户的场景,根据场景计算用户付款金额。
这种设计明显违反了开闭原则。开闭原则的"闭",指的是对修改关闭,但是这里假如算法又多了几种,那么必须再次修改这个付款的类。
这时候就可以使用策略模式。在付款的类里面持有一个付款接口的引用,每次根据不同场景传入一个具体的策略就好了。比如A类中要使用S0算法,就传入一个S0策略;B类中要使用S1算法,就传入一个S1算法。不需要把判断都放在付款的类中,代码的可读性、可维护性也更高了。付款这个类甚至可以直接生成一个.class文件放在一个jar包里面供调用。
Java中的应用:Comparator策略接口
public static void main(String[] args) {
Integer[] data = {4,3,5,9,2};
/**
* 1.匿名内部类实现了Comparator接口(策略接口),匿名类对象即new Comparator<Integer>() {}
* 2.匿名类对象中的compare方法其实就是具体的策略方法,可以指定不同的处理方式
*/
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
return 1;
} else {
return -1;
}
}
};
// 第二个参数相当于持有一个策略的引用
Arrays.sort(data, comparator);
System.out.println(data);
}