内部类

• 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类

• 分类：成员内部类，局部内部类（包含匿名内部类）

成员内部类

public class Hero {//外部类
    private String name;
    float hp;
    float armor;

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

    //外部类方法
    public void method(int s){
        System.out.println("外部类方法");
        new BattleScore().score(s);//使用外部类方法调用内部方法
    }

    public class BattleScore {//内部类
        //内部类方法
        public void score(int s){
            System.out.println(name + "的成绩是" + s);
        }
    }
}

/////////////////////////////////////////////////
public class InnerClassMain {
    public static void main(String[] args) {
        //方法一：通过外部方法间接调用内部方法
        Hero garen = new Hero("garen");
        garen.method(100);

        //方法二：直接调用内部类方法
        Hero.BattleScore sore = new Hero("garen").new BattleScore();
        sore.score(100);
    }
}

• 成员内部类为外部类嵌套一个类

• 访问成员内部类方法有两种：

• 通过外部类间接调用内部类方法

• 直接使用内部类方法： 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

• 内部类成员变量访问顺序：

  public class Outer {
      int num = 30;//外部类成员变量
  
      public class Inner{
          int num = 20;
          public void method(){
              int num = 10;
              System.out.println(num);//输出10
              System.out.println(this.num);//输出20
              System.out.println(Outer.this.num);//输出30
          }
      }
  
      public static void main(String[] args) {
          Outer.Inner obj = new Outer().new Inner();
          obj.method();
      }
  }
  

局部内部类

• 一个类是定义在一个方法内部的，则为局部内部类
• 只有当前所属方法才能使用，外界不能访问，要访问局部内部类要通过间接访问
• 权限修饰符：
  • 外部类：public, (default)
  • 成员内部类：public, protected, (default), private
  • 局部内部类：不能修饰

public class LocalInnerClass {
    //外部类方法
    public void method(){
        //局部内部类，且不能权限修饰符修饰
        class InnerClass{
            int num = 10;
            public void innerMethod(){
                System.out.println(num);
            }
        }
        //外界不能直接访问局部内部类，需要方法内创建对象
        //通过调用方法间接访问
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }

    public static void main(String[] args) {
        LocalInnerClass obj = new LocalInnerClass();
        obj.method();
    }
}

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

匿名内部类

• 如果接口的实现类（或者父类的子类）只需要使用唯一的一次，这种情况下可以省略该类的定义，使用匿名内部类

• 在声明一个抽象类（接口）的同时实例化它，可使代码更加简洁精练

• 接口名称 对象名 = new 接口名称(){ //覆盖重写所有的抽象方法 };

  或者 抽象类名称 对象名 = new 抽象类名称(){ //覆盖重写所有的抽象方法 };

  public abstract class Hero {//外部类
      private String name;
      float hp;
      float armor;
  
      public Hero(String name) {
          this.name = name;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public abstract void attrack();//抽象方法
  }
  
  /////////////////////////////////////////////
  
  public class InnerClassMain {
      public static void main(String[] args) {
          
          //匿名内部类
          Hero ADHero = new Hero("garen"){
              @Override
              public void attrack(){
                  System.out.println(getName()+"其他攻击方法");
              }
          };
          ADHero.attrack();
      }
  }
  

原文：https://www.cnblogs.com/geqianLee/p/13154501.html