java基础之内部类

内部类

内部类是一种较为特殊的类形式，定义在另一个类中的类，叫做内部类，是主类的一部分，可以把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。

作用

内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据
内部类可以对同一个包中的其他类隐藏起来

内部类分为

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

成员内部类

成员内部类可以等同的看做是成员变量，可以有权限修饰符，内部不能有静态声明

public class Outter {

    class Inner {
        public void print(String s) {
            System.out.println(s);
        }
    }

    public Inner buildInner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outter outter = new Outter();
        Inner inner = outter.buildInner();
        inner.print("输出");
    }
}

成员内部类与外部类联系

成员内部类可以使用外部类的所有成员，而且不需要任何特殊条件，且拥有其对于外部类所有元素的访问权。

在创建成员内部类对象时，它会与创建它的外围对象有某种联系隐式引用(内部类对象会秘密的捕获一个指向外部类的引用，通过这个引用可以用来访问外部类的成员)，通过这个隐式引用可以访问外部类的所有成员

public class Sequence {

    private Object[] items;

    private int next;

    public Sequence(int size) {
        items = new Object[size];
    }

    /**
     * 添加元素
     *
     * @param obj
     */
    public void add(Object obj) {
        if (next < items.length) {
            items[next] = obj;
            next++;
        }
    }

    public SequenceSelector selector() {
        return new SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);
        for (int i = 0; i < 10; i++) {
            sequence.add(i);
        }
        SequenceSelector selector = sequence.selector();
        while (!selector.end()) {

            System.out.print(selector.current() + " ");
            selector.next();
        }
    }

    private class SequenceSelector {

        private int current = 0;

        public boolean end() {
            return current == size();
        }

        public int size() {
            return items.length;
        }

        public Object current() {
            return items[current];
        }

        public void previous() {
            if (current > 0) {
                current--;
            }
        }

        public void next() {
            if (current < items.length) {
                current++;
            }
        }
    }
}

使用.this和.new

在成员内部类如何生成外部类对象的引用，使用外部类名.this

public class DoThis {
    class Inner{
        public DoThis outer(){
            return DoThis.this;
        }
    }

    public void f(){
        System.out.println("DoThis.f()");
    }

    public Inner inner(){
        return new Inner();
    }

    public static void main(String[] args) {
        DoThis doThis = new DoThis();
        Inner inner = doThis.inner();
        inner.outer().f();
    }
}

外部类如何创建成员内部类的对象，需要使用外部类实例.new

public class DoNew {

    class Inner {
        public void f(){
            System.out.println("Inner.f()");
        }
    }

    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        Inner inner = doNew.new Inner();
        inner.f();
    }
}

在拥有外部类对象之前是不可能创建成员内部类对象的，成员内部类对象会连接到创建它的外部类对象上，静态内部类不需要外部类对象的引用。

对于私有的成员内部类，外部类是可以访问到它的，其他的类无法访问到，如下

public class DoNew {

    private class Inner {
        public void f(){
            System.out.println("Inner.f()");
        }
    }

    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        // 外部类中可以访问到
        Inner inner = doNew.new Inner();
        inner.f();
    }
}

public class Test {
    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        // 其他类无法访问
        // 'DoNew.Inner' has private access in 'DoNew'
        //doNew.new Inner();
    }
}

成员内部类深度剖析

上面提到在拥有外部类对象之前是不可能创建成员内部类对象的，成员内部类对象会连接到创建它的外部类对象上，这里来说明一下为什么

来看一下这个Sequence.SequenceSelector类的构造器是什么

Javap -c Sequence.SequenceSelector

 com.zhanghe.study.inner.Sequence$SequenceSelector(com.zhanghe.study.inner.Sequence, com.zhanghe.study.inner.Sequence$1);
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #1                  // Method "<init>":(Lcom/zhanghe/study/inner/Sequence;)V
       5: return

发现这个Sequence.SequenceSelector类构造器默认并不是无参构造器，而是要传外部类对象的

局部内部类

在方法作用域内创建的类，称为局部内部类，局部内部类没有访问修饰符，可以等同的看做是局部变量，局部内部类在访问局部变量时，局部变量必须使用final修饰

Variable 'name' is accessed from within inner class, needs to be final or effectively final

public class MethodOuter {

    public Destination desc(String s){
        // 局部内部类
        class Inner implements Destination{
            @Override
            public void f(){
                System.out.println("Inner.f()传入参数"+s);
            }
        }
        return new Inner();
    }

    public static void main(String[] args) {
        MethodOuter methodOuter = new MethodOuter();
        methodOuter.desc("test").f();
    }
}

Inner是desc()方法的一部分，在方法之外访问不到

匿名内部类

匿名内部类，就是没有定义类名的一种嵌套类

如一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余

public interface Contents {
    void f();
}

public class Outer1 {
    public Contents contents(){
        return new Contents(){
            @Override
            public void f() {
                System.out.println("Contents匿名内部类.f()");
            }
        };
    }

    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.contents().f();
    }
}

静态内部类

静态内部类可以等同的看做是静态变量，可以有权限修饰符

静态内部类，内部类对象与外部类对象之间没有联系，将内部类声明为static，普通的内部类对象隐式的保存了一个引用，指向创建它的外部类对象，当内部类是static的时候，意味着

要创建静态内部类的对象，并不需要其外部类的对象

不能从静态内部类的对象中访问非静态的外围对象

普通内部类不能有static数据和static字段，也不能包含静态内部类，但是静态内部类可以。

public class Outer2 {
    private static class Inner2{
        private static int i = 0;
        private static void f(){
            System.out.println("Inner2.f()");
        }
    }

    public static void main(String[] args) {
        Inner2.f();
    }
}