设计模式-工厂方法模式

工厂方法模式思维导图.png

1.介绍：

     工厂方法模式顾名思义就是创建产品的，这里的产品在Java程序里面就是一个个对象，该模式就是用于封装对象的创建，是一种创建型模式。根据抽象程度的不同，它又分为：简单工厂模式、工厂方法模式和抽象工厂模式。

2.代码实例：

2.1：简单工厂方法模式：

     简单工厂模式其实不属于设计模式中的一种，他是把对象创建的一个简单封装，根据传递的参数创建不同的对象。

• 工厂生产的对象产品抽象

public interface Phone {
    void show();
}

• 具体产品

public class IPhone implements Phone {

    public IPhone() {
        this.show();
    }

    @Override
    public void show() {
        System.out.println("make apple phone");
    }
}


public class MiPhone implements Phone {

    public MiPhone() {
        this.show();
    }

    @Override
    public void show() {
        System.out.println("make mi phone");
    }
}

• 生产手机的简单工厂

public class SimpleFactory {

    //生产手机产品的静态方法
    public static Phone createPhone(String type) {
        if (type.equalsIgnoreCase("MiPhone")) {
            return new MiPhone();
        } else {
            return new IPhone();
        }
    }
}

• 客户端使用简单工厂方法

public class Client {

    public static void main(String[] args) {
        Phone miPhone = SimpleFactory.createPhone("MiPhone");
        Phone iphone = SimpleFactory.createPhone("Iphone");
        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
        System.out.println("iphone type " + iphone.getClass().getSimpleName());
    }
}

//控制台输出：
make mi phone
make apple phone
miPhone type MiPhone
iphone type IPhone

• 简单工厂方法UML类图展示：

  
  简单工厂方法类图.png

2.2：工厂方法模式：

     工厂方法模式是在简单工厂方法模式之上进行了一层抽象，把对象创建的方法抽象成一个接口，每一个具体的产品由一个具体的工厂来产生。

• AbstractFactory类

public interface AbstractFactory {

    Phone createPhone();
}

• MiPhonoeFactory类，生产MiPhone对象

public class MiPhoneFactory implements AbstractFactory {

    @Override
    public Phone createPhone() {
        return new MiPhone();
    }
}

• IPhoneFactory类，生产IPhone对象

public class IPhoneFactory implements AbstractFactory {

    @Override
    public Phone createPhone() {
        return new IPhone();
    }
}

• Client客户端的使用

public class Client {

    public static void main(String[] args) {
//        Phone miPhone = SimpleFactory.createPhone("MiPhone");
//        Phone iphone = SimpleFactory.createPhone("Iphone");
//        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
//        System.out.println("iphone type " + iphone.getClass().getSimpleName());


        AbstractFactory miPhoneFactory = new MiPhoneFactory();
        AbstractFactory iphoneFactory = new IPhoneFactory();
        Phone miPhone = miPhoneFactory.createPhone();
        Phone iphone = iphoneFactory.createPhone();
        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
        System.out.println("iphone type " + iphone.getClass().getSimpleName());
    }

//控制台输出：
make mi phone
make apple phone
miPhone type MiPhone
iphone type IPhone

• 工厂方法模式UML类图展示：

  
  工厂方法模式UML类图.png

2.3抽象工厂方法模式：

     抽象工厂方法模式是在工厂方法模式之上再进行抽象的，抽象工厂不再是像工厂方法模式那样只生成一个产品，抽象工厂方法模式是生成一系列的配套产品。抽象工厂就类似小米这个品牌，它能够生成电脑、手机和手环等一系列配套的产品。

• AbFactory类

public interface AbFactory {

    Phone createPhone();

    PC createPC();
}

• PC产品

public interface PC {
    void show();
}

public class MiPC implements PC {

    public MiPC() {
        this.show();
    }

    @Override
    public void show() {
        System.out.println("make mi pc");
    }
}

public class MacPC implements PC {

    public MacPC() {
        this.show();
    }

    @Override
    public void show() {
        System.out.println("make mac pc");
    }
}

• MiFactory

public class MiFactory implements AbFactory {

    @Override
    public Phone createPhone() {
        return new MiPhone();
    }

    @Override
    public PC createPC() {
        return new MiPC();
    }
}

• AppleFactory

public class AppleFactory implements AbFactory {

    @Override
    public Phone createPhone() {
        return new IPhone();
    }

    @Override
    public PC createPC() {
        return new MacPC();
    }
}

• Client客户端使用类

public class Client {

    public static void main(String[] args) {
//        Phone miPhone = SimpleFactory.createPhone("MiPhone");
//        Phone iphone = SimpleFactory.createPhone("Iphone");
//        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
//        System.out.println("iphone type " + iphone.getClass().getSimpleName());

//        AbstractFactory miPhoneFactory = new MiPhoneFactory();
//        AbstractFactory iphoneFactory = new IPhoneFactory();
//        Phone miPhone = miPhoneFactory.createPhone();
//        Phone iphone = iphoneFactory.createPhone();
//        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
//        System.out.println("iphone type " + iphone.getClass().getSimpleName());

        AbFactory miAbstractFactory = new MiFactory();
        AbFactory appleAbstractFactory = new AppleFactory();
        Phone miPhone = miAbstractFactory.createPhone();
        PC miPC = miAbstractFactory.createPC();
        Phone iphone = appleAbstractFactory.createPhone();
        PC macPC = appleAbstractFactory.createPC();
        System.out.println("miPhone type " + miPhone.getClass().getSimpleName());
        System.out.println("miPC type " + miPC.getClass().getSimpleName());
        System.out.println("iphone type " + iphone.getClass().getSimpleName());
        System.out.println("macPC type " + macPC.getClass().getSimpleName());
    }
}

• 抽象工厂模式UML类图：

  
  抽象工厂模式.png

3.使用场景：

     简单工厂模式就是一个很简单的对对象创建的封装，工厂方法模式是对每一个具体产品创建的封装，每一个产品对应有一个具体的工厂来创建，而抽象工厂模式是针对一系列产品对象的创建。3种工厂模式是在抽象层度上的不同，对于不同场景选择不同的工厂模式进行对象创建的封装。

3.1： 工厂方法模式的使用：

     在Java中就有工厂方法模式的使用：线程工厂的封装就是用来创建线程池，具体的线程创建交给具体的工厂实现。

public interface ThreadFactory {

    Thread newThread(Runnable r);
}