设计模式-创建型
设计模式-创建型
本章主要介绍有关对象创建的几种设计模式。
工厂模式
工厂模式：封装了对象的创建，使得获得对象更加符合实际逻辑
简单工厂
将所有对象的生产集中到一个工厂中
根据传参确定生产的对象类型
public abstract class Fruit {
private final String name;
public Fruit(String name){
this.name = name;
}
@Override
public 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> {
@Override
public 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，需要对象直接找getInstance
public 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;
}
@Override
public Object clone() throws CloneNotSupportedException { //针对成员变量也进行拷贝
Student student = (Student) super.clone();
student.name = new String(name);
return student;
}
}