JAVA设计模式--简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式(实际开发用的是这个)、工厂方法模式

工厂方法模式与简单工厂模式区别：
结构上：
简单工厂简洁，工厂方法模式结构不简洁
复杂度：
简单工厂比较复杂，工厂方法是比较简洁
简单工厂模式

Car.java–定义汽车的接口

public interface Car {
	void run();//定义车的接口方法
}

factory .java–定义生产汽车工厂方法

public class factory {
	public static Car getCar(String type){
		if(type.equals("奔驰")){//对于是"奔驰"则返回Ben()方法
			return  new Ben();
		}else if(type.equals("法拉利")){
			return new FaLaL();
		}else{
			return null;
		}
	}
	//此处代码复用性差,假如增加新的车型,就需要继续return新车型,
	public static Car getBen() {
		return new Ben();
	}
	public static Car getFaLaL() {
		return new FaLaL();
	}
}

Ben.java–自定义Ben类实现Car接口

public class Ben implements Car{

	public void run() {
		System.out.println("奔驰车里面坐了两个大胸美女。。。。");
	}

}

FaLaL.java–自定义FaLaL类实现Car接口

public class FaLaL implements Car{//实现Car的接口方法
	public void run() {
		System.out.println("小烁烁开着--法拉利");
	}
}

Test.java//测试类

public class Test {
	public static void main(String[] args) {
		//多态调用
		//这样子调用没有实现创建者和调用者分离，意味着我需要宝马车还要自己去生产
//		Car c1 = new Ben();
//		c1.run();
//		Car c2 = new FaLaL();
//		c2.run();
//调用方法1:		
		Car c1 = factory.getBen();
		c1.run();
		Car c2 = factory.getFaLaL();
		c2.run();
		System.out.println("-----------------");
//调用方法2:		
		//对于想要的汽车,直接让工厂去做
		Car c = factory.getCar("奔驰");
		c.run();
		Car c4 = factory.getCar("法拉利");
		c4.run();
	}
}

**

工厂方法模式

–当新增一类型汽车，就添加这个汽车类和汽车工厂类

**
对于factory .java出现的
问题（当新增一款车型,就需要增加新的代码）
//以下注释这样写的话，代码可复用性差,对于新增一种类型的汽车，就需要添加新增车型的代码
// public static Car getBen() {
// return new Ben();
// }
// public static Car getFaLaL() {
// return new FaLaL();
// }
}应该怎么样去解决他呢？
答：我们可以让每个车型对应于一个特有的生产工厂，而不是全部车型出自一个生产工厂。

1.我们先创建一个汽车接口
Car.java

 public interface Car {
    	void run();//汽车共有的抽象方法run()
    }

2.创建一个汽车生产工厂接口
CarFactory .java

public interface CarFactory {
	Car CreateNewCar();//汽车工厂生产汽车的抽象方法
}

3.1 Ben类去实现Car接口

public class Ben implements Car{

	@Override
	public void run() {//重写汽车的抽象方法
		System.out.println("奔驰车里面坐了两个大胸美女。。。。");	
	}
}

3.2 Ben类对应的Ben工厂类去实现汽车工厂类

public class Benfactory implements CarFactory{

	@Override
	public Car CreateNewCar() {//重写抽象方法
		return new Ben();//返回生产奔驰汽车的实例对象
	}	
}

4.1 Msld类实现Car接口

public class Msld implements Car{

	@Override
	public void run() {//重写抽象方法
		System.out.println("车里面全部都是妹子,除了司机小烁烁");
		
	}	
}

4.2Msld类对应的Msld工厂类去实现汽车工厂类

public class MsldFactory implements CarFactory{

	@Override
	public Car CreateNewCar() {
		return new Msld();//返回生产Msld的实例对象
	}	
}

5.测试类

public class Test {
	public static void main(String[] args) {
		Car c =new Benfactory().CreateNewCar();//当要购买奔驰车时候
		c.run();//c.run
		Car c0 = new MsldFactory().CreateNewCar();//当要购买玛莎拉蒂车时候
		c0.run();
	}
}

**

抽象工厂模式

1.汽车拥有椅子(Chair)、发动机(Engine)、燃油(Fuel)、方向盘(Steering),将这些定义为接口,并给抽象方法
2.将汽车都拥有的物品进行等级划分,高级(High)、中级(Middle)、低级(Low)
3.创建一个CarFactory接口，在里面定义生产各种零件的方法
4. 创建一个HighCarFactory生产对应全部High的汽车配件,
创建一个MiddleCarFactory生产对应全部Middle的汽车配件,
创建一个LowCarFactory生产对应全部Low的汽车配件,
同时HighCarFactory、MiddleCarFactory、LowCarFactory去实现对应的CarFactory接口方法
5.每个等级的物件都对应–>等级生产工厂,例如:椅子(Chair)拥有–>HighChair、MiddleChair、LowChair三个等级
6.用户可以自定义需要的产品

1.CarFactory.java–在汽车工厂里自定义椅子、燃油、发动机、方向盘的抽象组装方法

public interface CarFactory {
	//在汽车工厂里自定义椅子、燃油、发动机、方向盘的抽象组装方法
	Chair creatChair();
	Fuel  creatFuel();
	Engine creatEngine();
	Steering creatSteering();
}

1.1HighCarFactory.java–在这个HighCarFactory实现了CarFactory接口的方法，并且return实例High物品的实例对象

