文章目录
- 设计模式-创建型
- 工厂模式
- 简单工厂
- 工厂方法
- 抽象工厂
- 建造者模式
- 单例模式
- 原型模式
设计模式-创建型
本章主要介绍有关对象创建的几种设计模式。
工厂模式
工厂模式：封装了对象的创建，使得获得对象更加符合实际逻辑
简单工厂
将所有对象的生产集中到一个工厂中
根据传参确定生产的对象类型
public abstract class Fruit { private final String name;public Fruit(String name){this.name = name;}@Overridepublic String toString() {return name+"@"+hashCode();}
}
public class Apple extends Fruit{ public Apple() {super("苹果");}
}
public class Orange extends Fruit{ public Orange() {super("橘子");}
}
public class FruitFactory {public static Fruit getFruit(String type) {switch (type) {case "苹果":return new Apple();case "橘子":return new Orange();default:return null;}}
}
缺点：
逻辑不符合：一个工厂一般只是单一生产
工厂设计不封闭：增加和减少生产对象需要对原来代码进行修改，不符合软件设计的开闭原则
工厂方法
将工厂划分成一个继承机构，基类工厂提供了生产对象虚函数接口，而派生类代表生产某种对象的工厂，重写基类提供的虚函数接口，返回生产的对象
public abstract class FruitFactory<T extends Fruit> {public abstract T getFruit();
}
public class AppleFactory extends FruitFactory<Apple> { @Overridepublic Apple getFruit() {return new Apple();}
}
这样就可以使用不同类型的工厂来生产不同类型的水果了，并且如果新增了水果类型，直接创建一个新的工厂类就行，不需要修改之前已经编写好的内容。
缺点：
一个系列产品一个工厂结构，一种基类只能派生具有关联关系的生产工厂，不同类的需要构建其他的继承工厂结构
优点：
-
符合实际逻辑
-
符合开闭原则
抽象工厂
对有一组关联关系的产品簇提供产品的统一创建，即一个工厂生产一组相关联的产品
建立一个抽象工厂，一个实例工厂可以生产同一个产品簇的所有产品
public class Router {
}
public class Table {
}
public class Phone {
}
public abstract class AbstractFactory {public abstract Phone getPhone();public abstract Table getTable();public abstract Router getRouter();
}
所有的派生类需要重写所有的基类提供的虚函数接口
- 总结：
- 简单工厂simple Factory ：
优点：把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象，不用了解对象创建的详细过程
缺点：不符合实际生产逻辑，提供创建对象实例的接口函数不闭合，不能对修改关闭
- 工厂方法Factory Method:
优点:Factory基类，提供了一个纯虚函数（创建产品)，定义派生类(具体产品的工厂）负责创建对应的产品(重写虚函数)，可以做到不同的产品，在不同的工厂里面创建，能够对现有工厂，以及产品的修改关闭(符合软件开闭原则)
缺点：实际上，很多产品是有关联关系的，属于一个产品簇，不应该放在不同的工厂里面去创建，这样一是不符合实际的产品对象创建逻辑，二是工厂类太多了，不好维护
- 抽象工厂Abstract Factory:
把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面Abstract Factory，派生类(具体产品的工广)应该负责创建该产品簇里面所有的产品
所有派生类对基类提供的纯虚函数接口都要进行重写
建造者模式
有很多的框架都为我们提供了形如XXXBuilder的类型，一般可以使用这些类来创建我们需要的对象。
例如StringBuiler类：
public static void main(String[] args) {StringBuilder builder = new StringBuilder(); //创建一个StringBuilder来逐步构建一个字符串builder.append(666); //拼接一个数字builder.append("老铁"); //拼接一个字符串builder.insert(2, '?'); //在第三个位置插入一个字符System.out.println(builder.toString()); //转换为字符串
}
通过建造者来不断配置参数或是内容，当我们配置完所有内容后，最后再进行对象的构建。
相比直接去new一个新的对象，建造者模式的重心更加关注在如何完成每一步的配置，如果一个类的构造方法参数过多，通过建造者模式来创建这个对象，会更加优雅。
案例：
public class Student {...//一律使用建造者来创建，不对外直接开放private Student(int id, int age, int grade, String name, String college, String profession, List<String> awards) {...}public static StudentBuilder builder(){ //通过builder方法直接获取建造者return new StudentBuilder();}public static class StudentBuilder{ //这里就直接创建一个内部类//Builder也需要将所有的参数都进行暂时保存，所以Student怎么定义的这里就怎么定义int id;int age;int grade;String name;String college;String profession;List<String> awards;public StudentBuilder id(int id){ //直接调用建造者对应的方法，为对应的属性赋值this.id = id;return this; //为了支持链式调用，这里直接返回建造者本身，下同}public StudentBuilder age(int age){this.age = age;return this;}...public StudentBuilder awards(String... awards){this.awards = Arrays.asList(awards);return this;}public Student build(){ //最后我们只需要调用建造者提供的build方法即可根据我们的配置返回一个对象return new Student(id, age, grade, name, college, profession, awards);}}
}
使用建造者来为生成学生对象：
public static void main(String[] args) {Student student = Student.builder() //获取建造者.id(1) //逐步配置各个参数.age(18).grade(3).name("小明").awards("ICPC", "LPL").build(); //最后直接建造我们想要的对象
}
单例模式
单例模式即在我们的整个程序中，同一个类始终只会有一个对象来进行操作。
饿汉单例：在一开始类加载时就创建好了
public class Singleton {private final static Singleton INSTANCE = new Singleton(); //用于引用全局唯一的单例对象，在一开始就创建好private Singleton() {} //不允许随便new，需要对象直接找getInstancepublic static Singleton getInstance(){ //获取全局唯一的单例对象return INSTANCE;}
}
懒汉单例：延迟加载，当我们需要获取对象时，才会进行检查并创建。
由于懒汉式是在方法中进行的初始化，在多线程环境下，可能会出现问题
public class Singleton {private static volatile Singleton INSTANCE; //volatile保证线程可见性private Singleton() {} public static Singleton getInstance(){if(INSTANCE == null) {//减低锁竞争synchronized (Singleton.class) {//保证线程安全if(INSTANCE == null) INSTANCE = new Singleton(); }}return INSTANCE;}
}
不用加锁懒汉模式：
public class Singleton {private Singleton() {}private static class Holder { //由静态内部类持有单例对象，但是根据类加载特性，我们仅使用Singleton类时，不会对静态内部类进行初始化private final static Singleton INSTANCE = new Singleton();}public static Singleton getInstance(){ //只有真正使用内部类时，才会进行类初始化return Holder.INSTANCE; //直接获取内部类中的}
}
原型模式
原型模式实际上与对象的拷贝息息相关，原型模式使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象
- **浅拷贝：**对于类中基本数据类型，会直接复制值给拷贝对象；对于引用类型，只会复制对象的地址。
- **深拷贝：**无论是基本类型还是引用类型，深拷贝会将引用类型的所有内容，全部拷贝为一个新的对象，包括对象内部的所有成员变量，也会进行拷贝。
在Java中，通过实现Cloneable接口来实现原型模式：
Java为我们提供的clone方法对对象成员只会进行浅拷贝，要实现深拷贝需要进一步完成如何拷贝
public class Student implements Cloneable{String name;public Student(String name){this.name = name;}public String getName() {return name;}@Overridepublic Object clone() throws CloneNotSupportedException { //针对成员变量也进行拷贝Student student = (Student) super.clone();student.name = new String(name);return student; }
}
