30.Java_内部类

一、概述

1、什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B称为外部类。

2、成员内部类

• 成员内部类：定义在类中方法外的类

定义格式：

class 外部类{
    class 内部类{
       
    }
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如：汽车类Car中包含发动机Engine，这时，Engine就可以使用内部类来描述，定义在成员位置。

class Car{
    class Engine{
       
    }
}

(1)、访问特点

• 内部类可以直接访问外部类的成员，包括私有成员
• 外部类要访问内部类的成员，必须要建立内部类的对象

创建内部类的对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

• 定义类：

public class Person {
    private boolean live = true;
    class Heart{
        public void jump(){
            // 直接访问外部类成员
            if (live){
                System.out.println("心脏在跳动");
            }else{
                System.out.println("心脏不调动");
            }
        }
    }

    public boolean isLive(){
        return live;
    }

    public void setLive(boolean live){
        this.live = live;
    }
}

• 定义测试类

public class InnerDemo {
    public static void main(String[] args) {
        // 创建外部类对象
        Person p = new Person();
        // 创建内部类对象
        Person.Heart heart = p.new Heart();

        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class 文件，但是之前前面冠以外部类的类名和$符号

(2)、内部类的同名变量访问

// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
    int num = 10; // 外部类的成员变量

    public class Inner{
        int num = 20; // 内部类的成员变量

        public void methodInner(){
            int num = 30;// 局部变量
            System.out.println(num); // 30， 局部变量，就近原则
            System.out.println(this.num);// 20, 内部类的成员变量
            System.out.println(Outer.this.num); // 10， 外部类的成员变量
        }
    }
}


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

3、局部内部类

• 局部内部类：如果一个类是定义在一个方法内部的，那么这就是一个局部内部类，“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

(1) 、定义格式

修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
            // ...
        }
    }
}

(2) 、举例

public class Outer {
    public void methodOuter(){
        class Inner{// 局部内部类
            int num = 10;
            public void methodInner(){
                System.out.println(num); // 10
            }
        }

        Inner inner = new Inner();
        inner.methodInner();
    }
}


public class DemoMain {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();
    }
}

(3)、局部内部类的final问题

• 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

原因：

• new出现的对象在堆内存中
• 局部变量是跟着方法走的，在栈内存当中
• 方法运行结束之后，立刻出栈，局部变量就会立刻消失
• 但是new出来的对象会在堆当中持续存在，直到垃圾回收

public class MyOuter {
    public void methodOuter(){
        int num = 10; // 所在方法的局部变量
      //  num = 20; // 如果加上这句,num 不再是默认的final语句，下面的输出语句报错
        
        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

二、匿名内部类

• 匿名内部类：是内部类的简化写法，它的本质是一个带具体实现的 父类或者父接口的 匿名的子类对象。

开发中，最常用的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几个步骤：

• 定义子类
• 重写接口中的方法
• 创建子类
• 调用重写后的方法

我们的目的，最终只是为了调用方法，能不能简化下，将以上四步合为一步？匿名内部类就是做这样的快捷方式。

1、前提

匿名内部类必须继承一个父类或者实现一个父接口。

2、格式

new 父类名或者接口名{
    // 方法重写
    @Override
    public void method(){
        // 执行语句
    }
};

3、使用方法

public interface FlyAble {
    public abstract void fly();
}

  
public class InnerDemo {
    public static void main(String[] args) {
        /*
        1、等号右边：是匿名内部类，定义并创建该接口的子类对象
        2、等号左边：是多态赋值，接口类型引用指向子类对象
        */
        FlyAble f = new FlyAble() {
            @Override
            public void fly() {
                System.out.println("我飞了~");
            }
        };
        f.fly();
    }
}