内部类（成员内部类、局部内部类、匿名内部类、静态内部类）

最新推荐文章于 2024-06-06 11:01:57 发布

守猪_待兔

最新推荐文章于 2024-06-06 11:01:57 发布

阅读量5.3k

点赞数 10

文章标签：大数据 java 开发语言

本文链接：https://blog.csdn.net/weixin_44216665/article/details/125714168

版权

外部类：单独定义的一个类，不在其他类的内部，只能用 public 和缺省权限修饰符

内部类：在类的内部再定义一个类，根据内部类的定义位置和修饰符的不同，可以分为：

1. 成员内部类：

语法格式：

[修饰符] class 外部类{
[修饰符] class 内部类{ }
}

成员内部类特点：

1.不能使用static关键字，但是可以使用 static final关键字定义常量

2.内部类可以直接访问外部类的成员（包括私有成员）

3.内部类如果想要调用外部类的方法，需要使用 `外部类名.this.外部方法名`

4.可以使用final修饰内部类，表示不能被继承

5.编译以后也会有自己独立的字节码文件， Outer$Inner.class

6.外部函数的static成员的，不允许访问成员的内部类

7.可以在外部类里创建内部类对象，然后在通过方法返回，同事，也可以使用 new Outer().new Inner() 在外部直接访问内部类

public class Test {
    public static void main(String[] args) {
        // 直接使用 new Outer().new Inner() 方法创建一个Inner对象
        Outer.Inner inner1 = new Outer().new Inner();  
        
        // 创建一个 Outer 对象，
        //再调用 Outer 对象的 getInner方法，在getInner方法里创建并返回 Inner 对象
        Outer.Inner inner2 = new Outer().getInner();
    }
}
class Outer {
    int age = 19;
    private String name = "jack";
	
    private void test() {
        System.out.println("我是Outer类里的test方法");
    }
    
    class Inner {  // 可以把 Inner 想象成为和 age / name一样，只不过它的数据类型是class
        // static int a = 10;  报错，不能使用 static
        static final int b = 1;  // 可以使用 static final 定义常量
        private void test() {
            System.out.println("我是Inner类里的test方法");
        }
        public void demo() {
            // 内部类可以直接访问外部类的成员,包括私有成员。
            System.out.println(name);
            this.test();  // 等价于 test() 调用的是内部类的test方法
            Outer.this.test(); // 需要使用 Outer.this 调用外部类的 test 方法
        }
    }
    public static void foo() {
        // Inner inner = new Inner();  报错！外部static成员不允许访问非静态内部类
    }
    public Inner getInner() {
        return new Inner();
    }
}

示例：


//成员内部类
public class MemberOuter {
    private int x = 10;
    private static int m = 5;

    public final class MemberInner {
        private int a = 2;
        // private static int b = 4;
        private static final int c = 5;
        int x = 3;

        public void demo() {
            int x = 1;
            System.out.println("MemberInner类demo方法里的x = " + x);
            System.out.println("MemberInner类demo方法里的this.x = " + this.x);
            System.out.println("MemberInner类demo方法里的MemberOuter.this.x = " + MemberOuter.this.x);
            System.out.println(m);
            xxx();
        }
    }

    public void test() {
        MemberInner inner = new MemberInner();
        inner.demo();
    }

    public static void xxx() {
    }
}


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

        
        //创建成员内部类的对象必须先创建外部类对象！
        //创建成员内部类对象必须要先创建外部类对象

        //方式a：在外部类的内部创建对象并使用
        //方式b: 也可以直接创建一个成员内部类对象(和权限修饰符有关)
                //外部类名.内部类名  变量名 = 外部类对象名.new 成员内部类名();
        MemberOuter memberOuter = new MemberOuter();
        memberOuter.test();

        // MemberOuter.MemberInner memberInner = memberOuter.new MemberInner();
        MemberOuter.MemberInner memberInner = new MemberOuter().new MemberInner();

        
    }
}

总结：

成员内部类：

1. 和成员变量一样，可以使用全部的四种权限修饰符和final修饰符

2. 在成员内部类里可以访问外部类的所有成员变量，调用所有方法，包括静态的。

3.在成员内部类里可以定义非静态成员变量，也可以使用static final 定义静态成员常量，但是不能使用static定义静态变量

4. 调用成员内部类的方法和访问成员内部类里变量，需要先创建成员内部类对象

创建成员内部类对象必须要先创建外部类对象

a.在外部类的内部创建对象并使用

MemberOuter memberOuter = new MemberOuter();
memberOuter.test();

b.也可以直接创建一个成员内部类对象（和权限修饰符有关）

