建造者模式 构建数据结构的链表

最近迷上设计模式 这次带来的是建造者模式

1.建造者模式
将复杂的对象构建过程 分解开 降低耦合度，大幅提高可读性
2.建造者和工厂模式
个人理解：
建造者侧重于对象构建的过程，精髓在于director中如何去builer组装对象。
工厂模式侧重于构建对象的结果，客户端代码主要关注的是获取作者规定好的对象。
3.使用场景实例
jdk源码是学习设计模式很好的路径
例如：
jdk中 StringBuilder通过append（）拼接 AbstractStringBuilder中的 value[] 字符数组

4.构建链表
先定义链表的节点：

public class LinkedNode<T> {
    /**
     * 数据域
     */
    private T data;
    /**
     * 指针域
     */
    private LinkedNode next;

    public LinkedNode(T data, LinkedNode next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public LinkedNode getNext() {
        return next;
    }

    public void setNext(LinkedNode next) {
        this.next = next;
    }
}

链表类：

public class LinkedList<T> {
    /**
     * 节点
     */
    private LinkedNode<T> linkedNode;

    /**
     * 指针
     */
    private LinkedNode<T> temp;

    /**
     * 初始化链表 设置头节点
     *
     * @param linkedNode
     */
    public LinkedList(LinkedNode<T> linkedNode) {
        this.linkedNode = linkedNode;
        temp=linkedNode;
    }

    public LinkedNode<T> getLinkedNode() {
        return linkedNode;
    }

    public void setLinkedNode(LinkedNode<T> linkedNode) {
        this.linkedNode = linkedNode;
    }

    /**
     * 递归获取尾部节点 复杂度先不管先注重建造者模式
     *
     *
     * @return
     */
    public LinkedNode<T> getLastLinkedNode(){
        if(linkedNode==null){
            throw new RuntimeException("尚未初始化头节点");
        }
        if(temp.getNext()!=null){
           temp=temp.getNext();
          return getLastLinkedNode();
        }
        return temp;
    }

    /**
     * 先序遍历
     *
     */
    public void printList(){
        if(linkedNode==null){
            throw new RuntimeException("尚未初始化头节点");
        }
        System.out.println(temp.getData());
        if(temp.getNext()!=null){
            temp=temp.getNext();
            printList();
        }
    }

    /**
     * 翻转指针
     *
     */
    public void flip(){
        this.temp=this.linkedNode;
    }
}

建造者接口

public interface ILinkedListBuilder<T> {

    ILinkedListBuilder buildLinkedList(T data);

    LinkedList<T> getList();

    /**
     * 为了看到效果 加了一个接口
     */
    void print();
}

Integer类型链表建造者 因为指针需要翻转 所以利用了一点装饰模式的思想

public class IntegerLinkedListBuilder implements ILinkedListBuilder<Integer> {
    /**
     * 初始化头节点
     */
    private LinkedList<Integer> ls;

    public IntegerLinkedListBuilder(LinkedList<Integer> ls) {
        this.ls = ls;
    }

    @Override
    public ILinkedListBuilder buildLinkedList(Integer data) {
        ls.getLastLinkedNode().setNext(new LinkedNode(data,null));
        //翻转指针到头结点
        ls.flip();
        return this;
    }

    @Override
    public LinkedList<Integer> getList() {
        return ls;
    }

    @Override
    public void print(){
        ls.printList();
        ls.flip();
    }
}

测试类 可以；理解为director

public class testBuilder {
    public static void main(String[] args) {
        //初始化头节点
        ILinkedListBuilder<Integer> linkedListBuilder=new IntegerLinkedListBuilder(new LinkedList<>(new LinkedNode<>(12,null)));
        //构建链表 类似于 jdk的linkedList.add();但是linkedList不能linkedList.add().add().add()
        linkedListBuilder.buildLinkedList(11).buildLinkedList(10).buildLinkedList(9);
        //得到链表
        LinkedList<Integer> list = linkedListBuilder.getList();
        //打印链表
        linkedListBuilder.print();
    }
}

debug结果：

从结果看已经形成一条链表