工厂设计模式 —> 创建型模式

对象都需要创建,如果创建的时候直接 new 该对象,就会对该对象严重耦合

假如我们要更换对象,所有 new 对象的地方都需要修改一遍,显然违背了软件设计的开闭原则(OCP)。如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;

工厂模式最大的优点就是:解耦

三种工厂设计模式的使用:

  • 1、简单工厂
  • 2、工厂方法
  • 3、抽象工厂

1、简单工厂设计模式

定义:一个工厂方法,依据传入的参数,生成对应的产品对象;

角色:

  • 1、抽象产品类
  • 2、具体产品类
  • 3、具体工厂 类

使用说明:

  • 先将产品类抽象出来,比如,苹果和梨都属于水果。
  • 抽象出来一个水果类 Fruit,苹果和梨就是具体的产品类。
  • 然后创建一个水果工厂,分别用来创建苹果和梨。

image-20200506135112303

抽象水果类

public abstract class Fruit {

    public abstract void getName();
}

具体类 苹果

public class Apple extends Fruit {
    @Override
    public void getName() {
        System.out.println("apple");
    }
}

具体类 梨

public class Pear extends Fruit {
    @Override
    public void getName() {
        System.out.println("pear");
    }
}

水果工厂

public class FruitFactory {
    public Fruit creatFruit(String type) {
        System.out.println("======FruitFactory creatFruit====");
        if (type.equals("apple")) {//生产苹果
            return new Apple();
        } else if (type.equals("pear")) {//生产梨
            return new Pear();
        }
        return null;
    }
}

简单工厂的使用

public class simpleFactory {
    public static void main(String[] args) {
        FruitFactory fruitFactory = new FruitFactory();
        Fruit apple = fruitFactory.creatFruit("apple");//获得苹果
        apple.getName();
        Fruit pear = fruitFactory.creatFruit("pear");//获得梨
        pear.getName();
    }
}

一个简单工厂设计模式就完成了,但是有问题。如果我想吃香蕉,想吃橘子。这种方式,每当我想添加一种水果,就必然要修改工厂类,这显然也违反了开闭原则,亦不可取;所以简单工厂只适合于产品对象较少,且产品固定的需求,对于产品变化无常的需求来说不合适;

2、工厂方法设计模式

