设计模式->创建型模式->工厂方法模式

1.定义：定义一个用于创建对象的单元，让子类决定实例化那个具体的对象，该模式是一个类的实例化延迟到子类

2.UML

3.理论基础：里氏替换原则，继承，多态

4.涉及角色：

        抽象产品：某类产品的抽象，主要定义了产品具有的属性和行为

       抽象产品工厂：定义创建某类抽象产品的方法，返回值为抽象产品类型，该方法由具体的产品工厂实现

        产品工厂：该模式的核心，主要负责产品的创建，创建方法返回值为抽象产品,包含多个api，每个api决定创建具体的产品实力

        具体产品：抽象产品的子类

5.优点

        1.客户端只负责消费对象，不关心对象的创建细节，明确了各自的职责.有利于整体结构的优化

        2.工厂类中不需要包含大量的逻辑

        3.方法内部实现高内聚低耦合

6.缺点

       1. 违背开闭原则。后续其他具体产品加入时需要增加新的API以便生成新的产品对象，随着具体产品的增加工厂类中的API会越来越多，后续该类会越来越臃肿。针对于该缺点可以采用简单工厂中提到的反射+范型进行优化

       2.工厂方法一般都是静态的,无法被子类重载/重写，不具有扩展性

7.使用场景

        1.系统中抽象产品的种类以及具体产品的种类不多且固定

        2.不关心对象的创建，只负责消费对象

8.Code

／／抽象产品

package com.patterns.build.method.factory.common;

public interface Animal {
    public void eat(String food);
}

／／具体产品

package com.patterns.build.method.factory.version1;

import com.patterns.build.method.factory.common.Animal;

public class Fish implements Animal {
    @Override
    public void eat(String food) {
        System.out.println(this.getClass().getSimpleName() + " eat " + food);
    }
}


package com.patterns.build.method.factory.version1;

import com.patterns.build.method.factory.common.Animal;

public class Dog implements Animal{
    @Override
    public void eat(String food) {
        System.out.println(this.getClass().getSimpleName() + " eat " + food);
    }
}

／／工厂方法

package com.patterns.build.method.factory.version1;

import com.patterns.build.method.factory.common.Animal;

public class MethodFactory {

    public static Animal getDog() {
        return new Dog();
    }

    public static Animal getFish() {
        return new Fish();
    }
}

／／客户端

package com.patterns.build.method.factory.version1;

import com.patterns.build.method.factory.common.Animal;

public class MethodFactory {

    public static Animal getDog() {
        return new Dog();
    }

    public static Animal getFish() {
        return new Fish();
    }
}

工厂方法模式标准版

2.UML

3.优点

        1.客户端只负责消费对象，不关心对象的创建细节.

        2.工厂类中不需要包含大量的逻辑

        3.方法内部实现高内聚低耦合

        4.遵循单一职责&开闭原则

        5.对象的实例化延迟到子类

4.缺点

       1. 随着具体产品的增加，工厂会越来越多，导致系统存在大量的工厂

       2.工厂方法一般都是静态的,无法被子类重载/重写，不具有扩展性

5.使用场景

        1.系统中抽象产品的种类以及具体产品的种类不多且固定

        2.不关心对象的创建，只负责消费对象

6.Code

／／具体产品

package com.patterns.build.method.factory.version2;

import com.patterns.build.method.factory.common.Animal;

public class Cat implements Animal {
    @Override
    public void eat(String food) {
        System.out.println(this.getClass().getSimpleName() + " eat " + food);
    }
}



package com.patterns.build.method.factory.version2;

import com.patterns.build.method.factory.common.Animal;

public class Person implements Animal{
    @Override
    public void eat(String food) {
        System.out.print(this.getClass().getSimpleName() + " eat " + food);
    }
}

／／抽象工厂，定义了产生某类产品的具体接口，由于该特性实现了对象实例化延迟到子类，同时也实现了父类的复用

package com.patterns.build.method.factory.version2;

import com.patterns.build.method.factory.common.Animal;


public interface IAnimalFactory {
    public Animal getInstance();
}

／／具体工厂，负责生成一类具体的产品，遵循单一职责，由于每个工厂类只能生成某类具体产品的特性奠定了可扩展的基础

package com.patterns.build.method.factory.version2;

import com.patterns.build.method.factory.common.Animal;

public class CarFactory implements IAnimalFactory {

    private String name;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public Animal getInstance() {
        return new Cat();
    }
}


package com.patterns.build.method.factory.version2;

import com.patterns.build.method.factory.common.Animal;


public class PersonFactory implements IAnimalFactory {

    @Override
    public Animal getInstance() {
        return new Person();
    }
}

／／客户端

package com.patterns.build.method.factory.version2;

public class Cilent {
    public static void main(String[] args) {
        IAnimalFactory factory = new CarFactory();
        factory.getInstance().eat("Fish");

        factory = new PersonFactory();
        factory.getInstance().eat("Food");
    }
}