外部类名.内部类名变量名 = 外部类对象名.new 成员内部类名();

MemberOuter.MemberInner memberInner = new MemberOuter().new MemberInner();

5. 在成员内部类里出现内部类成员变量、内部类局部变量、外部类成员变量同名的情况

在方法里直接访问，访问的是局部变量
使用 this.变量名访问内部类的成员变量
使用外部类名.this.变量名访问外部类的成员变量

6. 成员内部类编译以后也会生成一个 .class文件，文件名是外部类名$内部类名.class。

2.静态内部类

静态内部类也被成为嵌套类，静态内部类不会持有外部类对象的引用

语法格式：

[修饰符] class 外部类{
[其他修饰符] static class 内部类{ }
}

静态内部类特点：

1. 使用static关键字修饰

2. 在静态内部类里，可以使用static关键字定义静态成员

3.只能访问外部的静态成员，不能访问外部的非静态成员

4. 外部类可以通过 静态内部类名.静态成员名 访问静态内部类的静态成员

class Outer {
    int age = 19;
    static String type = "outer";

    static class Inner {  // 需要使用 static 关键字
        static int x = 1;  // 能够定义静态变量
        public static void test() {
            // 只能访问外部的静态变量，不能访问非静态变量
            // System.out.println(age);
            System.out.println(type);
        }
    }
    public void  demo() {
        // 外部类可以直接通过 内部类.静态变量名,不需要创建对象
        System.out.println(Inner.x);  
    }
}

示例：

public class StaticOuter {
    private int x = 10;
    private static int m = 3;

    public static final class StaticInner {
        private int a = 5;
        private static int b = 7;
        private int x = 1;
        private static int m = 6;

        public void test() {
            // System.out.println(x);
            // foo();
            int x = 2;
            int m = 9;
            System.out.println("StaticInner类test方法里 x = " + x);  // 2
            System.out.println("StaticInner类test方法里 x = " + this.x);  // 1
            System.out.println("StaticInner类test方法里 m = " + m);  // 9
            System.out.println("StaticInner类test方法里 StatiInner.m = " + StaticInner.m);  // 6
            System.out.println("StaticInner类test方法里 StaticOuter.m = " + StaticOuter.m);  // 3
            demo();
        }

        public static void bar() {
            // System.out.println(x);
        }
    }

    public static void demo() {
    }

    public void foo() {
    }
}

public class InnerDemo {
    public static void main(String[] args) {
        MemberOuter memberOuter = new MemberOuter();
        memberOuter.test();

        // MemberOuter.MemberInner memberInner = memberOuter.new MemberInner();
        MemberOuter.MemberInner memberInner = new MemberOuter().new MemberInner();

        StaticOuter.StaticInner staticInner = new StaticOuter.StaticInner();
        StaticOuter.StaticInner.bar();

    }
}

总结：

静态内部类：

1. 定义的位置和成员内部类的位置一样，使用static关键字修饰

语法上可以理解为成员内部类前面使用static修饰

2. 可以使用四种权限修饰符和 final修饰符

3. 不能访问外部类的非静态成员变量，可以访问外部类的静态成员变量

总结：静态只能访问静态的。不能访问非静态的

4. 可以定义非静态成员变量，也可以定义静态成员变量

5. 创建静态内部类对象，可以不创建外部类对象

静态内部类就像是一个单独的类，只不过借用了外部类的命名空间

StaticOuter.StaticInner staticInner = new StaticOuter.StaticInner();

6. 也会生成独立的 .class文件，文件名是外部类名.静态内部类名

3. 局部内部类

局部内部类定义在外部类的方法中，就像局部变量一样，并不是外部类的成员。

局部内部类在方法外是无法访问到的，但它的实例可以从方法中返回，并且实例在不在被引用之前会一直存在。

语法格式：

[修饰符] class 外部类{
[修饰符] 返回值类型方法名([形参列表]){
[final/abstract] class 内部类{
}
}
}

局部内部类的特点：

1. 定义在类的某个方法里，而不是直接定义在类里

2. 局部内部类前面不能有权限修饰符

3. 局部内部类里不能使用static声明变量

4. 局部内部类访问外部类的静态成员

5. 如果这个局部内部类所在的方法是静态的，它无法访问外部类的非静态成员

6. 局部内部类可以访问外部函数的局部变量，但这个局部变量必须要非final修饰。JDK8以后，final可以省略

class Outer {
    int age = 19;
	static int m = 10;
    
