Java开发岗位面试被问到嵌套类怎么办

时间:2022-04-13 20:46:13

嵌套类分类

  • 静态内部类(静态嵌套类/静态成员类/静态类)
  • 内部类(非静态嵌套类)

内部成员类

本地内部类

匿名内部类

  • 嵌套接口

静态内部类

重要的结论:如果一个类被声明为static(即static修饰class),只有一种情况,该类是静态内部类。

1. 静态内部类中能声明哪些类,变量和方法?

没有限制,可以声明各种类型的类,变量,方法和静态代码块,细分为:

类:

  • 枚举类
  • 静态内部类
  • 内部类
  • 接口

变量:

  • 静态变量
  • 实例变量

方法:

  • 静态方法
  • 实例方法
  • 静态代码块

2. 静态内部类能访问外围类的哪些变量和方法?

静态内部类可以访问外围类的任何成员,包括外围类中声明为private的成员,分为:

  • 外围类的静态变量和方法(含私有):直接访问
  • 外围类的实例变量和方法(含私有):通过外围类的实例对象进行访问
  • 静态内部类类似类的静态变量,不需要依赖外围类的实例对象而存在,可以看作是顶层类,可以直接通过外围类来访问。

3. 继承方面

在继承方面,静态内部类与外围类没什么分别,在访问权限允许的情况下:任何类都可以继承静态内部类,静态内部类也可以继承任何类(类没有声明为final)或实现任何接口。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class OuterClass {
    // 静态变量
    final static boolean FLAG_VALUE = true;
    private static String name = "Outer Class";
    // 实例变量
    private int age;
    // 静态方法
    private static String getName() {
        return name;
    }
    // 实例方法
    private void setAge(int age) {
        this.age = age;
    }
    // 静态内部类
    public static class StaticInner {
        // 声明静态变量
        final static int x = 1;
        static int y = 2;
        // 声明实例变量
        int a;
        // 声明静态代码块
        static { }
        // 声明枚举类
        enum InnerEnum { }
        // 声明静态内部类
        static class Inner2 { }
        // 声明接口
        interface Inner3 { }
        // 声明内部类
        class Inner4 { }
        // 声明静态方法
        static void OperateStatic() {           
            System.out.println("静态内部类直接访问外围类的静态变量:name = " + name + ", FLAG_VALUE = " + FLAG_VALUE);
            System.out.println("静态内部类直接访问外围类的静态方法:getName : " + getName());
            // 静态内部类不能直接访问外围类的实例变量和方法
            //age = 30;
            //setAge(30);
            // 通过声明外围类对象,访问外围类对象的实例变量和方法
            OuterClass outerClass = new OuterClass();
            outerClass.age = 30;
            outerClass.setAge(30);
        }//加入Java开发交流君样:756584822一起吹水聊天
        // 声明实例方法
        void operate() {
            System.out.println("静态内部类直接访问外围类的静态变量:name = " + name + ", FLAG_VALUE = " + FLAG_VALUE);
            System.out.println("静态内部类直接访问外围类的静态方法:getName : " + getName());
            // 静态内部类不能直接访问外围类的实例变量和方法
            //age = 30;
            //setAge(30);
            // 通过声明外围类对象,访问外围类对象的实例变量和方法
            OuterClass outerClass = new OuterClass();
            outerClass.age = 30;
            outerClass.setAge(30);
        }
    }
}

内部类

1. 细分类

内部成员类

本地内部类(本地类/局部类)

匿名内部类(匿名类)

2. 内部类中能声明哪些类,变量和方法?

内部类可以声明实例变量,实例方法,final类型的静态变量。
内部类不可以声明静态成员:包括静态变量,静态方法,静态内部类,嵌套接口,静态初始化块。
细分为:

类:

  • 只能声明内部类
  • 不能声明枚举类,静态内部类,接口

变量:

  • 只能声明实例变量,final类型静态变量
  • 不能声明静态变量

方法:

  • 只能声明实例方法
  • 不能声明静态方法
  • 不能声明静态代码块

3. 内部类能访问外围类的哪些变量和方法?

没有限制,外围类的所有变量和方法(含私有)都可以直接访问。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class OuterClass {
    // 静态变量
    final static boolean FLAG_VALUE = true;
    private static String name = "Outer Class";
    // 实例变量
    private int age;
    // 静态方法
    private static String getName() {
        return name;
    }
    // 实例方法
    private int getAge() {
        return age;
    }
    // 内部类
    public class Inner {
        // 内部类不能声明静态变量
        //private static String innerName = "Inner Class";
        // 内部类只能声明实例变量和final类型静态变量
        private int a;
        final static int x = 1;
        // 内部类不能声明静态代码块,枚举类,静态内部类,接口(枚举类型和接口类型总是静态的)
        //static { }
        //enum InnerEnum { }
        //static class Inner2 { }
        //interface Inner3 { }
        // 内部类声明内部类
        class Inner4 { }
        // 内部类不能声明静态方法
        //static void OperateStatic() { }
        // 内部类只能声明实例方法
        void operate() {
            System.out.println("内部类访问外围类的静态变量:name = " + name);
            System.out.println("内部类访问外围类的静态final变量:FLAG_VALUE = " + FLAG_VALUE);
            System.out.println("内部类访问外围类的实例变量:age = " + (age = 40));
            System.out.println("内部类访问外围类的静态方法:getName() = " + getName());
            System.out.println("内部类访问外围类的实例方法:getAge() = " + getAge());
        }//加入Java开发交流君样:756584822一起吹水聊天
    }
}

