设计模式---工厂模式(创建型)

目录

1、什么是工厂设计模式

2、简单工厂模式

 3、工厂方法设计模式

4、抽象工厂模式

---

1、什么是工厂设计模式

        工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式。

        工厂模式是用工厂方法代替new操作的一种模式。我们不暴露创建对象的具体逻辑，而是将逻辑封装在一个函数中，那么这个函数就可以被视为一个工厂。

2、简单工厂模式

        该模式对对象创建管理方式最为简单，只需要对不同类对象的创建进行了一层薄薄的封装即可，即通过向工厂传递类型来指定要创建的对象。

代码实现:

        首先创建一个华为手机的接口:

public interface HuaweiPhone {
 
    /**
     * 打电话
     */
    void call();
}

        创建华为Mate50和P50:

public class Mate50 implements HuaweiPhone{
 
 
    public Mate50(){
        System.out.println("创建一个Mate50很复杂");
    }
 
    /**
     * 打电话
     */
    public void call() {
        System.out.println("使用Mate50打电话");
    }
}

public class P50 implements HuaweiPhone {
 
    public P50(){
        System.out.println("创建p50是一个很复杂的过程");
    }
 
    /**
     * 打电话
     */
    public void call() {
        System.out.println("使用P50打电话");
    }
}

        创建制造华为手机的工厂类:

//创建华为手机的工厂
public class HuaWeiPhoneFactory {
 
    public HuaweiPhone makeHuaei(String tpye){
        if("Mate50".equals(tpye))
        {
            //创建Mate50对象是复杂的 省略一万行
            return new Mate50();
        } else if("P50".equals(tpye)){
            //创建P50对象是复杂的 省略一万行
            return new P50();
        }else {
            throw  new RuntimeException("该类型的手机不存在！");
        }
 
    }
 
}

        测试:

public class phoneMain {
   public static void main(String[] args) {
        HuaWeiPhoneFactory factory=new HuaWeiPhoneFactory();
        P50 p50 = (P50) factory.makeHuaei("P50");
        p50.call();
        System.out.println("-------------------");
        Mate50 mate50 = (Mate50)factory.makeHuaei("Mate50");
        mate50.call();
        System.out.println("-------------------");
        HuaweiPhone iphone13 = factory.makeHuaei("iphone13");
        iphone13.call();
    }
}

缺点：简单工厂模式是违反“开闭原则“；因为如果要新增产品，就需要修改工厂类的代码。

比如我要新增一个Nova10手机，此时就需要改HuaWeiPhoneFactory的代码。

 3、工厂方法设计模式

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

        简单工厂模式中 工厂 负责的是生产所有产品，而工厂方法模式将生产不同产品的任务分发给不同的工厂，正所谓各司其职，减少依赖性。比如华为Mate50工厂就专门生产Mate50系列的手机，P50就生产P50系列的手机。既然工厂要不同，那就得把工厂抽象出来，具体的厂商自己实现。

代码实现:

        将上面的HuaWeiPhoneFactory 的工厂抽取出来:

        工厂接口:

/**
 * 生产华为手机的工厂接口
 */
public interface Factory {
 
    /**
     * 生产华为手机
     * @return
     */
    HuaweiPhone makeHuaWei();
}

        生产Mate50的工厂:

/**
 * Mate50工厂
 */
public class Mate50Factory implements Factory {
    /**
     * 生产华为Mate50
     *
     * @return
     */
    public HuaweiPhone makeHuaWei() {
        //经过一系列的复杂过程
        return new Mate50();
    }
}

        生产P50的工厂: 

/**
 * P50工厂
 */
public class P50Factory implements Factory{
 
    /**
     * 生产华为P50
     *
     * @return
     */
    public HuaweiPhone makeHuaWei() {
        return new P50();
    }
}

        测试:

public class phoneMain {
    public static void main(String[] args) {
        //创建Mate50工厂
        Factory factory=new Mate50Factory();
        HuaweiPhone mate50 = factory.makeHuaWei();
        mate50.call();
        System.out.println("------------------------");
        Factory factory1=new P50Factory();
        HuaweiPhone p50 = factory1.makeHuaWei();
        p50.call();
    }
}

        每个工厂只生产一种产品 ，此时如果想生产一个 Navo10手机就不需要改HuaWeiPhoneFactory的代码。只需要添加Navo10的产品和Navo的工厂。

4、抽象工厂模式

        他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品；而抽象工厂模式则是针对的多个产品。即工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类

代码实现:

1、定义产品抽象类

        电脑生产线:

public abstract class AbstractComputerProduct {
 
    // 生产电脑产品的共享方法
    public void sharedMethod(){
        System.out.println("这是生产电脑的产品线。");
    }
 
    abstract void networking();
}

        手机生产线:

public abstract class AbstractPhoneProduct {
 
    // 添加loge标签
    public void labelling(){
        System.out.println("这是小米的产品。");
    }
 
    abstract void networking();
}

 2、定义具体产品    

        我们定义两个华为的产品

public class MateBook16 extends AbstractComputerProduct {
    @Override
    public void networking() {
        System.out.println("Use a mateBook16 to connect to the Internet");
    }
}

public class Mate60 extends AbstractPhoneProduct {
    @Override
    public void networking() {
        System.out.println("Use a Mate60 to connect to the Internet");
    }
}

        定义两个小米的产品

public class Mi12 extends AbstractPhoneProduct {
    @Override
    public void networking() {
        System.out.println("Use a Mi12 to connect to the Internet");
    }
}

public class MiBookPro15 extends AbstractComputerProduct {
    @Override
    public void networking() {
        System.out.println("Use a MiBookPro15 to connect to the Internet");
    }
}

 3、定义抽象工厂

public abstract class AbstractFactory {
    /**
     * 生产手机的方法
     * @return
     */
    abstract AbstractPhoneProduct createPhone();
 
    /**
     * 生产电脑的方法
     * @return
     */
    abstract AbstractComputerProduct createComputer();
}

4、定义具体的产品工厂

        小米产品线的工厂:

public class MiFactory extends AbstractFactory {
 
    @Override
    AbstractPhoneProduct createPhone() {
        return new Mi12();
    }
 
    @Override
    AbstractComputerProduct createComputer() {
        return new MiBookPro15();
    }
}

        华为产品线的工厂 ：

public class HuaweiFactory extends AbstractFactory {
 
    @Override
    AbstractPhoneProduct createPhone() {
        return new Mate60();
    }
 
    @Override
    AbstractComputerProduct createComputer() {
        return new MateBook16();
    }
}

5、测试

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new MiFactory();
        AbstractPhoneProduct phone = factory.createPhone();
        phone.networking();
    }
}

        抽象工厂模式的缺点在于产品类的扩展，将会是十分费力的，假如需要加入新的产品，那么几乎所有的工厂类都需要进行修改，所以在使用抽象工厂模式时，对产品等级结构的划分是十分重要的。