简单工厂、工厂模式、抽象工厂模式、迭代器模式原理及实例

工厂模式

简单工厂模式

基本介绍

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

实例演示

1）UML类图

2）创建蔬菜接口

public interface Vegetable {
    public void sowVegetable();
    public void growthVegetable();
    public void fruitVegetable();
}

3）添加蔬菜种类

public class Carrot implements Vegetable {
    @Override
    public void sowVegetable() {
        System.out.println("播种了：胡萝卜");
    }

    @Override
    public void growthVegetable() {
        System.out.println( "胡萝卜成长了");
    }

    @Override
    public void fruitVegetable() {
        System.out.println("收获了：胡萝卜");
    }
}

4）创建简单工厂

public class VegetableSimpleFactory {
    Vegetable vegetable;
    
    public Vegetable growingVegetable(String variety){
        
        if (variety.equals("胡萝卜")){
            vegetable = new Carrot();
        } else if (variety.equals("豆薯")){
            vegetable = new Jicama();
        } else if (variety.equals("萝卜")){
            vegetable = new Radish();
        } else if (variety.equals("大头菜")){
            vegetable = new Turnip();
        }

        return vegetable;
    }
}

5）创建工人

public class Worker {
    VegetableSimpleFactory simpleFactory = new VegetableSimpleFactory();

    public void receiveMsg(String variety){
        Vegetable vegetable = simpleFactory.growingVegetable(variety);
        vegetable.sowVegetable();
        vegetable.growthVegetable();
        vegetable.fruitVegetable();
    }
}

6）测试

public class Test {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.receiveMsg("胡萝卜");
    }
}

小结

工厂方法模式

模式介绍

演示

1）UML类图

2）创建工厂抽象类

public abstract class VegetableFactory {
    public abstract Vegetable growingVegetable();

    public void creatVegetable(){
        Vegetable vegetable = growingVegetable();
        vegetable.sowVegetable();
        vegetable.growthVegetable();
        vegetable.fruitVegetable();
    }
}

3）创建工厂实例

public class StemVegetableFactory extends VegetableFactory{
    @Override
    public Vegetable growingVegetable() {
        return new Stem();
    }
}

4）测试

public class Test2 {
    public static void main(String[] args) {
        StemVegetableFactory stemVegetableFactory = new StemVegetableFactory();
        stemVegetableFactory.creatVegetable();
    }
}

小结

抽象工厂模式

基本介绍

1. 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)
4. 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展

实例演示

1）UML类图

工厂模式在JDK - Calendar应用的源码分析

if (aLocale.hasExtensions()) {
    String caltype = aLocale.getUnicodeLocaleType("ca");
    if (caltype != null) {
        switch (caltype) {
        case "buddhist":
        cal = new BuddhistCalendar(zone, aLocale);
            break;
        case "japanese":
            cal = new JapaneseImperialCalendar(zone, aLocale);
            break;
        case "gregory":
            cal = new GregorianCalendar(zone, aLocale);
            break;
        }
    }
}

总结

工厂模式的意义

设计模式的依赖抽象原则

迭代器模式

基本介绍

1. 迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式

2. 如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决

3. 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

实例演示

1）UML类图

2）创建菜品类

/*
* 菜单中的菜品的定义
* */
public class Dishes {
    private int price;
    private String menuName;
    private String desc; //菜单描述
    
}

3）创建菜单类

public class Menu1 {
    Dishes[] menu1;
    private int index = 0;

    /*
    * 这里我们直接用构造器来构建菜单
    * */
    public Menu1(int size) {
        menu1 = new Dishes[size];
    }

    public void add(Dishes menu){
        menu1[index] = menu;
        index++;
    }

    /*
    * 创建一个迭代器，每一个菜单存储菜品的方式都是不同的，那么就需要
    * 不同的迭代器来输出
    * */
    public Iterator<Dishes> creatIterator(){
        return new Menu1Iterator(menu1);
    }
}

4）创建出4个菜单的迭代器

/*
* 第一个菜单通过传统数组存储
* */
public class Menu1Iterator implements Iterator<Dishes> {
    Dishes[] menu1;
    private int index = 0; // 遍历数组时需要的数组下标

    // 通过构造器传入需要迭代的数组
    public Menu1Iterator(Dishes[] menu1) {
        this.menu1 = menu1;
    }

    /*
    * 判断数组中是否含有下一个元素，如果有返回为真，如果数组下标
    * 超过了数组的长度或者数组当前下标不含有元素，那么返回为假
    * */
    @Override
    public boolean hasNext() {
        if (index > menu1.length-1 || menu1[index] == null){
            return false;
        } else {
            return true;
        }
    }

    /*
    * 返回当前这个数组下标上的元素，并将数组下标向后移一位
    * */
    @Override
    public Dishes next() {
        Dishes dishes = menu1[index];
        index++;
        return dishes;
    }
}

5）编写测试类

/*
* 测试类：这里是在测试类中向每一个菜单添加添加菜品，当然也可以
* 直接才创建菜单的时候进行添加
*
* 注：其他菜单测试同理
* */
public class ClientMeiTuan {
    public static void main(String[] args) {
        Menu1 menu1 = new Menu1(5);
        Dishes dishes1 = new Dishes(20, "菜名1", "川菜");
        Dishes dishes2 = new Dishes(21, "菜名2", "川菜");
        Dishes dishes3 = new Dishes(22, "菜名3", "川菜");
        Dishes dishes4 = new Dishes(23, "菜名4", "川菜");
        Dishes dishes5 = new Dishes(24, "菜名5", "川菜");

        menu1.add(dishes1);
        menu1.add(dishes2);
        menu1.add(dishes3);
        menu1.add(dishes4);
        menu1.add(dishes5);

        Iterator<Dishes> dishesIterator1 = menu1.creatIterator();

        while (dishesIterator1.hasNext()){
            System.out.println(dishesIterator1.next().toString());
        }
    }
}

6）结果

小结

补充