设计模式之工厂模式

设计模式之工厂模式

工厂模式

工厂模式是java开发种最常用的设计模式之一,在工程模式中我们创建对象时不会为客户端创建逻辑,并且是通过一个共同的接口来指向新创建的对象

工厂模式又分为 简单工厂和抽象工厂模式

简单工厂

简单工厂模式分为

1. 普通简单工厂
2. 多方法简单工厂
3. 静态方法简单工厂

普通简单工厂

就是建立一个工厂类对实现了统一的接口一些类进行实例的创建

步骤一 创建一个接口

public interface car{
 	void done();//生产汽车
}																													

步骤二:创建实现接口的实体类

public class Bccar implements car{

 @override
 public void done(){
  System.out.println("生产奔驰汽车");
 }
}

public class Bw implement car{
@override
public void done(){
 System.out.println("生产宝马汽车");
}
}

步骤三创建一个工厂

public class CarFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Car getCar(String CarType){
      if(shapeType == null){
         return null;
      }        
      if(CarType.equalsIgnoreCase("bw")){
         return new BW();
      } else if(shapeType.equalsIgnoreCase("Bc")){
         return new Bc();
      }
      return null;
   }
}

步骤四使用改工厂

public class FactoryTest{
	public static void main (String  [] args){
	
		Carfactory f =new Carfactroy();
		f.getCar("bw").done();// 输出结果 生产宝马汽车
		
	}

}

多方法简单工厂

对普通工厂方法模式的改进,如果传递的类型出错就不能正确的创建对象我们可以直接修改工厂类直接提供方法创建调用方法

public class CarFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Car getbw(){
      
      return new Bw();
   }
   public Car getBc(){
      
      return new Bc();
   }
}

静态方法简单工厂

工厂里面的方法是静态的不需要创建实例,直接调用即可

修改工厂方法

public class CarFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public static Car getbw(){
      
      return new Bw();
   }
   public static Car getBc(){
      
      return new Bc();
   }
}

抽象工厂模式

简单工厂模式就是遇到一个问题就是,类的创建依赖工厂类,也就是说如果扩展程序就需要对工厂类进行修改,这样就是破坏了开放封闭原则,抽象工厂模式我们可以创建一个工厂接口和创建多个 工厂实现类需要添加什么工厂就实现什么接口

接下来我们重构上面代码,添加获取汽车价格接口

步骤一 :创建获取价格接口 ,创建获取车辆类型接口

//创建获取车辆接口
public inerface Car{
	void getcar();
}
//创建获取车辆价格
public inerface CarPrice{
	void getCarPrice();
}

步骤二: 实现接口车辆 ,实现价格接口

//宝马车接口
public BwCar implements Car{
	@override
	public void getCar(){
		 System.out.println("奔驰")
	}
}
//奔驰车接口
public Bc implements Car{
	@override
	public void getCar(){
		 System.out.println("宝马")
	}
}

//宝马车价格接口
public Bwprice implements CarPrice(){
	@override
	public void getCarPrice(){
	System.out.println("50万")
	}
}

//奔驰车价格接口
public Bcprice implements CarPrice(){
	@override
	public void getCarPrice(){
	System.out.println("30万")
	}
}

步骤三:创建抽象工厂来获取工厂

public abstract class AbstractFactory{
  //获取车辆接口 
  Car getCar(String carType);
  //获取车辆价格
  CarPrice getCarPrice(String carType);

}

步骤四实现抽象工厂

//车辆工厂
public class CarFactory extends AbstractFactory {
    
   @Override
   public Car getCar(String carType){
      if(carType == null){
         return null;
      }        
      if(carType.equalsIgnoreCase("Bw")){
         return new Bw();
      } else if(carType.equalsIgnoreCase("Bc")){
         return new BC();
      } 
      return null;
   }
   
   @Override
   public CarPrice getCarPrice(String carType) {
      return null;
   }
}
//价格工厂
public class CarPriceFactory extends AbstractFactory {
    
   @Override
   public Car getCarPrice(String carType){
      if(carType == null){
         return null;
      }        
      if(carType.equalsIgnoreCase("Bw")){
         return new Bwprice();
      } else if(carType.equalsIgnoreCase("Bc")){
         return new BCPrice();
      } 
      return null;
   }
   
   @Override
   public CarPrice getCar(String carType) {
      return null;
   }
}

//步骤五 通过工厂构造器生成工厂

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("car")){
         return new CarFactory();
      } else if(choice.equalsIgnoreCase("price")){
         return new CarPriceFactory();
      }
      return null;
   }
}

//步骤六通过factoryProducer 获取工厂

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取价格工厂
      AbstractFactory PriceFactory = FactoryProducer.getFactory("price");
 	  PriceFactory.getCarPrice("Bw").getcarPrice()//输出10万
 	  AbstractFactory carFactory = FactoryProducer.getFactory("car");
 	  carFactory.getcar("Bc").getcar()//输出奔驰
 	  
   }
}