Java基础 四种内部类

内部类

一个类定义在另一个类的内部；可以把内部类理解成寄生、外部类理解成宿主（人-> 心脏，汽车->发动机）

java类的五大成分：成员变量、成员方法、构造器、代码块、内部类

内部了的分类：

1. 静态内部类
2. 实力内部类
3. 局域内部类【很少见】
4. 匿名内部类【使用频繁】

 

（1）静态内部类

【定义&使用】

public class OuterTest {
    public static void main(String[] args) {

        System.out.println(Outer.num1);         // 10
        System.out.println(new Outer().num2);   // 20

        System.out.println(Outer.Inner.num3);   // 30
        System.out.println(new Outer.Inner().num4); // 40
        
        // 定义内部类对象 外.内 对象 = new 外.内();
        Outer.Inner in = new Outer.Inner();
    }
}


class Outer {
    static int num1=10;
    int num2=20;

    static class Inner{
        static int num3=30;
        int num4=40;
    }
}

（2）实例内部类

【定义&使用】 注意：1、内部类不内用static关键字，static是类属性、方法；2、private在外部类&内部类中是可以相互访问的。

public class OuterTest {
    public static void main(String[] args) {

        // 外部对象
        Outer ou = new Outer();
        System.out.println("ou.num1="+ou.num1);

        // 实例内部类
        // 分步实现    外类.内类 in_1 = 外对象.new 内类();
        Outer.Inner in_1 = ou.new Inner();
        System.out.println(in_1.num2);

        // 外类.内类 in = new 外类().内类()
        Outer.Inner in = new Outer().new Inner();
        System.out.println("in.num2="+in.num2);

        in.show();

    }
}


class Outer {
    private int num = 50;
    int num1 = 10;

    class Inner {
        private int num = 60;
        int num2 = 20;

        public void show() {
            int num = 70;
            System.out.println("show:num="+num);
            System.out.println("inner:num="+this.num);
            System.out.println("outer:num="+Outer.this.num);
        }
    }
}

运行结果：

• ou.num1=10
• in.num2=20
• show:num=70
• inner:num=60
• outer:num=50

（3）局域内部类【很少见】

【定义&使用】 注意：从内部类引用的本地变量必须是最终变量或实际上的最终变量, 可通过反编译生成的class文件观察这个现象

public class AreaClass {

    // 修饰符 返回值类型 方法名(参数列表)
    public static void main(String[] args) {

        // 1- 内部类访问的变量&方法必须是在该类声明前
        // 2-从内部类引用的本地变量必须是最终变量或实际上的最终变量
        final int num = 10;
        // 局域内部类

        class Inner{
            public void show(){
                System.out.println("num="+num); //10
            }
        }

        //num=20;

        Inner in = new Inner();
        in.show();

    }
}

运行结果：num=10

 

（4）匿名内部类【使用频繁】

前提：匿名内部类必须要有父类、父接口，这个匿名类就是父类、父接口的子类

常规的步骤：1、定义子类Mouse；2、重写方法；3、创建子类对象 mouse；4、调用重写后的方法 

如果定义一个只使用一次的类可以使用匿名内部类，目的是为了简化代码

public class AnonymityClass {

    public static void main(String[] args) {

        // 0 历史
        Mouse mouse = new Mouse();
        mouse.UsbProtocol();

        // 1 匿名类
        new Usb(){
            @Override
            public void UsbProtocol() {

            }
        }.UsbProtocol();


        // 2 多态格式： 父类型接收
        Usb usb2 = new Usb(){
            @Override
            public void UsbProtocol() {
                System.out.println("匿名内部类-多态格式： 父类型接收");
            }
        };
        usb2.UsbProtocol();


        // 3 多态中的: 参数多态
        show(new Usb() {
            @Override
            public void UsbProtocol() {
                System.out.println("匿名内部类-多态格式： 参数多态");
            }
        });


        // 4 多态中的 返回值多态
        Usb usb4 = call2();
        usb4.UsbProtocol();


    }

    // 方法1  参数多态
    public static void show(Usb usb ){
        usb.UsbProtocol();
    }

    // 方法2 返回值多态
    public static Usb call2(){
        return new Usb() {
            @Override
            public void UsbProtocol() {
                System.out.println("匿名内部类-多态格式： 返回值多态");
            }
        };
    } // end call2


} // end AnonymityClass


// 父接口
interface Usb{
    public void UsbProtocol();
}


class Mouse implements Usb{
    @Override
    public void UsbProtocol() {
        System.out.println("实现USB接口协议");
    }
}

运行结果：

• 实现USB接口协议
• 匿名内部类-多态格式： 父类型接收
• 匿名内部类-多态格式： 参数多态
• 匿名内部类-多态格式： 返回值多态