设计模式：工厂模式

定义

工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个子类的实例化延迟到其子类

Factory Pattern : Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses

 

优点

1. 良好的封装性，代码结构清晰
2. 优秀的扩展性
3. 屏蔽产品类
4. 典型的解耦框架：

• 迪米特法则：高层只需要知道产品的抽象类，其他的实现都不用关心
• 依赖倒置：只依赖产品类的抽象
• 里氏替换，使用产品子类替换产品父类

使用场景

    主要用于需要灵活可扩展的框架时

 

具体实现

• 通用工厂模式实现

//工厂需要制造的产品总接口
public interface Human {
 
    public void getColor();
 
    public void talk();
}

//每个产品的具体实现
public class BlackHuman implements Human {
 
    public void getColor() {
        System.out.println("My color is black!");
    }
 
    public void talk() {
        System.out.println("Hi, I am black human!");
    }
}
 
public class WhiteHuman implements Human {
 
    public void getColor() {
        System.out.println("My color is white!");
    }
 
    public void talk() {
        System.out.println("Hi, I am white human!");
    }
}
 
public class YellowHuman implements Human {
 
    public void getColor() {
        System.out.println("My color is yellow!");
    }
 
    public void talk() {
        System.out.println("Hi, I am yellow human!");
    }
}
 
//抽象产品创建工厂
public abstract class AbstractHumanFactory {
 
    public abstract <T extends Human> T createHuman(Class<T> c);
}
 
//产品创建工厂
public class HumanFactory extends AbstractHumanFactory {
 
    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("Error!");
        }
        return (T) human;
    }
}

//场景类（调用）
public static void main(String[] args) {
        AbstractHumanFactory ahf = new HumanFactory();
 
        Human h1 = ahf.createHuman(BlackHuman.class);
        h1.talk();
        h1.getColor();
 
        Human h2 = ahf.createHuman(WhiteHuman.class);
        h2.talk();
        h2.getColor();
 
        Human h3 = ahf.createHuman(YellowHuman.class);
        h3.talk();
        h3.getColor();
}

  

• 工厂扩展模式1：简单工厂模式

public class SimpleFactory {
 
    public static void main(String[] args) {
        Human h1 = HumanFactory.createHuman(BlackHuman.class);
        h1.talk();
        h1.getColor();
 
        Human h2 = HumanFactory.createHuman(WhiteHuman.class);
        h2.talk();
        h2.getColor();
 
        Human h3 = HumanFactory.createHuman(YellowHuman.class);
        h3.talk();
        h3.getColor();
    }
}
 
//工厂类
class HumanFactory {
 
    public static <T extends Human> T createHuman(Class<T> c) {
        Human human = null;
        try {
            human = (T) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("Error!");
        }
        return (T) human;
    }
}

     个人理解：简化了的工厂模式，舍弃了抽象工厂类，直接用静态方法的方式构建工厂方法。代码结构简化了，但同时扩展性降低。一种较常用的变种模式

 

工厂扩展模式2：多个工厂类

public class MultiFactories {
 
    public static void main(String[] args) {
        Human whiteHuman = (new WhiteHumanFactory()).createHuman();
        Human blackHuman = (new BlackHumanFactory()).createHuman();
        Human yellowHuman = (new YellowHumanFactory()).createHuman();
    }
}
 
abstract class AbstractHumanFactory {
 
    public abstract Human createHuman();
}
 
class WhiteHumanFactory extends AbstractHumanFactory {
 
    @Override
    public Human createHuman() {
        return new WhiteHuman();
    }
}
 
class BlackHumanFactory extends AbstractHumanFactory {
 
    @Override
    public Human createHuman() {
        return new BlackHuman();
    }
}
 
class YellowHumanFactory extends AbstractHumanFactory {
 
    @Override
    public Human createHuman() {
        return new YellowHuman();
    }
}

     个人理解：当工厂方法本身非常复杂的时候，可以使用这个模式。缺点是一个产品类就要对应一个工厂类，增加了扩展的难度

 

• 工厂扩展模式3：单例工厂模式

public class SingletonFactory {
 
    private static Singleton singleton;
 
    static {
        try {
            Class c1 = Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor constructor = c1.getDeclaredConstructor();
            //设置无参构造可访问
            constructor.setAccessible(true);
            //产生一个实例对象
            singleton = (Singleton) constructor.newInstance();
        } catch (Exception e) {
        }
    }
 
    public static Singleton getSingleton() {
        return singleton;
    }
}
 
class Singleton {
 
    private Singleton() {
    }
}

     个人理解：这也就是之前单例模式中提到的用反射实现在其他类中对仅拥有private构造函数的类进行初始化的方法。本人实际暂时还不能理解这种模式在什么场景下适用，今后如果有进一步体悟会来补全此处

 

抽象工厂模式

最后简单提一下抽象工厂模式

 

抽象工厂模式：为创建一组相关或相互依赖的对象提供一个借口，而且无需指定他们的具体类

Abstract Factory Pattern：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

 

暂时不开单章说明这个模式了，因为个人没有遇到过类似的场景，理解实在不深。大体来说就是把工厂方法的职能更加细化，分到各个车间生产线级别。同时这些车间生产线生产的产品存在一定的关联性（产品族）

 

参考内容：《设计模式之禅》秦小波