跳至主要內容

创建模式-工厂模式

Ms.Zyh2022/5/5大约 4 分钟设计模式基础设计模式

一，工厂模式

1.1 简单工厂模式

举例：小明初到华强北，小明的手机厂可以生产oppo手机，小米手机，苹果手机，通过工厂创建或者说生产手机。
模式结构成员构成：

  • Factory：工厂角色
  • AbstractProduct：抽象产品
  • Product：具体产品

Uml图：
image.png

示例代码：
工厂角色

public class SimplePhoneFactory{
    public static MobilePhone createMobilePhone(String type) {
        if("oppo".equals(type)){
            return new OppoMobilePhone();
        }else if("xiaoMi".equals(type)){
            return new XiaoMiMobilePhone();
        }else if("apple".equals(type)){
            return new AppleMobilePhone();
        }
        return null;
    }
}

抽象产品

public abstract class MobilePhone {
    public abstract Void printingName();
}

具体产品

public class AppleMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("苹果手机");
    }
}
public class OppoMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("oppo手机");
    }
}
public class XiaoMiMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("小米手机");
    }
}

测试

public class Test {
    public static void main(String[] args) {
        MobilePhone oppoPhone = SimplePhoneFactory.createMobilePhone("oppo");
        oppoPhone.printingName();
        MobilePhone xiaoMiPhone = SimplePhoneFactory.createMobilePhone("xiaoMi");
        xiaoMiPhone.printingName();
        MobilePhone applePhone = SimplePhoneFactory.createMobilePhone("apple");
        applePhone.printingName();
    }
}

结果

oppo手机
小米手机
苹果手机

优缺点：简单工厂模式有一个很大的问题，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，比如需要生产华为手机，就需要在工厂创建方法，新增if判断后新增代码，这违背了开闭原则，所以，从设计角度考虑，有一定的问题，如何解决？接着往下看吧少年。

1.2 工厂方法模式

举例：小明的初来乍到，小明的手机厂规定只能可以生产oppo手机，小红的手机厂可以生产小米手机，小狗的手机厂可以生产苹果手机，通过工厂创建或者说生产手机。
模式结构成员构成：

  • AbstractFactory：抽象工厂角色
  • Factory：工厂角色
  • AbstractProduct：抽象产品
  • Product：具体产品

Uml图：
image.png

示例代码：
抽象工厂角色

public interface AbstractFactory {
    MobilePhone createMobilePhone();
}

工厂角色

public class AppleFactory implements AbstractFactory{
    @Override
    public MobilePhone createMobilePhone() {
        System.out.println("苹果工厂生产");
        return new AppleMobilePhone();
    }
}
public class OppoFactory implements AbstractFactory{
    @Override
    public MobilePhone createMobilePhone() {
        System.out.println("oppo工厂生产");
        return new OppoMobilePhone();
    }
}
public class XiaoMiFactory  implements AbstractFactory {
    @Override
    public MobilePhone createMobilePhone() {
        System.out.println("小米工厂生产");
        return new XiaoMiMobilePhone();
    }
}

抽象产品

public abstract class MobilePhone {
    public abstract Void printingName();
}

具体产品

public class AppleMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("苹果手机");
    }
}
public class OppoMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("oppo手机");
    }
}
public class XiaoMiMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("小米手机");
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        AbstractFactory appleFactory = new AppleFactory();
        MobilePhone applePhone = appleFactory.createMobilePhone();
        applePhone.printingName();
        AbstractFactory oppoFactory = new OppoFactory();
        MobilePhone oppoPhone = oppoFactory.createMobilePhone();
        oppoPhone.printingName();
        AbstractFactory xiaoMiFactory = new XiaoMiFactory();
        MobilePhone xiaoMiPhone = xiaoMiFactory.createMobilePhone();
        xiaoMiPhone.printingName();
    }
}

结果：

苹果工厂生产
苹果手机
oppo工厂生产
oppo手机
小米工厂生产
小米手机

优缺点：工厂方法模式能够解决简单工厂模式的在新增产品时，需要修改已经写好代码的缺点，工厂方法模式在新增产品的时候，只需要新增对应的工厂就可以了，不会修改已经写好的代码，没有违背开闭原则。

1.3 抽象工厂模式

举例：小明的想要赚钱，不想只做手机了，小明的厂想要生产安卓产品，小红的厂生产苹果的产品
模式结构成员构成：

  • AbstractFactory：抽象工厂角色
  • Factory：工厂角色
  • AbstractProduct：抽象产品
  • Product：具体产品

Uml图：
image.png

示例代码：
抽象工厂角色

public interface AbstractFactory {
    MobilePhone createMobilePhone();
    Computer createComputer();
}

工厂角色

public class AndroidFactory implements AbstractFactory{
    @Override
    public MobilePhone createMobilePhone() {
        System.out.println("生产安卓手机");
        return new OppoMobilePhone();
    }

    @Override
    public Computer createComputer() {
        System.out.println("生产安卓电脑");
        return new HuaShuoComputer();
    }
}
public class AppleFactory implements AbstractFactory {
    @Override
    public MobilePhone createMobilePhone() {
        System.out.println("创建苹果手机");
        return new AppleMobilePhone();
    }

    @Override
    public Computer createComputer() {
        System.out.println("创建苹果电脑");
        return new AppleComputer();
    }
}

抽象产品

public abstract class MobilePhone {
    public abstract Void printingName();
}
public abstract class Computer  {
    public abstract void printingName();
}

具体产品

public class AppleComputer extends Computer{
    @Override
    public void printingName() {
        System.out.println("苹果电脑");
    }
}
public class HuaShuoComputer extends Computer{
    @Override
    public void printingName() {
        System.out.println("华硕电脑");
    }
}
public class AppleMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("苹果手机");
    }
}
public class OppoMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("oppo手机");
    }
}
public class XiaoMiMobilePhone extends MobilePhone{
    @Override
    public void printingName() {
        System.out.println("小米手机");
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        AbstractFactory androidFactory = new AndroidFactory();
        MobilePhone androidPhone = androidFactory.createMobilePhone();
        androidPhone.printingName();
        Computer androidComputer = androidFactory.createComputer();
        androidComputer.printingName();
        AbstractFactory appleFactory = new AppleFactory();
        MobilePhone applePhone = appleFactory.createMobilePhone();
        applePhone.printingName();
        Computer appleComputer = appleFactory.createComputer();
        appleComputer.printingName();
    }
}

结果：

生产安卓手机
oppo手机
生产安卓电脑
华硕电脑
创建苹果手机
苹果手机
创建苹果电脑
苹果电脑

抽象工厂和工厂模式区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个，抽象工厂就像真的工厂，工厂方法就像工厂中的一条生产线

最近更新
贡献者: zyh1020
默认页脚
Copyright © 2025 Ms.Zyh