Java设计模式之工厂模式

---

1. 概述

Java中万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。
需要对象时，直接调用工厂类中的工厂方法来为我们生成对象，这样，我们只需要修改工厂中的代码。

---

2. 简单工厂模式

• 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品 ：实现或者继承抽象产品的子类
• 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

优点：

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

缺点：

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

---

使用举例：

abstract class Person {   //人抽象类
        private String name;
        public abstract void method();
        public Person(String name){
                this.name = name;
        }
        public String getName() {
                return name;
        }
        @Override
        public String toString() {
                return name+"@"+hashCode();
        }
}

class Student extends Person{   //学生类

        public Student(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println("学生抽象方法");
        }
}

class Teacher extends Person{   //教师类

        public Teacher(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println("教师抽象方法");
        }
}

将对象的创建封装到工厂中：

class PersonFactory {
        /**
         * 直接一个静态方法根据指定类型进行创建
         * @param type 人的类型
         * @param name 人的姓名
         * @return 对应人的对象
         */
        public static Person getPerson(String type,String name) {
                switch (type) {
                        case "学生":
                                return new Student(name);
                        case "教师":
                                return new Teacher(name);
                        default:
                                return null;
                }
        }
}

//测试
Person student = PersonFactory.getPerson("学生","学生姓名");//工厂创建，而不是自己去创建
System.out.println(student);//学生姓名@1595428806

---

3. 工厂方法模式

考虑到简单工厂模式对于添加的新的类型需要修改工厂中的代码的问题，使完全遵循开闭原则。

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
• 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

• 定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

优点：

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
• 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

• 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

---

使用举例：

abstract class Person {   //人抽象类
        private String name;
        public abstract void method();
        public Person(String name){
                this.name = name;
        }
        public String getName() {
                return name;
        }
        @Override
        public String toString() {
                return name+"@"+hashCode();
        }
}

class Student extends Person{   //学生类

        public Student(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println("学生抽象方法");
        }
}

class Teacher extends Person{   //教师类

        public Teacher(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println("教师抽象方法");
        }
}

abstract class PersonFactory <T extends Person>{	//工厂变为抽象类，添加泛型T由子类指定类型
        public abstract T getPerson(String name);	//不同工厂，通过此方法生产不同产品
}

class StudentFactory extends PersonFactory<Student>{	//学生工厂

        @Override
        public Student getPerson(String name) {
                return new Student(name);
        }
}

class TeacherFactory extends PersonFactory<Teacher>{	//教师工厂

        @Override
        public Teacher getPerson(String name) {
                return new Teacher(name);
        }
}

//测试
Student student = new StudentFactory().getPerson("学生姓名");
System.out.println(student);//学生姓名@1072408673

---

4. 抽象工厂模式

将多个产品，都放在一个工厂中进行生成，按不同的产品族进行划分

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
• 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

优点：

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

使用举例：

abstract class Product {   //产品抽象类
        private String name;
        public abstract void method();
        public Product(String name){
                this.name = name;
        }
        public String getName() {
                return name;
        }
        @Override
        public String toString() {
                return name+"@"+hashCode();
        }
}

class Phone extends Product{   //手机类

        public Phone(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println(super.getName() + "手机抽象方法");
        }
}

class Computer extends Product{   //电脑类

        public Computer(String name) {
                super(name);
        }

        @Override
        public void method() {
                System.out.println(super.getName() + "电脑抽象方法");
        }
}

interface ProductFactory{ 	//产品工厂
        Computer createComputer();
        Phone createPhone();
}

class XiaomiFactory implements ProductFactory{	 //小米工厂

        @Override
        public Computer createComputer() {
                return new Computer("小米");
        }

        @Override
        public Phone createPhone() {
                return new Phone("小米");
        }
}

	class HuaweiFactory implements ProductFactory{ 	//华为工厂

        @Override
        public Computer createComputer() {
                return new Computer("华为");
        }

        @Override
        public Phone createPhone() {
                return new Phone("华为");
        }
}

//测试
Phone xiaomiphone = new XiaomiFactory().createPhone();
xiaomiphone.method(); //小米手机抽象方法
Computer huaweicomputer = new HuaweiFactory().createComputer();
huaweicomputer.method(); //华为电脑抽象方法

---

5. 工厂模式比较

简单工厂模式：

---

工厂方法模式：

---

抽象工厂模式：

---

——————END-2022-06-12——————