public class HighCarFactory implements CarFactory{
//在这个HighCarFactory实现了CarFactory接口的方法，并且return实例High物品的实例对象
	@Override
	public Chair creatChair() {	
		return new HighChair();
	}

	@Override
	public Fuel creatFuel() {		
		return new HighFuel();
	}

	@Override
	public Engine creatEngine() {		
		return new HighEngine();
	}

	@Override
	public Steering creatSteering() {
		return new HighSteering();
	}
	
}

1.2MiddleCarFactory.java–在这个MiddleCarFactory实现了CarFactory接口的方法，并且return实例Middle物品的实例对象

public class MiddleCarFactory implements CarFactory{
//在这个MiddleCarFactory实现了CarFactory接口的方法，并且return实例Middle物品的实例对象
	@Override
	public Chair creatChair() {
		return new MiddleChair();
	}

	@Override
	public Fuel creatFuel() {
		return new MiddleFuel();
	}

	@Override
	public Engine creatEngine() {
		return new MiddleEngine();
	}

	@Override
	public Steering creatSteering() {
		return new MiddleSteering();
	}
}

1.3LowCarFactory.java—在这个LowCarFactory实现了CarFactory接口的方法，并且return实例Low物品的实例对象```

public class LowCarFactory implements CarFactory{
//在这个LowCarFactory实现了CarFactory接口的方法，并且return实例Low物品的实例对象
	@Override
	public Chair creatChair() {
		return new LowChair();
	}

	@Override
	public Fuel creatFuel() {
		return new LowFuel();
	}

	@Override
	public Engine creatEngine() {
		return new LowEngine();
	}

	@Override
	public Steering creatSteering() {
		return new LowSteering();
	}

}

2.Chair.java–定义椅子的接口方法

//椅子
public interface Chair {
	void function();//自定义椅子功能
}

2.1HighChair.java

//高级椅子实现椅子接口方法
public class HighChair implements Chair{
	
	@Override
	public void function() {
		System.out.println("我是高级椅子,我能将人弹射出去！");		
	}
}

2.2.MiddleChair.java

//中级椅子实现椅子接口方法
public class MiddleChair implements Chair{
	
	@Override
	public void function() {
		System.out.println("我是中级椅子,我能够自动加热！");
		
	}
}

2.3.LowChair.java

//低级椅子实现椅子抽象方法
public class LowChair implements Chair{

	@Override
	public void function() {
		System.out.println("我是低级椅子,我带着刺！");
	}

}

3.Fuel.java–定义燃油接口方法

//燃油
public interface Fuel {
	void  type();//自定义燃油类型
}

3.1HighFuel.java

//高级燃油实现燃油接口方法
public class HighFuel implements Fuel{

	@Override
	public void type() {
		System.out.println("我是高级燃油,我只喝95号汽油！");
	}
}

3.2MiddleFuel.java

//中级燃油实现燃油接口方法
public class MiddleFuel implements Fuel{

	@Override
	public void type() {
		System.out.println("我是中级燃油,我只喝汽油--拒绝柴油！");	
	}
}

3.3.LowFuel.java

//低级燃油实现燃油接口方法
public class LowFuel implements Fuel{
	@Override
	public void type() {
		System.out.println("我是低级燃油,地沟油我都喝！");
	}
}

4.Engine.java–定义发动机接口方法

//发动机
public interface Engine {
	void power();//自定义发动机动力
}

4.1.HighEngine.java

//高级发动机实现发动机接口方法
public class HighEngine implements Engine{

	@Override
	public void power() {
		System.out.println("我是高级发动机,用我能比高铁还快！");	
	}
}

4.2. MiddleEngine.java

//中级发动机实现发动机接口方法
public class MiddleEngine implements Engine{

	@Override
	public void power() {
		System.out.println("我是中级发动机,我用在雷克萨斯身上！");
		
	}

}

4.3.LowEngine.java

//低级发动机实现发动机接口方法
public class LowEngine implements Engine {

	@Override
	public void power() {
		System.out.println("我是低级发动机,我用在五菱宏光身上！");
		
	}
	
}

`
5.Steering.java–定义方向盘接口方法

//方向盘
public interface Steering {
	void comfort();//自定义方向盘舒适度
}

5.1.HighSteering.java

//高级方向盘实现方向盘接口方法
public class HighSteering implements Steering{
	@Override
	public void comfort() {
		System.out.println("我是高级方向盘,我自带加热/制冷功能！");
		
	}
}

5.2.MiddleSteering.java

//中级方向盘实现方向盘接口方法
public class MiddleSteering implements Steering{

	@Override
	public void comfort() {
		System.out.println("我是中级方向盘,我还算比较舒服！");
	}
}

5.3LowSteering.java

//低级方向盘实现方向盘接口方法
public class LowSteering implements Steering{

	@Override
	public void comfort() {
		System.out.println("我是低级方向盘,我有点扎手！");
		
	}
	
}

6.Test.java–顾客选定制的产品

public class Test {
	public static void main(String[] args) {
		/*在这个Test类里，顾客可以根据自己的需求对Chair、Engine、Fuel、Steering四种物品
		的高端、中端、低端的选择
		*/
		//可以根据价位去组装对应的零件
		Chair c = new HighCarFactory().creatChair();
		c.function();
		Engine e = new HighCarFactory().creatEngine();
		e.power();
		Fuel f = new MiddleCarFactory().creatFuel();
		f.type();
		Steering s = new LowCarFactory().creatSteering();
		s.comfort();	
	}
}