本文介绍: a简单工厂:不能算是真正意义上的设计模式,但可以客户程序从具体类解耦。b工厂方法使用继承,把对象创建委托子类,由子类实现创建方法可以看作是抽象工厂模式中只有单一产品的情况。c抽象工厂:使对象创建实现工厂接口暴露出来的方法中。工厂模式可以帮助我们针对抽象/接口编程,而不是针对具体类编程,在不同的场景下按具体情况来使用

工厂模式

工厂模式是 Java 中最常用的设计模式之一,工厂模式模式的写法有好几种,这里主要介绍三种简单工厂模式、工厂模式、抽象工厂模式

1、简单工厂模式

这里以制造coffee例子开始工厂模式设计之旅。

我们知道coffee只是一种泛举,在点购咖啡需要指定具体的咖啡种类:美式咖啡、卡布奇诺、拿铁等等。

/**
 * 拿铁、美式咖啡、卡布奇诺等均为咖啡家族的一种产品
 * 咖啡则作为一种抽象概念
 * @author Lsj
 *
 */
public abstract class Coffee {
    /**
     * 获取coffee名称
     * @return
     */
    public abstract String getName();
}

/**
 * 美式咖啡
 * @author Lsj
 *
 */
public class Americano extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

/**
 * 卡布奇诺
 * @author Lsj
 *
 */
public class Cappuccino extends Coffee {

    @Override
    public String getName() {
        return "卡布奇诺";
    }
}
/**
 * 拿铁
 * @author Lsj
 *
 */
public class Latte extends Coffee {

    @Override
    public String getName() {
        return "拿铁";
    }
}

2、工厂模式

定义一个创建对象接口,但由子类决定要实例化的类是哪一个,工厂方法让类把实例化推迟到了子类

/**
 * 定义一个抽象的咖啡工厂
 * @author Lsj
 */
public abstract class CoffeeFactory {
    
    /**
     * 生产可制造的咖啡
     * @return
     */
    public abstract Coffee[] createCoffee();

}

/**
 * 中国咖啡工厂
 * @author Lsj
 *
 */
public class ChinaCoffeeFactory extends CoffeeFactory {
    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Cappuccino(), new Latte()};
    }
}
/**
 * 美国咖啡工厂
 * @author Lsj
 *
 */
public class AmericaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Americano(), new Latte()};
    }

}
/**
 * 工厂方法测试
 * @author Lsj
 *
 */
public class FactoryMethodTest {

    static void print(Coffee[] c){
        for (Coffee coffee : c) {
            System.out.println(coffee.getName());
        }
    }
    public static void main(String[] args) {
        CoffeeFactory chinaCoffeeFactory = new ChinaCoffeeFactory();
        Coffee[] chinaCoffees = chinaCoffeeFactory.createCoffee();
        System.out.println("中国咖啡工厂可以生产的咖啡有:");
        print(chinaCoffees);
        CoffeeFactory americaCoffeeFactory = new AmericaCoffeeFactory();
        Coffee[] americaCoffees = americaCoffeeFactory.createCoffee();
        System.out.println("美国咖啡工厂可以生产的咖啡有:");
        print(americaCoffees);
    }
}

3、抽象工厂

提供一个接口用于创建相关或依赖对象的家族,而不需要明确指定具体类。

在上述的场景上继续延伸:咖啡工厂做大做强,引入了新的饮品种类:茶、 碳酸饮料。中国工厂只能制造咖啡和茶,美国工厂只能制造咖啡和碳酸饮料。

如果用上述工厂方法方式,除去对应的产品实体类需要新增2个抽象工厂(茶制造工厂、碳酸饮料制造工厂),4个具体工厂实现。随着产品的增多,会导致类爆炸。

所以这里引出一个概念产品家族,在此例子中,不同的饮品就组成我们的饮品家族, 饮品家族开始承担创建者的责任负责制造不同的产品。

/**
 * 抽象的饮料产品家族制造工厂
 * @author Lsj
 *
 */
public interface AbstractDrinksFactory {

    /**
     * 制造咖啡
     * @return
     */
    Coffee createCoffee();
    
    /**
     * 制造茶
     * @return
     */
    Tea createTea();
    
    /**
     * 制造碳酸饮料
     * @return
     */
    Sodas createSodas();
}


/**
 * 中国饮品工厂
 * 制造咖啡与茶
 * @author Lsj
 *
 */
public class ChinaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return new MilkTea();
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return null;
    }

}


/**
 * 美国饮品制造工厂
 * 制造咖啡和碳酸饮料
 * @author Lsj
 *
 */
public class AmericaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return new CocaCola();
    }

}


/**
 * 抽象工厂测试类
 * @author Lsj
 *
 */
public class AbstractFactoryTest {
    
    static void print(Drink drink){
        if(drink == null){
            System.out.println("产品:--" );
        }else{
            System.out.println("产品:" + drink.getName());
        }
    }
    
    public static void main(String[] args) {
        AbstractDrinksFactory chinaDrinksFactory = new ChinaDrinksFactory();
        Coffee coffee = chinaDrinksFactory.createCoffee();
        Tea tea = chinaDrinksFactory.createTea();
        Sodas sodas = chinaDrinksFactory.createSodas();
        System.out.println("中国饮品工厂有如下产品:");
        print(coffee);
        print(tea);
        print(sodas);
        
        AbstractDrinksFactory americaDrinksFactory = new AmericaDrinksFactory();
        coffee = americaDrinksFactory.createCoffee();
        tea = americaDrinksFactory.createTea();
        sodas = americaDrinksFactory.createSodas();
        System.out.println("美国饮品工厂有如下产品:");
        print(coffee);
        print(tea);
        print(sodas);
    }
}

4、总结

a、简单工厂:不能算是真正意义上的设计模式,但可以将客户程序从具体类解耦。

b、工厂方法:使用继承,把对象创建委托子类,由子类实现创建方法,可以看作是抽象工厂模式中只有单一产品的情况。

c、抽象工厂:使对象的创建被实现在工厂接口暴露出来的方法中。

工厂模式可以帮助我们针对抽象/接口编程,而不是针对具体类编程,在不同的场景下按具体情况来使用。

原文地址:https://blog.csdn.net/weixin_44797327/article/details/134721915

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。

如若转载,请注明出处:http://www.7code.cn/show_14017.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注