10、Java继承与多态 - 内部类的概念与分类 1

什么是内部类？

        如果一个事物的内部包含另一个事物，那么这就是一个内部包含另一个类，称作内部类；

        例如：身体和心脏的关系，又如 -> 汽车和发动机的关系；只有在里边才能正常工作，叫做内部类，心脏只有在身体中才能工作吧，发动机也是一个道理；

而我们的内部类大致上分为两种 ->

        - 成员内部类

        - 局部内部类（包含匿名内部类）

成员内部类的定义格式，如下所示 ->

修饰符 class 外部类名称 {

        修饰符 class 内部类名称 {

                ......

        }

        ......

}

使用内部类时注意：内用外，随意访问；外用内，需要内部类对象； 

如何使用成员内部中的方法呢？有两种方式：

        1. 间接方式：在外部类的方法中调用内部类的方法；然后我们调用外部类的方法即可；

        2. 直接方式：通过创建内部类的对象去直接访问内部类的方法，创建方式 - 如下所示->

外部类名称.内部类名称  对象名  =  new  外部类名称( ).new 内部类名称( )； 

下面用代码，给大家演示一下 ->

创建一个 Body 类 和一个 Heart 内部类，如下所示 ->

public class Body {private String name;public void running() {System.out.println("跑步中......");Heart heart = new Heart(); //外部类不能随意访问内部类，需要创建内部类对象才能访问heart.jump();}public class Heart {public void jump() {System.out.println("我叫：" + name); //内部类可随意访问外部类中的属性System.out.println("心脏跳动-蹦蹦蹦......");}}
}

创建一个 Main.java 文件，如下所示 ->

public class Main {public static void main(String[] args) {//1.调用 running() 方法间接调用内部类 Heart 中的 jump() 方法 ->Body body = new Body();body.running();//2.创建内部类对象 -> 直接调用内部类 Heart 中的 jump() 方法 ->Body.Heart bh = new Body().new Heart();bh.jump();}
}

        在 main() 方法中，我们首先通过 Body 对象去调用 running() 方法，然后间接通过 running() 方法去访问内部类中的 jump() 方法 —— 这是间接访问；

        然后我们通过创建内部类 Heart 的对象 bh 可以直接访问到内部类中的属性 —— 这是直接访问； 

那么在内部类中如何区分 - 同名的 - 外部类成员变量，内部类成员变量，内部类局部变量呢 ？

下面用代码给大家演示一下：

创建一个 Outer 类 ，并在其内部创建一个 内部类 Inner ，如下代码所示 ->

public class Outer {int num = 30;public class Inner {int num = 20;public void InnerMethod() {int num = 10;System.out.println(num);// num = 10System.out.println(this.num);// num = 20System.out.println(Outer.this.num);// num = 30}}
}

        调用内部类 Inner 中的 InnerMethod( ) 方法输出的结果自然是10 20 30 ；

        这里要注意的是如果我们要在内部类中调用外部类的同名成员变量时，要在 this 关键字前加上外部类的名称；

局部内部类 ->

        如果一个类是定义在一个方法内部的，那么这就是一个局部的内部类；

        局部：只有当前所属的方法才能使用它，出了这方法外面就不能用了；

定义格式，如下所示 ->

修饰符 class 外部类名称 {

        修饰符 返回值类型 外部类方法名称 ( 参数列表 ) {

                class 局部内部类名称 {

                        ......

                }

        } 

}

用代码定义，如下所示 ->

public class Outer {public void OuterMethod() {//在OuterMethod()方法中定义一个局部内部类 - Innerclass Inner {//在局部内部类中定义一个方法 InnerMethod()，然后通过局部内部类对象去调用public void InnerMethod() {System.out.println("局部内部类方法......");}}Inner inner = new Inner(); //因为这是局部内部类，所以只能在该方法中创建局部内部类的对象inner.InnerMethod();}
}

通过调用外部类 Outer 中的方法 OuterMethod()，间接调用内部类中的方法 InnerMethod()；如下所示 ->

public class Main {public static void main(String[] args) {Outer outer = new Outer();outer.OuterMethod();}
}

在 局部内部类 中使用到 局部变量 时注意以下几点 ->

        1.如果在局部内部类中使用到局部变量时，该局部变量必须是 -> 有效final

什么是 -> 有效final ？

        就是该变量由 final 关键字修饰，或者只赋值过一次；（后者只有从 Java8 开始才可以实现）；

public class Outer {public void OuterMethod() {// 1. 要么局部变量 num 只赋值一次；// 2. 要么给 num 之前加上final 修饰符int num = 10; class Inner {public void InnerMethod() {System.out.println("num = "+num);}}}
}

给大家解释一下原因，如下 ->

其实之所以这么规定是因为 局部变量 受到 生命周期 的约束 ->

1.new 出来的对象在堆内存中；
2.局部变量是跟着方法走的，在栈内存当中；
3.方法运行结束之后，立刻出栈，局部变量就会立刻被销毁；
4.但是 new 出来的对象会在堆当中持续存在，直到垃圾回收才会 -> 消失；

小结一下类的权限修饰符：

public  >  protected  >  ( default )  >  private

定义一个类的时候，权限修饰符的规则：

        1. 外部类：public  /  ( default ) 

        2.成员内部类：public  /  protected  /  ( default )  /  private

        3.局部内部类：什么都不能写