javaee学习之路(十一)简单工厂模式

一、简单工厂模式

一、简单的工厂模式：
    简单的工厂模式：根据提供给他的数据，返回几个可能类中的一个类的实例。通常他返回的类有一个共同的父类和共同的方法，但每个方法执行的过程不同，而且根据不同的数据进行了优化。简单工厂模式可以作为工厂方法模式的一个引导。
二、其中的角色：
1、工厂类(Creator)角色：该角色是简单工厂模式的核心，含有按照一定商业逻辑创建的产品。工厂类在客户的直接调用下创建产品对象，它往往由一个具体类实现。
2、抽象产品(Producer)角色：担任这个角色的类是简单工厂模式所创建的对象的父类，或它们共同拥有的接口，抽象产品角色可以用一个接口或者抽象类实现。
3、具体产品(Concrete Product)角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体类实现。


1、interface Fruit

package cn.itcast.simple;
/**
 * 工厂模式中的抽象产品
 * @author Administrator
 *
 */
public interface Fruit {
    /*
     * 种植期
     */
    void planting();
    /*
     * 生长期
     */
    void growing();
    /*
     * 收获期
     */
    void having();
}

2、Apple.java

package cn.itcast.simple;
//工厂模式中的具体产品
public class Apple implements Fruit {

    @Override
    public void planting() {
        System.out.println("apple planting");
    }

    @Override
    public void growing() {
        System.out.println("apple growing");

    }

    @Override
    public void having() {
        System.out.println("apple having");

    }
}

3、Factory.java

package cn.itcast.factory;
import cn.itcast.simple.Apple;
import cn.itcast.simple.Banana;
import cn.itcast.simple.Fruit;
/*
 * 工厂模式中的工厂类
 */
public class Factory {
注意：工厂类中的方法都是static 静态方法
    public static Fruit createFruit(String string) {
        if("apple".equalsIgnoreCase(string)){
            return new Apple();
        }
        if("banana".equalsIgnoreCase(string)){
            return new Banana();
        }
        return null;
    }
}

4、Client.java

package cn.itcast.client;
import cn.itcast.factory.Factory;
import cn.itcast.simple.Apple;
import cn.itcast.simple.Fruit;
/**
 * 客户端
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        /*
         * 客户只知道有生产水果的工厂，我传递一个参数过去就能得到工厂生产的对应水果
         * 不知道还有Apple、Banana类
         */
        //客户购买apple
        Fruit appleFruit = Factory.createFruit("apple");
        appleFruit.growing();
        //客户端购买banana
        Fruit bananaFruit=Factory.createFruit("banana");
        bananaFruit.growing();
    }
}

5、Banana.java

package cn.itcast.simple;
//工厂模式中增加新产品
public class Banana implements Fruit {
    @Override
    public void planting() {
        System.out.println("banana planting");
    }
    @Override
    public void growing() {
        System.out.println("banana growing");
    }
    @Override
    public void having() {
        System.out.println("banana having");
    }
}

迪米特法则：
      一个软件产品应该对内修改关闭，对外扩展开放!
二次开发！

简单工厂模式的致命弱点：增加新产品时（orange），产品这一块（Fruit）没有任何问题,达到了扩展，但是工厂这一块就得修改,假设增加1000中产品，工厂createFruit()时就得判断1000次，会变得异常复杂！屏蔽简单工厂的弱点：工厂方法模式！！！
二、工厂方法模式

