【设计模式】简单工厂模式、工厂方法模式、抽象工厂模式

1 简介

• 简单工厂模式：根据传入的参数返回需要创建的对象，而不需要知道具体类的类名。（不属于GoF设计模式）
• 工厂方法模式：引入抽象工厂类，将具体产品的创建过程封装在其子类中，即具体工厂类中。增加新的具体产品类时，只需增加一个相应的具体工厂类。（1个具体工厂只需生产1种具体产品）
• 抽象工厂模式：相较于工厂方法模式，抽象工厂模式中的具体工厂可以生产相关的一组具体产品，这样的一组产品称之为产品族，产品族中的每一个产品都分属于某一个产品继承等级结构

2 简单工厂模式

        产品（Product） 

public interface Product {
	public void show();
}

public class ProductA implements Product{
	@Override
	public void show() {
		System.out.println("I am A");
	}
}

public class ProductB implements Product{	
	@Override
	public void show() {
		System.out.println("I am B");
	}
}

        工厂（Factory） 

public class Factory {
	public static Product produce(String type) {
		if(type.equals("A")) {
			return new ProductA();
		}else if(type.equals("B")) {
			return new ProductB();
		}else {
			return null;
		}
	}
}

        客户端（Client）

public class Client {
	public static void main(String[] args) {
		Product product1=Factory.produce("A");
		Product product2=Factory.produce("B");
		product1.show();
		product2.show();
	}
}

3 工厂方法模式

        产品（Product）

public interface Product {
	public void show();
}

public class ProductA implements Product{
	@Override
	public void show() {
		System.out.println("I am A");
	}
}

public class ProductB implements Product{	
	@Override
	public void show() {
		System.out.println("I am B");
	}
}

        工厂（Factory）

public interface Factory {	
	public Product produce();
}

public class Factory1 implements Factory {
	@Override
	public Product produce() {
		return new ProductA();
	}
}

public class Factory2 implements Factory {
	@Override
	public Product produce() {
		return new ProductB();
	}
}

        客户端（Client）

public class Client {
	public static void main(String[] args) {
		Factory factoryA=new Factory1();
		Product product1=factoryA.produce();
		product1.show();
		
		Factory factoryB=new Factory2();
		Product product2=factoryB.produce();
		product2.show();
	}
}

4 抽象工厂模式

        产品族A（ProductA）

public interface ProductA {
	public void showA();
}

public class ProductA1 implements ProductA{
	@Override
	public void showA() {
		System.out.println("I am A1");
	}
}

public class ProductA2 implements ProductA{
	@Override
	public void showA() {
		System.out.println("I am A2");
	}
}

        产品族B（ProductB） 

public interface ProductB {
	public void showB();
}

public class ProductB1 implements ProductB{	
	@Override
	public void showB() {
		System.out.println("I am B1");
	}
}

public class ProductB2 implements ProductB{	
	@Override
	public void showB() {
		System.out.println("I am B2");
	}
}

        工厂（Factory）

public interface Factory {
	public abstract ProductA produceA();
	public abstract ProductB produceB();
}

public class Factory1 implements Factory {
	@Override
	public ProductA produceA() {
		return new ProductA1();
	}
	@Override
	public ProductB produceB() {
		return new ProductB1();
	}
}

public class Factory2 implements Factory {
	@Override
	public ProductA produceA() {
		return new ProductA2();
	}
	@Override
	public ProductB produceB() {
		return new ProductB2();
	}
}

        客户端（Client）

public class Client {
	public static void main(String[] args) {
		Factory factory1=new Factory1();
		ProductA productA1=factory1.produceA();
		ProductB productB1=factory1.produceB();
		productA1.showA();
		productB1.showB();
		
		Factory factory2=new Factory2();
		ProductA productA2=factory2.produceA();
		ProductB productB2=factory2.produceB();
		productA2.showA();
		productB2.showB();
	}
}