设计模式之工厂模式

YYDS程序猿

已于 2023-09-06 20:16:04 修改

阅读量49

点赞数

分类专栏：设计模式文章标签：设计模式简单工厂模式工厂方法模式抽象工厂模式

于 2023-09-02 13:38:27 首次发布

本文链接：https://blog.csdn.net/weixin_72454762/article/details/132636781

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 定义

客户端不直接new对象，而是通过工厂类获取所需的对象，工厂类封装了对象的具体创建过程。

2. 使用场景

对象的创建过程比较复杂，不希望重复执行创建过程，那么可将对象的创建过程封装到工厂类。即使后续需要修改类的创建过程，那么也不需要修改客户端代码，而只需要修改工厂类。

3. 工厂模式分类

简单工厂模式：工厂类根据客户端传入的条件创建相应的产品并返回。

工厂方法模式：一个产品对应一个具体的工厂类，客户端创建哪个产品就使用哪个具体的工厂类。

抽象工厂模式：一个品牌对应一个具体的工厂类，品牌工厂类含有创建此品牌下系列产品的方法。

3.1 简单工厂模式

/**
 * 抽象产品类：电脑
 */
abstract class Computer {

    // 抽象方法：设置操作系统
    public abstract void setOS();

}

class AComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("A—OS");
    }

    @Override
    public String toString() {
        return "我是AComputer，我的操作系统是A—OS";
    }
}

class BComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("B—OS");
    }

    @Override
    public String toString() {
        return "我是BComputer，我的操作系统是B—OS";
    }
}

/**
 * 简单工厂
 */
class ComputerFactory {

    public static Computer createComputer(String type) {
        Computer computer = null;
        if (type.equalsIgnoreCase("A")) {
            computer = new AComputer();
            computer.setOS();
        } else {
            computer = new BComputer();
            computer.setOS();
        }
        return computer;
    }

}

public class FactoryTest {

    public static void main(String[] args) {
        Computer aComputer = ComputerFactory.createComputer("A");
        System.out.println(aComputer); // 我是AComputer，我的操作系统是A—OS

        Computer bComputer = ComputerFactory.createComputer("B");
        System.out.println(bComputer); // 我是BComputer，我的操作系统是B—OS
    }
    
}

简单工厂模式，代码逻辑简单且易实现，通过不同的条件创建不同的产品，但是违反了开闭原则（为修改关闭，对扩展开放），例如：后续新增CComputer，那么就需要修改ComputerFactory，在createComputer方法中添加CComputer相关的判断条件。

3.2 工厂方法模式

/**
 * 抽象产品类：电脑
 */
abstract class Computer {

    // 抽象方法：设置操作系统
    public abstract void setOS();

}

class AComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("A—OS");
    }

    @Override
    public String toString() {
        return "我是AComputer，我的操作系统是A—OS";
    }
}

class BComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("B—OS");
    }

    @Override
    public String toString() {
        return "我是BComputer，我的操作系统是B—OS";
    }
}

/**
 * 抽象工厂类
 */
abstract class AbstractComputerFactory {

    // 抽象方法：创建Computer
    public abstract Computer createComputer();

}

class AComputerFactory extends AbstractComputerFactory {

    @Override
    public Computer createComputer() {
        Computer aComputer = new AComputer();
        aComputer.setOS();
        return aComputer;
    }
}

class BComputerFactory extends AbstractComputerFactory {

    @Override
    public Computer createComputer() {
        Computer bComputer = new BComputer();
        bComputer.setOS();
        return bComputer;
    }
}

public class FactoryTest {

    public static void main(String[] args) {
        AbstractComputerFactory aFactory = new AComputerFactory();
        Computer aComputer = aFactory.createComputer();
        System.out.println(aComputer); // 我是AComputer，我的操作系统是A—OS

        AbstractComputerFactory bFactory = new BComputerFactory();
        Computer bComputer = bFactory.createComputer();
        System.out.println(bComputer); // 我是BComputer，我的操作系统是B—OS
    }

}

工厂方法模式，一个具体产品对应一个具体的工厂类，客户端直接调用具体的工厂类便可获得对应的产品；后续新增产品，只需新增具体产品类以及对应的工厂类，而无需修改已有代码，符合开闭原则，但是会新增很多类。例如：新增产品APhone、BPhone，那么就会新增对应的工厂类APhoneFactory、BPhoneFactory，此时我们可以通过抽象工厂模式，解决类增多的问题。

3.3 抽象工厂模式

/**
 * 抽象产品类：电脑
 */
abstract class Computer {

    // 抽象方法：设置操作系统
    public abstract void setOS();

}

class AComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("A—OS");
    }

    @Override
    public String toString() {
        return "我是AComputer，我的操作系统是A—OS";
    }
}

class BComputer extends Computer {

    @Override
    public void setOS() {
        System.out.println("B—OS");
    }

    @Override
    public String toString() {
        return "我是BComputer，我的操作系统是B—OS";
    }
}

/**
 * 抽象产品类：手机
 */
abstract class Phone {

    // 抽象方法：设置操作系统
    public abstract void setOS();

}

class APhone extends Phone {

    @Override
    public void setOS() {
        System.out.println("APhone-OS");
    }

    @Override
    public String toString() {
        return "我是APhone，我的操作系统是APhone-OS";
    }
}

class BPhone extends Phone {

    @Override
    public void setOS() {
        System.out.println("BPhone-OS");
    }

    @Override
    public String toString() {
        return "我是BPhone，我的操作系统是BPhone-OS";
    }
}

/**
 * 抽象工厂类：品牌工厂
 */
abstract class AbstractFactory {

    public abstract Computer createComputer();

    public abstract Phone createPhone();

}

class AFactory extends AbstractFactory {

    @Override
    public Computer createComputer() {
        Computer aComputer = new AComputer();
        aComputer.setOS();
        return aComputer;
    }

    @Override
    public Phone createPhone() {
        Phone aPhone = new APhone();
        aPhone.setOS();
        return aPhone;
    }
}

class BFactory extends AbstractFactory {

    @Override
    public Computer createComputer() {
        Computer bComputer = new BComputer();
        bComputer.setOS();
        return bComputer;
    }

    @Override
    public Phone createPhone() {
        Phone bPhone = new BPhone();
        bPhone.setOS();
        return bPhone;
    }
}

public class FactoryTest {

    public static void main(String[] args) {
        AbstractFactory aFactory = new AFactory();
        Computer aComputer = aFactory.createComputer();
        Phone aPhone = aFactory.createPhone();
        System.out.println(aComputer); // 我是AComputer，我的操作系统是A—OS
        System.out.println(aPhone); // 我是APhone，我的操作系统是APhone-OS

        AbstractFactory bFactory = new BFactory();
        Computer bComputer = bFactory.createComputer();
        Phone bPhone = bFactory.createPhone();
        System.out.println(bComputer); // 我是BComputer，我的操作系统是B—OS
        System.out.println(bPhone); // 我是BPhone，我的操作系统是BPhone-OS
    }

}

抽象工厂模式，一个品牌对应一个具体的工厂类，品牌工厂类含有创建此品牌下系列产品的方法。