手撸Java工厂模式

Java工厂模式

1、 手写简单工厂（抽象类）
2、 手写工厂模式（接口类）
3、 手写抽象工厂模式

手写简单工厂：

定义抽象类abstract，同时定义抽象方法

/**
 * 面条的抽象类
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:11
 * @Version: 1.0
 */
public abstract class INoodler {

    //该类描述了面条的品类
    public abstract String getDes();
}

上面我们定义的抽象类，需要继承

/**
 * 面条品系-有兰州拉面
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:14
 * @Version: 1.0
 */
public class LzNoodler extends INoodler{

    @Override
    public String getDes() {
        return "兰州拉面很好吃，味道是香";
    }
}

工厂

/**
 * 面条工厂 --可以煮哪几种面条
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:16
 * @Version: 1.0
 */
public class SimpleNoodlerFactory {

    /**
     * 店里的面条的种类
     * @param type 1:兰州
     * @return
     */
    public static INoodler createNoodler(int type){
        switch (type){
            case 1:
                return new LzNoodler();//兰州拉面
            default:
                return null;
        }
    }
}

/**
 * 客户来店里点菜 （利用的是抽象类）
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:21
 * @Version: 1.0
 */
public class Customer {

    public static void main(String[] args) {

        //A--点拉州拉面
        INoodler noodler = SimpleNoodlerFactory.createNoodler(1);
        System.out.println(noodler.getDes());

    }
}

手写工厂模式（接口类）

定义一个接口

/**
 * 定义面条 接口
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:25
 * @Version: 1.0
 */
public interface INoodlerFactory {
    //下面定义的是面条的属性

    //味道
    public String getDesc();
}

/**
 * 实现接口
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:28
 * @Version: 1.0
 */
public class MessageFactory implements INoodlerFactory{

    /**
     * 面的味道
     * @return
     */
    public String getDesc() {
        return "味道是辣的";
    }

}

/**
 * 通过接口的模式实现工厂模式
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:31
 * @Version: 1.0
 */
public class CustomerEat {

    public static void main(String[] args) {
        //客户点面
        INoodlerFactory iNoodlerFactory = new MessageFactory();
        System.out.println(iNoodlerFactory.getDesc());
    }
}

手写抽象工厂模式

定义产品1

/**
 * IProduct1 产品1
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:44
 * @Version: 1.0
 */
public interface IProduct1 {
    public String show();//特性
}

/**
 * IProduct1 产品2
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:44
 * @Version: 1.0
 */
public interface IProduct2 {
    public String show();//特性
}

实现接口

public class Product1 implements IProduct1 {

    public String show() {
        return "我是产品1";
    }
}

public class Product2 implements IProduct2 {

    public String show() {
        return "我是产品2";
    }
}

定义工厂用户管理产品接口

/**
 * 工厂 生产 产品1 和产品 2
 * @Date: 2021/9/23 0023 下午 14:48
 * @Version: 1.0
 */
public interface IFactory {

    public IProduct1 createProduct1();

    public IProduct2 createProduct2();

}

实现工厂类的接口

public class Factory implements IFactory {

    public IProduct1 createProduct1() {
        return new Product1();
    }

    public IProduct2 createProduct2() {
        return new Product2();
    }
}

验证

/**
 * 用户在 店里 选择他想要的产品
 * @Description:
 * @Date: 2021/9/23 0023 下午 14:51
 * @Version: 1.0
 */
public class CustomerControler {
    public static void main(String[] args) {
        //在工厂里面选择 1-2
        IFactory factory = new Factory();
        System.out.println(factory.createProduct1().show());
        System.out.println(factory.createProduct2().show());

        //我只需要去维护我工厂能生产的产品就可以
        //不管我们用什么样设计模式，其实都是为了解决 耦合问题
    }
}

总结：无论是使用简单工厂还是使用工厂模式，他们都属于工厂模式，他们的目的是为了解决耦合问题，