Java内部类的使用

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

内部类的定义其实一点都不难理解，但是较难理解的是什么时候该用内部类？该用内部类的哪种形式？这个可能是大部分人比较难以理解的。我在这里自己实现一个Java集合中的链式线性表MyLinkedList，然后结合这个实现来发表一下我对内部类的看法。

MyLinkedList实现依赖于下列最基本的类。

    class Node<E> {
        E element;
        Node<E> next;
        
        public Node(E element) {
            this.element = element;
        }
    }

现在需要考虑的是要将这个类定位成public 类，default 类，还是内部类？这个时候就需要分析这个类是用来干什么的。很明显它出现的目的就是为了服务MyLinkedList，其他类并不需要访问到这类，因此应该将这个数据这个类设计成内部类。
<font color="red">这里反问一下，不设计成内部类可以么？</font>是可以的，但是由于Node类只用于LinkedList,所以为了数据封装，应该把它设计成内部类。所以更改如下：

    private class Node<E> {
        E element;
        Node<E> next;
        
        public Node(E element) {
            this.element = element;
        }
    }

内部类还有静态和非静态内部类，这个类该设计成哪种？首先要明白静态内部类和非静态内部类的区别，下面是两者的区别

• 内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用
• 非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。只能访问外部类的静态成员
• 一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面

由于Node不需要访问MyLinkedList任何实例成员变量，所以它应该设计成静态内部类。

    private static class Node<E> {
        E element;
        Node<E> next;
        
        public Node(E element) {
            this.element = element;
        }
    }

下面给出MyLinkedList的实现，里面还有一个非静态内部类LinkedListIterator。这个类为什么需要设计成非静态的？其实是因为它需要访问MyLinkedList的实例成员变量private Node<E> head, tail; ，如果把它改成静态内部类，会报错。可以在IDE里试试更改成静态内部类看看报错信息。

MyLinkedList实现的接口

public interface MyList<T> extends Iterable<T> {
    public void add(T t);
    public void add(int index,T t);
    public void clear();
    public boolean contains(T t);
    public T get(int index);
    public int indexOf(T e);
    public boolean isEmpty();
    public int lastIndexOf(T t);
    public boolean remove(T t);
    public T remove(int index);
    public Object set(int index,T t);
    public int size();
}

MyLinkedList继承的父类

/**
 * @author: gethin
 * @create: 2018-05-22 15:21
 * @description: 
 **/
public abstract class MyAbstrctList<E> implements MyList<E> {
    protected int size = 0;
    
    protected MyAbstrctList() {
    
    }
    
    protected MyAbstrctList(E[] objects) {
        for (int i = 0; i < objects.length; i++) {
            add(size, objects[i]);
        }
    }
    
    @Override
    public void add(E e) {
        add(size, e);
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    @Override
    public boolean remove(E e) {
        if (indexOf(e) >= 0) {
            remove(indexOf(e));
            return true;
        } else {
            return false;
        }
    }
    
    @Override
    public int size() {
        return 0;
    }
    
}

MyLinkedList实现

/**
 * @author: gethin
 * @create: 2018-05-24 10:55
 * @description: 我的链式线性表
 **/

public class MyLinkedList<E> extends MyAbstrctList<E> {
    private Node<E> head, tail;
    
    public MyLinkedList() {
    
    }
    
    public MyLinkedList(E[] object) {
        super(object);
    }
    
    public E getFirst() {
        if (size == 0) {
            return null;
        } else {
            return head.element;
        }
    }
    
    public E getLast() {
        if (size == 0) {
            return null;
        } else {
            return tail.element;
        }
    }
    
    public void addFirst(E e) {
        Node<E> newNode = new Node<>(e);
        newNode.next = head;
        head = newNode;
        size++;
        if (tail == null) {
            tail = head;
        }
    }
    
    public void addLast(E e) {
        Node<E> newNode = new Node<>(e);
        if (tail == null) {
            head = tail = newNode;
        } else {
            tail.next = newNode;
            tail = tail.next;
        }
        size++;
    }
    
    public E removeFirst() {
        if (size == 0) {
            return null;
        } else {
            Node<E> temp = head;
            head = head.next;
            size--;
            if (head == null) {
                tail = null;
            }
            return temp.element;
        }
    }
    
