创建型设计模式分类
工厂方法模式(Factory Method): 定义一个创建对象的接口,但由子类决定需要实例化哪一个类。 工厂方法使得子类实例化的过程推迟
抽象工厂模式(Abstract Factory): 提供一个接口,可以创建一系列相关或相互依赖的对象,而无需指定它们具体的类
构建器模式(Builder): 将一个复杂类的表示与其构造相分离,使得相同的构建过程能够得出不同的表示
单例模式(Singleton): 保证一个类只有一个实例,并提供一个访问它的全局访问点
原型模式(Prototype): 用原型实例指定创建对象的类型,并且通过拷贝这个原型来创建新的对象
正文开始====================================
工厂方法模式(Factory Method)
适用场景:创建对象需要大量的重复代码。客户端(应用层)不依赖于产品类实例如何被创建和实现等细节。一个类通过其子类来指定创建哪个对象。
特点:1.用户只需要关系所需产品对应的工厂,无须关心创建细节。2.加入新产品符合开闭原则,提高了系统的可扩展性。
缺点:类的数量容易过多,增加了代码结构的复杂度。增加了系统的抽象性和理解难度。
public class BMW {
public BMW(){}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
//抽象的工厂类Factory
public interface FactoryBMW {
BMW createBMW();
}
public class FactoryBMW320 implements FactoryBMW{
@Override
public BMW320 createBMW() {
return new BMW320();
}
}
public class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {
return new BMW523();
}
}
public class FactoryMethodTest {
public static void main(String[] args) {
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
BMW320 bmw320 = factoryBMW320.createBMW();
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
BMW523 bmw523 = factoryBMW523.createBMW();
//
// System.out.println(bmw320);
// System.out.println(bmw523);
}
}
抽象工厂模式(Abstract Factory)
适用场景:1.客户端(应用层)不依赖于产品类实例如何被创建和实现等细节。
2.强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。
3.提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。
优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。
//空调以及型号
public interface Aircondition {
}
public class AirconditionA implements Aircondition{
public AirconditionA(){
System.out.println("制造-->AirconditionA");
}
}
public class AirconditionB implements Aircondition{
public AirconditionB(){
System.out.println("制造-->AirconditionB");
}
}
//发动机以及型号
public interface Engine {
}
public class EngineA implements Engine{
public EngineA(){
System.out.println("制造-->EngineA");
}
}
public class EngineB implements Engine{
public EngineB(){
System.out.println("制造-->EngineB");
}
}
//创建工厂的接口
public interface AbstractFactory {
//制造发动机
Engine createEngine();
//制造空调
Aircondition createAircondition();
}
//为宝马320系列生产配件
public class FactoryBMW320 implements AbstractFactory{
@Override
public Engine createEngine() {
return new EngineA();
}
@Override
public Aircondition createAircondition() {
return new AirconditionA();
}
}
//宝马523系列生产配件
public class FactoryBMW523 implements AbstractFactory {
@Override
public Engine createEngine() {
return new EngineB();
}
@Override
public Aircondition createAircondition() {
return new AirconditionB();
}
}
public class Customer {
public static void main(String[] args){
//生产宝马320系列配件
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
factoryBMW320.createEngine();
factoryBMW320.createAircondition();
//生产宝马523系列配件
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
factoryBMW523.createEngine();
factoryBMW523.createAircondition();
}
}
构建器模式(Builder)
适用场景:适用于创建对象需要很多步骤,但是步骤顺序不一定固定。如果一个对象有非常复杂的内部结构(属性),把复杂对象的创建和使用进行分离。
特点:1.封装性好,创建和使用分离 2.扩展性好,建造类之间独立,在一定程度上解耦
缺点:1.会产生多余的Builder对象 2.产品内部发生变化,建造者也需要修改,成本可能会随着业务场景的改变而改变
//产品类 电脑
public class Computer {
private String motherboard;
private String cpu;
private String memory;
public Computer() {
}
public Computer(String motherboard, String cpu, String memory) {
this.motherboard = motherboard;
this.cpu = cpu;
this.memory = memory;
}
public String getMotherboard() {
return motherboard;
}
public void setMotherboard(String motherboard) {
this.motherboard = motherboard;
}
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
@Override
public String toString() {
return "Computer{" +
"motherboard='" + motherboard + '\'' +
", cpu='" + cpu + '\'' +
", memory='" + memory + '\'' +
'}';
}
}
// 抽象 builder类(接口) 组装电脑
public interface ComputerBuilder {
Computer computer = new Computer();
void buildMotherboard();
void buildCpu();
void buildMemory();
Computer build();
}
//具体 builder类
public class AsusComputerBuilder implements ComputerBuilder {
@Override
public void buildMotherboard() {
computer.setMotherboard("Extreme主板");
}
@Override
public void buildCpu() {
computer.setCpu("Inter 12900KS");
}
@Override
public void buildMemory() {
computer.setMemory("芝奇幻峰戟 16G*2");
}
@Override
public Computer build() {
return computer;
}
}
/**
* 指挥者类
*
* 指挥者类ComputerDirector在建造者模式中具有很重要的作用,它用于指导具体构建者如何构建产品,
* 控制调用先后次序,并向调用者返回完整的产品类
*/
public class ComputerDirector {
private ComputerBuilder computerBuilder;
public Computer construct() {
computerBuilder.buildMotherboard();
computerBuilder.buildCpu();
computerBuilder.buildMemory();
return computerBuilder.build();
}
public ComputerDirector(ComputerBuilder computerBuilder) {
this.computerBuilder = computerBuilder;
}
}
public class BuilderTest {
// 测试
public static void main(String[] args) {
ComputerDirector computerDirector = new ComputerDirector(new AsusComputerBuilder());
// Computer(motherboard=Extreme主板, cpu=Inter 12900KS, memory=芝奇幻峰戟 16G*2)
System.out.println(computerDirector.construct());
}
}
单例模式(Singleton)
饿汉式
适用场景:需要确保在任何情况下绝对只需要一个实例
特点:主要特点是在类加载时就创建并初始化单例对象,保证了在多线程环境下的线程安全性
缺点:1.提前占用内存空间,饿汉式在类加载时就创建单例对象,无论是否会使用该对象,都会占用一定的内存空间。
2.无法延迟加载
3.可能造成资源浪费,如果在程序运行过程中始终没有使用该单例对象,而它又是在类加载时就创建的,就会造成资源的浪费
4.无法处理异常情况,如果在单例对象的初始化过程中发生异常,可能会导致整个应用程序启动失败。这是因为单例对象的创建发生在类加载阶段,而异常无法捕获和处理。
public class Singleton1 {
//构造方法私有化。目的:防止外面调用造对象 如果不将其定义成私有的,那么便可以在外面不断的创建类对象 无法做到只有一个对象
private Singleton1(){}
//饿汉式创建单例模式
private static Singleton1 singleton1 = new Singleton1();
//提供公共的静态方法,返回类对象
public static Singleton1 getSingleton1() {
return singleton1;
}
}
public class Singleton1Test {
public static void main(String[] args) {
Singleton1 singleton1 = Singleton1.getSingleton1();//通过调用内部类的方法 从而调用该对象
Singleton1 singleton2 = Singleton1.getSingleton1();//通过调用内部类的方法 从而调用该对象
System.out.println(singleton1);
System.out.println(singleton2);
}
}
懒汉式
适用场景:需要确保在任何情况下绝对只需要一个实例
特点:第一次调用才初始化,避免内存浪费。
缺点:首次使用对象时,需要等待对象的创建,而且每次都需要判断对象是否为空,运行效率较低。
public class Singleton2 {
private static Singleton2 singleton2;
/*
* 懒汉式创建单例模式 由于懒汉式是非线程安全, 所以加上线程锁保证线程安全
*/
public static synchronized Singleton2 getInstance(){
if(singleton2 == null){
singleton2 = new Singleton2();
}
return singleton2;
}
}
public class Singleton2Test {
public static void main(String[] args) {
Singleton2 instance1 = Singleton2.getInstance();
Singleton2 instance2 = Singleton2.getInstance();
System.out.println(instance1);
System.out.println(instance2);
System.out.println(instance1 == instance2);
}
}
静态内部类
适合在需要频繁使用、且资源占用较小的单例对象时使用
优点:1.使用了Java类加载机制,单例对象在类加载阶段就已经创建好且只会创建一次,因此是线程安全的。
2.利用静态内部类特点实现延迟加载,效率高
缺点: 1.可能会增加类的数量,因为需要一个静态内部类来保存单例对象
2.第一次加载时可能会略微增加启动时间
public class Singleton3 {
private Singleton3(){}
private static class SingletonHolder{
private static final Singleton3 INSTANCE = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.INSTANCE;
}
}
public class Singleton3Test {
public static void main(String[] args) {
Singleton3 instance1 = Singleton3.getInstance();
Singleton3 instance2 = Singleton3.getInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
原型模式(Prototype)
特点:1.可以避免创建复杂对象时的开销,在性能上比直接 new 一个对象更加优良。
2.原型模式能够保护现有对象的状态。
缺点:1.在实现原型模式时,必须注意克隆对象的所有属性,包括私有属性和引用类型属性。
2.如果原型对象的属性包含大量数据,那么复制对象的成本将会很高。
3.需要实现Cloneable接口,并且需要重写clone方法,这会增加代码量和复杂度。
public class Student implements Cloneable {
private String name;
private String sex;
private Integer age;
public Student() {
}
public Student(String name, String sex, Integer age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
// @Override
// protected Object clone() throws CloneNotSupportedException {//默认的clone
// return super.clone();
// }
//重写clone方法,或者用默认的clone方法也行,只不过调用时候需要抛异常
@Override
protected Object clone() {
Student student = null;
try {
student = (Student)super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return student;
}
}
public class PrototypeTest {
public static void main(String[] args) throws Exception{
Student stu1 = new Student("张三", "男", 18);
Student stu2 = (Student)stu1.clone();//复制对象
stu2.setName("李四");
System.out.println(stu1);// Student(name=张三, sex=男, age=18)
System.out.println(stu2);// Student(name=李四, sex=男, age=18)
}
}
参考总结而来,供学习!!!