设计模式-----------工厂模式之抽象工厂模式（创建型）

1、抽象工厂模式定义

提供一个创建一系列相关或相互依赖对象的接口、无须指定它们具体的类。

产品族：一个品牌下的商品。比如海尔企业下的：海尔电视、海尔空调、海尔洗衣机…

产品等级：同一个商品不同的企业生产。比如 海尔电视、格力电视、美的电视…

（理解：比如说，海尔电器这个企业可以生产、海尔电视机、海尔空调。格力这个企业可以生产海尔电视机、海尔空调。这个时候可以定义一个电视的抽象接口和空调的抽象接口。让每个企业生产的对应产品对应不同的抽象产品。然后再来一个格力工厂、专门生产格力企业下的产品。海尔工厂、专门生产海尔企业下的产品、、、）

2、应用场景

• 需要生成产品族的情形

3、UML类图

4、抽象工厂模式的通用写法

package com.zheng;

public class Client {

    public static void main(String[] args) {
        //1、创建某一个企业的工厂
        IAbstractFactory factory = new contreteFactoryA();
        //2、工厂创建该企业下的商品并调用相应方法
        factory.createProduceA().dosome();
        factory.createProduceB().dislay();
    }


    //抽象工厂
    public interface IAbstractFactory {
        IabstractA createProduceA();

        IabstractB createProduceB();
    }


    //抽象产品
    public interface IabstractA {
        void dosome();
    }

    public interface IabstractB {
        void dislay();
    }


    //企业A下的产品
    static class ContreteProduceAWithFamilyA implements IabstractA {

        @Override
        public void dosome() {
            System.out.println("我是A企业下的具体产品A");
        }
    }

    static class ContreteProduceBWithFamilyA implements IabstractB {

        @Override
        public void dislay() {
            System.out.println("我是A企业下的具体产品B");
        }
    }

    //企业B下的产品

    static class ContreteProduceAWithFamilyB implements IabstractA {

        @Override
        public void dosome() {
            System.out.println("我是B企业下的具体产品A");
        }
    }

    static class ContreteProduceBWithFamilyB implements IabstractB {

        @Override
        public void dislay() {
            System.out.println("我是B企业下的具体产品B");
        }
    }

    //具体工厂A

    static class contreteFactoryA implements IAbstractFactory {

        @Override
        public IabstractA createProduceA() {
            return new ContreteProduceAWithFamilyA();
        }

        @Override
        public IabstractB createProduceB() {
            return new ContreteProduceBWithFamilyA();
        }
    }

    //具体工厂B
    static class contreteFactoryB implements IAbstractFactory {

        @Override
        public IabstractA createProduceA() {
            return new ContreteProduceAWithFamilyB();
        }

        @Override
        public IabstractB createProduceB() {
            return new ContreteProduceBWithFamilyB();
        }
    }


}

5、结果

6、举列子

java课程有录播的视频和笔记。

抽象工厂

package com.zheng.demo3;

public interface CourseFactory {
    INote cerateNote();
    IViedo cerateViedo();
}

抽象产品

抽象产品1，视频

package com.zheng.demo3;

public interface IViedo {
    void record();
}

抽象产品2，笔记

package com.zheng.demo3;

public interface INote {
    void edit();
}

具体产品
python下的具体产品viedo

package com.zheng.demo3;

public class PythonViedo implements IViedo {
    @Override
    public void record() {
        System.out.println("我是python相关的视频");
    }
}

python下的具体产品note

package com.zheng.demo3;

public class PythonNote implements INote {
    @Override
    public void edit() {
        System.out.println("我是Python相关的笔记");
    }
}

生产python相关的工厂

package com.zheng.demo3;

public class createPythonFactory implements CourseFactory {
    @Override
    public INote cerateNote() {
        return new PythonNote();
    }

    @Override
    public IViedo cerateViedo() {
        return new PythonViedo();
    }
}

客户端测试

package com.zheng.demo3;

public class TestClient {
    public static void main(String[] args) {
        //1、创建具体工厂
        CourseFactory factory = new createPythonFactory();

        //2、通过工厂创建商品
        IViedo viedo = factory.cerateViedo();
        INote note = factory.cerateNote();

        //3、调用实例的方法
        viedo.record();
        note.edit();
    }
}

结果

。还可以继续扩展其他的课程、比如python、c语言、C++。只需要扩展对应的实现类和对应的工厂生产就可以了。

7、抽象工厂模式优点

优点：

• 需要产品族时，可以保证客户端只使用一个产品的产品族
• 增强了程序的可扩展性，新产品族的增加，只需要实现一个新的具体工厂就可以

缺点

• 规定了所有可能被创建的产品集合，产品族扩展新商品、需要修改抽象工厂的接口
• 增加了系统的抽象性和难理解度。