Java设计模式:工厂模式

2020.08.01 05:08:19
5
阅读约3分钟

简单工厂模式🎪 #

简单工厂模式(simple factory pattern)是指由一个工厂对向决定创建哪一种产品类的实例,但它不属于GoF的23种设计模式。简单工厂模式适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对如何创建对象并不关心。

我们可以定义一个标准的交通工具类。

abstract  class Vehicle{
   abstract void travel();
}

作为交通工具,我们可以创建一个卡车、小汽车以及自行车的子类,像这样

class Bike extends Vehicle{
    @Override
    void travel() {
        System.out.println("自行车在开");
    }
}

class Car extends Vehicle{
    @Override
    void travel() {
        System.out.println("汽车在开");
    }
}

class Truck extends Vehicle{

    @Override
    void travel() {
        System.out.println("卡车在开");
    }
}

接下来我们要创建一个工厂

public class VehicleFactory {
// 类型
    public enum VehicheType{
        Bike,Car,Truck
    }
    public static Vehicle create (VehicheType type){
        if(type.equals(VehicheType.Bike)){
            System.out.println("创建了自行车");
//            return new Bike();
        }
        if(type.equals(VehicheType.Car)){

            return new Car();
        }
        if(type.equals(VehicheType.Truck)){
            return new Truck();
        }
        return null;
    }

}

现在当我们想要拿到一个交通工具类的实例时候,就可以用下面这种方式

class main{
    public static void main(String[] args) {
        VehicleFactory.create(VehicleFactory.VehicheType.Bike);
    }
     vehicle.travel();
}

运行之后,控制台打印 img

但是如果我们想要添加新的交通工具,还是需要修改工厂的代码,这不符合开闭原则。所以我们还可以继续优化,使用反射来进行类的注册。

反射工厂函数 #

让我们修改一下我们的工厂函数,通过类名来实例化我们的对象。

class VehicleFactory {
   public Vehicle create(Class<? extends Vehicle> clazz){
        try {
            if(null!=clazz){
                return  clazz.newInstance();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

在主函数中调用

 VehicleFactory vehicleFactory = new VehicleFactory();
        Vehicle vehicle = vehicleFactory.create(Bike.class);
        vehicle.travel();

img 继承关系 img

工厂方法模式 #

是指定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法模式让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂,无需关心创建细节,而且加入新的产品时符合开闭原则。 工厂方法模式主要是对工厂本身进行了抽象。

创建交通工具类 #

abstract  class Vehicle{
   abstract void travel();
}

class SmallTruck extends Vehicle {
    @Override
    void travel() {
        System.out.println("SmallTruck在开");
    }
}


class LargeTruck extends Vehicle {
    @Override
    void travel() {
        System.out.println("LargeTruck在开");
    }
}

class SportCar extends Vehicle {
    @Override
    void travel() {
        System.out.println("SportCar在开");
    }
}

class SedanCar extends Vehicle {
    @Override
    void travel() {
        System.out.println("SedanCar在开");
    }
}

创建抽象工厂 #

只有一个创建实体工厂的抽象方法

public  abstract class VehicleFactory {
    protected  abstract Vehicle create(String size);
}

定义实体工厂 #

更具size来创建不同的交通工具类型

// 汽车实体工厂
class CarFactory extends VehicleFactory {
    @Override
    protected Vehicle create(String size) {
          if(size.equals("small")){
            return new SportCar();
        }else if(size.equals("large"))
            return new SedanCar();
        return null;
    }
}

//卡车实体工厂
class TruckFactory extends VehicleFactory {
    @Override
    protected Vehicle create(String size) {
       if(size.equals("small")) return new SmallTruck();
        else if(size.equals("large")) return new LargeTruck();
        return  null;
    }
}

主函数调用 #

   CarFactory carFactory = new CarFactory();
        Vehicle vehicle = carFactory.create("small");
        vehicle.travel();

img

接口方式的抽象工厂模式 #

vihicle接口如下

   interface Vehicle{
        public void travel();
    }

创建一个抽象的工厂类

    interface VehicleFactory{
        Vehicle createVehicle();
    }

创建一个卡车类

   public class Truck implements  Vehicle{
        @Override
        public void travel() {
            System.out.println("卡车在开车");
        }
    }

创建一个卡车的具体工厂

  class TruckFactory implements VehicleFactory{
    @Override
    public Vehicle createVehicle() {
        return new Truck();
    }
}

主函数调用

 TruckFactory truckFactory = new TruckFactory();
        Vehicle vehicle = truckFactory.createVehicle();
        vehicle.travel();

img 抽象工厂的缺点:如果我们要进行扩展,那我们我们的代码从抽象工厂到具体工厂都要调整,很显然不符合开闭原则。

  1. 规定了所有可能被创建的产品集,产品族中扩展新的产品困难,需要修改抽象工厂的接口。
  2. 增加了系统的抽象性和理解难度。
阅读:5 . 字数:737 发布于 13 天前
本作品系 原创 , 采用 《署名-非商业性使用-禁止演绎 4.0 国际》许可协议
推荐阅读
资源
  • 创意设计
  • 书栈网
  • 帮助中心
  • 声望与权限
  • 服务中心
  • 合作
  • 关于我
  • 广告投放
  • 职位发布
  • 联系我们
  • 关注
  • 技术日志
  • 运营日志
  • ❤ 609 天
  • 条款
  • 服务条款
  • 隐私政策
  • 下载 App
  • Copyright © 2018-2020 Siques