设计模式-工厂模式

工厂模式

工厂模式属于创建型模式，调用者只需要产品的类名就可以，减低耦合性，符合迪米特原则。
扩展性方面：增加产品类的情况下，只需要修改工厂类或者扩展一个工厂类，也符合依赖倒置原则。
工厂模式实质是new一个对象的替代品。

实现步骤：
让所有产品都遵循同一接口。 该接口必须声明对所有产品都有意义的方法。
在创建类中添加一个空的工厂方法。 该方法的返回类型必须遵循通用的产品接口。
在创建者代码中找到对于产品构造函数的所有引用。 将它们依次替换为对于工厂方法的调用， 同时将创建产品的代码移入工厂方法。
如果应用中的产品类型太多， 那么为每个产品创建子类并无太大必要， 这时你也可以在子类中复用基类中的控制参数。
应用工厂方法模式需要引入许多新的子类， 代码可能会因此变得更复杂。 最好的情况是将该模式引入创建者类的现有层次结构中。

常规

//接口
public interface Human {
    public void getColor();
    public void talk();
}
//实现类
public class BlankHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黑色人种是黑色的");
    }

    @Override
    public void talk() {
        System.out.println("黑种人说话");
    }
}
//抽象工厂
public abstract class AbstractHumanFactory {
    public abstract <T extends Human> T createHuman(Class<T> c);
}

//工厂类
package com.wb.magic.rest.design.factory;

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;
    }`在这里插入代码片`
}

//测试
    AbstractHumanFactory abstractHumanFactory=new HumanFactory();
        BlankHuman human = abstractHumanFactory.createHuman(BlankHuman.class);
        human.getColor();

简单工厂模式

当然可以通过HumanFactory区分不同参数返回指定对象。

//接口
public interface Human {
    public void getColor();
    public void talk();
}
//实现类
public class BlankHuman implements Human{
    @Override
    public void getColor() {
        System.out.println("黑色人种是黑色的");
    }

    @Override
    public void talk() {
        System.out.println("黑种人说话");
    }
}
//去除抽象工厂

//工厂类
package com.wb.magic.rest.design.factory;

public class HumanFactory{
    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;
    }`在这里插入代码片`
}

//工厂类也可以这样写,通过type参数来书写
public <T extends Human> T createHuman(Integer type) {
      if(type==0){
          return (T) new BlankHuman();
      }
      return null;

    }

//测试
    HumanFactory humanFactory=new HumanFactory();
        BlankHuman human = humanFactory.createHuman(BlankHuman.class);
        human.getColor();

多工厂模式（工厂方法模式）

public abstract class AbstractHumanFactory {
    public abstract Human createHuman();
}

public class BlankFactory extends AbstractHumanFactory{

    @Override
    public Human createHuman() {
        return new BlankHuman();
    }
}

public class WhiteFactory extends AbstractHumanFactory {

    @Override
    public Human createHuman() {
        return new WhiteHuman();
    }
}

public interface Human {
    public void getColor();

    public void talk();
}

public class BlankHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黑色人种是黑色的");
    }

    @Override
    public void talk() {
        System.out.println("黑种人说话");
    }
}
//whiteHuman同理

工厂模式配合枚举

public enum HumanEnum {

    WHITE{
        @Override
        public <T extends Human> T getHuman() {
            return (T) new WhiteHuman();
        }
    },
    BLANK{
        @Override
        public <T extends Human> T getHuman() {
            return (T) new BlankHuman();
        }
    };

    public abstract <T extends Human>T getHuman();
 }


public class BlankHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黑色人种是黑色的");
    }

    @Override
    public void talk() {
        System.out.println("黑种人说话");
    }
}

public interface Human {
    public void getColor();

    public void talk();
}
	
Human human = HumanEnum.BLANK.getHuman();
human.getColor();

替换单例模式

    private static Singleton singleton;

    static {
        try {
            Class cl=Class.forName(Singleton.class.getName());
            Constructor declaredConstructor = cl.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            singleton = (Singleton)declaredConstructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Singleton getSingleton(){
        return singleton;
    }