    public E removeLast() {
        if (size == 0) {
            return null;
        } else if (size == 1) {
            Node<E> temp = head;
            head = tail = null;
            size = 0;
            return temp.element;
        } else {
            Node<E> current = head;
            for (int i = 2; i < size - 2; i++) {
                current = current.next;
            }
            Node<E> temp = tail;
            tail = current;
            tail.next = null;
            size--;
            return temp.element;
        }
    }
    
    
    @Override
    public void add(int index, E e) {
        if (index == 0) {
            addFirst(e);
        } else if (index >= size) {
            addLast(e);
        } else {
            Node<E> current = head;
            for (int i = 1; i < index; i++) {
                current = current.next;
            }
            Node<E> temp = current.next;
            current.next = new Node<>(e);
            current.next.next = temp;
            size++;
        }
    }
    
    @Override
    public void clear() {
        head = tail = null;
        size = 0;
    }
    
    @Override
    public boolean contains(E e) {
        if (size == 0) return false;
        Node<E> current = head;
        do {
            if (current.element.equals(e)) {
                return true;
            }
            current = current.next;
        } while (current != null);
        return false;
    }
    
    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            return null;
        } else {
            Node<E> current = head;
            for (int i = 0; i < size; i++) {
                if (index == size) {
                    break;
                }
                current = current.next;
            }
            return current.element;
        }
    }
    
    @Override
    public int indexOf(E e) {
        if (e == null) {
            return -1;
        }
        int index = 0;
        Node<E> current = head;
        for (; index < size; index++) {
            if (current.element.equals(e)) {
                break;
            }
            current = current.next;
        }
        return index < size ? index : -1;
    }
    
    @Override
    public int lastIndexOf(E e) {
        if (e == null) {
            return -1;
        }
        int lastIndex = -1;
        Node<E> current = head;
        for (int i = 0; i < size; i++) {
            if (current.element.equals(e)) {
                lastIndex = i;
            }
            current = current.next;
        }
        return lastIndex;
    }
    
    @Override
    public E remove(int index) {
        if (index == 0 || index >= size) {
            return null;
        } else if (index == 0) {
            return removeFirst();
        } else if (index == size - 1) {
            return removeLast();
        } else {
            Node<E> previous = head;
            for (int i = 1; i < index; i++) {
                previous = previous.next;
            }
            Node<E> current = previous.next;
            previous.next = current.next;
            size--;
            return current.element;
        }
    }
    
    @Override
    public E set(int index, E e) {
        if (index < 0 || index > size) {
            return null;
        } else {
            Node<E> current = head;
            for (int i = 0; i < size; i++) {
                if (index == i) {
                    break;
                }
                current = current.next;
            }
            E old = current.element;
            current.element = e;
            return old;
        }
    }
    
    @Override
    public String toString() {
        StringBuilder result = new StringBuilder("[");
        Node<E> current = head;
        for (int i = 0; i < size; i++) {
            result.append(current.element);
            current = current.next;
            if (current != null) {
                result.append(", ");
            } else {
                result.append("]");
            }
        }
        return result.toString();
    }
    
    @Override
    public Iterator iterator() {
        return new LinkedListIterator();
    }
    
    private class LinkedListIterator implements Iterator<E> {
        private Node<E> current = head;
        
        @Override
        public void remove() {
            Node<E> previous = head;
            while (previous.next != current) {
                previous = previous.next;
            }
            previous.next = previous.next.next;
            size--;
        }
        
        @Override
        public boolean hasNext() {
            return current != null;
        }
        
        @Override
        public E next() {
            E e = current.element;
            current = current.next;
            return e;
        }
    }
    
    //This class is only used in MyLinkedList,so it is private.
    //This class is not need to access any instance numbers of MyLinkedList,so it is defined static 
    private static class Node<E> {
        E element;
        Node<E> next;
        
        public Node(E element) {
            this.element = element;
        }
    }
    
    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        list.add("zhangsan");
        list.add(1, "lisi");
        list.addLast("wangwu");
        list.add("lisi");
        System.out.println(list);
        System.out.println(list.contains("lisi"));
        System.out.println(list.indexOf("lisi"));
        System.out.println(list.lastIndexOf("lisi"));
        list.set(3, "lisi2");
        System.out.println(list);
        Iterator iterator = list.iterator();
        boolean flag = true;
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            if (flag) {
                iterator.remove();
                flag = false;
            }
        }
        System.out.println(list);
    }
}

使用内部类的原因可以总结为：
1. 如果一个类只对另一个类有用，那么将它嵌入该类并将它们保持在一起是合乎逻辑的。 嵌套这样的“帮助类”使得它们的包更加简化
2. 它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过在类A中隐藏类B，可以将A的成员声明为私有，并且B可以访问它们。 另外，B本身可以被外界隐藏起来。
3. 通过在类A中隐藏类B，可以将A的成员声明为私有，并且B可以访问它们。 另外，B本身可以被外界隐藏起来
需要更加全面了解，可以访问Oracle官方教程链接