Java 四大内部类有点全

Java 内部类

基本介绍

一个类的内部又完整的嵌套了另一个结构，被嵌套的类称为 内部类（inner class），嵌套其他类的类称为 外部类 （outer Class），是我们类的第五大成员，内部类可以直接访问其外部类的私有属性。

🚀类的五大成员

1.属性
2.方法
3.构造器
4.代码块
5.内部类

基本语法

内部类分类

1. 定义在外部类局部位置上： （例如方法内）
1）局部内部类
2）匿名内部类
2. 定义在外部类的成员位置上：
1）成员内部类（没用static修饰）
2）静态内部类（使用static修饰）

局部内部类

局部类细节一

局部内部类是定义在外部类的局部位置上的，例如方法中，并且有类名
1. 可以直接访问外部类的所有成员，包括私有属性和私有方法。
2. 不能添加访问修饰符，因为它相当于一个局部变量，局部变量是不可以使用修饰符的，但是可以使用 final 修饰，因为局部变量可以用 final 修饰。
3. 作用域： 只在定义它的方法或者代码块中（和局部变量一样）。
4. 局部内部类访问其外部类的成员可以直接访问，但是外部类访问局部内部类的成员，必须通过创建对象的方式来访问，并且在作用域内。
代码示例

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

class Outer {
    private int n1 = 100;

    private void fun1() {
        System.out.println("外部类fun1方法");
    }

    public void fun2() {
        class Inner {//局部内部类
            public void fun() {
                System.out.println("n1 = " + n1);
                fun1();
            }
        }

        //在作用域内创建内部类对象，访问其fun方法
        Inner inner = new Inner();
        inner.fun();
    }
}

运行结果：

局部类细节二

如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想要访问外部类的成员，可以使用 外部类名.this.成员 来访问。
代码示例

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

class Outer {
    private int num = 100;

    public void fun1() {
        class Inner {
            private int num = 200;//与外部类属性重名
            public void fun() {
                System.out.println("内部类num = " + num);
                System.out.println("外部类num = " + Outer.this.num);
            }
        }

        //在作用域内创建内部类对象，访问其fun方法
        Inner inner = new Inner();
        inner.fun();
    }
}

运行结果：

🚀解读： 外部类名.this. 本质上就是外部类对象，在代码示例中表示调用fun1方法的对象。

匿名内部类

匿名内部类介绍

匿名内部类定义在外部类的局部位置，比如方法中，并且没有类名，它本质上还是一个类，同时还是一个对象。

匿名内部类基本语法

基于接口的匿名内部类

传统的我们使用接口，首先需要创建一个类实现该接口并且重写接口的方法，然后通过这个类创建对象，最后调用其方法，但是如果我们只想使用一次，那么创建一个类是不是显得很不划算呢？这时候就可以借助匿名内部类来简化开发。

代码示例

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.attack();
    }
}

class Hero {
    public void attack() {
        
        Skill skill = new Skill() { //匿名内部类
            @Override
            public void bigMove() {
                System.out.println("英雄释放了大招~~~");
            }
        };
        skill.bigMove(); //调用bigMove方法
    }
}

//接口
interface Skill {
    public void bigMove();
}

运行结果：

🚀解读：

在代码示例中，skill的编译类型是Skill类型，但是其运行类型就是匿名内部类，在JDK底层实现了这个内部类，我们可以认为这个内部类名字为XXXX，这个内部类实现了Skill接口，如下：

基于类的匿名内部类

代码示例

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

class Outer {
    public void fun() {
        Hero hero = new Hero() {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        hero.test();
    }
}

class Hero {
    public void test() {
        System.out.println("Hero中的test方法");
    }
}

运行结果:

🚀解读：

在代码示例中，hero的编译类型为Hero，但是它的运行类型为匿名内部类，在JDK底层实现了这个内部类，我们可以认为这个内部类名字为XXXX，这个内部类继承了Hero类，如下：

🚨注意： 如果是基于抽象类的匿名内部类，就必须重写其方法。

匿名内部类使用细节

1. 匿名内部类可以直接访问外部类的所有成员，包括私有成员。
2. 不可以添加访问修饰符，因为它相当于一个局部变量。
3. 作用域： 仅仅在定义它的方法和代码块中。
4. 外部其他类不可以访问匿名内部类
5. 如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想要访问外部类的成员，可以使用 外部类名.this.成员 来访问。

成员内部类

成员内部类定义在外部类的成员位置，并且没有 static 修饰。

🚀使用细节：
1. 可以直接访问外部类的所有成员，包括私有的。
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它本身就是一个成员。
3. 作用域： 和外部类的其他成员一样，为整个类体。
4. 外部类访问成员内部类，可以在其成员方法中创建对象再访问。
5. 如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想要访问外部类的成员，可以使用 外部类名.this.成员 来访问。
6. 外部其他类访问成员内部类有两种方式：

   //方式一 构建外部类对象
   Outer.Inner inner = outer.new Inner();
   //方式二 在外部类中定义方法，返回内部类对象
   Outer.Inner instance = outer.getInstance();

代码示例

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.fun2();

        //外部其他类访问成员内部类
        //方式一 构建外部类对象
        Outer.Inner inner = outer.new Inner();
        //方式二 在外部类中定义方法，返回内部类对象
        Outer.Inner instance = outer.getInstance();
    }
}

class Outer {
    private int num1 = 10;

    public void fun1()  {
        System.out.println("fun1方法");
    }

    //外部类访问内部类
    public void fun2() {
        Inner inner = new Inner();
        inner.fun();
    }

    public Inner getInstance() {
        return new Inner();
    }

    class Inner {
        private int num1 = 20;//与外部类属性重名
        public void fun() {
            System.out.println("Inner_num1 = " + num1);
            System.out.println("Outer_num1 = " + Outer.this.num1);
        }
    }
}

运行结果：

静态内部类

静态内部类定义在外部类的成员位置，并且使用 static 修饰。

🚀使用细节：
1. 可以直接访问外部类的所有静态成员，包括私有的，但不能访问非静态成员。
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它本身就是一个成员。
3. 作用域： 和外部类的其他成员一样，为整个类体。
4. 外部类访问成员内部类，可以在其成员方法中创建对象再访问。
5. 如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想要访问外部类的成员，可以使用 外部类名.成员 来访问。
6. 外部其他类访问静态内部类有两种方式：

	//外部其他类访问静态内部类
    //方式一 new Outer.Inner();
    Outer.Inner inner = new Outer.Inner();
    //方式二 在外部类中定义方法，返回内部类对象
    Outer.Inner inner1 = new Outer().getInner();

代码示例

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.fun1();

        //外部其他类访问静态内部类
        //方式一 new Outer.Inner();
        Outer.Inner inner = new Outer.Inner();
        //方式二 在外部类中定义方法，返回内部类对象
        Outer.Inner inner1 = new Outer().getInner();
    }
}

class Outer {
    private static int num = 10;

    //外部类访问内部类
    public void fun1() {
        Inner inner = new Inner();
        inner.fun();
    }
    
    public Inner getInner() {
        return new Inner();
    }

    static class Inner {
        private static int num = 20;//与外部类属性命名冲突

        public void fun() {
            System.out.println("Outer_num = " + Outer.num);
            System.out.println("Inner_num = " + num);
        }
    }
}

运行结果：