Java从入门到精通15==》内部类、API文档、Object类

Java从入门到精通15

2023.8.2

一、内部类

1、什么是内部类

将一个类定义在另一个类里面或者一个方法里面时，这个类就叫做内部类

2、内部类分类

1.成员内部类

1. 普通内部类
   未被static修饰的成员内部类就称为普通内部类；类中方法外的类
2. 静态内部类
   static修饰的内部成员类就称为静态内部类，这个类属于外部类本省而不属于外部类的某个对象；类中方法外的类

使用：

1. 外部类内
   在外部类中使用内部类，与平常使用普通类相同，唯一区别就是不可以在外部类的静态成员（静态方法，静态初始化块）中使用非静态内部类，静态成员不能访问非静态成员，静态内部类只能访问外部类中的静态成员（静态方法，静态初始化块）
   其中普通内部类方法可以直接访问外部类的任何成员
   普通内部类：

package 外部类内;
class A{  //A类为外部类
class B{  //B类为内部类
    int a=12;
    }
    B b = new B();//在外部类A内直接调用内部类B
}
//验证
public class Demo {//这个类只起到测试功能
    public static void main(String[] args) {
        var x = new A();    //实例化A类，看看A类中是否成功实力化B类
        System.out.println(x.b.a);
    }
}

静态内部类：

package 外部类内;

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(C.c);
        C.a();
    }
   static class C{
    static  int c=23;//静态内部类的静态变量
    static void a(){}//静态内部类的静态发发
   }
}

2. 外部类外
   1. 普通内部类
      初始化:
      外部类.内部类 变量名 = new 外部类().new 内部类()
   2. 静态内部类
      初始化:
      外部类.内部类 变量名 = new 外部类.内部类();

package 外部类外;
public class Demo {
    public static void main(String[] args) {
          System.out.println(new A().new B().a);
          System.out.println(A.C.b);//A类实例化过一次，所以不需要再次实例化
// 不然因为System.out.println(new A().C.b)
    }
}
class A{
    class B{
            int a=0;
    }
    static class C{
           static int b=10;
    }
}

注意：
当成员内部类拥有和外部类同名的成员变量或者方法时，默认情况下访问的是成员内部类的成员，如若像访问外部类成员变量则需要如下形式
外部类.this.成员变量
外部类.this.成员方法

package 同名;
public class Demo {
    int a = 12;
    void x(){
        System.out.println("外部类方法");
    }
    public static void main(String[] args) {
        new Demo().new A().m();
    }
class A{
     int a=18;
     void m(){
         System.out.println(a);
         System.out.println(Demo.this.a);
         x();
         Demo.this.x();

     }
    void x(){
        System.out.println("内部类方法");
    }
    }
}

2.局部内部类

{}内的类生命周期只要{}内，出了{}内生命周期结束

特点：

• 局部内部类只能在所定义的方法体内部使用；
• 不能被public、static等修饰符修饰；
• 不能在局部内部类中定义静态成员；
• 局部内部类不能被public、static等访问限定符修饰，若加上修饰符，就会报错

3.匿名内部类

匿名内部类主要用于快速实现接口和实例化抽象类的
格式：
new 类名(){
//重写该类的所有抽象方法
}；

package 匿名内部类;
public class Demo {
    public static void main(String[] args) {
     A  x=new A(){      //创建一个x对象接收地址值
            void a() {
                System.out.println("重写的抽象类A的抽象方法a");
            }
        };   x.a();
      new  B(){
          public void b() {
              System.out.println("重写的接口抽象方法b");
          }
         }.b();        //直接使用方法
    }
}
abstract class A{
   abstract void a();
}
interface B{
    abstract void b();
}

注意：

1. 类名必须是已存在的接口名或者抽象类名
2. 定义之后必须马上使用，没办法通过引用进行使用
3. 只能实现一个抽象类或者一个抽象方法，可以重写抽象类中非抽象方法
4. 定义匿名内部类是直接生成对象，所以匿名内部类不能为抽象类
5. 重写所有的抽象方法

二、API文档

1、什么是API文档

api文档就是用于说明了每个类、方法的功能和用法等

2、如何使用

1. 搜索类名称，注意可能出现类名称相同，包不相同

2. 找到后所需要的类后，了解类基本信息

   1. 检查包
   2. 看类的基本信息：抽象类、接口、具体类、继承
   3. 了解类的作用
      

3. 使用类，实例化类，只有实例化才能使用其实例方法

4. 仔细看每一个方法的使用权限范围、返回值类型、是否有形参列表

三、Object类

现在我只讲述怎么看API文档，怎么自己学习Java提供好的类，细节以后讲

1、观察类

2、观察方法（大体预览）

3、观察方法的详细信息

看其使用规则，使用权限，形参列表、返回值等等其他的细节，并结合代码论证