1.内部类定义

  1.   内部类：是一个相对的概念，即在类中定义类
  • 内部类可以直接访问外部类的所有的成员—包括私有的
  • 外部类要访问内部类的成员，必须要创建对象

  • 内部类：
  • 成员内部类：定义在成员的位置

  • 局部内部类：定义在局部的位置，比如在一个方法内

    2.成员内部类

    成员内部类：

  • 语法：

  • 定义在成员位置的内部类
  • 格式：
  • public class Outer{

class Inner{
//代码
}

  • }
  • 访问格式：
  • 成员内部类创建对象，必须有外部类对象，才能有内部类对象

  • Outer.Inner x=new Outer().new Inner();

  • 在jvm编译的时候，只要有一个class存在就会生成一个.class文件，不管是内部类还是外部类

  • 内部类.class文件的命名：外部类名$内部类名

    1. public class NestedClass {
    2.   //定义一个成员变量
    3.   private String name="王嘉尔";
    5.   //成员内部类--可以使用权限修饰符
    6.   public class Inner{
    7.       //内部类中声明方法
    8.       public void innerMethod(){
    9.           System.out.println("内部类的方法");
    10.           //访问外部类中的内容
    11.           System.out.println("外部的name："+name);
    12.       }
    14.   }
    16.   //生成get/set
    17.   public String getName() {
    18.       return name;
    19.   }
    21.   public void setName(String name) {
    22.       this.name = name;
    23.   }
    24. }
    1. public class NestedClassDemo {
    2.   public static void main(String[] args) {
    3.       //创建成员内部类的对象
    4.       NestedClass.Inner inner=new NestedClass().new Inner();
    5.       inner.innerMethod();
    6.   }
    7. }

    3.局部内部类

    3.1 局部内部类

    语法：

  • 定义在方法的里面—局部

  • 访问格式：

  • 1.创建外部类
  • 2.通过外部类的对象调用方法来操作局部内部类

image.png
注意：定义好局部内部类之后可以使用类—必须使用！！！

  1. //定义好局部内部类之后可以使用类--必须使用！！！
  2.         InnerClass inner=new InnerClass();
  3.         inner.innerMethod();
  1. public class NestedClass {
  2.     //定义一个成员变量
  3.     private String name="王嘉尔";
  5.     //外部类的方法
  6.     public void OuterMethod(){
  7.         //定义一个局部内部类
  8.         class InnerClass{
  9.             //声明一个局部内部类的方法
  10.             public void innerMethod(){
  11.                 System.out.println("局部内部类的方法");
  12.                 System.out.println("外部类的成员变量name："+name);
  13.             }
  14.         }
  15.         //定义好局部内部类之后可以使用类--必须使用！！！
  16.         InnerClass inner=new InnerClass();
  17.         inner.innerMethod();
  18.     }
  20.     //生成get/set
  21.     public String getName() {
  22.         return name;
  23.     }
  25.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  28. }
  1. public class NestedClassDemo {
  2.     public static void main(String[] args) {
  3.         //创建外部类的对象
  4.        NestedClass nc=new NestedClass();
  5.        //通过外部类的对象调用方法来操作局部内部类
  6.         nc.OuterMethod();
  7.     }
  8. }

4.匿名内部类

4.1匿名内部类

  1.   匿名内部类：没有名字的内部类
  • 创建某个类（接口）的子类对象
  • 步骤：
  • 1.定义带名字的类
  • 2.创建对象

  • 意义：
  • 匿名内部类是创建某个类型子类的快捷方式—语法简单
  • 我们临时定义的一个类的子类，并且创建子类的对象而使用的匿名内部类

  • 优点：
  • 1.节省代码量
  • 2.一次性的

  • 格式：

  • new 父类（）{

    1.     //重写父类的方法

  • }

    1. /**
    2. * 父类--抽象类
    3. *
    4. * 吃饭，睡觉
    5. */
    6. public abstract class Animal {
    8.   public abstract void eat();
    10.   public abstract void sleep();
    11. }
    1. /**
    2. * 实现类--子类
    3. *
    4. * 定义子类的方法
    5. * 重写父类的方法
    6. */
    7. public class Dog extends Animal{
    8.   @Override
    9.   public void eat() {
    10.       System.out.println("啃骨头");
    11.   }
    13.   @Override
    14.   public void sleep() {
    15.       System.out.println("睡狗窝");
    16.   }
    17. }

    ```java public class AnonymousInnerClassDemo { public static void main(String[] args) {

    1.   //使用有类名的子类（多态的使用）--父类的引用指向子类的对象
    2.   Animal ad=new Dog();
    3.   ad.eat();
    4.   ad.sleep();
    6.   System.out.println("-------------------");
    8.   //使用匿名内部类的方式实现--创建了一个子类
    9.   Animal a=new Animal() {
    10.       @Override
    11.       public void eat() {
    12.           System.out.println("吃草");
    13.       }
    15.       @Override
    16.       public void sleep() {
    17.           System.out.println("站着睡");
    18.       }
    19.   };
    21.   //使用匿名内部类的方法
  1.     //只是看语法：这个匿名内部类是用来实现线程的--系统中直接拿过来用
  2.     new Thread(){
  3.         @Override
  4.         public void run(){
  6.         }
  7.     };
  8. }

}

  1. <a name="4vQUe"></a>
  2. ### 4.2匿名内部类的应用
  3. ```java
  4. package nimingneibulei;
  6. /**
  7.  * @author Lynn
  8.  * @create 2020-12-05-10:48
  9.  */
  10. public interface Inter {
  11.     public abstract void eat();
  13.     void jump();
  14. }
  1. package nimingneibulei;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-05-10:45
  6.  */
  7. public class Outer {
  8.     public void study(){
  9.         /*new Inter(){
  10.             @Override
  11.             public void eat() {
  12.                 System.out.println("匿名内部类");
  13.             }
  14.         }.eat();*/
  16.         //多次调用匿名内部类
  17.         /*Inter i=new Inter(){
  18.             @Override
  19.             public void eat() {
  20.                 System.out.println("匿名内部类");
  21.             }
  22.         };
  23.         i.eat();
  24.         i.eat();
  25.         i.eat();*/
  26.     }
  28.     public void method(Inter i){
  29.         i.jump();
  30.     }
  31. }
  1. package nimingneibulei;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-05-10:45
  6.  */
  7. public class OuterDemo {
  8.     public static void main(String[] args) {
  9.         Outer o=new Outer();
  10.         o.study();
  12.         o.method(new Inter() {
  13.             @Override
  14.             public void eat() {
  16.             }
  18.             @Override
  19.             public void jump() {
  20.                 System.out.println("狗跳高");
  21.             }
  22.         });
  24.         o.method(new Inter() {
  25.             @Override
  26.             public void eat() {
  28.             }
  30.             @Override
  31.             public void jump() {
  32.                 System.out.println("猫跳高");
  33.             }
  34.         });
  35.     }
  36. }