单例模式Singleton Pattern
确保类只有一个实例，而且自行实例化并向整个系统提供这个实例
public class Singleton{
private static final Singleton singleton = new Singleton();
private Singleton(){}
public static Singleton getSingleton(){
return singleton;
}
}
节省内存开支，减少性能开销，应用启动产生单例对象，永久驻留内存
单例模式与单一职责原则冲突，把“需要单例”功能和业务逻辑融合在一个类
私有构造函数的对象仍然可以被复制，单例模式类不应该实现Cloneable接口
单例模式拓展，多个实例的单例模式
public class MoreSingleton{
private static final int maxNum=2;
private static ArrayList<MoreSingleton> singletonList = new ArrayList<MoreSingleton>();
ArrayList<MoreSingleton>(String value){
valueList.add(value);
}
private static ArrayList<String> valueList = new ArrayList<String>();
//产生所有对象
static{
for(int i=0;i<maxNum;i++){
singletonList.add(new MoreSingleton(value));
}
}
private MoreSingleton(){}
public static MoreSingleton getMoreSingleton(int index){
return singletonList.get(index);
}
}
工厂方法模式Factory Pattern
定义一个用于创建对象的接口，让子类决定实例化哪一个类
//定义抽象产品类
public abstract class Product{
public abstract void method();
}
//定义具体产品类
public class ConProduct extends Product{
public void method(){}
}
//定义抽象工厂类
public abstract class Factory{
public abstract <T extends Product> T createProduct(Class<T> c);
//泛型，所有继承Product的类
}
//具体工厂类
public class ConFactory extends Factory{
public <T extends Product> T createProduct(Class<T> c){//工厂函数
Product product=null;
try{
product=(Product)Class.forName(c.getName()).newInstance();//内省
}catch(Exception e){//异常处理}
return (T)product;
}
}
工厂方法模式封装良好，结构清晰，易于扩展。是典型的解耦框架，高层模块只需要知道产品的抽象类，符合迪米特法则和依赖倒置原则，只依赖产品类的抽象，也符合里氏替换原则。
工厂方法模式扩展
简单工厂模式Simple Factory Pattern,去除抽象工厂类，将工厂函数设为static。
多工厂模式，每个具体产品对应一个共产类，类职责清晰，结构简单，但增加了扩展难度。
替代单例模式
public class Singleton{
private Singleton();
}
public class SingletonFactory{
private static Singleton singleton;
static{
try{
//通过反射方式创建单例类
Class cl = Class.forName(Singleton.class.getName());
//获得无参构造
Constructor con = c1.getDeclaredConstructor();
//设置无参构造可访问
con.setAccessible(true);
//产生实例
singleton = (Singleton)con.newInstance();
}catch(Exception e){//异常处理}
}
public static Singleton getSingleton(){
return singleton;
}
}
延迟初始化，对象创建后在类内保存引用，在下次创建对象时查找类内是否存在，有则直接取出返回，如在ProductFactory类内定义private static final Map<String,Product> prMap = new HashMap();
抽象工厂模式Abstract Factory Pattern
为一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
抽象工厂模式是工厂方法模式的升级版本，当有多个业务品种，业务分类时，通过抽象工厂模式解决。
//抽象产品类A
public abstract class AbstractProductA{
public abstract void method();
}
//A系列产品A1实现类
public class ProductA1 extends AbstractProductA{
public void method(){}
}
//A系列产品A2实现类
public class ProductA2 extends AbstractProductA{
public void method(){}
}
//抽象产品类B
public abstract class AbstractProductB{
public abstract void method();
}
//B系列产品B1实现类
public class ProductB1 extends AbstractProductB{
public void method(){}
}
//B系列产品B2实现类
public class ProductB2 extends AbstractProductB{
public void method(){}
}
//抽象工厂类
public abstract class AbstractFactory{
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
//产品1工厂类
public class Factory1 extends AbstractFactory{
public AbstractProductA createProductA(){
return new ProductA1();
}
public AbstractProductB createProductB(){
return new ProductB1();
}
}
//产品2工厂类
public class Factory2 extends AbstractFactory{
public AbstractProductA createProductA(){
return new ProductA2();
}
public AbstractProductB createProductB(){
return new ProductB2();
}
}
抽象工厂模式产品族扩展复杂
设计模式小计——23种设计模式1,布布扣,bubuko.com
时间： 2024-10-05 23:36:54