Java 内部类：成员内部类 静态内部类 匿名内部类

成员内部类

类中的一个普通成员，类似普通的成员变量和成员方法

内部类的对象如何创建？

• 先创建外部对象再创建内部对象
• Outer.Inner innerObject = new Outer().new Inner()

内部类如何访问其他类中的数据成员？

• 方法内的临时数据变量，直接访问
• 内部类的数据成员:this.xxx
• 外部类的数据成员:OuterClassName.this.xxx

public class Outer{
  private age = 99;
  public static String a;
  // 成员内部类
  public class Inner{
    public static String schoolName; // JDK16才开始支持定义静态成员的
    private String name;
    private int age = 88;
    
    public string getName(){
      return name;
    }
    public string setName(String name){
      this.name = name;
    }
    
    public void test(){
      System.out.println(age);
      System.out.println(a);
      
      int age = 66;
      System.out.println(age); //66
      System.out.println(this.age);//88
      System.out.println(Outer.this.age);//99
    }
  }
}

public class Test{
  public static void main(String args){
    Outer.Inner in = new Outer().new Inner();
    in.test()
  }
}

静态内部类

用static 修饰的内部类，属于外部类自己持有的：

• 创建：
  • 由于类是静态的，所以不用创建外部类的对象就可以创建静态内部类：
  • Outer.Inner innerObject = new Ounter.Inner()
• 静态内部类访问外部类的特点：
  • 可以直接访问外部类的静态成员
  • 不能直接访问外部类的实例成员，必须经过外部类的对象才能访问外部类的实例成员

public class Outer{
  public static class Inner{
  }
}

public class Outer{
  public static String SchoolName;
  private int age;
  // 静态内部类
  public static class Inner{
    public String name;
    public static int a;
        
    public string getName(){
      return name;
    }
    public string setName(String name){
      this.name = name;
    }
    
    public void test(){
      //static 内部类可以访问 static 成员
      System.out.println(schoolName);
      // System.out.println(age);// 实例成员不可访问  
    }
  }
  
  public static void test2(){
    System.out.println(schoolName); // static成员可以访问
    // System.out.println(age);// 非static成员不可访问
  }
}

public class Test{
  public static void main(String args){
    // 创建：
    Outer.Inner in = new Outer.Inner();
    in.test();
  }
}

局部内部类

局部内部类定义在方法中，代码块中，构造器等执行体中的类

public class Test{
  public static void main(String[] args){
    
  }
  
  public static void go(){
    // 局部内部类
    class A{
    
    }
    
    abstract class B{
    
    }
    
    interface C{
    
    }
  }
}

匿名内部类

特殊创建的局部内部类；匿名是指创建的这个内部类没有名字；格式：

new 类/接口(参数值){
    类体(一般是函数的重写)
}

e.g.:
new Animal(){
    @Override
    public void cry(){
        ...
    }
}

使用方式和作用：

class Test{
    public static void main(String[] args){
        Animal cat = new Cat(); // 创建一个父类指针指向子类对象
        cat.cry()
        // 需要有子类cat
        // 有时候我们只需要有一个对象，却要多写一个Cat类
        
        // 使用匿名内部类，可以不用子类名字创建一个子类对象
        Animal a = new Animal(){
            @Override
            public void cry(){
                ...
            }
        }
        a.cry();
    }
}

class Cat extends Animal{
    @Override
    public void cry(){
        ...
    }
}

abstract class Animal(){
    public abstract void cry()
}

特点：

匿名内部类本质是一个子类（实现类），可以更方便的创建一个子类对象

匿名内部类的使用场景

通常作为参数传递给方法

Class Test{
    public static void main(String[] args){
        /*
        Swimming s1 = new Swimming(){
            @Override
            public void swim(){
              System.out.println("dog swim");
            }
        }
        */
        // 作为参数传递给函数，而不需要创建一个父类指针指向的子类对象变量
        go(new Swimming(){
            @Override
            public void swim(){
              System.out.println("dog swim");
            }
        });
    }
    
    // 设计一个方法，可以接收swimming接口的一切实现类对象来参加游泳比赛
    public static void go(Swimming s){
        System.out.println("开始--------");
        s.swim();
    }
}

interface Swimming{
  void swim();
}