1、 工厂方法模式：又称为虚拟构造器模式或者多台工厂模式，属于类的创建型模式。在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的兑现个，这样做的目的是将类的实例化操作延迟到子类中完成，则由子类来据顶究竟应该实体化哪一个类！！！
2、其中的角色：
(1)、抽象工厂类(Creator)角色：该角色是工厂方法模式的核心，他负责定义创建抽象产品对象的工厂方法。抽象工厂不能被外界直接调用，但任何在模式中勇于创建产品对象的工厂类都必须实现由他所定义的工厂方法
(2)、具体工厂类：是工厂方法模式的对外接口，它负责实现创建具体产品对象的内部逻辑，具体工厂与应用密切相关，可以被外界直接调用，创建所需要的产品。
(3)、抽象产品角色：是工厂方法模式所创建的所有对象的父类，它负责描述所有具体产品共有的公共接口
(4)、具体产品角色：是工厂方法模式的创建目标，所有创建的兑现个都是充当这一角色的某个具体类的实例
3、好处：扩展性好(增加新产品只需增加工厂和具体产品的类)
坏处：代码量增多

(1)、Fruit.java

package cn.itcast.method;
/**
 * 工厂方法模式中的抽象产品
 * @author Administrator
 *
 */
public interface Fruit {
    /*
     * 种植期
     */
    void planting();
    /*
     * 生长期
     */
    void growing();
    /*
     * 收获期
     */
    void having();
}

(2)Apple.java

package cn.itcast.method;
//工厂方法模式中的具体产品
public class Apple implements Fruit {
    @Override
    public void planting() {
        System.out.println("apple planting");
    }
    @Override
    public void growing() {
        System.out.println("apple growing");
    }
    @Override
    public void having() {
        System.out.println("apple having");
    }
}

(3)Factory.java

package cn.itcast.factory;
import cn.itcast.method.Fruit;
/*
 * 工厂方法模式中的抽象工厂
 */
public interface Factory {
    Fruit createFruit();

}

(4)FactoryApple.java

package cn.itcast.factory;
import cn.itcast.method.Apple;
import cn.itcast.method.Fruit;
/**
 * 工厂方法模式中的具体工厂--Apple工厂
 * @author Administrator
 *
 */
public class FactoryApple implements Factory {
    @Override
    public Fruit createFruit() {
        return new Apple();
    }
}

(5)Client.java

package cn.itcast.client;
import *;
public class Client {
    public static void main(String[] args) {
        //客户订单apple
        //实例化Apple工厂
        Factory appleFactory=new FactoryApple();
        //创建APPLE
        Fruit appleFruit = appleFactory.createFruit();
        appleFruit.growing();
/**********************************************************************/        
        //客户订单banana

        //实例化banana工厂
        Factory bananaFactory=new FactoryBanana();
        Fruit bananaFruit = appleFactory.createFruit();
        bananaFruit.growing();  
    }
}

增加新产品：
(6)、Banana.java

package cn.itcast.method;
//工厂方法模式中增加新产品
public class Banana implements Fruit {
    @Override
    public void planting() {
        System.out.println("banana planting");
    }
    @Override
    public void growing() {
        System.out.println("banana growing");
    }
    @Override
    public void having() {
        System.out.println("banana having");
    }
}

(7)、FactoryBanana.java

package cn.itcast.factory;
import cn.itcast.method.Banana;
import cn.itcast.method.Fruit;
/**
 * 工厂方法模式中的具体工厂--banana工厂
 * @author Administrator
 */
public class FactoryBanana implements Factory {
    @Override
    public Fruit createFruit() {
        return new Banana();
    }
}

三、工厂模式在项目中的应用
将web项目employees改为工厂设计模式：

工厂类代码：
创建一个包cn.itcast. factory

package cn.itcast.factory;
import cn.itcast.dao.DaoEmployee;
import cn.itcast.daoIml.DaoEmployeeImpl;
/*
 * 工厂模式中的具体工厂
 */
public class DaoFactory {
    /**
     * 创建DaoEmployeeImpl对象
     * @return
     */
    public static DaoEmployee getDaoEmployee(){
        return new DaoEmployeeImpl();
    }
}

那么，在用到DaoEmployee daoEmployee=new DaoEmployeeImpl();的地方都改为：
DaoFactory daoEmployee=DaoFactory.getDaoEmployee();
就行！！！！！