工厂模式,就是将创建对象的过程交给“工厂”,需要创建对象时调用对应工厂类的对象创建方法即可。为什么要使用工厂模式?有些时候我们不能简单地通过“new()”来创建一个对象,我们需要对对象创建进行权限控制、装饰和日志输出等操作,从而灵活地控制对象生产过程。工厂模式一般可分为简单生产模式、工厂方法模式和抽象工厂模式。需要注意的是,对于phone等实体类进行抽象规范时一般使用抽象类,因为这是一个实体类,完全可能具有成员属性。而由于工厂只是负责创建对象,是一个过程或者说动作,一般不需要成员属性,故在对一个工厂进行抽象规范的时候,不是使用抽象类而是使用接口。一般来说,名词等实体类用抽象类定义,形容词或动词等非实体用接口定义。
简单生产模式一个工厂生产多个类对象,如一个ComputerFactory生产HuaweiComputer对象、Mac对象等。
注:可以定义一个抽象Computer类,规范HuaweiComputer类和Mac类。
优点:写法简单,统一用一个工厂就可以获得不同类产品。
缺点:这样带来的问题是每次增加一个实现Computer抽象类的新类,我们就需要修改ComputerFactory工厂类,让它具有生产新Computer类对象的能力,这样显然不符合开闭原则。
使用场景:工厂生产产品类型不多的情况下可考虑使用
Computer类
public abstract class Computer {
public abstract void powerOn();
public abstract void powerOff();
public abstract void use();
}
HuaweiComputer类
public class HuaweiComputer extends Computer {
@Override
public void powerOn() {
System.out.println("华为电脑开机");
}
@Override
public void powerOff() {
System.out.println("华为电脑关机");
}
@Override
public void use() {
System.out.println("使用华为电脑");
}
}
Mac类
public class Mac extends Computer {
@Override
public void powerOn() {
System.out.println("苹果电脑开机");
}
@Override
public void powerOff() {
System.out.println("苹果电脑关机");
}
@Override
public void use() {
System.out.println("使用苹果电脑");
}
}
ComputerFactory类(从代码可见耦合度很高)
public class ComputerFactory {
Computer create(String type){
if(type.equals("huawei")){
return new HuaweiComputer();
}else if(type.equals("apple")){
return new Mac();
}else return null;
}
}
测试类
public class SimpleTest {
public static void main(String args[]){
ComputerFactory computerFactory=new computerFactory();
Computer huaweicomputer=computerFactory.create("huawei");
Computer mac=computerFactory.create("apple");
huaweicomputer.use();
mac.use();
}
}
结果
工厂方法模式使用华为电脑
使用苹果电脑
简单生产模式带来的问题是工厂类可能会因为功能拓展经常进行修改违反开闭原则,所以工厂模式则要为每一个类的对象创建定义一个专属的工厂,如HuaweiComputer有HuaweiComputerFactory,Mac有AppleComputerFactory。
注:实际上可以定义一个工厂接口,规范工厂类,如此例可定义ComputerFactory接口。当定义这么一个工厂接口时,实际上工厂方法模式可以看成是一族只生产一类产品的抽象工厂模式。
优点:不用每次都对一个工厂的代码进行修改,用拓展的方式代替了修改的方式。
缺点:每增加一个类,就需要定义一个对应的工厂类。
适用场景:产品类型的扩展。当产品类型较多时不考虑简单工厂,此时若考虑产品类型的扩展,则使用工厂方法模式。
Computer类
public abstract class Computer {
public abstract void powerOn();
public abstract void powerOff();
public abstract void use();
}
huaweiComputer类
public class HuaweiComputer extends Computer {
@Override
public void powerOn() {
System.out.println("华为电脑开机");
}
@Override
public void powerOff() {
System.out.println("华为电脑关机");
}
@Override
public void use() {
System.out.println("使用华为电脑");
}
}
Mac类
public class Mac extends Computer {
@Override
public void powerOn() {
System.out.println("苹果电脑开机");
}
@Override
public void powerOff() {
System.out.println("苹果电脑关机");
}
@Override
public void use() {
System.out.println("使用苹果电脑");
}
}
HuaweiComputerFactory类
public class HuaweiComputerFactory {
public HuaweiComputer create() {
return new HuaweiComputer();
}
}
AppleComputerFactory类
public class AppleComputerFactory {
public Mac create(){
return new Mac();
}
}
测试类
public class Test {
public static void main(String args[]){
HuaweiComputer huaweiComputer=new HuaweiComputerFactory().create();
Mac mac=new AppleComputerFactory().create();
huaweiComputer.use();
mac.use();
}
}
结果
抽象工厂模式使用华为电脑
使用苹果电脑
抽象工厂模式和工厂方法模式用到的工厂抽象类不是一个概念,工厂方法模式的抽象工厂类是对某一类工厂的抽象或规范,而抽象工厂不是对某一工厂的抽象,它规范的是某一族应该具备创建某些产品的方法。比如上面提到的HuaweiPhoneFactory可以生产HuaweiPhone,IphoneFactory可以生产Iphone,但是实际上,Huawei和Apple公司不只生产手机,假设这两个公司作为两个不同的产品族,那么就可以使用抽象工厂模式了。抽象工厂模式适用于族类对象的工厂实现。也就是说,每次增加一个族都包含若干类,每增加一个族就增加一个族的抽象工厂的实现,从而避免了增加一个族需要新增多个工厂。
如本例,我们可以定义一个CompanyFactory接口(抽象工厂),该抽象工厂类具有创建phone和创建computer的方法(工厂方法模式需要为Huawei和Apple的phone和computer类分别创建四个工厂,当一个company有不只两个类对象需要创建时,则差距将更大),使用抽象工厂模式一个company只需要定义一个抽象工厂即可。
优点:每次增加一个族都包含若干类的创建,每增加一个族只需要增加一个族的抽象工厂的实现,而不需要为族内的每一个产品都单独设计一个工厂
缺点:当增加一个族的产品类型数量时,如Company除了生产手机和电脑还要生产平板电脑,则需要修改抽象工厂,而所有实现抽象工厂的工厂类都需要修改以实现对新产品的生产,可能会涉及大量的代码修改。
适用场景:成族产品的生产扩展。如Huwei生产电脑手机平板,Apple生产电脑手机平板,则电脑手机平板可看作族。使用抽象工厂模式添加新的一族只需要新建一个族的工厂,如新增小米一族,则只需要新建一个XiaoMiFactory,不需要为族内的电脑手机平板各自设计一个factory。但产品族的产品类型应该相对稳定,不会经常有产品的新增或修改(否则使用工厂方法模式)。
定义一个对computer和Phone抽象的device类(可不这么写,此处为了更好地使用多态,另外,不使用接口是因为作为实体可能需要添加属性)
public abstract class Device {
public abstract void powerOn();
public abstract void powerOff();
public abstract void use();
}
定义两个抽象产品类
public abstract class Computer extends Device{
public abstract void powerOn();
public abstract void powerOff();
public abstract void use();
}
public abstract class Phone extends Device {
public abstract void powerOn();
public abstract void powerOff();
public abstract void use();
}
继承电脑产品类实现HuaweiComputer和Mac
public class HuaweiComputer extends Computer {
@Override
public void powerOn() {
System.out.println("华为电脑开机");
}
@Override
public void powerOff() {
System.out.println("华为电脑关机");
}
@Override
public void use() {
System.out.println("使用华为电脑");
}
}
package com.weiqi.factory;
public class Mac extends Computer {
@Override
public void powerOn() {
System.out.println("苹果电脑开机");
}
@Override
public void powerOff() {
System.out.println("苹果电脑关机");
}
@Override
public void use() {
System.out.println("使用苹果电脑");
}
}
继承手机产品类实现HuaweiPhone和Iphone
public class HuaweiPhone extends Phone{
@Override
public void powerOn() {
System.out.println("华为手机开机");
}
@Override
public void powerOff() {
System.out.println("华为手机关机");
}
@Override
public void use() {
System.out.println("使用华为手机");
}
}
public class Iphone extends Phone{
@Override
public void powerOn() {
System.out.println("苹果手机开机");
}
@Override
public void powerOff() {
System.out.println("苹果手机关机");
}
@Override
public void use() {
System.out.println("使用苹果手机");
}
}
定义CompanyFactory接口作为抽象工厂
public interface CompanyFactory {
Computer ComputerProduct();
Phone PhoneProduct();
}
实现HuaweiFactory
public class HuaweiFactory implements CompanyFactory {
@Override
public Computer ComputerProduct() {
return new HuaweiComputer();
}
@Override
public Phone PhoneProduct() {
return new HuaweiPhone();
}
}
实现AppleFactory
public class AppleFactory implements CompanyFactory{
@Override
public Computer ComputerProduct() {
return new Mac();
}
@Override
public Phone PhoneProduct() {
return new Iphone() ;
}
}
由此,我们通过对抽象工厂的两个实现,便完成了对两族的四个对象的工厂实现,后续增加新的族类也只需要对抽象工厂进行实现即可。
测试
public class Test {
public static void main(String args[]){
HuaweiFactory huaweiFactory= new HuaweiFactory();
AppleFactory appleFactory= new AppleFactory();
Computer huaweiComputer = huaweiFactory.ComputerProduct();
Computer mac =appleFactory.ComputerProduct();
Phone huaweiPhone =huaweiFactory.PhoneProduct();
Phone iphone = appleFactory.PhoneProduct();
use(huaweiComputer);
use(mac);
use(huaweiPhone);
use(iphone);
}
public static void use(Device device){
device.powerOn();
device.use();
device.powerOff();
}
}
结果
华为电脑开机
使用华为电脑
华为电脑关机
苹果电脑开机
使用苹果电脑
苹果电脑关机
华为手机开机
使用华为手机
华为手机关机
苹果手机开机
使用苹果手机
苹果手机关机Process finished with exit code 0
也可以这么写
public class Test {
public static void main(String args[]){
CompanyFactory Factory= new HuaweiFactory();
// CompanyFactory Factory= new AppleFactory();
Computer computer = Factory.ComputerProduct();
Phone phone =Factory.PhoneProduct();
use(computer);
use(phone);
}
public static void use(Device device){
device.powerOn();
device.use();
device.powerOff();
}
}
运行结果
华为电脑开机
使用华为电脑
华为电脑关机
华为手机开机
使用华为手机
华为手机关机
如果需要改成使用苹果系列的产品只需要把CompanyFactory Factory那一行代码换成注释掉的那一行。
public class Test {
public static void main(String args[]){
// CompanyFactory Factory= new HuaweiFactory();
CompanyFactory Factory= new AppleFactory();
Computer computer = Factory.ComputerProduct();
Phone phone =Factory.PhoneProduct();
use(computer);
use(phone);
}
public static void use(Device device){
device.powerOn();
device.use();
device.powerOff();
}
}
运行结果
苹果电脑开机
使用苹果电脑
苹果电脑关机
苹果手机开机
使用苹果手机
苹果手机关机



