优雅的使用java内部类

此文通过看相关视频（慕课网视频）以及java书籍总结得出，以便后续复习之用。

什么是内部类呢？

简而言之，内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

那为什么要将一个类定义在另一个类里面呢？

具体来说，有以下几个作用：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类有几种呢？

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类
  我们先直观的看下内部类的使用

public class HelloWorld {
    
    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {
        
        // 内部类的方法
        public void show() {
            System.out.println("welcome to china!");
        }
    }
    
    public static void main(String[] args) {
        
        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner();
        // 调用内部类对象的方法
        i.show();
    }
}

1、成员内部类

成员内部类，也就是普通的内部类，和类中的属性和方法一样的地位，例如

public class InnerClass {
    private String name = "jack";
    int age = 20;

    public class Inner {
        String name = "wille";

        public void show() {
            System.out.println("外部类中的name:" + InnerClass.this.name);
            System.out.println("内部类中的name:" + name);
            System.out.println("外部类中的age:" + age);
        }
    }

    public static void main(String[] args) {
        InnerClass o = new InnerClass();
        Inner inn = o.new Inner();
        inn.show();
    }
}

需要说明以下几点：

1. 当内部类与外部类拥有同名的属性时，需要通过this关键字，例如InnerClass.this.name
2. 当没有同名的属性时，可以直接通过属性名来访问。
3. 创建内部类的对象，需要借助外部类的对象来创建。

InnerClass o = new InnerClass();
Inner inn = o.new Inner();

2 、静态内部类

静态内部类是 static 修饰的内部类
静态内部类有以下特点：

• 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问
• 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
• 如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
• 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类()

通过以下代码来解释上面表述是什么意思：

public class StaticInnerClass {
    // 外部类中的静态变量score
    private static int score = 84;
    // 外部类非静态成员
    private  String name = "wille";
    // 外部类中的静态变量gender
    private static String gender = "male";
    // 创建静态内部类
    public static class SInner {
        // 内部类中的变量score
        int score = 91;

        public void show() {
            StaticInnerClass sc = new StaticInnerClass();
            System.out.println("访问外部类非静态成员:" + sc.name);
            System.out.println("访问外部类中的与内部类同名score：" + StaticInnerClass.score);
            System.out.println("访问外部类的静态变量的gender：" + gender);

        }
    }

    // 测试静态内部类
    public static void main(String[] args) {
        // 直接创建内部类的对象
        SInner si = new SInner();
        // 调用show方法
        si.show();
    }

}

3 、方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
一定要注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

public class MethodInnerClass {
    private String name = "willie";
    // 外部类中的show方法
    public void show() {
        // 定义方法内部类
        class MInner {
            int score = 83;
            public int getScore() {
                return score + 10;
            }
        }
        // 创建方法内部类的对象
        MInner min = new MInner();
        // 调用内部类的方法
        int newScore = min.getScore();
        System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
    }

    // 测试方法内部类
    public static void main(String[] args) {
        // 创建外部类的对象
        MethodInnerClass mo = new MethodInnerClass();
        // 调用外部类的方法
        mo.show();
    }
}