设计模式—工厂模式博客学习小结

学习博客：

https://blog.csdn.net/zxt0601/article/details/52798423

https://blog.csdn.net/jason0539/article/details/23020989

小结：

1）简单（静态）工厂模式：

有一个抽象类（代表一个系列的产品），不同的产品继承这个抽象类（例如博客中定义了BMW的抽象类，不同类型的产品BMW320，BMW523继承这个抽象类）

一个工厂生成不同的商品(比如博客中的，一个工厂既生产BMW320又生产523,通过switch语句选择生产不同的产品)

简单工厂的缺点：每增加一个新的产品，都要对工厂类进行修改。

无抽象工厂，通过swtich()语句，选择生产不同的产品。

代码示例：

abstract class BMW{
	public BMW(){
		
	}
}

class BMW320 extends BMW{
	public BMW320(){
		System.out.println("制造--320");
	}
}

class BMW520 extends BMW{
	public BMW520(){
		System.out.println("制造--520");
	}
}

class Factory{
	public BMW createBMW(int type){
		switch(type){
		case 320:
			return new BMW320();
		case 520:
			return new BMW520();
		default:
			break;
		}
		return null;
	}
}

class FactoryBlog{
	public static void main(String[] args) {
		Factory factory = new Factory();
		factory.createBMW(320);
		factory.createBMW(520);
	}
}

另一种形式：

abstract class BMW {
	public BMW() {

	}
}

class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造--320");
	}
}

class BMW520 extends BMW {
	public BMW520() {
		System.out.println("制造--520");
	}
}


class Factory{
	public static BMW createBMW320(){
		return new BMW320();
	}
	
	public static BMW createBMW520(){
		return new BMW520();
	}
}

class FactoryBlog{
	public static void main(String[] args) {
		//生产BWM320
		Factory.createBMW320();
		//生产BMW520
		Factory.createBMW520();
	}
}

工厂模式：

有一个抽象工厂，定义了一类产品的生产函数，多个生成不同产品的工厂继承抽象工厂，不同的产品交给不同的工厂生产。

但每个工厂生成一种类型的产品。（例如每个不同的工厂只生产一种面条）

相比与简单工厂，抽象工厂类中有生产生成的方法，每增加新的产品，增加生产这个新产品的工厂。

工厂方法的好处：每增加一个新的产品，不需要去改工厂类，而只需要增加响应的继承工厂类。

工厂方法的缺点：当产品种类很多的时候，会出现大量的与之对应的工厂对象，这不是我们希望的。

代码示例：

abstract class BMW{
	public BMW(){
		
	}
}

class BMW320 extends BMW{
	public BMW320(){
		System.out.println("制造--320");
	}
}

class BMW520 extends BMW{
	public BMW520(){
		System.out.println("制造--520");
	}
}


interface FactoryBMW{
	BMW createBMW();
}

class FactoryBMW320 implements FactoryBMW{
	public BMW createBMW(){
		return new BMW320();
	}
}

class FactoryBMW520 implements FactoryBMW{
	public BMW createBMW(){
		return new BMW520();
	}
}

class FactoryBlog{
	public static void main(String[] args) {
		FactoryBMW320 factory320 = new FactoryBMW320();
		factory320.createBMW();
		
		FactoryBMW520 factory520 = new FactoryBMW520();
		factory520.createBMW();
	}
}

抽象工厂模式：

定义了两个不同类型商品的抽象类（例如汽车抽象类和儿童安全座椅抽象类），继承这两个抽象类可以得到不同的类型产品（上面的两种模式得到的是同种系列的产品）

一个抽象工厂，与上面不同的是，这个抽象工厂里面生产不同类型的产品（例如汽车加儿童座椅）。抽象工厂类中有生产两种商品方法，不同的具体工厂搭配生产两种不同类型的商品。

代码示例：

abstract class BMW {
	public BMW() {

	}
}

class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造--320");
	}
}

class BMW520 extends BMW {
	public BMW520() {
		System.out.println("制造--520");
	}
}

abstract class SafeChair{
	public SafeChair(){
		
	}
}

class ChairA extends SafeChair{
	ChairA(){
		System.out.println("生成款式A的儿童椅");
	}
}

class ChairB extends SafeChair{
	ChairB(){
		System.out.println("生产款式B的儿童椅");
	}
}


abstract class Factory{
	abstract public BMW createBMW();
	abstract public SafeChair createChair();
}

class Factory_NanTong extends Factory{

	@Override
	public BMW createBMW() {
		return new BMW320();
	}

	@Override
	public SafeChair createChair() {
		return new ChairA();
	}
	
}

class Factory_ShenYang extends Factory{

	@Override
	public BMW createBMW() {
		return new BMW520();
	}

	@Override
	public SafeChair createChair() {
		return new ChairB();
	}
	
}

class FactoryBlog{
	public static void main(String[] args) {
		Factory factory1 = new Factory_NanTong();
		factory1.createBMW();
		factory1.createChair();
		
		Factory factory2 = new Factory_ShenYang();
		factory2.createBMW();
		factory2.createChair();
	}
}