Java的四个内部类总结及为什么使用内部类

为什么使用内部类？

• 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
• 内部类有效实现了“多重继承”，优化Java单继承的缺陷。
• 内部类具有很好的封装性。

---

知道为什么使用内部类了，就直接开始说四个内部类了。

静态内部类

静态内部类可以访问外部类所有的静态变量，不可以访问外部类的非静态变量。

定义静态内部类

class Outer{
    private static int i = 1;
    static class InnerS{
        public void method(){
            System.out.println("InnerS-func:" + num);
        }
    }
}

静态内部类创建方式

Outer.InnerS innerS = new Outer.InnerS();
innerS.method();

---

成员内部类

成员内部类可以访问外部类所有的变量和方法。

定义成员内部类

class Outer{
    private static int num1 = 1;
    private int num2 = 2;
    class Inner{
        public void method(){
            System.out.println("Inner func static:" + num1);
            System.out.println("Inner func:" + num2);
        }
    }
}

成员内部类创建方式

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

---

局部内部类

定义在方法内部的类就是局部内部类。
定义在实例方法中的局部类可以访问外部类的所有变量和方法。
定义在静态方法中的局部类只能访问外部类的静态变量和方法。

class Outer{
    private int num1 = 1;
    private static int num2 = 2;

    public void methodC1() {
        int inner_num = 3;
        class Inner{
            private void fun(){
                System.out.println("Outer num1:" + num1);
                System.out.println("Outer static num2:" + num2);
                System.out.println("methodC1 inner_num:" + inner_num);
            }
        }
        //在这里创建了
        Inner inner = new Inner();
        inner.fun();
    }

    public static void methodC2(){
        int inner_numS = 4;
        class Inner{
            private void fun(){
                System.out.println("Outer static num2:" + num2);
                System.out.println("methodC2 inner_num4:" + inner_numS);
            }
        }
        //在这里创建了
        Inner inner = new Inner();
        inner.fun();
    }
}

注意：局部内部类的创建方式是在对应方法内。

使用局部内部类

Outer outer = new Outer();
outer.methodC1(); //注意这里是对象实例
Outer.methodC2(); //注意这里是类名

---

匿名内部类

• 匿名内部类必须继承一个抽象类或实现一个接口。
• 匿名内部类不能定义任何静态成员和静态方法。
• 当所在的方法的形参需要被匿名内部类使用时，必须声明为final。
• 匿名内部类不能是抽象的，必须实现接口或抽象父类的所有抽象方法，方法也不能是抽象的。
• 匿名内部类访问的外部类成员变量或成员方法必须用static修饰，可以访问外部类私有变量和方法。

先看定义

interface Inner1{
    public String print();
}

abstract class Inner2 implements Inner1{
}

class Inner3 implements Inner1{
    @Override
    public String print() {
        return "this is Inner3";
    }
}

class Outer{
    public void method1(Inner1 inner){
        System.out.println(inner.print());
    }
    public static String method2(){
        return "this is Outer static method2";
    }
}

匿名内部类的使用

Outer outer = new Outer();
//Inner1为接口
outer.method1(new Inner1() {
      @Override
      public String print() {
          return "method1 Inner1";
      }
 });

//Inner2为抽象类
outer.method1(new Inner2() {
      @Override
      public String print() {
          return "method1 Inner2";
      }
 });

//Inner3为普通类
outer.method1(new Inner3() {
    @Override
    public String print() {
        return Outer.method2();
    }
});

若有不当之处，欢迎指正！ ^ - ^