设计模式之创建型模式
创建型模式主要是用于创建对象，主要分为5大类：工厂方法模式（factory method pattern）、抽象工厂模式（Abstract factory pattern）、单例模式（Singleton pattern）、建造者模式（Builder pattern）、原型模式（prototype pattern）。
一、工厂方法模式（factory method pattern）
工厂方法模式主要分为三种：普通工厂模式、多工厂方法模式、静态工厂方法模式
1、普通工厂模式：创建一个工厂类，为有共同接口的类创建对象；通过传入的值和工厂类的判断条件进行匹配，创建不同的对象。
//对象的共同接口 public interface Phone { void call(); } public class MiPhone implements Phone{ @Override public void call() { System.out.println("雷布斯为你打call，，，，"); } } public class IPhone implements Phone { @Override public void call() { System.out.println("果粉为你打call。。。。。。。。"); } } public class HuaWeiPhone implements Phone { @Override public void call() { System.out.println("华为海军为你打call！！！！"); } } //对象的生产工厂 public class PhoneFactory { public Phone produce(String type){ if("小米".equals(type)){ return new MiPhone(); }else if("华为".equals(type)){ return new HuaWeiPhone(); }else if("苹果".equals(type)){ return new IPhone(); }else { return null; } } } //测试类 public class FactoryMethodPatternTest { public static void main(String[] args) { PhoneFactory phoneFactory = new PhoneFactory(); Phone xiaomi = phoneFactory.produce("小米"); Phone huawei = phoneFactory.produce("华为"); Phone pingguo = phoneFactory.produce("苹果"); xiaomi.call(); huawei.call(); pingguo.call(); } }
2、多工厂方法模式：对普通工厂方法模式进行改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，直接调用不同的方法来创建不同的对象，这样不容易出错。
/** *只需要将工厂方法和调用方法修改一下 */ //多方法对象的生产工厂 public class PhoneFactory { public Phone produceMiPhone(){ return new MiPhone(); } public Phone produceHuaweiPhone(){ return new HuaWeiPhone(); } public Phone produceIPhone(){ return new IPhone(); } } //测试类 public class FactoryMethodPatternTest { public static void main(String[] args) { PhoneFactory phoneFactory = new PhoneFactory(); Phone xiaomi = phoneFactory.produceMiPhone(); Phone huawei = phoneFactory.produceHuaweiPhone(); Phone pingguo = phoneFactory.produceIPhone(); xiaomi.call(); huawei.call(); pingguo.call(); } }
3、静态工厂方法模式：将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
//静态方法对象的生产工厂 public class PhoneFactory { public static Phone produceMiPhone(){ return new MiPhone(); } public static Phone produceHuaweiPhone(){ return new HuaWeiPhone(); } public static Phone produceIPhone(){ return new IPhone(); } } //测试类 public class FactoryMethodPatternTest { public static void main(String[] args) { Phone xiaomi = PhoneFactory.produceMiPhone(); Phone huawei = PhoneFactory.produceHuaweiPhone(); Phone pingguo = PhoneFactory.produceIPhone(); xiaomi.call(); huawei.call(); pingguo.call(); } }
二、抽象工厂模式（Abstract factory pattern）
上面的工厂方法模式如果要扩展就必须修改代码，这样就违反了开闭原则。抽象工厂模式将对象的生产工厂也进行抽象，方便程序扩展。
//对象生产工厂接口 public interface PhoneFactory { Phone produce(); } public class MiPhoneFactory implements PhoneFactory{ @Override public Phone produce() { return new MiPhone(); } } public class HuaWeiPhoneFactory implements PhoneFactory{ @Override public Phone produce() { return new HuaWeiPhone(); } } public class IPhoneFactory implements PhoneFactory { @Override public Phone produce() { return new IPhone(); } } //测试类 public class AbstractFactoryPatternTest { public static void main(String[] args) { PhoneFactory miPhoneFactory = new MiPhoneFactory(); PhoneFactory huaWeiFactory = new HuaWeiPhoneFactory(); PhoneFactory iphoneFactory = new IPhoneFactory(); Phone miPhone = miPhoneFactory.produce(); Phone huaWeiPhone = huaWeiFactory.produce(); Phone iPhone = iphoneFactory.produce(); miPhone.call(); huaWeiPhone.call(); iPhone.call(); } }
三、单例模式（Singleton pattern）：
单例模式主要分为：饿汉式、懒汉式、双重检测锁、静态内部类、枚举类
1、饿汉式：顾名思义就是很饥饿，还不需要该对象的时候就直接创建该对象。
//饿汉单例模式 public class Singleton { //在类的初始化阶段就直接创建好对象 private static Singleton instance = new Singleton(); //私有化构造方法，保证无法创建更多对象，该对象只能通过getInstance方法来进行获取 private Singleton(){} public static Singleton getInstance(){ return instance; } }
2、懒汉式：需要用到该对象的时候才会区创建对象
//懒汉单例模式，只在第一次需要的时候才会创建对象，有线程安全问题 public class Singleton2 { private static Singleton2 instance = null; private Singleton2 (){} public static Singleton2 getInstance(){ if( instance == null ){ instance = new Singleton2(); } return instance; } }
//懒汉单例模式，只在第一次需要的时候才会创建对象，没有线程安全问题，但是每次取对象的时候都需要获取锁，影响效率 public class Singleton3 { private static Singleton3 instance = null; private Singleton3 (){} public static synchronized Singleton3 getInstance(){ if( instance == null ){ instance = new Singleton3(); } return instance; } }
3、双重检测锁模式：在懒汉式基础上改进，效率比懒汉式要高。
//双重检测锁单例模式，是线程安全的，并且只有前几次需要获取锁，效率比饿汉线程安全模式高。 //但是由于jvm底层的原因，在创建对象的时候有可能出现指令重排，后面的线程获取了还未初始化的对象，并且去执行对应的方法，这样就会出现问题。 //可以通过volatile 来防止指令重排 public class Singleton4 { private static Singleton4 instance = null; private Singleton4 (){} public static Singleton4 getInstance(){ if( instance == null ){ synchronized (Singleton4.class) { if( instance == null ){ instance = new Singleton4(); } } } return instance; } }
3.1、补充
//这种方式貌似能够解决双重检测锁的问题 public class Singleton7 { private static Singleton7 instance = null; private Singleton7 (){} private static synchronized void createSingleton7(){ instance = new Singleton7(); } public static Singleton7 getInstance(){ if( instance == null ){ synchronized (Singleton7.class) { if( instance == null ){ createSingleton7(); } } } return instance; } }
4、静态内部类模式：运用静态内部类的特性来构造单例
//静态内部类单例模式,这种方式线程安全并且是懒加载 public class Singleton5 { private Singleton5 (){} public static class SingletonContainer{ private static Singleton5 instance = new Singleton5(); } public static Singleton5 getInstance(){ return SingletonContainer.instance; } }
5、枚举类：枚举类的元素本身就是单例对象。
//枚举类的元素就是单例的，并且无线程安全问题。在序列化和反序列化之后也能保证单例 public enum Singleton6 { INSTANCE; //需要执行的操作 public void doSomeThing(){} }
四、建造者模式（Builder pattern）
建造者模式又名创建者模式，是将一个复杂对象的构建过程与它的表示分离，从而使得相同的构建过程可以创建不同的表示；创建者模式隐藏了复杂对象的创建过程，它把复杂对象的构建加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。
与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
public class Car { private String Body; private String wheel; public String getBody() { return Body; } public void setBody(String body) { Body = body; } public String getWheel() { return wheel; } public void setWheel(String wheel) { this.wheel = wheel; } @Override public String toString() { return "Car [Body=" + Body + ", wheel=" + wheel + "]"; } }
public interface Builder { void buildBody(); void buildWheel(); Car getCar(); } public class BenzBuilder implements Builder { private String body; private String wheel; @Override public void buildBody() { this.body = "奔驰车身"; } @Override public void buildWheel() { this.wheel = "奔驰轮子"; } @Override public Car getCar() { Car car = new Car(); car.setBody(body); car.setWheel(wheel); return car; } }
//对车辆进行组装 public class Director { private Builder builder; public Director(Builder builder){ this.builder = builder; } public void setBuilder(Builder builder){ this.builder = builder; } //组装车辆 public Car constructCar(){ builder.buildBody(); builder.buildWheel(); builder.buildWheel(); builder.buildWheel(); builder.buildWheel(); return builder.getCar(); } } //测试 public class BuilderTest { public static void main(String[] args) { Builder benzBuilder = new BenzBuilder(); Director director2= new Director(benzBuilder); Car car2 = director2.constructCar(); System.out.println(car2); } }
五、原型模式（prototype pattern）
原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。直接创建对象的代价比较大时，则采用这种模式。
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了。
java中通过clone来实现对象的浅复制，一个原型类，只需要实现Cloneable接口，覆写clone方法就可以实现浅复制。通过实现Serializable 接口然后通过序列化和反序列化进行深度复制。
public class Prototype implements Cloneable, Serializable { private static final long serialVersionUID = 1L; private String name; private List<String> list; public String getName() { return name; } public void setName(String name) { this.name = name; } public List<String> getList() { return list; } public void setList(List<String> list) { this.list = list; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } protected Object deepClone() throws IOException, ClassNotFoundException { /* 写入当前对象的二进制流 */ ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); /* 读出二进制流产生的新对象 */ ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject(); } @Override public String toString() { return "Prototype [name=" + name + ", list=" + list + "]"; } }
public class PrototypeTest { public static void main(String[] args) throws Exception { Prototype p = new Prototype(); p.setName("a"); List<String> list = new ArrayList<>(); list.add("b"); p.setList(list); System.out.println(p); //浅复制 Prototype p1 = (Prototype)p.clone(); System.out.println(p1); //深复制 Prototype p2 = (Prototype)p.deepClone(); System.out.println(p2); System.out.println("------------------------------"); //修改原型的值,发现复制后的对象的值也被修改了 list.add("c"); p.setName("A"); p.setList(list); System.out.println(p); System.out.println(p1); System.out.println(p2); } }
