java之工厂模式

简单工厂模式

产品类接口

public interface Product {

	public String getName();
}

具体产品类A

public class ProductA implements Product {

	public String getName(){
		return "productA";
	}
}

具体产品类B

public class ProductB implements Product {

	public String getName(){
		return "productB";
	}
}

简单工厂类

public class SimpleFactory {
	public static Product getProduct(String name){
		if("productA".equals(name)){
			return new ProductA();
		}else if("productB".equals(name)){
			return new ProductB();
		}
		return null;
	}
	
	public static void main(String[] args) {
		Product productA = SimpleFactory.getProduct("productA");
		Product productB = SimpleFactory.getProduct("productB");
		System.out.println(productA.getName());
		System.out.println(productB.getName());
	}
}

工厂方法模式

工厂方法接口

public interface FactoryMethod {
	public Product getProduct();
}

具体工厂方法实现类A

public class FactoryMethodA implements FactoryMethod {

	@Override
	public Product getProduct() {
		return new ProductA();
	}

}

具体工厂方法实现类B

public class FactoryMethodB implements FactoryMethod {

	@Override
	public Product getProduct() {
		return new ProductB();
	}

}

public class FactoryMethodTest {

	public static void main(String[] args) {
		Product productA = new FactoryMethodA().getProduct();
		Product productB = new FactoryMethodB().getProduct();
		System.out.println(productA.getName());
		System.out.println(productB.getName());
	}
}

抽象工厂

另外产品族的产品1接口

public interface Product1 {

	public String getName();
}

具体的产品1A

public class Product1A implements Product1 {

	@Override
	public String getName() {
		return "product1A";
	}

}

具体的产品1B

public class Product1B implements Product1 {

	@Override
	public String getName() {
		return "product1B";
	}

}

抽象工厂接口，接口中有获取不同的产品族产品方法；

public interface AbstractFactory {

	public Product getProduct();
	
	public Product1 getProduct1();
}

抽象工厂实现类01，用来生产产品族productA产品跟产品族Product1A

public class AbstractFactoryImpl01 implements AbstractFactory {

	@Override
	public Product getProduct() {
		return new ProductA();
	}

	@Override
	public Product1 getProduct1() {
		return new Product1A();
	}

}

抽象工厂实现类02，用来生产产品族productB产品跟产品族Product1A

public class AbstractFactoryImpl02 implements AbstractFactory {

	@Override
	public Product getProduct() {
		// TODO Auto-generated method stub
		return new ProductB();
	}

	@Override
	public Product1 getProduct1() {
		// TODO Auto-generated method stub
		return new Product1A();
	}

}

抽象工厂实现类03，用来生产产品族productA产品跟产品族Product1B

public class AbstractFactoryImpl03 implements AbstractFactory {

	@Override
	public Product getProduct() {
		return new ProductA();
	}

	@Override
	public Product1 getProduct1() {
		return new Product1B();
	}

}

抽象工厂实现类04，用来生产产品族productB产品跟产品族Product1B产品

public class AbstractFactoryImpl04 implements AbstractFactory {

	@Override
	public Product getProduct() {
		return new ProductB();
	}

	@Override
	public Product1 getProduct1() {
		return new Product1B();
	}

}

抽象工厂测试类

public class AbstractFactoryTest {

	public static void main(String[] args) {
		System.out.println("AbstractFactoryImpl01:获取产品族Product:"+new AbstractFactoryImpl01().getProduct().getName()
				+"，获取产品族Product1:"+new AbstractFactoryImpl01().getProduct1().getName());
		System.out.println("AbstractFactoryImpl02:获取产品族Product:"+new AbstractFactoryImpl02().getProduct().getName()
				+"，获取产品族Product1:"+new AbstractFactoryImpl02().getProduct1().getName());
		System.out.println("AbstractFactoryImpl03:获取产品族Product:"+new AbstractFactoryImpl03().getProduct().getName()
				+"，获取产品族Product1:"+new AbstractFactoryImpl03().getProduct1().getName());
		System.out.println("AbstractFactoryImpl04:获取产品族Product:"+new AbstractFactoryImpl04().getProduct().getName()
				+"，获取产品族Product1:"+new AbstractFactoryImpl04().getProduct1().getName());
	}
}

区别

可参考

1. 简单工厂模式：根据传递的参数判断实例化哪个类；优点：将实例化对象跟适用对象解耦，缺点：增加新产品就得修改逻辑；
2. 工厂方法模式：抽象出来同一个产品族的接口，接口中包含一个抽象的实例化方法，然后子类实现这个接口然后实现具体的实例化方法；优点：克服简单工厂的缺点，新增产品，扩展新子类实现接口即可，缺点：不易于维护，当产品类修改了，其工厂类也得修改；
3. 抽象工厂模式：抽象出来不同产品族的接口，接口中包含抽象的多个不同产品族的实例化方法；优点：可以控制产品系列，有利于产品一致性，缺点：新增一个产品族很困难