内部类。

内部类：

1、成员内部类。

内用外，随意访问。 外用内，需要内部类对象。

public class Body {
    public class Heart{
        public void beat(){
            System.out.println("heart");
        }
    }
    public void methodBody(){
        System.out.println("外部类的方法。");
    }
}

使用：

1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法。

 public void methodBody(){
        new Heart().beat();
        System.out.println("外部类的方法。");
    }

main中，调用methodBody的时候使用了内部类。

2、直接方式：外部类.内部类  对象名 =new 外部类（）. new 内部类 ()。

 public static void main(String[] args) {
        Body.Heart heart=new Body().new Heart();
        heart.beat();
    }

同名变量的访问：

public class Outer {
    int num=10;  //外部类的成员变量
    public class Inner{
        int num=20;  //内部类的成员变量
        public void InnerMethod(){
            int num=30; //方法的局部变量。
            System.out.println(num); //局部变量，就近
            System.out.println(this.num); //内部类的成员变量。
            System.out.println(Outer.this.num); //外部类的成员变量


        }
    }
}

2、局部内部类：

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

只有所属方法能使用它。

不用写访问修饰符。

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

}

 局部内部类的final问题：

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

所以下面num变量是 final的。

public class Outer {
    public void method(){
        int num=10;
        class Inner{
            public void InnerMethod(){
                System.out.println(num);
            }
        }
    }

}

原因：

1、new出来的对象（Inner的对象）在堆内存中

2、局部变量是跟着方法的，在栈内存中。

3、方法运行结束后，局部变量会立刻消失，而new 出来的对象会持续存在，知道垃圾回收。

匿名内部类：

如果接口的实现类（或是父类的子类），只需要使用一次，

那么可以省略该类的定义，而使用【匿名内部类】

匿名内部类的定义格式：

接口名称 对象名 =new 接口名称（）{

     覆盖重写所有抽象方法。

}

接口：

public interface MyInterface {
   public void method();
    }

使用：

public static void main(String[] args) {
      MyInterface obj=new MyInterface() {
          @Override
          public void method() {
              System.out.println("匿名内部类实现了方法。");
          }
      };
      obj.method();
    }

匿名内部类是省略了【实现类/子类名称】，匿名对象是省略了【对象名称】。

类作为成员变量类型。

接口作为成员变量类型。