设计模式:工厂方法模式与抽象工厂模式

一、工厂方法模式

工厂方法模式定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类

1、工厂方法的主要角色

在这里插入图片描述

  • 抽象产品(Product):定义具体产品的公共接口
  • 具体产品(ConcreteProduct):继承抽象产品类并定义生产的具体产品
  • 抽象工厂(Creator):定义具体工厂的公共接口
  • 具体工厂(ConcreteCreator):继承抽象工厂类并定义创建对应具体产品实例的方法

2、实现工厂方法

//抽象产品类
public abstract class Product {
    //产品类的公共方法
    public void method() {
        //业务逻辑处理
    }

    //抽象方法
    public abstract void method2();
}
//具体产品类
public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        //业务逻辑
    }
}
//具体产品类
public class ConcreteProduct2 extends Product {
    @Override
    public void method2() {
        //业务逻辑
    }
}
//抽象工厂类
public abstract class Creator {
    public abstract <T extends Product> T createProduct(Class<T> c);
}
//具体工厂类
public class ConcreteCreator extends Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
            e.printStackTrace();
        }
        return (T) product;
    }
}
public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        //业务逻辑
    }
}

3、缩小为简单工厂模式

//抽象产品类
public abstract class BMW {
    public BMW() {
    }
}
//具体产品类
public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造BMW320...");
    }
}
//具体产品类
public class BMW523 extends BMW {
    public BMW523() {
        System.out.println("制造BMW523...");
    }
}
//工厂类
public class Creator {
    public static <T extends BMW> T createBMW(Class<T> c) {
        BMW bmw = null;
        try {
            bmw = (BMW) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
            e.printStackTrace();
        }
        return (T) bmw;
    }
}
public class Client {
    public static void main(String[] args) {
        BMW bmw320 = Creator.createBMW(BMW320.class);
        BMW bmw523 = Creator.createBMW(BMW523.class);
    }
}

执行结果如下:

制造BMW320...
制造BMW523...

简单工厂模式也称为静态工厂模式,缺点是工厂类的扩展比较困难,但是仍然非常实用

主要角色如下:

  • 工厂类角色:用来创建产品
  • 抽象产品角色:定义具体产品的公共接口
  • 具体产品角色:继承抽象产品类并定义生产的具体产品

二、抽象工厂模式

抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类。抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象工厂模式来产生需要的对象

两个产品族的类图如下:

在这里插入图片描述

public abstract class AbstractProductA {
    //每个产品共有的方法
    public void shareMethod() {

    }

    //每个产品相同方法,不同实现
    public abstract void doSomething();
}
public class ProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}
public class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}

产品B与此类似

//抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能
public abstract class AbstractCreator {
    //创建A产品家族
    public abstract AbstractProductA createProductA();
    
    //创建B产品家族
    public abstract AbstractProductB createProductB();
}
//产品等级1的实现类
public class Creator1 extends AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}
//产品等级2的实现类
public class Creator2 extends AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

有M个产品等级就应该有M个实现工厂类,在每个实现工厂中,实现不同产品族的生产任务

public class Client {
    public static void main(String[] args) {
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        AbstractProductA a1 = creator1.createProductA();
        a1.doSomething();
        AbstractProductA a2 = creator2.createProductA();
        a2.doSomething();
        AbstractProductB b1 = creator1.createProductB();
        b1.doSomething();
        AbstractProductB b2 = creator2.createProductB();
        b2.doSomething();
    }
}

抽象工厂模式的缺点就是产品族扩展相对困难

三、工厂方法和抽象工厂的区别

工厂方法模式

一个抽象产品类,可以派生出多个具体产品类

一个抽象工厂类,可以派生出多个具体工厂类

每个具体工厂类只能创建一个具体产品类的实例

抽象工厂模式

多个抽象产品类,每个抽象产品类可以派生出多个具体产品类

一个抽象工厂类,可以派生出多个具体工厂类

每个具体工厂类可以创建多个具体产品类的实例

区别

工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个

工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个

  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

邋遢的流浪剑客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值