常用设计模式之单例模式、策略模式、工厂模式

单例模式

单例模式属于创建型模式

饿汉模式：立即加载

public class Singleton {  private static Singleton instance = new Singleton();  private Singleton (){}  public static Singleton getInstance() {  return instance;  }  
}

懒汉模式，懒加载

线程不安全

public class Singleton {private static Singleton instance;private Singleton (){}public static Singleton getlnstance() {if (instance == null){instance = new Singleton();}return instance;}
}

线程安全

public class Singleton {  private static Singleton instance;  private Singleton (){}  public static synchronized Singleton getInstance() {  if (instance == null) {  instance = new Singleton();  }  return instance;  }  
}

双重锁

public class Singleton {  private volatile static Singleton singleton;  private Singleton (){}  public static Singleton getSingleton() {  if (singleton == null) {  synchronized (Singleton.class) {  if (singleton == null) {  singleton = new Singleton();  }  }  }  return singleton;  }  
}

静态内部类

public class Singleton {private Singleton() {}//内部类在外部类调用的时候才会被初始化// 内部类一定要在方法调用之前初始化private static class SingletonInstance {private static final Singleton instance = new Singleton();}// static 使单例空间共享// final使得方法不能被重写重载public static final Singleton getInstance() {return SingletonInstance.instance;}
}

策略模式

策略模式属于行为型模式

核心思想是对算法进行封装，委派给不同对象来管理。

比如我们旅游可以选择出行的策略有：自行车、电动车、公交车等-

结构

策略模式饱汉三种类：

角色	关系	作用
抽象策略类strategy	是所有类的父类	定义一个公共接口，定义一些算法标识和抽象方法
具体策略concrete strategy	是抽象策略的接口实现类	实现抽象策略定义的抽象方法，描述具体法的算法实现
环境context	维护一个抽象策略类的引用实例	委托策略变量，调用具体策略所实现的抽象策略接口中的方法

工厂模式

概念

工厂模式，提供一种创建对象的方式，

在创建对象时提供一种封装机制，将实际创建对象的代码与使用代码分离

定义一个创建对象的接口，让其子类自己决定实例化哪个工厂类，工厂模式使其创建过程延迟到子类进行。

不暴露对象创建逻辑的情况下创建对象，

主要解决接口选择问题

角色

抽象产品：产品的共同接口或抽象类

具体产品：实现了抽象产品接口

抽象工厂：声明创建产品的抽象方法

具体工厂实现抽象工厂接口

分类

分为：简单工厂、方法工厂、抽象工厂

实现

简单工厂

//简单工厂：每创建一个产品就会增加一个对应的具体的工厂类
// 违背了开闭原则，不属于23种GOF
public class Test {public static void main(String[] args) {Baozi baozi = SimpleFactory.createBaozi("jiangrou");System.out.println(baozi.createBaozi());Baozi baozi1 = SimpleFactory.createBaozi("jiangrou");System.out.println(baozi1.createBaozi());}
}

//抽象工厂
interface Baozi {String createBaozi();
}

//产品的具体的实现
class JiangRou implements Baozi {@Overridepublic String createBaozi() {return "酱肉";}
}

class XianRou implements Baozi {@Overridepublic String createBaozi() {return "鲜肉";}
}

//工厂类是关键
//判断要做什么包子，整个做包子的生产都被这个工厂类封装起来了
//用户不需要关注这里面的细节
//适合创建对象比较少的情况，只需传递具体参数，忽略生产细节
class SimpleFactory {public static Baozi createBaozi(String type) {switch (type) {case "jiangrou":return new JiangRou();case "xianrou":return new XianRou();}return null;}
}

方法工厂

