java-内部类

将一个类定义在另一个类或者方法中，这个类称为内部类

内部类分为：成员内部类、局部内部类、匿名内部类

将一个类定义在另一个类的内部，和成员方法同级，
	
格式：
修饰符  class 外部类名称   {
​        //........
​        修饰符 class 内部类名称{
​                 //.....
​         }
}

注意：内用外，随意访问，外用内，必须借助内部类对象
使用成员内部类的方法：

• 1.直接访问： 公式：外部类.内部类 对象名 = new 外部类（）. new 内部类（）；
• 2.间接访问：通过外部类的方法中，使用内部类，然后在main方法中调用外部类的方法。

package Interface.demo9;


public class WaiClass {   //外部类

    public class NeiClass{   
        public void method2(){
            System.out.println("我是内部类");
            System.out.println(a);
        }
    }

    private int a = 20;
    public void method(){
        System.out.println("我是外部类");
        NeiClass neiClass = new NeiClass();
        neiClass.method2();
    }
}

package Interface.demo9;

public class DemoClass {

    public static void main(String[] args) {

        // 方法一：通过外部类的对象，调用外部类的方法，里面间接使用内部类，
        WaiClass waiClass = new WaiClass();
        waiClass.method();

        System.out.println(".......................");

        //方法二：直接定义内部类的对象，来调用内部类的方法
        WaiClass.NeiClass  neiClass = new WaiClass().new NeiClass();
        neiClass.method2();
    }
}

我是外部类
我是内部类
20
…
我是内部类 20

【Outer.this.num】
外部类.this.num;

package Interface.demo9;

public class Outer {
    int num = 10;   //外部类成员变量

    public class inner{
        int num = 20;   //内部类成员变量

        public void method (){

            int num = 30;    //内部类局部变量
            System.out.println(num);   //  10;
            System.out.println(this.num);   //20
            System.out.println(Outer.this.num);   //30
        }

    }
}

package Interface.demo9;

public class Demo2Class {

    public static void main(String[] args) {

        //通过间接方法来创建内部类
        Outer.inner inner = new Outer().new inner();
        inner.method();
    }
}

30
20
10

如果一个类定义在一个方法中，那么我们将这个类称为局部内部类
“局部”：表示只有所属方法才可以使用

package Interface.demo9;

public class Outer2 {   //外部类

    public void method(){
        class Inner{
            int num = 10;
            public void methodInner(){
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}

package Interface.demo9;

public class Demo3Class {

    public static void main(String[] args) {

        Outer2 outer2 = new Outer2();
        outer2.method();
    }
}

10

小结：

1. 权限修饰符：public / protected / (default) / private
2. 外部类：public / (default)
3. 成员内部类 ： public / protected / ( default ) / private
4. 局部内部类：什么都不写

局部内部类如果希望访问所在方法的局部变量，那么这个布局变量必须是用final来修饰

备注：从java8 +开始，这个final可以省略

原因：new 出来的东西放在堆中，，而局部变量是跟着方法走的，在栈内存中，方法运行结束后，立刻出栈，局部变量就会消失，但是new出来的对象会在堆中持续存在，直到垃圾回收。

package Interface.demo9;

public class Outer3 {

    public void method(){
        final int num = 10;  //局部变量
         class inner{
             public void metodInner(){
                 System.out.println(num);
             }
         }
    }
}

如果接口实现类，只需使用一次，那么我们就可以使用匿名内部类

格式： 接口名称 对象名 = new 接口名称（）{

​ //覆盖重写的方法

}

package Interface.demo10;

public abstract interface MyInterface {

    abstract void method();
}

package Interface.demo10;

import Interface.demo10.MyInterface;

public class MyInterfaeImp implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现类抽象方法");
    }
}

package Interface.demo10;

public class DemoMain {

    public static void main(String[] args) {

        MyInterface myInterface = new MyInterfaeImp();
        myInterface.method();

        //使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        };
        obj.method();
    }
}

实现类抽象方法
匿名内部类实现了方法

注意：匿名内部类是省略了【类名称】，而匿名对象是省略了对象名

​ 匿名内部类与匿名对象不是同一回事。