    public void test() {
        // final String y = "good";
        String y = "good";  // JDK8 以后，final可以省略
        class Inner {  // 定义在外部类的某个方法里
            // static int a = 10; 不能定义静态变量!  
            private  void demo() {
                System.out.println(age);
                // 不能修改外部函数的局部变量
				// y = 'yes';
                // 只能访问被 final 修饰的外部函数的局部变量
                // JDK8 以后，如果外部函数的局部变量没有加 final,编译器会自动加 final
                System.out.println(y);
            }
        }
        Inner inner = new Inner();
        inner.demo();
    }
}

示例：

public class LocalOuter {
    private int x = 6;

    public void test() {
        int x = 10;
        int y = 0;

        class LocalInner {
            private int a = 1;
            // private static int b = 2;
            private static final int c = 3;
            private int x = 5;

            public void demo() {
                int x = 1;
                System.out.println("demo方法里的x = " + x);  // 1
                System.out.println("demo方法里的this.x = " + this.x);  // 5
                System.out.println("外部类里的成员变量x = " + LocalOuter.this.x); // 6
                // 如果出现同名的情况，无法再访问 方法里的同名局部变量
                System.out.println(y);
            }
        }
        // y = 3; 局部变量 y 被局部内部类使用了，不能再修改了

        LocalInner localInner = new LocalInner();
        localInner.demo();
    }
}

总结：

局部内部类：

1. 定义在一个方法里，和局部变量定义的位置相同

2. 不能使用任何的权限修饰符和 static修饰符

3. 可以定义非静态成员变量、静态成员变量但不能定义静态变量

4. 局部内部类可以访问所在方法里的局部变量

但是如果出现同名的情况

访问局部内部类里的局部变量直接写变量名

访问局部内部类里的成员变量使用 this.变量名

访问外部类里的成员变量，使用外部类名.this.变量名

不能访问局部内部类所在方法的同名局部变量

5. 被局部内部类访问的局部变量，需要被final修饰。JDK8以后，final可以省略

6. 局部内部类只能在声明它的那个方法里使用

7. 生成独立的.class文件，文件名是外部类名.编号局部内部名

4. 匿名内部类

用来创建一个接口或者抽象类对象

（抽象类或者接口本不可以直接创建对象，可使用匿名内部类方法直接创建）

语法格式：

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

匿名内部类特点：

1. 匿名内部类就是一种特殊的局部内部类，只不过没有名称而已，基本特点和局部内部类一致

2. 匿名内部类不能有构造器，匿名内部类没有类名，肯定无法声明构造器

3. 匿名内部类的前提是，这个内部类必须要继承自一个父类或者父接口

4. 匿名内部类是接口的一种常见简化写法，也是我们开发中最常使用的一种内部类。它的本质是一个实现类父类或者父类接口具体方法的一个匿名对象。

abstract class Animal{
    abstract void shout();
}

class Demo{
    public void demo(){
        Animal animal = new Animal() {
            @Override
            void shout() {
                System.out.println("动物在叫");
            }
        };
    }
}

示例：

AInterface接口

public interface AInterface {
    void test();
}

用AInterface直接创建类，用匿名内部类方法

public class AnonymousDemo {

    public static void main(String[] args) {
        AnonymousDemo x = new AnonymousDemo();
        x.demo();
    }

    public void demo(){

        /*class Son implements AInterface{
            @Override
            public void test() {

            }
        }

        //Son s = new Son();s.test();
        new Son().test();*/

        //匿名内部类
        AInterface a = new AInterface() {
            @Override
            public void test() {
                System.out.println("helloA");
            }
        };

        //对象a的类型不是AInterface类型，而是AInterface类型的子类！这个类没有名字
        a.test();
        System.out.println(a.getClass());


        //匿名内部类 + 匿名对象 :  可以将一个方法当作另一个方法的参数使用
        new AInterface() {
            @Override
            public void test() {
                System.out.println("helloB");
            }
        }.test();
    }
}

匿名内部类的作用：可以将一个方法当作另一个方法的参数使用

public class AnonymousTest {

    public static void main(String[] args) {
        AnonymousTest test = new AnonymousTest();

        Calculator c = new Calculator() {
            @Override
            public int doCalculator(int a, int b) {
                return a+b;
            }
        };
        int x = test.calculate(1,9,c);

        //等价
        int y = test.calculate(1, 9, new Calculator() {
            @Override
            public int doCalculator(int a, int b) {
                return a+b;
            }
        });

        System.out.println(x);
    }

    public int calculate(int a,int b,Calculator calculator){
        return calculator.doCalculator(a, b);
    }
}

interface Calculator{
    int doCalculator(int a,int b);
}