//工厂方法：定义一个用于创建产品的接口，由子类决定生产什么产品
//如果还有其他类型的包子，需要在SimpleFactory里面加判断，因为只能在那里生产包子，违反开闭原则
//是简单工厂的的抽象，抽象一个工厂接口，
//增加新产品时，需要增加新的工厂
//一个工厂只生产一种产品
public class Test {public IPhone getPhoneGrete(String type){if ("huawei".equals(type)){HuaWeiPhoneFactory huaWeiPhoneFactory = new HuaWeiPhoneFactory();IPhone phone = huaWeiPhoneFactory.createPhone();return phone;}if ("xiaomi".equals(type)){XiaomiPhoneFactory xiaomiPhoneFactory = new XiaomiPhoneFactory();IPhone phone = xiaomiPhoneFactory.createPhone();return phone;}return null;}public IPC getPcCreate(String type){if ("huawei".equals(type)){HuaWeiPCFactory huaWeiPCFactory = new HuaWeiPCFactory();IPC pc = huaWeiPCFactory.createPC();return pc;}if ("xiaomi".equals(type)){XiaomiPCFactory xiaomiPCFactory = new XiaomiPCFactory();IPC pc = xiaomiPCFactory.createPC();return pc;}return null;}public static void main(String[] args) {Test test = new Test();IPC huawei = test.getPcCreate("huawei");IPC xiaomi = test.getPcCreate("xiaomi");IPhone xiaomi1 = test.getPhoneGrete("xiaomi");}
}
//抽象产品
interface IPhone {void createPhone();
}
interface IPC {void createPC();
}
interface ISW {void createSW();
}
//具体的产品
class HuaWeiPhone implements IPhone {@Overridepublic void createPhone() {}
}
class XiaoMiPhone implements IPhone {@Overridepublic void createPhone() {}
}
class HuaWeiPC implements IPC {@Overridepublic void createPC() {}
}
class XiaoMiPC implements IPC {@Overridepublic void createPC() {}
}//手机工厂
interface PhoneAbstractFactory {IPhone createPhone();
}
//电脑工厂
interface PCAbstractFactory {IPC createPC();
}
//华为手机工厂
class HuaWeiPhoneFactory implements PhoneAbstractFactory {@Overridepublic IPhone createPhone() {return new HuaWeiPhone();}
}
//华为电脑工厂
class HuaWeiPCFactory implements PCAbstractFactory {@Overridepublic IPC createPC() {return new HuaWeiPC();}
}
//小米手机工厂
class XiaomiPhoneFactory implements PhoneAbstractFactory {@Overridepublic IPhone createPhone() {return new XiaoMiPhone();}
}
//小米电脑工厂
class XiaomiPCFactory implements PCAbstractFactory {@Overridepublic IPC createPC() {return new XiaoMiPC();}
}

抽象工厂

//一个工厂可以生产不同产品等级的产品族
public class Test  {public static void main(String[] args) {HuaweiFactory huaweiFactory = new HuaweiFactory();huaweiFactory.createPhone();huaweiFactory.createPC();XiaomiFactory xiaomiFactory = new XiaomiFactory();xiaomiFactory.createPhone();xiaomiFactory.createPC();}
}//抽象产品族
interface Phone {void createPhone();
}interface PC {void createPC();
}interface SWI {void createSWI();
}//具体产品族
class XiaoMiPhone implements Phone {@Overridepublic void createPhone() {System.out.println("小米手机");}
}
class XiaoMiSWI implements SWI {@Overridepublic void createSWI() {System.out.println("小米手表");}
}class HuaweiPhone implements Phone {@Overridepublic void createPhone() {System.out.println("华为手机");}
}class XiaoPC implements PC {@Overridepublic void createPC() {System.out.println("小米电脑");}
}class HuaweiPC implements PC {@Overridepublic void createPC() {System.out.println("华为电脑");}
}//抽象工厂，一个工厂可以生产不同产品等级的产品族
abstract class AbstractFactory {public abstract Phone createPhone();public abstract PC createPC();public abstract SWI ccreateSWI();
}//具体工厂
class HuaweiFactory extends AbstractFactory {@Overridepublic Phone createPhone() {return new HuaweiPhone();}@Overridepublic PC createPC() {return new HuaweiPC();}@Overridepublic SWI ccreateSWI() {return null;}
}
class XiaomiFactory extends AbstractFactory {@Overridepublic Phone createPhone() {return new XiaoMiPhone();}@Overridepublic PC createPC() {return new XiaoPC();}@Overridepublic SWI ccreateSWI() {return new XiaoMiSWI();}
}