设计模式之简单工厂

第一步：

/*******************新建一个Apple类**********************/  
public class Apple {   
    /**  
     * 采集  
     */  
    public void get() {   
        System.out.println("采集苹果");   
    }   
}   
/******************新建一个Banana类**********************/  
public class Banana implements Fruit {   
    /**  
     * 采集  
     */  
    public void get() {   
        System.out.println("采集香蕉");   
    }   
}   
/***************再新建一个MainClass主类******************/  
public class MainClass {   
  
    public static void main(String[] args) {   
        Apple apple = new Apple();   
        Banana banana = new Banana();   
        apple.get();   
        banana.get();   
    }   
}   
/*  
 * 输出  
 * 采集苹果  
 * 采集香蕉  
 */  
//由此可以看出Apple,Banana这两个类可以抽象出一个方法,他们都是水果,他们都有一个get()这个方法 

 

 

第二步：

//抽取一个接口   
public interface Fruit {   
    /**  
     * 采集  
     */  
    public void get();   
}   
  
//Apple去实现Fruit这个接口   
public class Apple implements Fruit{   
    /**  
     * 采集  
     */  
    public void get() {   
        System.out.println("采集苹果");   
    }   
}   
//Banana也去实现Fruit这个接口   
public class Banana implements Fruit {   
    /**  
     * 采集  
     */  
    public void get() {   
        System.out.println("采集香蕉");   
    }   
}   
//这么做的好处是什么呢?我们用了多肽,这是我们要去new Apple,Banana的话,我们可以用接口来做   
public class MainClass {   
    public static void main(String[] args) {   
        Fruit apple = new Apple();   
        Fruit banana = new Banana();   
        apple.get();   
        banana.get();   
    }   
}   
/*  
 * 输出  
 * 采集苹果  
 * 采集香蕉  
 */  

 

 

回归概念：简单工厂模式
简单工厂模式属于类的创建模式,又叫做静态工厂方法模式.通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类.
第三步：

//根据以上定义来定义一个工厂   
public class FrutiFactory {   
    /**  
     * 获得Apple实例  
     */  
    public static Fruit getApple() {   
        return new Apple();   
    }   
  
    /**  
     * 获得Banana实例  
     */  
    public static Fruit getBanana() {   
        return new Banana();   
    }   
}   
//这是的MainClass   
public class MainClass {   
    public static void main(String[] args) {   
        // 实例化一个Apple   
        Fruit apple = FrutiFactory.getApple();   
        // 实例化一个Banana   
        Fruit banana = FrutiFactory.getBanana();   
        apple.get();   
        banana.get();   
    }   
}   
/*  
 * 输出  
 * 采集苹果  
 * 采集香蕉  
 */  
//这就是静态工厂的实现   
/**  
 * 1,工厂角色(FrutiFactory)  
 *   简单工厂模式的核心,它负责实现所有实例的内部逻辑.  
 *   工厂类可以被外界直接调用,创建所需的产品对象  
 * 2,抽象角色(Fruit)  
 *   简单工厂模式所创建的所有对象的父类,他负责描述所有实例所共有的公共接口  
 * 3,具体产品角色(apple.get(),banana.get())  
 *   简单工厂模式所创建的具体实例的对象  
 */  

 

第四步：

//来改进FrutiFactory   
public class FrutiFactory {   
    /**  
     * get方法,获得所有产品对象  
     *   
     * @throws IllegalAccessException  
     * @throws InstantiationException  
     */  
    public static Fruit getFruit(String type) throws InstantiationException,   
            IllegalAccessException {   
        if (type.equalsIgnoreCase("apple")) {   
            return Apple.class.newInstance();   
        } else if (type.equalsIgnoreCase("banana")) {   
            return Banana.class.newInstance();   
        } else {   
            System.out.println("找不到相应的实例化类");   
            return null;   
        }   
    }   
}   
//MainClass运行   
    public static void main(String[] args) throws InstantiationException,   
            IllegalAccessException {   
        Fruit apple = FrutiFactory.getFruit("apple");   
        Fruit banana = FrutiFactory.getFruit("banana");   
        apple.get();   
        banana.get();   
    }  

 

第五步：

//继续改进FrutiFactory   
public class FrutiFactory {   
    /**  
     * get方法,获得所有产品对象  
     *   
     * @throws ClassNotFoundException  
     * @throws IllegalAccessException   
     * @throws InstantiationException   
     *   
     * @throws IllegalAccessException  
     * @throws InstantiationException  
     */  
    public static Fruit getFruit(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {   
        Class<?> fruit = Class.forName(type);   
        return (Fruit) fruit.newInstance();   
    }   
}   
//MainClass运行   
public class MainClass {   
    public static void main(String[] args) throws InstantiationException,   
            IllegalAccessException, ClassNotFoundException {   
        Fruit apple = FrutiFactory.getFruit("cobra.simpleFactory.Apple");   
        Fruit banana = FrutiFactory.getFruit("cobra.simpleFactory.Banana");   
        apple.get();   
        banana.get();   
    }   
}  

 

总结：
工厂类是整个模式的关键所在,它包含了必要的判断逻辑,能够根据外界给定的信息,决定究竟创建哪个具体类的对象.在使用时可以直接根据工厂类去创建所需实例,而无需了解这些对象是如何创建的.有利于整个软件体系的结构优化
缺点就是：高类聚做的不够好,另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类的修改,扩展性不好.