生产对象的一种模式，通过增加一个工厂类使创建产品的时候延迟到子类
工厂模式是理解依赖倒置的法宝，
依赖倒置
1，高层组件不依赖底层组件
2，他们都依赖于抽象
工厂模式里的工厂是高级组件，产品是低级组件，要想建立产品你就需要实现工厂的产品接口，也就是高层组件不依赖底层组件
工厂类和产品类都是依赖，抽象工厂和产品接口的所以他们都是依赖于抽象
工厂模式可分为以下5种
拿女娲造人为例，造人的炉子是工厂，人是产品，分为黑种人，黄种人，白种人
第一种，抽象工厂
抽象工厂类图.png
1，首先我们创建抽象工厂
这里使用了泛型，参数传入class字节码用于反射创建产品对象
public abstract class AbstractHumanFactory {
public abstract <T extends Human> T createHuman(Class<T> c);
}
2，创建人类接口
人类接口有颜色，也可以说话
public interface Human {
void getColor();
void talk();
}
3，抽象接口都实现了我们来创建实例了，产品类，三种人如下
public class BlackHuman implements Human{
@Override
public void getColor() {
System.out.println("黑种人");
}
@Override
public void talk() {
System.out.println("我是黑种人");
}
}
public class WhiteHuman implements Human{
@Override
public void getColor() {
System.out.println("白种人");
}
@Override
public void talk() {
System.out.println("我是白种人");
}
}
public class YellowHuman implements Human{
@Override
public void getColor() {
System.out.println("黄种人");
}
@Override
public void talk() {
System.out.println("我是黄种人");
}
}
4，创建工厂类
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("生成人种错误");
}
return (T)human;
}
}
5，好了准备工作都做完了现在可以调用工厂类生产人类了，如果我们想更换人类只需要更换入参class就可以了，其他位置不需要修改
public static void main(String[] args){
AbstractHumanFactory humanFactory = new HumanFactory();
Human human = humanFactory.createHuman(YellowHuman.class);
human.getColor();
human.talk();
}
第二种，简单工厂叫静态工厂更好理解我感觉
他与抽象工厂的区别就是简单工厂不使用抽象类，使用静态方法生成产品，在调用工厂的时候变得简单了，但也失去了开放关闭原则，不好实现扩展
1，抽像产品类同1中
2，产品类同1中
3，去掉抽象工厂类，修改生成产品的工厂类，如下
public 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("生成人种错误");
}
return (T)human;
}
}
4，调用工厂
public class Main {
public static void main(String[] args){
Human human = HumanFactory.createHuman(YellowHuman.class);
human.getColor();
human.talk();
}
}
第三种，多工厂
他与抽象工厂的区别是分别生产对应的产品工厂，专门生产黑人的黑人工厂，白人工厂，黄人工厂
1，产品抽象同1
2，产品类同1
3，修改抽象工厂类，去掉入参，因为他的子类都是生成对应的产品了
public abstract class AbstractHumanFactory {
public abstract Human createHuman();
}
4，生产各个工厂
public class BlackHumanFactory extends AbstractHumanFactory{
@Override
public Human createHuman() {
return new BlackHuman();
}
}
public class WhiteHumanFactory extends AbstractHumanFactory{
@Override
public Human createHuman() {
return new WhiteHuman();
}
}
public class YellowHumanFactory extends AbstractHumanFactory{
@Override
public Human createHuman() {
return new YellowHuman();
}
}
5，调用工厂
public class Main {
public static void main(String[] args){
Human human = new YellowHumanFactory().createHuman();
human.getColor();
human.talk();
}
}
我们看大这种方式逻辑比较清晰，但问题是如果我们需要扩展产品类也同时需要扩展工厂类
第三种，单例工厂
我们可以通过工厂，反射生成单例类，当然别人也可以反射生成单例，这样就需要组内协商了
1，构造单例类
public class Single {
private Single(){}
public void talk() {
System.out.println("我是Single");
}
}
2，构造单例工厂
public class SingleFactory {
private static Single INSTANCE;
static {
try {
Class cl = Class.forName(Single.class.getName());
//获得构造函数
Constructor constructor = cl.getDeclaredConstructor();
//设置无参构造可以访问
constructor.setAccessible(true);
//产生一个实例对象
INSTANCE = (Single) constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Single getInstance(){
return INSTANCE;
}
}
3，调用工厂
public class Main {
public static void main(String[] args){
SingleFactory.getInstance().talk();
}
}
这里我们通过反射调用无参构造函数创建了一个单例，这个单例是饿汉式单例
第四种，延迟初始化工厂，我觉得这个叫缓存工厂更贴切一点
他是在创建对象的时间将对象存储到map中，在下一次获取对象的时候先在缓存map中取，如果没有在创建对象，一下是代码
1，产品接口同1
2，产品类同1
3，修改工厂类增加map缓存
public class HumanFactory {
private static final Map<String,Human> humanMap = new HashMap<>();
public static synchronized Human createHuman(String type){
Human human = null;
if (humanMap.containsKey(type)){
human = humanMap.get(type);
} else {
if (type.equals("yellow")){
human = new YellowHuman();
} else if (type.equals("black")){
human = new BlackHuman();
} else {
human = new WhiteHuman();
}
humanMap.put(type,human);
}
return human;
}
}
4，调用工厂
public class Main {
public static void main(String[] args){
Human human1 = pattern.factory.five.HumanFactory.createHuman("yellow");
human1.getColor();
human1.talk();
Human human2 = pattern.factory.five.HumanFactory.createHuman("yellow");
human2.getColor();
human2.talk();
Human human3 = pattern.factory.five.HumanFactory.createHuman("yellow");
human3.getColor();
human3.talk();
}
}
网友评论