26.【内部类】 – 源码巴士

内部类

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

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

比如：Person$Heart.class

成员内部类

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

定义格式：

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

访问特点

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

创建内部类对象格式：

外部类名称.内部类名称 对象名 = 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 InnerDeno {
    public static void main(String[] args) {
        // 创建外部类对象
        Person p = new Person();
        // 创建内部类对象
        Person.Heart heart = p.new Heart();

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

结果：

是心动啊~
不，你没心动~

匿名内部类【重点】

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

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

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

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

前提

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

格式

new 父类名或者接口名() {
	// 覆盖重写所有的抽象方法
    @Override
    public void method() {
        // 执行语句
    }
};

使用方式

1. 以接口为例，匿名内部类的使用

定义接口：

public abstract class Fly {
    public abstract void fly();
}

// 也一样
public interface Fly {
    public void fly();
}

创建匿名内部类，并调用：

public class InnerDemo01 {
    public static void main(String[] args) {
        /*
            等号左边:是多态赋值，接口类型引用指向子类对象
            等号右边:是匿名内部类，定义并创建该接口的子类对象
         */
        Fly f = new Fly() {
            @Override
            public void fly() {
                System.out.println("我会飞~~~");
            }
        };
        // 调用fly方法，执行重写后的结果
        f.fly();
    }
}

2. 若方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。

代码如下：

public class InnerDemo02 {
    public static void main(String[] args) {
        /*
            等号左边:是多态赋值，接口类型引用指向子类对象
            等号右边:是匿名内部类，定义并创建该接口的子类对象
         */
        Fly f = new Fly() {
            @Override
            public void fly() {
                System.out.println("我也会飞~~~");
            }
        };
        // 将f传递给showFly方法中
       showFly(f);
    }

    private static void showFly(Fly f) {
        f.fly();
    }
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo03 {
    public static void main(String[] args) {
        /*
            将前两种方法简化为一步
            创建匿名内部类，直接传递给showFly(fly f)
         */
        // 将f传递给showFly方法中
       showFly(new Fly() {
           @Override
           public void fly() {
               System.out.println("我也会飞~~~");
           }
       });
    }

    private static void showFly(Fly f) {
        f.fly();
    }
}

内部类