单例模式
确保一个类只有一个实例,并且自行实例化并向整个系统提供这个实例。
饿汉式单例模式
饿汉式单例模式在类加载的时候完成了实例化,因为我们将构造函数设为了私有,所有其他的对象不能通过new类创建这个类的实例,然后提供了一个公共的静态方法返回这个类的唯一实例。因为只有一个实例化对象,所以不存在线程安全问题,在平时不能通过new进行对象的创建,只能通过给定的那个全局访问点通过类名进行调用
/**
* 饿汉式单例模式
*/
public class SingletonPattern {
// 在类加载时完成了实例化
private static SingletonPattern singletonPattern = new SingletonPattern();
// 私有化构造函数,防止其他对象使用new创建该类的对象
private SingletonPattern() {
}
// 提供一个公共的静态方法,返回该类的唯一实例
public static SingletonPattern getSingletonPattern() {
return singletonPattern;
}
}
懒汉式单例模式
懒汉式单例在类加载的时候不创建对象,在第一次使用的时候进行创建,这样创建的优点是如果该单例对象在系统中没有被使用,那么就不会造成资源的浪费。但是懒汉式单例会出现线程安全问题,当多线程访问时,有可能出现多个线程同时if,就会创建出多个对象。
/**
* 懒汉式单例模式
*/
public class SingletonPattern1 {
// 初始化一个null对象
private static volatile SingletonPattern1 singletonPattern = null;
// 私有化构造函数,防止别的对象使用new创建该类的对象
private SingletonPattern1() {
}
// 提供一个公共的静态方法,返回该类的唯一实例
public static SingletonPattern1 getSingletonPattern() {
if (singletonPattern == null) {
singletonPattern = new SingletonPattern1();
}
return singletonPattern;
}
}
要解决这个线程安全的问题可以有两种方式,第一种是给方法加锁,但是给方法加锁之后一次只能获取到一个线程,效率较低。第二种是给代码块加锁,需要使用双重检索
双重检索单例模式
既提高了效率,又提高了安全性,使用双重if的原因是,当只有一个if时,如果锁加载if代码块的外面,这时候和加载方法上是一样的,效率低;如果加在if内,这是后如果并发量大,几个线程同时进行if然后进入if,虽然内部代码被锁包裹,但是已经进入的线程一个接一个执行,仍然会创建出多个对象,此时需要给内部代码块再加一层if,这时候即提高了效率,又提高了安全性。
/**
* 双重检索单例模式
*/
public class SingletonPattern2 {
// 初始化一个null对象
private static SingletonPattern2 singletonPattern = null;
// 私有化构造函数,防止别的对象使用new创建该类的对象
private SingletonPattern2() {
}
// 提供一个公共的静态方法,返回该类的唯一实例
public static SingletonPattern2 getSingletonPattern() {
if (singletonPattern == null) {
synchronized (SingletonPattern2.class) {
if (singletonPattern == null) {
singletonPattern = new SingletonPattern2();
}
}
}
return singletonPattern;
}
}
此时问题并没有完全解决,我们知道一个对象创建的过程主要分为三步,分配内存,初始化对象,指向刚分配的地址,但是第二步和第三步由于CPU的优化,可能会产生排序,我们一般认为执行顺序为123,但是可能会先执行3再执行2,这时候的对象是一个半成品对象,但是也不是null所以此时的情况并没有完全解决,需要添加volatile,只有当所有步骤都执行完之后才会将对象的地址传给引用参数。
工厂模式
简单工厂模式
简单工厂模式又称为静态工厂方法模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责其他类的实例,被创建的实例通常都具有共同的父类。优点是实现对象的创建和使用分离,创建完全交给专门的工厂类去负责,程序员不关心怎么创建,只关心怎么使用。缺点是工厂类不够灵活,如果新增一个产品就要修改工厂类,就要修改它的判断逻辑,如果产品很多的话,这个逻辑就会非常复杂。比如就是一台咖啡机可以理解为一个工厂模式,你只需要按下想喝的咖啡品类的按钮,他就会给你生产一杯相应的咖啡,你不需要管他的内部具体实现,只需要告诉它你的需求。
工厂(方法)模式
简单工厂模式当有新产品加入时必须要修改工厂类,需要在其中加入必要的业务逻辑,这违反了开闭原则,没有办法做到灵活扩展。工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化那个类。工厂方法使一个类的实例化延迟到其子类。
在工厂模式中,之前的核心工厂变成了一个抽象接口,负责给出工厂应该实现的方法,它不在负责所有产品的创建,将具体产品的创建交给子类去做,这样就诞生了具体的子工厂,子工厂即子类,负责生成具体的产品对象,这样做可以将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类,在现在的工厂模式中,如果需要新增一个产品,不需要修改原有的工厂类逻辑,但是需要新增一个工厂,这样看起来比较复杂,但是在面向对象语言中,需要遵循开闭原则,就是程序对于扩展是开放的,对于修改时封闭的
Collection就是一个常见的工厂方法模式,其中Collection就是抽象工厂,具体工厂时LinkedList和ArrayList,抽象产品就是Iterator,具体产品就是ListItr和Itr。
抽象工厂模式
抽象工厂模式可以使具体工厂类,可以创建多个大类对象,但是还需要修改抽象工厂和具体工厂的代码,违反开闭原则。
原型模式
原型模式属于创建型模式,用来创建一个已有的对象的完全相同的复制品。这个时候如果直接复制的话,需要创建一个相同类的对象,然后遍历原始对象的所有成员变量以及所有属性,然后将这些变量的值复制到新的对象中,但是这个对象的某些成员变量是私有的,不对外公开,或没有提供访问器,那么外部是没有办法去复制的,并且对象实现的某个接口传给我们时,我么你只知道它的某个接口的实现类,他具体的类是哪一个,这是不知道的。那么原型模式就是去解决复制对象的问题的,原型模式将这个复制过程称之为克隆,原型模式就是将这个克隆的过程委派给被克隆的实际对象,由这个被克隆的对象自己去负责克隆,原型模式为所有被克隆的对象提供了一个通用接口,原型对象需要克隆的话就去实现这个接口(clone),就在克隆方法中去实现自己的克隆逻辑。
代理模式
代理模式就是为其他对象提供一种代以控制这个对象的访问。例:黄牛买票,婚介
代理模式分为静态代理和动态代理,动态代理又分为JDK代理和CGLIB动态代理
优点是代理模式能够协调调用者和被调者,在一定程度上降低系统的耦合度,并且可以灵活的隐藏被代理对象的部分功能和服务,也增加了额外的功能和服务,缺点就是使用代理模式程序没有直接调用性能高,并且使用代理模式提高了代码的复杂度。