前言
在这篇文章中，荔枝将会介绍有关迭代器模式、访问者模式和建造者模式的相关知识，其中迭代器和建造者相对来说用的比较多，访问者模式相对来说使用的比较少。重点还是需要理解不同模式的特点吧~希望能帮助到有需要的小伙伴~~~
文章目录
一、迭代器模式Iterator
迭代器模式一般用于容器和容器遍历，在基本的数据结构的底层一般都曹勇了迭代器模式。迭代器模式的应用是为我们提供一种方法顺序访问一个聚合对象中的各个元素，而又无需明确对象内部的遍历逻辑。
为了更好理解这种软件设计模式，我们看看这么一组demo：
首先创建两个接口，一个是迭代器接口Iterator_，另一个是数据结构的总接口Collection_
再定义两个容器类ArrayList_和LinkedList_，这两个类实现Collection_接口，该接口中定义了对容器中的数据进行添加的操作、得到容器大小的操作、以及通过Iterator接口的方法提供了遍历的接口方法。通过实现Collection_接口并重写该接口中的方法得到两个容器类。
ArrayList_
package com.crj.Iterator;
class ArrayList_ implements Collection_ {
Object[] objects = new Object[10];
//objects中下一个空的位置在哪儿,或者说，目前容器中有多少个元素
private int index = 0;
public void add(Object o) {
if(index == objects.length) {
Object[] newObjects = new Object[objects.length*2];
System.arraycopy(objects, 0, newObjects, 0, objects.length);
objects = newObjects;
}
objects[index] = o;
index ++;
}
public int size() {
return index;
}
@Override
public Iterator_ iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator implements Iterator_{
private int currentIndex = 0;
@Override
public boolean hasNext() {
if(currentIndex >= index) return false;
return true;
}
@Override
public Object next() {
Object o = objects[currentIndex];
currentIndex ++;
return o;
}
}
}LinkedList_
package com.crj.Iterator;
/**
* 相比数组，这个容器不用考虑边界问题，可以动态扩展
*/
class LinkedList_ implements Collection_ {
Node head = null;
Node tail = null;
//目前容器中有多少个元素
private int size = 0;
public void add(Object o) {
Node n = new Node(o);
n.next = null;
if(head == null) {
head = n;
tail = n;
}
tail.next = n;
tail = n;
size++;
}
private class Node {
private Object o;
Node next;
public Node(Object o) {
this.o = o;
}
}
public int size() {
return size;
}
@Override
public Iterator_ iterator() {
return null;
}
}
main类
package com.crj.Iterator;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
Collection_ list = new ArrayList_();
for(int i=0; i<15; i++) {
list.add(new String("s" + i));
}
System.out.println(list.size());
//这个接口的调用方式：
Iterator_ it = list.iterator();
while(it.hasNext()) {
Object o = it.next();
System.out.println(o);
}
}
}在main中我们可以看到，我们并不需要知晓两个容器类中各自封装的逻辑以及相应的遍历容器内部元素的逻辑实现，我们只需要通过.next()这种类似指针的迭代器方法就可以获取到容器中的元素，这就是迭代器模式。
二、访问者模式Visitor
在结构不变的情况下动态改变对于内部元素动作的模式，Visitor模式比较适合结构不变的类对象的使用，对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。访问者模式在日常的使用中比较少，它的一个主要的应用场景是做编译器Compiler。这个模式理解起来比较简单，下面我们通过一些代码示例来了解。
public class VisitorPatternDemo {
public static void main(String[] args) {
ComputerPart computer = new Computer();
computer.accept(new ComputerPartDisplayVisitor());
}
}
/*
* 接口
*/
interface ComputerPart {
public void accept(ComputerPartVisitor computerPartVisitor);
}
/*
* 接口实现类
*/
class Keyboard implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
class Mouse implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
/*
* 访问者接口
*/
interface ComputerPartVisitor {
public void visit(Mouse mouse);
public void visit(Keyboard keyboard);
}
//实现类
class ComputerPartDisplayVisitor implements ComputerPartVisitor {
@Override
public void visit(Mouse mouse) {
System.out.println("Displaying Mouse.");
}
@Override
public void visit(Keyboard keyboard) {
System.out.println("Displaying Keyboard.");
}
}不同的访问者接口提供了相应的实现类，通过将访问者接口实现类实例化对象传入ComputerPart的实例化方法中，实现接口相应的方法的调用。
三、建造者模式Builder
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。针对的场景：对于一个类的对象的构建方法中需要传递许多的参数，为了简写demo我们可以通过链式调用生成多个对象的方式来得到最后的复杂类对象的构建。我们可以通过一个demo示例来理解：
首先定义一个TerrainBuilder接口，该接口定义了四个接口方法
package com.crj.builder;
public interface TerrainBuilder {
TerrainBuilder buildWall();
TerrainBuilder buildFort();
TerrainBuilder buildMine();
Terrain build();
}
接着定义接口的实现类，该接口实现类实现了TerrainBuilder接口，demo中对四种接口方法进行了方法重写，最后再build()方法中会将terrain对象返回
package com.crj.builder;
public class ComplexTerrainBuilder implements TerrainBuilder {
Terrain terrain = new Terrain();
@Override
public TerrainBuilder buildWall() {
terrain.w = new Wall(10, 10, 50, 50);
return this;
}
@Override
public TerrainBuilder buildFort() {
terrain.f = new Fort(10, 10, 50, 50);
return this;
}
@Override
public TerrainBuilder buildMine() {
terrain.m = new Mine(10, 10, 50, 50);
return this;
}
@Override
public Terrain build() {
return terrain;
}
}
对象类
package com.crj.builder;
public class Terrain {
Wall w;
Fort f;
Mine m;
}
class Wall {
int x, y, w, h;
public Wall(int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
}
class Fort {
int x, y, w, h;
public Fort(int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
}
class Mine {
int x, y, w, h;
public Mine(int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
}
定义main类
package com.crj.builder;
public class Main {
public static void main(String[] args) {
TerrainBuilder builder = new ComplexTerrainBuilder();
Terrain t = builder.buildFort().buildMine().buildWall().build();
}
}
在main类中，我们可以看到Terrain类对象的实例化是借助于一连串链式的调用方式，而不是传统的调用含参构造函数来实现的。
总结
对于设计模式我们其实需要了解理论即可，不需要区分的特别开，因为不同的软件代码模式往往都包含着多种设计模式。在学习设计模式时还是比较枯燥的哈哈，整理输出后，希望荔枝不会这么快忘记哈哈哈
今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~