UM2L10——内部类

内部类

Java中的内部类和C#中区别较大，在使用时一定要注意他们的区别之处

1. Java中的内部类在外部使用时必须伴随包裹它的外部类的出现而出现
2. 外部类中的所有内容（包括私有）都可以直接在内部类中使用
3. 内部类和外部类中的同名成员，通过this​ 和 外部类.this​来区分

匿名类使用较少，主要做了解，能看懂即可

Java中的内部类的使用

注意：Java中的内部类的使用和C#有很大的不同

1. Java中的内部类在外部使用时必须伴随包裹它的外部类的出现而出现，声明语法为：

   外部类 outer = new 外部类();
   外部类.内部类 inner = outer.new 内部类();

   也就是说，在外部使用非静态的内部类，必须要先实例化一个外部类对象，再通过这个外部类对象实例化内部类，实际例子：

   Outer outer = new Outer();
   Outer.Inner inner = outer.new Inner();

2. 外部类中的所有内容（包括私有）都可以直接在内部类中使用

   因为内部类是基于外部类实例化的，因此是可以使用外部类对象的成员

   // 外部类
   public class Outer {
       private int i = 1;
       public String str = "123";
       public Inner i1 = new Inner();
   
   
       //在一个类里声明的类，一般成为内部类
       public class Inner {
           public void test() {
               System.out.println(i);
               System.out.println(str);
               i = 10;
               str = "唐老狮";
               System.out.println(i);
               System.out.println(str);
           }
       }
   }

   public class Lesson13 {
       public static void main(String[] args) {
           Outer outer = new Outer();
           Outer.Inner inner = outer.new Inner();
           inner.test();
       }
   }

   输出：

   1
   123
   10
   唐老狮

3. 内部类和外部类中的同名成员，通过 this​ 和 外部类.this​ 来区分

   // 外部类
   public class Outer {
       private int i = 1;
       public String str = "123";
       public Inner i1 = new Inner();
   
   
       //在一个类里声明的类，一般成为内部类
       public class Inner {
           public int i = 2;
   
           public void test() {
               int i = 3;
               System.out.println(i);
               System.out.println(this.i);
               System.out.println(Outer.this.i);
           }
       }
   }

   输出：

   3
   2
   1

匿名内部类

匿名内部类，在声明一个类对象时临时拓展该对象，可以重写方法，但是拓展的内容一般是基于外部类的
常用于重写方法，或者重新声明已有内容，在匿名内部类拓展的新成员变量和成员方法都是不能在外部直接​ ​.​ ​出来用的
可以配合抽象类使用，用于临时实例化一个类似于继承并重写方法的对象

注意：

1. 不能写构造方法
2. 不能定义静态成员
3. 一般基于外部类已有方法实现内容
4. 如果匿名类创建的对象不记录，用完一次后会马上被销毁

// 外部类
public class Outer {
    public void eat() {

    }

    public void speak() {

    }
}

public class Lesson13 {
    public static void main(String[] args) {
        Outer outer2 = new Outer() {
            @Override
            public void eat() {
                System.out.println("吃东西");
            }

            @Override
            public void speak() {
                System.out.println("说话");
            }
        };

        outer2.eat();
        outer2.speak();
    }
}

输出：

吃东西
说话

配合抽象类使用：

public abstract class TestTest {
    public abstract void Test1();
    public abstract void Test2();
}

public class Lesson13 {
    public static void main(String[] args) {
        TestTest tt = new TestTest() {
            @Override
            public void Test1() {
                System.out.println("111");
            }

            @Override
            public void Test2() {
                System.out.println("222");
            }
        };
        tt.Test1();
        tt.Test2();
    }
}

输出：

111
222

‍