Java 工厂模式

本文最后更新于:2020年9月10日 下午

1、工厂模式的定义

工厂模式是我们最常用的实例化对象模式,是用工厂方法代替 new 操作的一种模
式。工厂模式抽象了对象创建的具体细节,隐藏了创建过程的复杂度。

2、工厂模式的好处

会给系统带来更好的可扩展性和尽量少的修改量(不是新增量)。

3、工厂模式分类

简单工厂模式:把对象的创建放到一个工厂类中,通过参数来创建不同的对象。缺点是每添一个对象,就需要对简单工厂类进行修改。

//懒,就写一起了
public class Factory {
    //测试方法
    public static void main(String[] args) {
        Factory factory = new Factory();
        //打印我是ProductA
        factory.getProduct("A").showProduct();
        //打印我是ProductB
        factory.getProduct("B").showProduct();

    }
    //工厂方法
    private IProduct getProduct(String pruductName){
        switch (pruductName){
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: return new ProductA();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
}

工厂方法模式:提供一个用于创建对象的工厂接口,让其实现类 (工厂实现类) 决定实例化哪一种产品类,并且由该实现类创建对应类的实例

//懒,就写一起了
public class MainTest {
    //测试方法
    public static void main(String[] args) {
        MainTest mainTest = new MainTest();
        mainTest.test();
    }
    public void test(){
        IFactory factoryA = new FactoryA();
        IProduct productA = factoryA.getProduct();
        //打印我是ProductA
        productA.showProduct();

        IFactory factoryB = new FactoryB();
        IProduct productB = factoryB.getProduct();
        //打印我是ProductB
        productB.showProduct();
    }
    //工厂接口
    private interface IFactory{
        IProduct getProduct();
    }
    //工厂A
    private class FactoryA implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductA();
        }
    }
    //工厂B
    private class FactoryB implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductB();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
}

抽象工厂模式:工厂方法的复杂化,可以把一些有联系或者功能相近的产品,放到一个工厂去生产,没有必要单独再开一个工厂了。

//懒,就写一起了
public class MainTest {
    //测试方法
    public static void main(String[] args) {
        MainTest mainTest = new MainTest();
        mainTest.test();
    }
    public void test(){
        IFactory factoryA = new FactoryA();
        IProduct productA = factoryA.getProduct();
        //打印我是ProductA
        productA.showProduct();
        IWoker wokerA = factoryA.getWoker();
        //打印我是WokerA
        wokerA.showWoker();

        IFactory factoryB = new FactoryB();
        IProduct productB = factoryB.getProduct();
        //打印我是ProductB
        productB.showProduct();
        IWoker wokerB = factoryB.getWoker();
        //打印我是WokerB
        wokerB.showWoker();
    }
    //工厂接口
    private interface IFactory{
        IProduct getProduct();
        IWoker getWoker();
    }
    //工厂A
    private class FactoryA implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductA();
        }
        @Override
        public IWoker getWoker() {
            return new WokerA();
        }
    }
    //工厂B
    private class FactoryB implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductB();
        }
        @Override
        public IWoker getWoker() {
            return new WokerB();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
    //工种接口
    private interface IWoker{
        void showWoker();
    }
    //工种A
    private class WokerA implements IWoker{
        @Override
        public void showWoker() {
            System.out.println("我是WokerA");
        }
    }
    //工种B
    private class WokerB implements IWoker{
        @Override
        public void showWoker() {
            System.out.println("我是WokerB");
        }
    }
}

本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!