Java笔试面试-详解内部类

梦里梦外; 2021-09-23 07:32 463阅读 0赞

## 内部类 ##

Java 内部类，分为以下四种：

*  成员内部类
 *  静态成员内部类
 *  局部内部类
 *  匿名内部类

## 成员内部类： ##

在一个类中定义了另一个类，则将定义在类中的那个类称之为成员内部类。成员内部类也是最普通的内部类。示例如下：

class Outer {
        public Outer() {
            System.out.println("Outer Class.");
        }
        class Inner {
            public void sayHi() {
                System.out.println("Hi, Inner.");
            }
        }
    }

其中 Inner 类则为成员内部类。  
而成员内部类的创建和使用，参考以下完整的代码：

class InnerTest {
        public static void main(String[] args) {
            Outer out = new Outer();
            // 创建成员内部类
            Outer.Inner inner = out.new Inner();
            inner.sayHi();
        }
    }
    class Outer {
        public Outer() {
            System.out.println("Outer Class.");
        }
        class Inner {
            public void sayHi() {
                System.out.println("Hi, Inner.");
            }
        }
    }

**成员内部类的创建**  
语法：Outer.Inner inner = new Outer().new Inner();

**内部类访问外部类**  
语法：Outer.this.xxx

示例：

class Outer {
        private String name = "OuterClass";
        public void sayHi() {
            System.out.println("Hi, Outer.");
        }
        class Inner {
            public void sayHi() {
                // 内部类访问外部类
                Outer.this.sayHi();
                System.out.println(Outer.this.name);
                System.out.println("Hi, Inner.");
            }
        }
    }
    class InnerTest {
        public static void main(String[] args) {
            Outer.Inner inner =  new Outer().new Inner();
            inner.sayHi();
        }
    }

**外部类访问内部类**  
语法：new Inner().xxx

示例：

class Outer {
        public void sayHi() {
            System.out.println(new Inner().name);
            System.out.println("Hi, Outer.");
        }
        private class Inner {
            String name = "InnerClass";
            public void sayHi() {
                System.out.println("Hi, Inner.");
            }
        }
    }
    class InnerTest {
        public static void main(String[] args) {
            new Outer().sayHi();
        }
    }

**总结：**

*  成员内部类可直接访问外部类（使用：外部类.this.xxx）；
 *  外部成员类要访问内部类，必须先建立成员内部类对象；
 *  成员内部类可使用任意作用域修饰（public、protected、默认、private）；
 *  成员内部类可访问外部类任何作用域修饰的属性和方法；
 *  外部类建立成员内部类对象之后，可以访问任何作用域修饰的内部类属性和方法。

## 静态成员内部类 ##

在一个类中定义了另一个 static 类，则将定义在类中的那个 static 类称之为静态成员内部类，静态成员内部类也就是给内部成员类加上 static 修饰符，示例如下：

class OuterClass {
        public OuterClass() {
            System.out.println("OuterClass Init.");
        }
        protected static class InnerClass {
            public void sayHi() {
                System.out.println("Hi, InnerClass.");
            }
        }
    }
    class InnerClassTest {
        public static void main(String[] args) {
            OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
            innerClass.sayHi();
        }
    }

与内部成员类的创建方式 new Outer().new Inner() 不同，静态成员内部类可使用 new OuterClass.InnerClass() 的方式进行创建。

**注意：不能从静态成员内部类中访问非静态外部类对象。**

## 局部内部类 ##

一个类定义在另一个类的局部（方法或者任意作用域），这个类就称之为局部内部类，示例如下：

class OutClass {
        public void sayHi() {
            class InnerClass {
                InnerClass(String name) {
                    System.out.println("InnerClass:" + name);
                }
            }
            System.out.println(new InnerClass("Three"));
            System.out.println("Hi, OutClass");
        }
    }
    class OutTest {
        public static void main(String[] args) {
            new OutClass().sayHi();
        }
    }

**局部内部类特点：**

*  局部内部类不能使用任何访问修饰符；
 *  局部类如果在方法中，可以直接使用方法中的变量，不需要通过 OutClass.this.xxx 的方式获得。

## 匿名内部类 ##

没有名字的内部类就叫做匿名内部类，示例：

interface AnonymityOuter {
        void hi();
    }
    class AnonymityTest {
        public static void main(String[] args) {
            AnonymityOuter anonymityOuter = new AnonymityOuter() {
                @Override
                public void hi() {
                    System.out.println("Hi, AnonymityOuter.");
                }
            };
            anonymityOuter.hi();
        }
    }

**匿名内部类特点：**

*  匿名内部类必须继承一个父类或者实现一个接口
 *  匿名内部类不能定义任何静态成员和方法
 *  匿名内部类中的方法不能是抽象的

笔试面试题见：https://blog.csdn.net/huanglei305/article/details/100770810