定义:将工厂提取成一个接口或抽象类,具体生产什么产品由子类决定。(具体工厂生产具体类

角色:

  • 1、抽象产品类
  • 2、具体产品类
  • 3、抽象工厂类
  • 4、具体工厂类

image-20200506141253660

和上例中一样,产品类抽象出来,此例把工厂类也抽象出来,工厂方法模式将对象的实例化推迟到子类。


水果抽象类 苹果类和梨类 代码和上例一样

抽象工厂类

public abstract class FruitFactory {
    public abstract Fruit creatFruit();
}

具体工厂 苹果工厂

public class AppleFactory extends FruitFactory {
    @Override
    public Fruit creatFruit() {
        return new Apple();
    }
}

具体工厂 梨工厂

public class PearFactory extends FruitFactory {
    @Override
    public Fruit creatFruit() {
        return new Pear();
    }
}

工厂方法使用

public class factoryMethod {
    public static void main(String[] args) {
        AppleFactory appleFactory = new AppleFactory();//苹果工厂生产苹果
        Fruit apple = appleFactory.creatFruit();
        apple.getName();
        PearFactory pearFactory = new PearFactory();//梨工厂生产梨
        Fruit pear = pearFactory.creatFruit();
        pear.getName();
    }
}

以上这种方式,虽然解耦了,也遵循了开闭原则,但是问题根本还是没有解决啊,换汤没换药,如果我需要的产品很多的话,需要创建非常多的工厂,所以这种方式的缺点也很明显;

3、抽象工厂设计模式

定义:为创建一组相关或者是相互依赖的对象提供的一个接口,而不需要指定它们的具体类。

角色:

  • 1、抽象产品类
  • 2、具体产品类
  • 3、抽象工厂类
  • 4、具体工厂类

抽象工厂和工厂方法的模式基本一样,区别在于,工厂方法是生产一个具体的产品,而抽象工厂可以用来生产一组相同,有相对关系的产品;重点在于一组,一批,一系列。


举个例子,假如生产 Iphone 手机,Iphone 手机有很多系列,Iphone8、IphoneXS等;假如Apple8生产需要 CPU A11的处理器,LCD屏幕,而 AppleXs 需要 CPU A12 的处理器和 OLED 屏幕;用抽象工厂来实现:

image-20200506141638638

CPU 抽象类和实现类

public abstract class Cpu {
    public abstract void run();
}

class A11 extends Cpu{
    @Override
    public void run() {
        System.out.println("A11");
    }
}

class A12 extends  Cpu{
    @Override
    public void run() {
        System.out.println("A12");
    }
}

屏幕 抽象类和实现类

public abstract class Screen {
    public abstract void isScreen();
}

class LCD extends Screen{
    @Override
    public void isScreen() {
        System.out.println("LCD");
    }
}

class OLCD extends Screen{
    @Override
    public void isScreen() {
        System.out.println("OLCD");
    }
}

手机工厂接口

public interface PhoneFactory {
    Cpu getCpu();//获得cpu
    Screen getScreen();//获得屏幕

}

手机工厂实现

public class Iphone8Factory implements PhoneFactory {
    @Override
    public Cpu getCpu() {
        return new A11();
    }

    @Override
    public Screen getScreen() {
        return new OLCD();
    }
}

public class IPhoneXSFactory implements  PhoneFactory {
    @Override
    public Cpu getCpu() {
        return new A12();
    }

    @Override
    public Screen getScreen() {
        return new LCD();
    }
}

抽象工厂使用

public class abstractFactory {
    public static void main(String[] args) {
        Iphone8Factory iphone8Factory = new Iphone8Factory();
        IPhoneXSFactory iPhoneXSFactory = new IPhoneXSFactory();
        System.out.println("========iphone8Factory==========");
        Cpu cpuA11 = iphone8Factory.getCpu();
        Screen screen = iphone8Factory.getScreen();
        cpuA11.run();
        screen.isScreen();
        System.out.println("========iPhoneXSFactory==========");
        Cpu cpuA12 = iPhoneXSFactory.getCpu();
        Screen screen1 = iPhoneXSFactory.getScreen();
        cpuA12.run();
        screen1.isScreen();
    }
}

以上例子可以看出,抽象工厂可以解决一系列的产品生产的需求,对于大批量,多系列的产品,用抽象工厂可以更好的管理和扩展;


三种工厂方式总结

  • 1、对于简单工厂和工厂方法来说,两者的使用方式实际上是一样的,如果对于产品的分类和名称是确定的,数量是相对固定的,推荐使用简单工厂模式;
  • 2、抽象工厂用来解决相对复杂的问题,适用于一系列、大批量的对象生产;

JDK 中工厂设计模式的应用 Calendar 类

Calendar.getInstance();

public static Calendar getInstance(){
        return createCalendar(TimeZone.getDefault(), 					                              Locale.getDefault(Locale.Category.FORMAT));
}

public static Locale getDefault(Locale.Category category) {
    // do not synchronize this method - see 4071298
    switch (category) {
        case DISPLAY:
            if (defaultDisplayLocale == null) {
                synchronized(Locale.class) {
                    if (defaultDisplayLocale == null) {
                        defaultDisplayLocale = initDefault(category);
                    }
                }
            }
            return defaultDisplayLocale;
        case FORMAT:
            if (defaultFormatLocale == null) {
                synchronized(Locale.class) {
                    if (defaultFormatLocale == null) {
                        defaultFormatLocale = initDefault(category);
                    }
                }
            }
            return defaultFormatLocale;
        default:
            assert false: "Unknown Category";
    }
    return getDefault();
}


private static Calendar createCalendar(TimeZone zone,Locale aLocale){
    CalendarProvider provider =
        LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
        .getCalendarProvider();
    if (provider != null) {
        try {
            return provider.getInstance(zone, aLocale);
        } catch (IllegalArgumentException iae) {
            // fall back to the default instantiation
        }
    }

    Calendar cal = null;

    if (aLocale.hasExtensions()) {
        String caltype = aLocale.getUnicodeLocaleType("ca");
        if (caltype != null) {
            switch (caltype) {
                case "buddhist":
                    cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
            }
        }
    }
    if (cal == null) {
        // If no known calendar type is explicitly specified,
        // perform the traditional way to create a Calendar:
        // create a BuddhistCalendar for th_TH locale,
        // a JapaneseImperialCalendar for ja_JP_JP locale, or
        // a GregorianCalendar for any other locales.
        // NOTE: The language, country and variant strings are interned.
        if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
            cal = new BuddhistCalendar(zone, aLocale);
        } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                   && aLocale.getCountry() == "JP") {
            cal = new JapaneseImperialCalendar(zone, aLocale);
        } else {
            cal = new GregorianCalendar(zone, aLocale);
        }
    }
    return cal;
}