了解设计模式：23工厂模式和抽象工厂模式

1.工厂模式实现了创建者和调用者的分离。

详细分类：简单工厂模式（静态工厂模式），工厂方法模式，抽象工厂模式

2.简单工厂实现

public interface Car {
	void run();
}


public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪在跑！");
	}

}


public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("比亚迪在跑！");
	}

}

//简单工厂类
public class CarFactory {
	
	public static  Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if("比亚迪".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
	
}

//简单工厂例2
public class CarFactory2 {
	
	public static  Car createAudi(){
		return new Audi();
	}
	public static  Car createByd(){
		return new Byd();
	}
	
}


//不使用简单工厂
public class Client01 {   //调用者
	
	public static void main(String[] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		
		c1.run();
		c2.run();
		
	}
}


//使用简单工厂
public class Client02 {   //调用者
	
	public static void main(String[] args) {
		Car c1 =CarFactory.createCar("奥迪");
		Car c2 = CarFactory.createCar("比亚迪");
		
		c1.run();
		c2.run();
		
	}
}

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。对于新增产品无能为力！不修改代码，无法扩展。

3.工厂模式实现

public interface Car {
	void run();
}


public interface CarFactory {
	Car createCar();
}


public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪在跑！");
	}

}


public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Audi();
	}

}


public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("比亚迪在跑！");
	}

}


public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Byd();
	}

}

//扩展增加奔驰，只需这样添加
public class Benz implements Car {

	@Override
	public void run() {
		System.out.println("奔驰在跑！");
	}

}


public class BenzFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Benz();
	}

}

工厂模式比简单工厂模式更复杂，但根据设计理论建议：工厂方法模式。实际上一般都用简单工厂模式。

4.抽象工厂模式实现

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}

//低级产品族
public class LowCarFactory implements CarFactory {

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

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}


}

//高级产品族
public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}


}


public interface Engine {
	void run();
	void start();
}


class LuxuryEngine implements Engine{

	@Override
	public void run() {
		System.out.println("转的快！");
	}

	@Override
	public void start() {
		System.out.println("启动快!可以自动启停！");
	}
	
}

class LowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("转的慢！");
	}
	
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
	
}


public interface Seat {
	void massage();
}

class LuxurySeat implements Seat {

	@Override
	public void massage() {
		System.out.println("可以自动按摩！");
	}
	
}
class LowSeat implements Seat {

	@Override
	public void massage() {
		System.out.println("不能按摩！");
	}
	
}


public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转不磨损！");
	}
	
}

class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转磨损快！");
	}
	
}


//测试
public static void main(String[] args) {
	CarFactory  factory = new LuxuryCarFactory();
	Engine e = factory.createEngine();
	e.run();
	e.start();
		
}

抽象工厂模式用来生产不同产品族的全部产品。对于增加新的产品无能为力，支持增加产品族。

5.总结：

1）工厂模式要点：

-简单工厂模式：虽然某种程度不符合设计原则，但实际使用最多。

-工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。

-抽象工厂模式：不可以增加产品，可以增加产品族。

2）应用场景：

-JDK中Calendar的getInstance方法

-JDBC中Connection对象的获取

-Hibernate中SessionFactory创建Session

-Spring中IOC容器创建管理bean对象

-XML解析时的DocumentBuilderFactory常见解析器对象