1.单例模式
单例模式主要用于某个类有且只能用一个对象的场景,单例模式下不能外部实例化对象,由类内部自行私有化实例对象并提供一个可以获得该对象的方法。单例模式主要有饿汉模式(安全,但在编译时就会自动创建对象,即使不使用对象也会存在,会造成一定资源的浪费)、懒汉模式(安全,通过synchroized锁实现,每次获取对象时都会加锁,会对性能有一定影响)、DCL模式(基本安全,通过synchroized锁实现,在获取对象的方法内部加锁,当已经实例化对象时不会加锁直接返回对象,但在极少数情况下会出现线程不安全的情况)、静态内部类模式(安全,在类内定义一个静态的私有化的类来实例化对象)。
饿汉模式:
public class CEO {
private static final mCEO = new CEO();//私有化实例化对象
private CEO() { }//私有化构造方法
public static CEO getCEO() {
return mCEO;
}//提供获取对象的接口
}
懒汉模式:
public class CEO {
private static CEO mCEO;
private CEO() { }
public static synchroized CEO getCEO() {
if(mCEO == null) {
mCEO = new CEO();
}
return mCEO;
}//synchroized,加同步锁,保证唯一;
}
DCL模式:
public class CEO {
private static CEO mCEO = null;
private CEO() { }
public static CEO getCEO() {
if(mCEO == null) {
synchroized(CEO.class) {
if(mCEO == null) {
mCEO = new CEO();
}
}
}
return mCEO;
}
}
静态内部类模式:当外部类被加载时,静态内部类不会立即加载,
只有在第一次调用内部类的静态成员或方法时才会加载,这样实现了懒加载的效果。
同时,类加载过程是线程安全的,因此静态内部类单例模式也是线程安全的
public class CEO {
private CEO() { }
public static CEO getCEO() {
return CEOInstance.mCEO;
}
//静态内部类
private static class CEOInstance {
private static final CEO mCEO = new CEO();
}
}
2.构建者模式
用于创建复杂对象,将对象的创建与表示分离、按步奏创建对象,通常包含以下角色。
模式1:
产品(Product)——要创建的复杂对象,一般包含多种属性;
抽象构建者(Abstract Builder)——创建产品的各个抽象方法,以及返回最终产品的方法;
具体构建者(Concrete Builder)——负责产品的具体创建,以及最终产品的返回;
指导者(Director)——使用构建者构建产品;
public class Product {
private String partA;
private Int partB;
private Double partC;
public get();//相应参数的get方法
public set();//相应参数的set方法
}
public interface Builder {
void buildPartA(String part);
void buildPartA(Int part);
void buildPartA(Double part);
Product getProduct();
}
public ConcreteBuilder implements Builder {
private Product product;
public ConcreteBuilder() {
product = new Product();
}
@Override
public void buildPartA(String part) {
product.setPartA(part);
}
@Override
public void buildPartA(Int part) {
product.setPartB(part);
}
@Override
public void buildPartA(Double part) {
product.setPartC(part);
}
@Override
public Product getProduct() {
return product;
}
}
public class Director {
private Builder builder;
public void setBuilder(Builder builder) {
this.builder = builder;
}
public Product concreteProduct() {
builder.builderPartA("partA");
builder.builderPartB(45);
builder.builderPartC(1.44);
return builder.getProduct();
}
}
//实际使用
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director();
director.setBuilder(builder);
Product product = director.concreteProduct();
模式2:
public class Product {
private String A,B;
class Builder {
private Product product;
private String A,B;
public Builder setA(A) {
this.A = A;
return this;
}
public Builder setB(B) {
this.B = B;
return this;
}
public Product build() {
product = new Product();
product.A = A;
product.B = B;
return product;
}
}
}
Product product = Product.Builder().setA(A).setB(B).build();
3.工厂模式
特点:向上转换思想;不直接new对象,子类具体决定实例化什么对象;
应用:需要生成复杂对象的地方;
角色:抽象工厂、具体工厂、抽象产品、具体产品;
通用模式写法:
抽象工厂——定义一个返回抽象产品的抽象方法,该方法负责构造产品;
具体工厂——重写构造产品的方法,返回对象为具体产品;
抽象产品——定义一个抽象方法,该方法与产品关联;
具体产品——根据具体产品重写父类中与产品关联的抽象方法;
//抽象产品
public abstract class Product{
public abstract void fuction();
}
//具体产品A
public class ProductA extends Product{
@Override
public void function() {
system.out.println("产品A的功能是...");
}
}
//具体产品B
public class ProductB extends Product{
@Override
public void function() {
system.out.println("产品B的功能是...");
}
}
//抽象工厂写法
public abstract class Factory{
public abstract Product createProduct();
}
//具体工厂写法
public ConcreteFactoryA extends Factory {
@Override
public ProductA createProduct() {
return new ProductA();
}
}
public ConcreteFactoryB extends Factory {
@Override
public ProductB createProduct() {
return new ProductB();
}
}
//客户or测试
public class Client{
public static void main(String[] args) {
Factory factory = new ConcerateFactoryA();
Product product = factory.createProduct();
product.fuction();
}
}
4.原型模式
通过一个对象去创建(克隆)另一个与自己具有相同属性的对象,需要继承Cloneable接口重写clone方法。
注意:
1.克隆时不会调用构造函数,因此一些成员变量的初始化不能放在构造函数里
2.原型模式要注意深拷贝和浅拷贝的问题
public Prototype implents Cloneable {
private String mStr;//浅拷贝
private ArrayList<String> mStrs = new ArrayList<String>();//深拷贝
@Override
public Prototype clone() {
try{
Prototytpe obj = (Prototype)super.clone();
obj.mStr = this.mStr;//obj.mStrs = this.mStrs;//此处为浅拷贝
obj.mStrs = (ArrayList<String>)this.mStrs.clone();//此处为深拷贝
return obj;
} catch(Exception e) {
...
}
return null;
}
public void setMstr(String str) {
mStr = str;
}
public void setMstrs(ArrayList<String> strs) {
mStrs = strs;
}
...//该类的其他方法
}
public class Test{
public static void main(String[] args) {
Prototype prototype = new Prototype();
Prototype clonePrototype = prototype.clone()//此处为初始化String 和 ArrayList<String> ,会使用默认值
}
}