手撸Java工厂模式

àì夳堔傛蜴生んèń 2022-09-12 08:53 154阅读 0赞

# 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());
    
            //我只需要去维护我工厂能生产的产品就可以
            //不管我们用什么样设计模式，其实都是为了解决 耦合问题
        }
    }

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