Java内部类学习笔记

内部类：定义在java类内部的类。

定义在文件中的类。一个文件中只能有一个公有类，与文件同名，但是也可以定义其它类。

类的修饰：只能是public或者无。一个类文件中，只能有一个定义成public,与文件同名，其它无修饰。

内部类：

1.成员内部类（非静态内部类）：

作为类的成员，可以使用成员访问修饰符。

如何创建成员内部类的对象：必须先创建外部类的对象，然后使用外部类对象创建内部类对象。

语法：Outer outer = new Outer(); Outer.Inner inner = outer.new Inner();

特点：

1.1.在外部类中，可以直接创建内部类的实例，可以访问内部类的任意（不限修饰符）成员。内部类的成员访问修饰符对外部类不限制，实际上是对其外部类的外部类受限。

1.2.成员内部类，可以任意自由的访问外部类实例的成员，不限访问修饰符。成员内部类持有一个指向其外部类的引用。语法：outer.this.成员

1.3 通过hack的方式，可以间接实现类的多重继承。

Outer.java

public class Outer {
    private String name;

    public Outer(String name) {
        this.name = name;
    }

    void sayhello() {
        System.out.println("hello i am" + name);
    }

    void insayhello() {
        Inner in = new Inner("内部类");
        in.sayhello();
    }

    public class Inner {  //成员内部类
        private String name;

        public Inner(String name) {
            this.name = name;
        }

        void sayhello() {
            System.out.println("hello i am" + name + "i am" + Outer.this.name + "的内部类");
        }
    }
}

Test.java

public class Test {

    public static void main(String[] args) {
        Outer out =new Outer("外部类");
        out.sayhello();
        out.insayhello();
        Outer.Inner in  = out.new Inner("内部类");
        in.sayhello();
    }
}

2.静态内部类：

相对于成员内部类而言，其使用static修饰。相当于类的静态成员（类成员）。

如何创建静态内部类的对象：无须先创建外部类的对象。

语法：

Outer.Inner inner = new Outer.Inner(); 如果通过import导入静态内部类，则Outer可省略。

特点：

2.1 静态内部类是其所在外部类的静态成员（类成员），可以使用成员访问修饰符。创建对象，无须先创建外部类的实例，直接创建对象即可。

2.2 没有指向其外部类实例的引用，不能访问其所在外部类的普通成员，但是可以任意自由的访问其外部类的静态成员。

Outer.java

public class Outer {

    public static class StaticInner {
        void sayhello() {
            System.out.println("i am 静态内部类");
        }
    }
}

Test.java

public class Test {

    public static void main(String[] args) {
        Outer.StaticInner si = new Outer.StaticInner();
        si.sayhello();
    }
}

3.局部内部类：

在除类的作用域之外的作用域内定义的类，一般定义在方法的内部。不能使用成员访问修饰符。其可见性（有效空间作用域），从类定义位置开始，到其所在作用域结束。其有效时间作用域，从代码执行到定义类的位置开始，一直到代码执行到作用域结束。

特点：

3.1 仅在局部有效，在其所在作用域内有效。

3.2 使用场景：一、类仅需在局部有意义。二、局部内部类可以继承其它类，或实现接口，使用多态特性，使用接口或父类的引用指向此类的实例。

Outer.java

public class Outer {

    void jbsayhello() {
        class jbinner {
            void sayhello() {
                System.out.println("i am 局部内部类");
            }
        }
        jbinner jbin = new jbinner();
        jbin.sayhello();
    }
}

 Test.java

public class Test {

    public static void main(String[] args) {
        Outer out = new Outer();
        out.jbsayhello();
    }
}

4.匿名内部类：

使用频率高。

顾名思义，没有名字的内部类。

特点：

在定义类的同时，创建此类的实例，无法第二次创建实例。因为没有类型名称，只能使用超类（祖先类）或接口的引用来指向此内部类的实例。

匿名内部类，必须是继承自其它类，或者实现某接口。

语法：

超类或接口 变量 = new 超类或接口(){

//类定义

};

使用场景：某个对象只需要创建一次的场景。

接口Inter

public interface Inter {
    void sayhello();
}

Outer.java

public class Outer {
    
    Inter inneriter = new Inter(){

        @Override
        public void sayhello() {
            System.out.println("i am 匿名内部类");
        }
    };
}

Test.java

public class Test {

    public static void main(String[] args) {
        Outer out = new Outer();
        out.inneriter.sayhello();
    }
}