一、工厂方法模式
工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。简单工厂模式就是将所有对象的创建放在一个类里面,由外面传的参数,用if else或者是switch语句来判断是创建何种对象,过于简单,这里就不赘述了。
工厂方法模式:简单来说就是一类产品用一个工厂类来创建。
产品父类:
public class Product {
public void showMsg(){}
}
产品A类:
public class ProductA extends Product{
@Override
public void showMsg(){
System.out.println("生产了A产品");
}
}
产品B类:
public class ProductB extends Product{
@Override
public void showMsg(){
System.out.println("生产了B产品");
}
}
抽象工厂类:
public abstract class Factory {
public abstract Product makeProduct();
}
A工厂类
public class FactoryA extends Factory{
@Override
public Product makeProduct() {
return new ProductA();
}
}
B工厂类
public class FactoryB extends Factory {
@Override
public Product makeProduct() {
return new ProductB();
}
}
测试类:
public class MyClass {
public static void main(String[] args) {
FactoryA factoryA = new FactoryA();
factoryA.makeProduct().showMsg();
FactoryB factoryB = new FactoryB();
factoryB.makeProduct().showMsg();
}
}
输出结果
生产了A产品
生产了B产品
工厂方法模式相对于简单工厂模式,将产品创建进行了很好的封装,少了较长的switch或者if else语句,但会多很多工厂类。一个工厂只能创建一类产品。
针对上述缺点,对代码做了以下改善
修改了Factory 类,创建产品时需要传入想生产的实现类的类名
public abstract class Factory {
public abstract<T extends Product> T makeProduct(Class<T> tClass);
}
工厂实现类,通过传入的产品实现类,用反射生产出实际的产品,然后返回。
public class FactoryImp extends Factory{
@Override
public <T extends Product> T makeProduct(Class<T> tClass) {
Product product = null;
try {
product = (Product)Class.forName(tClass.getName()).newInstance();
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return (T) product;
}
}
测试类,生产产品时,只需要传入想要生产的class类即可。
public class MyClass {
public static void main(String[] args) {
FactoryImp factory = new FactoryImp();
factory.makeProduct(ProductA.class).showMsg();
factory.makeProduct(ProductB.class).showMsg();
}
}
优化后的代码,只需要创建一个工厂实现类,是代码简洁了许多。也易维护了。
二、抽象工厂模式
定义:为创建一组相关或者相互依赖的对象提供一个接口,而不需要指定他们的具体类。
使用场景:一组对象,具有相同的约束条件,可以抽象成一类对象,这类对象的创建就可以用抽象工厂模式。
如产品的生产和产品包装纸箱的生产,都属于一条生产线上的。
看看代码的实现方式
产品的工厂类
public abstract class ProductFactory {
//包含产品的生产和包装两个方法
public abstract Product makeProduct();
public abstract ProductPacking makeProductPacking();
}
产品包装抽象类
public abstract class ProductPacking {
public abstract void showMsg();
}
产品B包装类
public class ProductBPacking extends ProductPacking {
@Override
public void showMsg() {
System.out.println("产品B包装好了");
}
}
产品B的工厂类:
public class FactoryB extends ProductFactory {
@Override
public Product makeProduct() {
return new ProductB();//产品B类的代码同上
}
@Override
public ProductPacking makeProductPacking() {
return new ProductBPacking();
}
}
测试代码
public class MyClass {
public static void main(String[] args) {
FactoryB factoryB = new FactoryB();
factoryB.makeProduct().showMsg();
factoryB.makeProductPacking().showMsg();
}
}
输出结果:
生产了B产品
产品B包装好了
通过抽象工厂模式,可以将一个产品线上的所有产品生产完。