项目网站建设业务分析,平面设计和室内设计的区别,app公司简介范文大全,seo排名赚app官网文章目录 设计模式-创建型工厂模式简单工厂工厂方法抽象工厂 建造者模式单例模式原型模式 设计模式-创建型
本章主要介绍有关对象创建的几种设计模式。
工厂模式
工厂模式#xff1a;封装了对象的创建#xff0c;使得获得对象更加符合实际逻辑
简单工厂
将所有对象的生产… 文章目录 设计模式-创建型工厂模式简单工厂工厂方法抽象工厂 建造者模式单例模式原型模式 设计模式-创建型
本章主要介绍有关对象创建的几种设计模式。
工厂模式
工厂模式封装了对象的创建使得获得对象更加符合实际逻辑
简单工厂
将所有对象的生产集中到一个工厂中
根据传参确定生产的对象类型
public abstract class Fruit { private final String name;public Fruit(String name){this.name name;}Overridepublic String toString() {return namehashCode();}
}
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 FruitFactoryT extends Fruit {public abstract T getFruit();
}
public class AppleFactory extends FruitFactoryApple { 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, ListString 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;ListString 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; }
}
