工厂模式

图片.png

1、具体实现通过反射，代码量少，便于维护。
2、定义Plant接口，已经实现该接口的具体实现类
3、定义常量类，静态常量值为包引用
4、简单工厂类，返回Plant接口对象，具体实现通过Class.forName(具体的包引用).getDeclaredConstructor().newInstance()反射，返回对象
5、测试类进行测试

• 接口Plant

package com.alan.plant;

/**
 * 定义植物类的接口
 */
public interface Plant {

    public String getName();

    public void  fight();
}

• PlantNameConstant 常量定义类

package com.alan.plant;

public class PlantNameConstant {

    //定义植物的名称
//    public static final String BEAN_NAME = "Bean";
//    public static final String ICE_NAME = "Ice";
//    public static final String WALL_NAME = "Wall";
    //通过反射实现定义常量
    public static final String BEAN_NAME = "com.alan.plant.Bean";
    public static final String ICE_NAME = "com.alan.plant.Ice";
    public static final String WALL_NAME = "com.alan.plant.Wall";
}

• 实现接口的具体实体类

package com.alan.plant;

public class Bean implements Plant {

    public String getName(){
        return "绿逗";
    }

    public void fight(){
        System.out.println("发射一个豆子");
    }
}

package com.alan.plant;

/**
 * 实现接口的实体类
 */
public class Ice implements Plant {

    public String getName(){
        return "蓝冰";
    }


    public void fight(){
        System.out.println("发射一个冰豆");
    }
}

package com.alan.plant;


/**
 * 实现接口的实体类
 */
public class Wall implements Plant {

    public String getName(){
        return "果墙";
    }

    public void fight(){
        System.out.println("稳稳的站在那里");
    }
}

• 核心工厂实现类

package com.alan.factory;

import com.alan.plant.*;

public class SimpleFactory {

    /**
     * 实现方式一
     * @param name
     * @return
     */
    public  static Plant creatPlant(String name){
        Plant plant = null;
        if(PlantNameConstant.BEAN_NAME.equals(name)){
            plant = new Bean();
        }else if(PlantNameConstant.ICE_NAME.equals(name)){
            plant = new Ice();
        }else if(PlantNameConstant.WALL_NAME.equals(name)){
            plant = new Wall();
        }

        return plant;
    }

    /**
     * 实现方式二（通过反射实现）(不需要判断类了，方便多了)
     * @param name
     * @return
     */
    public static Plant createPlantByClassName(String name) throws Exception {

       return  (Plant) Class.forName(name).getDeclaredConstructor().newInstance();
    }

}

• 功能实现类

package com.alan.util;

import com.alan.factory.SimpleFactory;
import com.alan.plant.Bean;
import com.alan.plant.Ice;
import com.alan.plant.Plant;
import com.alan.plant.Wall;

public class Function {


    public void  put(String name, int number) throws Exception {
        Plant plant = SimpleFactory.createPlantByClassName(name);
        System.out.println("将"+ plant.getName() + "放在" + number + "号草地上");
        plant.fight();
    }

}

• 测试类

package com.alan.test;

import com.alan.plant.Plant;
import com.alan.plant.PlantNameConstant;
import com.alan.util.Function;

public class Test1 {

    public static void main(String[] args) {
        Function function = new Function();
        try {
            function.put(PlantNameConstant.BEAN_NAME,2);
            function.put(PlantNameConstant.ICE_NAME,8);
            function.put(PlantNameConstant.WALL_NAME,12);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

• 设计模式的目的：代码复用性、增加可维护性。

• 设计原则：单一职责原则、开闭原则、迪米特法则....

  
  图片.png

开闭原则

1、 对扩展开放
2、对修改关闭

图片.png