工厂方法模式和抽象工厂模式
工厂方法模式是创建型设计模式之一。工厂方法模式是一种结构简单的设计模式。
定义一个用于创建对象的接口,让子类决定实例化哪个类。
在任何需要生成复杂对象的地方,都可以使用工厂模式。
抽象产品类定义Product
/**
* 抽象产品定义
*/
public abstract class Product {
public abstract void method();
}
具体产品A ConcreteAProduct
/**
* 具体产品A
*/
public class ConcreteAProduct extends Product {
@Override
public void method() {
System.out.println("具体的产品A");
}
}
具体产品B ConcreteBProduct
/**
* 具体产品B
*/
public class ConcreteBProduct extends Product {
@Override
public void method() {
System.out.println("具体的产品B");
}
}
抽象工厂 Factory
/**
* 抽象工厂类
*/
public abstract class Factory {
public abstract Product createProduct();
}
具体工厂实现 ConcreteFactory
/**
* 具体工厂实现
*/
public class ConcreteFactory extends Factory {
@Override
public Product createProduct() {
return new ConcreteAProduct();
}
}
客户端
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
Factory factory=new ConcreteFactory();
Product product=factory.createProduct();
product.method();
}
}
输出
具体的产品A
public abstract class Factory2 {
public abstract T createProduct(Class clz);
}
public class ConcreteFactory2 extends Factory2 {
@Override
public T createProduct(Class clz) {
Product p = null;
try {
p = clz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) p;
}
}
客户端使用
/**
* 客户端
*/
public class Client2 {
public static void main(String[] args) {
Factory2 factory=new ConcreteFactory2();
Product product=factory.createProduct(ConcreteBProduct.class);
product.method();
}
}
当只需要一个工厂时,可以不需要定义 抽象工厂基类,只需提供一个静态创建方法即可。此时退化为简单工厂模式或者叫静态工厂模式。
public class FactorySimple {
public static Product createProduct(){
return new ConcreteAProduct();
}
}
抽象工厂模式也是创建型设计模式的一种。
为创建一组相关或者相互依赖的对象提供一个接口,而不需要指定具体的类。
一个对象族有相同的约束时可以使用抽象工厂模式。比如Android,IOS,Windows Phone 都有短信和拨号软件,两者都属于Software的范畴,但是他们操作系统平台不一样,即便是同一家公司出品的软件,代码逻辑也是不相同的,这个时候就可以考虑使用抽象工厂模式 来产生Android,IOS ,Windows Phone 下的短信和拨号软件。
抽象产品A 定义
/**
* 抽象产品A 定义
*/
public abstract class AbstractProductA {
public abstract void method();
}
抽象产品B定义
/**
* 抽象产品B定义
*/
public abstract class AbstractProductB {
public abstract void method();
}
具体产品A1
/**
* 具体产品A1
*/
public class ConcreteA1Product extends AbstractProductA{
@Override
public void method() {
System.out.println("生产了A1");
}
}
具体产品A2
/**
* 具体产品A2
*/
public class ConcreteA2Product extends AbstractProductA{
@Override
public void method() {
System.out.println("生产了A2");
}
}
具体产品B1
/**
* 具体产品B1
*/
public class ConcreteB1Product extends AbstractProductB{
@Override
public void method() {
System.out.println("生产了B1");
}
}
具体产品B2
/**
* 具体产品B2
*/
public class ConcreteB2Product extends AbstractProductB {
@Override
public void method() {
System.out.println("生产了B2");
}
}
抽象工厂类,定义生产产品的方法
/**
* 抽象工厂类,定义生产产品的方法
*/
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
具体工厂实现1
/**
* 具体工厂实现1
*/
public class ConcreteFactory1 extends AbstractFactory{
@Override
public AbstractProductA createProductA() {
return new ConcreteA1Product();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteB1Product();
}
}
具体工厂2
/**
* 具体工厂2
*/
public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteA2Product();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteB2Product();
}
}
客户端使用
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA pA1 = factory1.createProductA();
AbstractProductB pB1 = factory1.createProductB();
pA1.method();
pB1.method();
AbstractFactory factory2 = new ConcreteFactory2();
AbstractProductA pA2 = factory2.createProductA();
AbstractProductB pB2 = factory2.createProductB();
pA2.method();
pB2.method();
}
}
输出
生产了A1
生产了B1
生产了A2
生产了B2
从这两种设计模式的定义和使用来看,都是为了方便外部调用,屏蔽程序内部设计细节,减少耦合,便于扩展。
工厂方法模式 简单来说只有一个工厂,抽象工厂模式则有多个工厂,用于产生相同类别但是不同属性的产品。