JAVA的四种内部类及为什么要用内部类

原创 2018年04月16日 17:07:21
        最近在看java的源码,但是时长能看一个类中都会有几个内部类比如LinkedList中
private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (modCount == expectedModCount && nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

然后就开始想为什么java本身中要用内部类呢?

首先介绍下四种内部类

  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类

一 成员内部类

1.没有使用static修饰的内部类。
2.在成员内部类中不允许出现静态变量和静态方法的声明。static只能用在静态常量的声明上。
3.成员内部类中可以访问外部类中所有的成员(变量,方法),包含私有成员,如果在内部类中定义有和外部类同名的实例变量,访问:OuterClass.this.outerMember;
4.构建内部类的实例,要求必须外部类的实例先存在
外部类的外部/外部类的静态方法:new Outer().new Inner();

外部类的实例方法:new Inner();this.new Inner();

二 静态内部类

1.声明在类体部,方法体外,并且使用static修饰的内部类
2.访问特点可以类比静态变量和静态方法
3.脱离外部类的实例独立创建
 在外部类的外部构建内部类的实例 new Outer.Inner();
 在外部类的内部构建内部类的实例 new Inner();

 4.静态内部类体部可以直接访问外部类中所有的静态成员,包含私有

三 局部内部类

 1.定义在方法体,甚至比方法体更小的代码块中
 2.类比局部变量。
 3.局部内部类是所有内部类中最少使用的一种形式。
 4.局部内部类可以访问的外部类的成员根据所在方法体不同。
 如果在静态方法中:可以访问外部类中所有静态成员,包含私有
 如果在实例方法中:可以访问外部类中所有的成员,包含私有。

 局部内部类可以访问所在方法中定义的局部变量,但是要求局部变量必须使用final修饰。

四 匿名内部类

 1.没有名字的局部内部类。
 2.没有class,interface,implements,extends关键字
 3.没有构造器。

 4.一般隐式的继承某一个父类或者实现某一个接口


介绍完四种内部类后来说下我理解的为什么要用内部类

1 起到更好的封装作用,不让你知道具体实现细节,神秘感很足,比如:

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

这个就是LinkedList中的内部类,也是链表结果的实现所需要的类

2 能巧妙躲过java中只能单继承的弊端,比如:

private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }
这个内部类+接口就很好的实现了多继承

Java内部类的使用小结 形参为什么要用final

部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。 *内部类可以是静态static的,也可用public,default,protected和private修饰。(而外部顶级类即类...
  • JIESA
  • JIESA
  • 2017-09-01 15:58:24
  • 261

java 四种内部类区别

Java中的内部类共分为四种:   静态内部类static inner class (also called nested class)   成员内部类member inner class   局部内...
  • tuolaji8
  • tuolaji8
  • 2015-10-13 18:01:40
  • 1280

Java 中的访问修饰符和内部类

内部类: 问:什么是内部类呢? 答:内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。 问:那为什么要将一个类定义在另一个类...
  • qq516230226
  • qq516230226
  • 2017-05-14 01:04:15
  • 400

内部类的特性

内部类是一个比较特殊的类,它有一些特殊的性质,总结如下: 内部类的类型只用于定义它的类或语句块之内,在外部引用它时,必须给出带有外包类名的完整名称,并且内部类的名字不许与外包类的名字相同;内部类可...
  • u014753393
  • u014753393
  • 2016-04-26 00:14:01
  • 360

为什么java内部类访问局部变量必须声明为final?

先抛出让我疑惑了很久的一个问题 编程时,在线程中使用局部变量时候经常编译器会提示:局部变量必须声明为final package test; public class ThreadTest { ...
  • z55887
  • z55887
  • 2015-10-18 19:35:17
  • 3240

Java 四种内部类

Java 内部类  分四种:成员内部类、局部内部类、静态内部类和匿名内部类。  1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问...
  • superit401
  • superit401
  • 2016-07-30 18:01:02
  • 10346

5.6-全栈Java笔记:内部类的四种实现方式

 一般情况,我们把类定义成独立的单元。有些情况下,我们把一个类放在另一个类的内部定义,称为内部类(innerclasses)。 内部类的作用 1.内部类提供了更好的封装。只能让外部类...
  • quanzhanjavabiji
  • quanzhanjavabiji
  • 2017-06-27 11:06:32
  • 745

Java内部类访问外部对象为什么必须是final的呢?

为什么必须是final的呢? 一个谜团 如果你用过类似guava这种“伪函数式编程”风格的library的话,那下面这种风格的代码对你来说应该不陌生: 1 2...
  • WALLEZhe
  • WALLEZhe
  • 2016-08-16 15:12:31
  • 1687

java 四种内部类 使用细节(含代码)

一: 内部类     定义在类体部,方法体部,甚至比方法体更小的代码块内部的类(if 语句里面等)     1.静态内部类(内部类中最简单的形式)         1.声明在类体部,方法体外,并...
  • qq_33599978
  • qq_33599978
  • 2017-04-27 23:28:19
  • 5261

java链表 分别用内部类和外部类实现

java内部类和外部类实现链表数据结构
  • Miss_Jasmine
  • Miss_Jasmine
  • 2016-05-10 23:55:04
  • 934
收藏助手
不良信息举报
您举报文章:JAVA的四种内部类及为什么要用内部类
举报原因:
原因补充:

(最多只允许输入30个字)