内部类详解

如果一个事物内部包含另一个事物，就是一个类中包含着其他类。

**例如：**身体和心脏的关系，汽车和发动机的关系。。。

分类:

1. 成员内部类 public /protected/（default）/private
2. 局部内部类（匿名内部类）无访问修饰符

1、成员内部类

package com.hanxiao.inner;

public class Body {
    
    
    private String name;
    
    public class Hert{
    
        public void beat(){
    
            System.out.println("心脏跳动:beng ,beng ,beng !");
            System.out.println("我是： "+ name);
        }
    }
    
    public void methodBody(){
    
        System.out.println("外部类的方法");
        Hert hert = new Hert();
        hert.beat();
    }
}

class Test{
    
    public static void main(String[] args) {
    
        // 1.间接使用：通过外部类中的方法new内部类对象调用
       	Body body = new Body();
        body.methodBody();
        System.out.println("===========");
        //2.直接使用：外部类名称.内部类名称  对象名 = new 外部类名().new 内部类名()
        Body.Hert hert = new Body().new Hert();
        hert.beat();
    }
}

成员内部类变量访问

package com.hanxiao.inner;
public class Outer {
    
    int num = 10; //外部类成员变量
    public class Inner{
    
        int num = 20;//内部类成员变量
        public void methodInner(){
    
            int num = 30;  //内部类局部变量
            System.out.println(num); //内部类局部变量 30
            System.out.println(this.num); //  内部类成员变量 20 
            System.out.println(Outer.this.num); //外部类成员变量  外部类名.this.外部类成员变量 10
        }
    }
}

2、局部内部类

定义在方法内的类，只有当前所属的方法才能使用它，出了这个方法就不能用了

package com.hanxiao.inner;
public class Outer {
    
    public void methodOuter(){
    
        int a = 20;//此处必须为 final int num =10,只是省略了
        class Inner{
    
            int num = 10; 
            public void methodInner(){
    
                System.out.println(num);
                System.out.println(a);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}
class Test2{
    
    public static void main(String[] args) {
    
        //只能这么使用
        Outer outer = new Outer();
        outer.methodOuter();
    }
}

3、匿名内部类，最重要的

如果接口的实现类（或者师父类的子类）只需要使用唯一的一次，这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

定义格式：

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

​ //覆盖重写所有的抽象方法

}；

1. 先得有一个接口

   package com.hanxiao.inner;
   
   public interface MyInterface {
         
       public abstract void method();
   }
   

2. 使用匿名内部类实现调用

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