设计模式—简单工厂模式

简单工厂模式：

　　简单工厂模式是创建一个操作类或者操作的接口，通过其子类继承或者实现来实现自己具体的功能，然后操作的实例是由一个工厂类来创建的，也就是工厂类创建操作的实例，是一个产生对象的工厂。

　　下面举一个例子来说明，通过Java面向对象的特点来实现计算器加减乘除的功能，计算器的功能可扩展可以增加开根等运算。看例子的代码：

/**
 * 创建操作类，实现计算的各种操作。
 */
public class Operate {
    //创建加法运算方法
    public int AddOperate(int num_1, int num_2) {
        int result = 0;
        return result;
    }
    //创建减法运算方法
    public int SubOperate(int num_1, int num_2) {
        int result = 0;
        return result;
    }
    //创建乘法运算方法
    public int MulOperate(int num_1, int num_2) {
        int result = 0;
        return result;
    }
    //创建除法运算方法
    public int DivOperate(int num_1, int num_2) {
        int result = 0;
        return result;
    }
}

/**
 * 创建加法类继承操作类
 */
public class AddOperate extends Operate{
    public int AddOperate(int num_1, int num_2) {
        int result = 0;
        result = num_1+num_2;
        return result;
    }
}
/**
 * 创建减法类继承操作类
 */
public class SubOperate extends Operate  {
    public int SubOperate(int num_1, int num_2) {
        int result = 0;
        result = num_1-num_2;
        return result;
    }
}
/**
 * 创建乘法类继承操作类
 */
public class MulOperate extends Operate {
    public int MulOperate(int num_1, int num_2) {
        int result = 0;
        result = num_1*num_2;
        return result;
    }
}
/**
 * 创建除法类继承操作类
 */
public class DivOperate extends Operate {
    public int DivOperate(int num_1, int num_2) {
        int result = 0;
        result = num_1/num_2;
        return result;
    }
}

/**
 * 创建实例工厂，产生操作实例
 */
public class FactoryOperate {
    public Operate createOperate(String operate){

        Operate obj =null ;
        switch(operate){
        case"+":
            obj = new AddOperate();
            break;
        case"-":
            obj = new SubOperate(); 
            break;
        case"*":
            obj = new MulOperate(); 
            break;
        case"/":
            obj = new DivOperate(); 
            break;          
        }
        return obj;
    }
}

再举一个例子：

睡觉的接口，接口中有睡觉的抽象方法。

public interface Sleep {
    public void sleep();
}

老师类，实现睡觉的接口，并且实现睡觉的方法，具备睡觉的能力。

public class Teacher implements Sleep{
    @Override
    public void sleep() {
        System.out.println("老师睡觉啦！");
    }
}

学生类，实现睡觉的接口，并且实现睡觉的方法，具备睡觉的能力。

public class Student implements Sleep{
    @Override
    public void sleep() {
        System.out.println("学生睡觉啦！");       
    }
}

Factory类来创建Person类的对象。

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Factory {
    public static Sleep creatFactory(){
        //首先创建一个空的Person对象。
         Sleep person = null;
         //创建一个属性集对象
         Properties p = new Properties();
         try {
            //加载属性文件
            p.load(new FileInputStream("config.properties"));
            //获取键值为Person的属性值。
            String clazzName = p.getProperty("Person");
            //返回指定字符串指定类或接口。
            Class<?> clazz = Class.forName(clazzName);
            //创建clazz所指类或接口的实例。
            person = (Sleep) clazz.newInstance();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return person;
    }
}

属性文件：

//文件名为：config.properties,内容如下：
Person = com.java.testclass.Student

测试类：

public class Factorytest {

    public static void main(String[] args) {
        Sleep person= Factory.creatFactory();
        person.sleep();
    }
}

测试结果为：（此处不在贴图）

学生睡觉啦！