4. 内部类是怎样绑定外围对象?

总结: 创建内部类对象(调用内部类的构造器)时,编译器会隐式地在内部类中声明一个final的外围类类型的成员变量,然后将外围类的对象,通过内部类的构造器传递给该final成员变量,用来将内部类对象绑定到外围类对象。

?
1
2
3
4
5
6
7
8
9
10
11
public class Outer {
    public class Inner {
        // 编译器自动隐式生成的外围类类型的成员变量
        final Outer this$0;
        // 通过内部类构造器将外围类的对象传递给this$0成员变量,实现内部类与外围类对象的绑定
        public Inner(Outer outer) {
            this$0 = outer;
            super();
        }
    }
}

创建内部类对象,如下:

?
1
2
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

创建内部类对象时,系统会自动将外围类的对象(outer)作为参数传入内部类的构造器中,可认为是下面的方式:

?
1
Outer.Inner inner = outer.new Inner(outer);

5. 继承方面

在访问权限允许的情况下:内部类可以继承任何类,也可以由任何类继承。

问:那内部类与静态内部类在继承方面有什么区别呢?

答:内部类的对象总是要依赖于外部对象,因此一个类A继承了一个内部类,则类A也必须要与内部类的外围类对象相绑定,否则产生编译错误。

1.反例:产生编译错误

?
1
2
3
4
5
public class A extends Outer.Inner { }
 
class Outer {
    class Inner { }
}

2.错误原因:想要创建A类对象,即A a = new A(); 会调用A类构造器,A类继承内部类(Outer.Inner),则会调用内部类的构造器

这时没有有效的外围类对象,则无法实现内部类对象与外围类对象的绑定,产生编译错误。

3.修正

方法一:在A类构造器中传递一个外围类的引用,通过外围类对象来调用内部类的构造器,就相当于将外围类的对象传递给了内部类的构造器,实现了内部类对象与外围类对象的绑定。

?
1
2
3
4
5
6
7
8
public class A extends Outer.Inner {
    public A(Outer outer) {
        outer.super();
    }
}
class Outer {
    class Inner { }
}

方法二:外部类继承外部类,内部类继承内部类

?
1
2
3
4
5
6
public class A extends Outer {
    class InnerA extends Outer.Inner { }
}
class Outer {
    class Inner { }
}

创建A类的内部类InnerA对象:

?
1
2
A a = new A();
A.InnerA innerA = a.new InnerA();

创建内部类A.InnerA对象时,需要绑定外围对象,a引用就是外围类的对象,

内部类A.InnerA继承了另外一个内部类Outer.Inner,在A.InnerA调用父类构造器时,也需要传递父类的外围类(Outer)对象,
A类继承了Outer类,因为子类的对像可以当作父类的对象来使用,因此a引用也是另一个内部类Outer.Inner的外围对象。

6. 本地内部类

本地内部类:就是在方法,构造器,初始化块中声明的类。

本地内部类不是类的成员,从结构上类似一个局部变量,因此不能使用访问修饰符(public,protected,private),也不能使用static修饰。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class LocalInnerDemo {
    private int x = 100;
    // 1.本地内部类声明在实例初始化块中
    {
        class Local1 { }
    }
    // 2.本地内部类声明在静态初始化块中
    static {
        class Local2 { }
    }
    // 3.本地内部类声明在构造器中
    public LocalInnerDemo() {
        int y = 2;
        final int z = 3;
        class Local3 {
            int a = x;
            int b = y;
            int c = z;
        }
    }//加入Java开发交流君样:756584822一起吹水聊天
    // 4.本地内部类声明在实例方法中
    public T1 method1() {
        // 使用本地内部类实现某个接口,然后以接口形式返回
        class Local4 implements T1 {
            @Override
            public void operate() {
                System.out.println("Start to operate.");
            }
        }
        return new Local4();
 
    }
    // 5.本地内部类声明在静态方法中
    public static T1 method2() {
        class Local5 implements T1 {
            @Override
            public void operate() {
                System.out.println("Start to operate.");
            }
        }
        return new Local5();
    }
}
interface T1 {
    void operate();
}

问:本地内部类声明在实例环境(实例方法,构造器,实例初始化块)和静态环境中有什么区别呢?

答:实例环境:本地内部类需要与外围类绑定,即会在类中隐式生成一个final的引用。
静态环境:本地内部类不需要与外围类绑定。

嵌套接口

嵌套接口:就是在类或者接口中声明的接口。

  • 不管声明在类中,还是接口中,嵌套接口永远都是静态的。
  • 当类实现了某个接口时,不需要实现嵌套接口的方法。

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/wj1314250/article/details/117046078