Java--工厂模式

一：什么是工厂模式

　　我的理解：是一个特殊的产品的功能工厂

　　官方理解：实例化对象，用工厂方法代替new操作

二：工厂模式作用

　　因为工厂模式相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如 A a = new A（）；工厂模式也是用来创建实例对象的，虽然会多做一些工作，但是好处在于会给系统带来更大的可扩展性和尽量少的修改

三：应用场景：

　　比如在玩游戏极品飞车，游戏者可以选择从不同的品牌选择赛车，那么这个品牌其实就是工厂，每个工厂生产的赛车都不一样，这就是典型的工厂模式的应用场景。

　　使用简单工厂模式的优势是：让对西那个的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂申请即可，从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性、扩展性。

四：工厂模式有哪些

　　简单工厂（Simple Factory）模式

　　工厂方法（Factory Method）模式

　　抽象工厂（Abstract Factory）模式

五：三类工厂模式详解

　　1：简单工厂模式

　　　　简单工厂模式是类的创建，又叫静态工厂方法模式。简单工厂模式是一个由工厂对象决定创造哪一种产品类的实例

　　　　例如：有一个农场，生产各种水果，有苹果、桃子等，农场的园丁要根据客户的需求，提供相应的水果。

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午2:50
 */
public class FactoryExample {

    public static Fruit fruitBean (String fruitKind) throws BadFruitException{
        if ("apple".equals(fruitKind)){
            return new Apple();
        } else if ("pench".equals(fruitKind)){
            return new Pench();
        } else {
            throw new BadFruitException("bad request");
        }
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午2:50
 */
public interface Fruit {
    void plant();

    void grow();

    void reward();
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午2:53
 */
public class Apple implements Fruit {

    public Apple() {
        System.out.println("apple");
    }

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

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

    @Override
    public void reward() {

        System.out.println("apple reward");
    }

    public void color(){
        System.out.println("apple color is red");
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午2:59
 */
public class Pench implements Fruit {

    public Pench() {
        System.out.println("pench");
    }

    @Override
    public void plant() {
        System.out.println("pentch plant");
    }

    @Override
    public void grow() {
        System.out.println("pentch grow");
    }

    @Override
    public void reward() {
        System.out.println("pentch reward");
    }

    public void taste (){
        System.out.println("pentch taste");
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:08
 */
public class BadFruitException extends Exception {

    public BadFruitException(String warnMesg){
        super(warnMesg);
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:11
 */
public class FruitFactoryTest {

    public void test (String fruitKind){
        try {
            FactoryExample.fruitBean(fruitKind);
        } catch (BadFruitException e){
            System.out.println(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        FruitFactoryTest test = new FruitFactoryTest();
        test.test("apple");
        test.test("pench");
        test.test("123");
    }
}

运行后的结果：

apple

pench

bad request

　　2：工厂方法模式

　　　　定义：一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例延迟到其子类。

　　　　适用性：1.当一个类不知道它所必须创建的对象类的时候。

　　　　　　　　2.当一个类希望由他的子类来制定它创建的对象的时候。

　　　　　　　　3.当创建对象的指责委托给多个帮助类子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候。

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:32
 */
public interface IWorkFactory {
    Work getWork();
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:27
 */
public interface Work {
    void doWork();
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:33
 */
public class StudentWorkFactory implements  IWorkFactory {
    @Override
    public Work getWork() {
        return new StudentWork();
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午3:41
 */
public class TeacherWorkFactory implements IWorkFactory{
    @Override
    public Work getWork() {
        return new TeacherWork();
    }
}

public class TeacherWork implements Work {
    @Override
    public void doWork() {
        System.out.println("teacher work");
    }
}

public class StudentWork implements Work {
    @Override
    public void doWork() {
        System.out.println("student work");
    }
}

public class WorkFactoryTest {
    public static void main(String[] args) {
        IWorkFactory stunentWorkFactory = new StudentWorkFactory();
        stunentWorkFactory.getWork().doWork();

        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
        teacherWorkFactory.getWork().doWork();
    }
}

运行结果：

student work
teacher work

　　3.抽象工厂

　　定义一个创建一系列相关或相互依赖对象的接口，而无需指定她们具体的类

　　适用性：1.一个系统要独立于它的产品的创建、组合和表示时

　　　　　　2.一个系统要由多个产品系列中的一个来配置时。

　　　　　　3.当你要强调一系列相关的产品对象的涉及以便进行联合使用时

　　　　　　4.当你提供一个产品类库时，而只是想显示他们的接口而不是实现时。

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:28
 */
public interface IAnimalFactory {
    ICat createCat();
    IDog createDog();
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:32
 */
public class BlackAnimanalFactory implements IAnimalFactory {
    @Override
    public ICat createCat() {
        return new BlackCat();
    }

    @Override
    public IDog createDog() {
        return new BlackDog();
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午7:59
 */
public class WhiteAnimanalFactory implements IAnimalFactory {
    @Override
    public ICat createCat() {
        return new WhiteCat();
    }

    @Override
    public IDog createDog() {
        return new WhiteDog();
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:30
 */
public interface ICat {
    void eat();
}



/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:30
 */
public interface IDog {
    void eat();
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:33
 */
public class BlackCat implements ICat {

    @Override
    public void eat() {
        System.out.println("black cat eat");
    }
}




/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:33
 */
public class BlackDog implements IDog {
    @Override
    public void eat() {
        System.out.println("black dog eat");
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:37
 */
public class WhiteCat implements ICat {
    @Override
    public void eat() {
        System.out.println("white cat is eating");
    }
}



/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午5:38
 */
public class WhiteDog implements IDog {
    @Override
    public void eat() {
        System.out.println("white dog is eating");
    }
}

/**
 * @Author zhangliwei
 * @Date 2018/7/19 下午8:00
 */
public class Client {
    public static void main(String[] args) {
        IAnimalFactory blackAnimalFactory = new BlackAnimanalFactory();
        blackAnimalFactory.createCat().eat();
        blackAnimalFactory.createDog().eat();
        IAnimalFactory whiteAmimalFactory = new WhiteAnimanalFactory();
        whiteAmimalFactory.createCat().eat();
        whiteAmimalFactory.createDog().eat();

    }
}

运行结果：　　

black cat eat
black dog eat
white cat is eating
white dog is eating

六：总结三者区别：

　　1.简单工厂：用来生产同一等级结构中的任意产品（对于新增加的产品，无能为力）

　　2.工厂方法：用来生产同一等级结构中的固定产品（支持增加任意产品）　　

　　3.抽象工厂：用来生产不同产品族的全部产品（对于增加新的产品，无能为力，支持增加产品族）

其实，无论是简单工厂、工厂方法、抽象工厂模式，她们本质都是将不变的地方抽离出来，将可变的部分做成接口，达到最大程度的复用。究竟要用哪种设计模式，要根据具体的业务来决定。