工厂模式（Factory）

一、简单工厂模式

简单工厂模式是属于工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式（但简单工厂模式并不属于23种设计模式的范畴，因为它不符合开闭原则）

简单工厂模式中要求所有的产品必须有共同的接口或者父类﹐是属于同一个产品系列的

---

代码实现

实体类：

public class Animal {
    public void say(){
        System.out.println("动物叫声");
    }
}

public class Cat extends Animal{

    @Override
    public void say(){
        System.out.println("miaomiao");
    }
}

public class Dog extends Animal{

    @Override
    public void say(){
        System.out.println("汪汪汪");
    }
}

工厂类：

import com.pang.pojo.Animal;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;

public class BeanFactory {

    public static Animal getAnimal() throws ClassNotFoundException {
        InputStream in = Class.forName("com.pang.util.BeanFactory").getResourceAsStream("/config.xml");
        SAXReader saxRead = new SAXReader();

        try {
            Document document = saxRead.read(in);//把document和config.xml做一个映射
            Element element = (Element) document.selectObject("/animal/animal");
            Animal animal = (Animal) Class.forName(element.getStringValue()).newInstance();
            return animal;
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }
}

最核心的语句

Animal animal = (Animal) Class.forName(element.getStringValue()).newInstance();

也就是通过读取xml中的类去创建实例对象，如果客户不需要狗叫了，需要猫叫，直接通过修改xml中的类就可以满足客户需求，工厂返回的对象类型是Animal，采用了多态，所以不需要改源代码

<?xml version="1.0" encoding="UTF-8" ?>
<animal>
    <animal>com.pang.pojo.Dog</animal>
</animal>

---

二、工厂方法模式

抽象工厂角色，具体工厂角色，抽象产品角色和具体产品角色，简单工厂模式并没有抽象工厂角色，在增加相关产品时，要修改代码，如果用了工厂方法模式，就只需增加相应产品的工厂和具体产品就可以了，符合开闭原则。

要满足所有的产品子类都有同一个父类或接口，属于同一个产品系列

代码实现

• 抽象产品和具体产品

package factory;

/**
 * @author pangjian
 * @Interface Animal
 * @Description 一个抽象产品对应多个具体产品
 * @date 2021/9/27 12:54
 */

public interface Animal {
    void say();
}

class WhileDog implements Animal {
    @Override
    public void say() {
        System.out.println("wang");
    }
}

class BlankCat implements Animal {
    @Override
    public void say() {
        System.out.println("miao");
    }
}

• 抽象工厂和具体工厂

package factory;

/**
 * @author pangjian
 * @ClassName AnimalFactory
 * @Description 抽象工厂和具体工厂
 * @date 2021/9/27 11:20
 */
public interface AbstractFactory {

    Animal getAnimal();

}

class DogFactory implements AbstractFactory {
    @Override
    public Animal getAnimal() {
        return new WhileDog();
    }
}

class CatFactory implements AbstractFactory {
    @Override
    public Animal getAnimal() {
        return new BlankCat();
    }
}

• 客户端测试

public class Client {

    private static AbstractFactory abstractFactory = new CatFactory();

    public static void main(String[] args) {
        Animal cat = abstractFactory.getAnimal();
        cat.say();
    }

}

---

三、抽象工厂模式

抽象工厂模式中，打破了一个具体工厂只能生产一个具体产品的一对一关系，一个具体的工厂类可以生产多个大类的产品，抽象工厂模式就是在工厂方法模式上拓展了具体工厂的功能，使其可以产生多个大类。—系列相互关联的产品,会简化客户端的调用。并且更换产品系列非常方便，更换一个工厂类即可。

现在华为工厂既可以生产手机，也可以生产机械狗，当抽象工厂模式只有一个产品系时候就退化为工厂方法模式

代码实现

• 抽象产品类别和具体产品

public interface Phone {

    void getName();

}

class HuaWei implements Phone{
    @Override
    public void getName() {
        System.out.println("huawei");
    }
}

class Iphone implements Phone {
    @Override
    public void getName() {
        System.out.println("pinguo");
    }
}

• 抽象产品类别和具体产品

public interface Animal {
    void say();
}

class WhileDog implements Animal {
    @Override
    public void say() {
        System.out.println("wang");
    }
}

class BlankCat implements Animal {
    @Override
    public void say() {
        System.out.println("miao");
    }
}

• 抽象工厂和具体工厂

public interface AbstractFactory {

    Animal getAnimal();

    Phone getPhone();

}

class HuaWeiFactory implements AbstractFactory {
    @Override
    public Animal getAnimal() {
        return new BlankCat();
    }

    @Override
    public Phone getPhone() {
        return new HuaWei();
    }
}

class IphoneFactory implements AbstractFactory {
    @Override
    public Animal getAnimal() {
        return new WhileDog();
    }

    @Override
    public Phone getPhone() {
        return new Iphone();
    }
}

• 测试

public class Client {

    private static AbstractFactory abstractFactory = new HuaWeiFactory();

    public static void main(String[] args) {
        Animal cat = abstractFactory.getAnimal();
        cat.say();
        Phone huawei = abstractFactory.getPhone();
        huawei.getName();
    }

}