java设计模式—— 工厂模式

菜鸡互啄。。。

工厂模式通过定义一个创建对象的接口，让其子类决定实例化哪个工厂类。因此我们要解决接口选择的问题，实现不同的计划创建不同的对象。

首先我们定义一个轿车接口

public interface Car(){
    void  bulidCar();
}

然后我们建立三种不同的轿车类，实现这个接口

public class Benz implements Car {
    @Override
    public void buildCar() {
        System.out.println("奔驰");
    }
}

public class Bmw implements Car {

    @Override
    public void buildCar() {
        System.out.println("宝马");
    }
}

　　

public class Jeep  implements Car{
    @Override
    public void buildCar() {
        System.out.println("Jeep指南者");
    }
}

创建好三种轿车，我们需要一个汽车工厂，来根据我们的需求生产汽车

public class CarFactory {
   // 返回一个轿车，根据传入的轿车名字，我们生产轿车
    public Car getCar(String carName) {
        if (carName == null) {
            return null;
        }
        if (carName.equals("Jeep")) {
            return new Jeep();
        }
        if (carName.equals("Bmw")) {
            return new Bmw();
        }
        if (carName.equals("Benz")) {
            return new Benz();
        }
        return null;
    }

}

现在我们验证下，在main函数中使用我们使用这个工厂

  public static void main(String[] args) {
        
        CarFactory carFactory = new CarFactory();
       //获取轿车，并调用他的创建方法
        carFactory.getCar("Jeep").buildCar();
        
    }

　结果输出

Jeep指南者

工厂类选择汽车的时候，我们可以修改一下。我们可以使用反射机制来解决每增加一种轿车就需要一个建造工厂的缺点

 public Object getCar(Class<?extends Car> className){
        Object obj=null;
        try {
            obj=Class.forName(className.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    }

当我们调用的时候，需要类型强制转换

  Benz benz=(Benz)carFactory.getCar(Benz.class);
  benz.buildCar();


输出结果：奔驰

　　通过这种方式，我们只需要创建一个工厂就可以了。

工厂模式的优点：1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

工厂模式缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。