学习笔记之Java篇（0728）

p 内部类

1、定义

我们把一个类放在另一个类的内部定义，成为内部类（inner class)
2、内部类的两个要点

1. 内部类提供了更好的封装。只能让外部类直接访问，不允许同一包中的其他类直接访问。
2. 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
3. 注意

内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部类定义的名为Inner的内部类。编译完后会出现Outer.class和Outer$Inner.class两个类的字节码文件。所以内部类是相对独立的一种存在，其成员变量/方法名可以和外部类相同。

3、非静态内部类

非静态内部类（外部类里使用非静态内部类和平时使用其他类没有什么不同）

1. 非静态内部类对象必须及存在一个外部类对象里(Outer.Inner inner = new Outer().new Inner();)里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
2. 非静态内部类可以直接访问外部类成员，但是外部类不能直接访问非静态内部类的成员。
3. 非静态内部类不能有静态方法、静态属性、静态初始化块。
4. 翻译变量访问要点：
   1. 内部类属性：this.变量名
   2. 外部类属性：外部类名.this.变量名

5、内部类的访问

1. 外部类中定义内部类：new Inner()
2. 外部类以外的地方使用非静态内部类：Outer.Inner varname = new Outer().new Inner()

package Package.InnerClass;

/**
 * 测试内部类
 */
public class Outer {
  private int age = 10;
  public void show(){
    System.out.println("Outer.show");
    System.out.println(age);
  }

//  内部类
  public class Inner{
    private int age = 20;
    public void show(){
      System.out.println("Inner.show");
      System.out.println("内部类的age");
      System.out.println(age);
      System.out.println("外部类的age");
      System.out.println(Outer.this.age);
    }
}
//  外部类中定义内部类：`new Inner()`
    Inner i = new Inner();
 

  public static void main(String[] args) {
    Inner inner =new Outer().new Inner();
    inner.show();
  }
} 

package Package.InnerClass;

public class TestInner {
  public static void main(String[] args) {
//    创建外部类对象
    Outer o =new Outer();
    System.out.println("=======================外部类=======================");
    o.show();
//    创建内部类对象
    Outer.Inner inner = new Outer().new Inner();
    System.out.println("=======================内部类=======================");
    inner.show();
  }
}

4、静态内部类

定义方法

static class ClassName{
//类体
}

使用要点

1. 静态内部类可以访问外部类的静态成员，不能方位外部类的普通成员
2. 静态内部类看作外部类的一个静态成员。

package Package.InnerClass;

public class Outer2 {
  private int a = 10;
  private static int b = 20;
//  相当于外部类的一个静态成员
  static class Innter2{
    public void test(){
//      静态内部类不能访问外部类的普通属性
//      System.out.println(a);
//      静态内部类可以访问外部类的静态属性
      System.out.println(b);
    }
}


  public static void main(String[] args) {
//    通过 new 外部类名.内部类名()  来创建内部类对象
    Outer2.Innter2 innter2 = new Outer2.Innter2();
    innter2.test();
  }
}

5、匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。在安卓开发、awt、swing开发中常见。

语法：

new 父类构造器（实参类型）\实现接口（）{
//那么内部类类体！
}

package Package.InnerClass;

public class TestAnonymousInnerClass {
  public void test1(A a){
    a.run();
  }

  public static void main(String[] args) {
    TestAnonymousInnerClass t =new TestAnonymousInnerClass();
//    此处不是创建一个接口对象，只是创建这个匿名类，作为接口的实现方法
    t.test1(new A() {
      @Override
      public void run() {
        System.out.println("第一个匿名内部类");
      }
    });

    t.test1(new A() {
      @Override
      public void run(){
        System.out.println("第二个匿名内部类");
      }
    });
  }
}
interface A{
  void run();
}

6、局部内部类

定义在方法内部的，作用域只限于本方法，称为局部内部类。（实际开发应用很少）

package Package.InnerClass;

public class TestLocalInnerClass {
  public void show(){
//    作用域仅限于该方法
    class Inner3{
      public void fun(){
        System.out.println("局部内部类");
      }
    }

    new Inner3().fun();
  }

  public static void main(String[] args) {
    new TestLocalInnerClass().show();
  }
}

明天work,今天躺平！