8、工厂设计模式（Factory）

明月常新

已于 2022-08-05 15:21:40 修改

阅读量120

点赞数

分类专栏：设计模式文章标签：抽象工厂模式

于 2022-04-06 13:57:41 首次发布

本文链接：https://blog.csdn.net/weixin_45905210/article/details/123987322

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

8.1、什么是工厂设计模式？

工厂设计模式脑图下载

工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

8.2、简单工厂（Simple Factory）

定义：
一个工厂方法，依据传入的参数，生成对应的产品对象；
角色：
1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者
使用说明：
先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类Fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨。代码如下：

水果接口：

package com.edu.mianshi.moshi.工厂设计;

/**
 * 水果接口：无返回值
 */
public interface Fruit {
    void whatIm();
}

苹果类：

package com.edu.mianshi.moshi.工厂设计;

/**
 * 苹果类：
 */
public class Apple implements Fruit {
    @Override
    public void whatIm() {
        System.out.println("苹果");
    }
}

梨类：

package com.edu.mianshi.moshi.工厂设计;

/*
梨类：
 */
public class Pear implements Fruit{
    @Override
    public void whatIm() {
        System.out.println("梨");
    }
}

水果工厂：

package com.edu.mianshi.moshi.工厂设计;

public class FruitFactory {

    public Fruit createFruit(String type){
        if(type.equals("apple")){//生产苹果
            return new Apple();
        }else if (type.equals("pear")){//生产梨
            return new Pear();
        }
        return null;
    }

}

使用工厂生产产品：

package com.edu.mianshi.moshi.工厂设计;

//使用工厂生产产品：
public class FruitApp {

    public static void main(String[] args) {

        FruitFactory fruitFactory = new FruitFactory();
        Apple apple = (Apple)fruitFactory.createFruit("apple");
        Pear pear = (Pear)fruitFactory.createFruit("pear");
        apple.whatIm();
        pear.whatIm();
    }

    /**
     * 以上的这种方式，每当添加一种水果，就必然要修改工厂类，违反了开闭原则；
     * 所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适。
     */
}

8.3、工厂方法（Factory Method）

定义：
将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；
角色：
1、抽象产品
2、具体产品
3、抽象工厂
4、具体工厂
使用说明：
和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定。代码如下：
水果接口、苹果类和梨类：
代码和上例一样

原来是水果接口现在是水果工厂接口
原来是void whatIm(); 现在是 Fruit createFruit();//生产水果
抽象工厂接口：

package com.edu.mianshi.moshi.工厂设计.工厂方法;

import com.edu.mianshi.moshi.工厂设计.简单工厂.Fruit;

public interface FruitFactory {

    Fruit createFruit();//生产水果  
    
}

苹果工厂：

package com.edu.mianshi.moshi.工厂设计.工厂方法;

import com.edu.mianshi.moshi.工厂设计.简单工厂.Apple;
import com.edu.mianshi.moshi.工厂设计.简单工厂.Fruit;

public class AppleFactory implements FruitFactory {
    /**
     * 方法重写 返回值 改为 apple
     * @return
     */
    @Override
    public Apple createFruit() {
        return new Apple();
    }
}

梨工厂：

package com.edu.mianshi.moshi.工厂设计.工厂方法;

import com.edu.mianshi.moshi.工厂设计.简单工厂.Pear;

public class PearFactory implements FruitFactory  {
    @Override
    public Pear createFruit() {
        return new Pear();
    }
}

使用工厂生产产品：

package com.edu.mianshi.moshi.工厂设计.工厂方法;

import com.edu.mianshi.moshi.工厂设计.简单工厂.Apple;
import com.edu.mianshi.moshi.工厂设计.简单工厂.Pear;

public class FruitApp {

    public static void main(String[] args){
            AppleFactory appleFactory = new AppleFactory();
            PearFactory pearFactory = new PearFactory();
            Apple apple = appleFactory.createFruit();//获得苹果
            Pear pear = pearFactory.createFruit();//获得梨
            apple.whatIm();
            pear.whatIm();
        }
    /**
     * 以上这种方式，虽然解耦了，也遵循了开闭原则，但是如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显。
     */

}

8.4、抽象工厂（Abstract Factory）

定义：
为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。
角色：
1、抽象产品
2、具体产品
3、抽象工厂
4、具体工厂
使用说明：
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；举个例子，假如生产小米手机，小米手机有很多系列，小米note、红米note等；假如小米note生产需要的配件有825的处理器，6英寸屏幕，而红米只需要650的处理器和5寸的屏幕就可以了。用抽象工厂来实现：

cpu接口和实现类：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public interface Cpu {

    void run();


    class Cpu650 implements Cpu{

        @Override
        public void run() {
            System.out.println("650 也厉害");
        }
    }

    class Cpu825 implements Cpu {

        @Override
        public void run() {
            System.out.println("825 更强劲");
        }
    }

    
}

屏幕接口和实现类：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public interface Screen {

    void size();

    class Screen5 implements Screen {

        @Override
        public void size() {
            System.out.println("" + "5寸");
        }
    }

    class Screen6 implements Screen {

        @Override
        public void size() {
            System.out.println("6寸");
        }
    }

    
}

抽象工厂接口：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public interface PhoneFactory {

    Cpu getCpu();//使用的cpu
    Screen getScreen();//使用的屏幕
    
}

小米手机工厂：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu825 getCpu() {
        return new Cpu.Cpu825();//高性能处理器
    }

    @Override
    public Screen.Screen6 getScreen() {
        return new Screen.Screen6();//6寸大屏  
    }
}

红米手机工厂：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public class HongMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu650 getCpu() {
        return new Cpu.Cpu650();//高效处理器
    }

    @Override
    public Screen.Screen5 getScreen() {
        return new Screen.Screen5();//小屏手机
    }
}

使用工厂生产产品：

package com.edu.mianshi.moshi.工厂设计.抽象工厂;

public class PhoneApp {
    public static void main(String[] args){
                HongMiFactory hongMiFactory = new HongMiFactory();
                XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
                Cpu.Cpu650 cpu650 = hongMiFactory.getCpu();
                Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();
                cpu650.run();
                cpu825.run();

                Screen.Screen5 screen5 = hongMiFactory.getScreen();
                Screen.Screen6 screen6 = xiaoMiFactory.getScreen();
                screen5.size();
                screen6.size();
            }

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

}