设计模式之-三种工厂模式

工厂模式划分：

1、简单工厂模式：又叫静态工厂，只有一个工厂类，工厂类内有静态工厂方法

2、工厂方法模式：工厂抽象化，工厂方法由子类实现

3、抽象工厂模式：产品层次化

三种模式是一步一步的抽象化，刚开始只有一个工厂多类产品，把工厂抽象化之后变为多个工厂多类产品，再把产品分层次后变为多个层次工厂多类产品，举个例子：

人分为男人和女人，简单的划分使用简单工厂模式即可，一个工厂，一个抽象类人，两个具体类男人和女人；

如果还要增加其他的划分，比如老人、小孩等，则需要工厂抽象化，因为在简单工厂增加时需要修改工厂方法的代码，违背了开闭原则；工厂抽象化后一个工厂创建一种人，划分越多类就越多；

如果这时人再加一个地域属性，北方男人、女人，南方男人、女人；那么工厂方法则需要分为男人和女人，工厂类分为北方工厂和南方工厂

一、简单工厂模式

/**
 * 简单工厂：又叫静态工厂，只有一个工厂类，工厂类内有静态工厂方法，根据传入的参数生成不同的产品
 * 
 * @author zhumaoxian 公众号：寻先族谱
 * @date 2023年9月21日
 */
public class SimpleFactory {

    // 静态方法，通过判断返回不同的对象，如果有新增的对象需要修改代码，不符合开闭原则，所以简单工厂模式适合类型个数固定且数量少的情况
    public static Person create(String type) {
        if ("man".equals(type)) {
            return new Man();
        } else if ("weman".equals(type)) {
            return new Weman();
        }
        return null;
    }
}

// 人，使用接口或抽象都可以，只是抽象有单继承的局限性
interface Person {
    abstract void eat();
}

class Man implements Person {

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

class Weman implements Person {

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

}

二、工厂方法模式

/**
 * 工厂方法
 * 
 * @author zhumaoxian 公众号：寻先族谱
 * @date 2023年9月21日
 */
public interface MethodFactory {

    Person1 create();

    public static void main(String[] args) {
        MethodFactory factory = new ManFactory();
        factory.create().eat();
    }
}

class ManFactory implements MethodFactory {

    @Override
    public Person1 create() {
        return new Man1();
    }
}

class WemanFactory implements MethodFactory {

    @Override
    public Person1 create() {
        return new Weman1();
    }

}

// 人，使用接口或抽象都可以，只是抽象有单继承的局限性
interface Person1 {
    abstract void eat();
}

class Man1 implements Person1 {

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

class Weman1 implements Person1 {

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

}

三、抽象工厂模式

/**
 * 抽象工厂
 * 
 * @author zhumaoxian 公众号：寻先族谱
 * @date 2023年9月21日
 */
public interface AbstractFactory {

    Person2 man();

    Person2 weman();

    public static void main(String[] args) {
        AbstractFactory factory = new NorthFactory();
        factory.man().eat();
    }
}

class NorthFactory implements AbstractFactory {

    @Override
    public Person2 man() {
        return new NorthMan();
    }

    @Override
    public Person2 weman() {
        return new NorthWeman();
    }

}

class SouthFactory implements AbstractFactory {

    @Override
    public Person2 man() {
        return new SouthMan();
    }

    @Override
    public Person2 weman() {
        return new SouthWeman();
    }
}

// 人，使用接口或抽象都可以，只是抽象有单继承的局限性
interface Person2 {
    abstract void eat();
}

class NorthMan implements Person2 {

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

class NorthWeman implements Person2 {

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

}

class SouthMan implements Person2 {

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

class SouthWeman implements Person2 {

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

}