划重点！！！面试归来我重新总结了Java嵌套类

青旅半醒 2021-07-24 17:03 252阅读 0赞

# 嵌套类分类 #

*  静态内部类（静态嵌套类/静态成员类/静态类）
 *  内部类（非静态嵌套类）
    
    内部成员类  
    本地内部类  
    匿名内部类
 *  嵌套接口

# 静态内部类 #

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

## 1. 静态内部类中能声明哪些类，变量和方法？ ##

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

**类：**

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

**变量：**

*  静态变量
 *  实例变量

**方法：**

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

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

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

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

## 3. 继承方面 ##

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

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. 内部类能访问外围类的哪些变量和方法？ ##

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

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成员变量，用来将内部类对象绑定到外围类对象。

public class Outer { 
        public class Inner { 
            // 编译器自动隐式生成的外围类类型的成员变量
            final Outer this$0;
            // 通过内部类构造器将外围类的对象传递给this$0成员变量，实现内部类与外围类对象的绑定
            public Inner(Outer outer) { 
                this$0 = outer;
                super();
            }
        }
    }

创建内部类对象，如下：

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

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

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

## 5. 继承方面 ##

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

**问：那内部类与静态内部类在继承方面有什么区别呢？**

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

1.反例：产生编译错误

public class A extends Outer.Inner {  }
    
    class Outer { 
        class Inner {  }
    }

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

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

## 3.修正 ##

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

public class A extends Outer.Inner { 
        public A(Outer outer) { 
            outer.super();
        }
    }
    class Outer { 
        class Inner {  }
    }

方法二：外部类继承外部类，内部类继承内部类

public class A extends Outer { 
        class InnerA extends Outer.Inner {  }
    }
    class Outer { 
        class Inner {  }
    }//加入Java开发交流君样：756584822一起吹水聊天

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

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修饰。

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();
    }//加入Java开发交流君样：756584822一起吹水聊天

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

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

# 嵌套接口 #

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

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

[**最新2021整理收集的一些高频面试题（都整理成文档），有很多干货，包含mysql，netty，spring，线程，spring cloud、jvm、源码、算法等详细讲解，也有详细的学习规划图，面试题整理等，需要获取这些内容的朋友请加Q君样：756584822**][2021_mysql_netty_spring_spring cloud_jvm_Q_756584822]

[2021_mysql_netty_spring_spring cloud_jvm_Q_756584822]: https://jq.qq.com/?_wv=1027&k=0IsBuUb0