java 内部类

内部类分为以下四种：

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

一、静态内部类

• 静态内部类： 在类中用static关键字声明的内部类。

• 静态内部类不依赖于外围类对象实例而独立存在

• 静态内部类的可以访问外围类中的所有静态成员，包括private的静态成员。

• 同时静态内部类可以说是所有内部类中独立性最高的内部类，其创建对象、继承（实现接口）、扩展子类等使用方式与外围类并没有多大的区别。

public class OuterClass {//外部类
   
    public int aa; //普通成员变量
    private static float f = 1.5f;//private的静态成员
    
    static void myPrintln() {
        System.out.println("静态方法");
    }
    
    protected static class StaticInnerClass{//protected的静态内部类
        
        float a;
        
        public StaticInnerClass() {
             a = f;// 外围类的private静态变量
             myPrintln();//外围类的静态方法
        }
    }
}

class OtherClass{

   public static void main(String[] args) {
       //创建静态内部类的对象
    OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass(); 
   } 
}

二、成员内部类

• 成员内部类是最普通的内部类，它的定义为位于一个类的内部

• 成员内部类可以访问外部类的所有成员属性和成员方法（包括静态成员，可以拥有private访问权限、protected访问权限、public访问权限及包访问权限）

• 成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。

• 成员内部类是不可以声明静态成员（包括静态变量、静态方法、静态成员类、嵌套接口）,但有个例外：可以声明 static final的变量， 这是因为编译器对final类型的特殊处理，是直接将值写入字节码

• 成员内部类对象都隐式地保存了一个引用，指向创建它的外部类对象；或者说，成员内部类的入口是由外围类的对象保持着（静态内部类的入口，则直接由外围类保持着）

成员内部类中的 this关键字：

• 获取外部类对象：OuterClass.this
• 明确指定使用外部类的成员（当内部类与外部类的名字冲突时）：
  OuterClass.this.成员名

成员内部类访问外部类成员

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，默认情况下访问的是成员内部类的成员。

如果要访问外部类的同名成员，需要以下面的形式进行访问：

  - 外部类.this.成员变量
  - 外部类.this.成员方法

外部类访问成员内部类的成员

1.先创建一个成员内部类的对象
2.再通过指向这个对象的引用来访问。

创建成员内部类对象的一般方式：

在外部类的成员方法中创建成员内部类 （内部类名 对象名=new 内部类名();）与 在其他类中或静态方法中创建成员内部的方式是不一样的

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 ///////////////////////////////////////////////////////////////////////////////
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

成员内部类被继承

在内部类的访问权限允许的情况下，成员内部类也是可以被继承的。由于成员内部类的对象依赖于外围类的对象。因此，继承了成员内部类的子类必须要与一个外围类对象关联起来。同时，子类的构造器是必须要调用父类的构造器方法，所以也只能通过父类的外围类对象来调用父类构造器。

class ChildClass extends OuterClass.InnerClass{
    
    //成员内部类的子类的构造器的格式
    public ChildClass(OuterClass outerClass) {
        outerClass.super();//通过外围类的对象调用父类的构造方法
    }
}

三、局部内部类

• 局部内部类： 就是在方法、构造器、初始化块中声明的类，在结构上类似于一个局部变量。

• 局部内部类的访问仅限于方法内或者该作用域内,局部内部类是不能使用访问修饰符。

• 局部内部类只能访问final的局部变量

• 局部内部类定义在实例环境中（构造器、对象成员方法、实例初始化块），则可以访问外围类的所有成员；但如果内部类定义在静态环境中（静态初始化块、静态方法），则只能访问外围类的静态成员

public class OuterClass {
    
    private int a = 21;
    
    static {//静态域中的局部内部类
       class LocalClass1{
              //  int z = a; //错误，在静态的作用域中无法访问对象成员
       }
    }
    
    {//实例初始化块中的局部内部类
        class localClass2{          
        }
    }
    
    public OuterClass(){
        int x = 2;
        final int y = 3;
        // x = 3;//若放开此行注释，编译无法通过，因为局部变量x已经是final类型
        //构造器中的局部内部类
        class localClass3{
            int z = y; //可以访问final的局部变量
            int b = a;//可以访问类的所有成员
             //访问没有用final修饰的局部变量
            int c = x;
        }
    }
    
    public void createRunnable() {
        
        final int x = 4;
        //方法中的局部内部类
        class LocalClass4 implements Runnable {//
            @Override
            public void run() {
                System.out.println("局部final变量："+x);
                System.out.println("对象成员变量："+a);
            }
            
        }
    }
}

四、匿名内部类

• 匿名内部类也是不能有访问修饰符和static修饰符的。

• 匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class、Outter$2.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

• 在创建这个匿名内部类后，便会立即用来创建并返回此内部类的一个对象引用。

作用：

匿名内部类用于隐式继承某个类（重写里面的方法或实现抽象方法）或者实现某个接口。

匿名内部类的访问限制：

在实例环境中（构造器、对象成员方法、实例初始化块），则可以访问外围类的所有成员；但如果内部类定义在静态环境中（静态初始化块、静态方法），则只能访问外围类的静态成员

匿名内部类的优缺点：

• 优点：
  编码方便快捷；

• 缺点：
  只能继承一个类或实现一个接口，不能再继承其他类或其他接口。
  只能用于创建一次对象实例；

一个例子：

class MyOuterClass {

    private int x = 5;

    void createThread() {
        
        final int a = 10;
        int b = 189;
        
        // 匿名内部类继承Thread类，并重写Run方法
        Thread thread = new Thread("thread-1") {

            int c = x;  //访问成员变量
            int d = a;  //final的局部变量
            int e = b; //访问没有用final修饰的局部变量
            
            @Override
            public void run() {
                System.out.println("这是线程thread-1");
            }
        };

        // 匿名内部类实现Runnable接口
        Runnable r = new Runnable() {

            @Override
            public void run() {
                System.out.println("线程运行中");
            }
        };
    }
}

内部类嵌套内部类

• 成员内部类可以继续包含成员内部类，而且不管一个内部类被嵌套了多少层，它都能透明地访问它的所有外部类所有成员；
• 成员内部类可以继续嵌套多层的成员内部类，但无法嵌套静态内部类；
• 静态内部类则都可以继续嵌套这两种内部类。
  下面的例子是基于上面的例子进行改造：

class InnerClass{//成员内部类
        private double aa; //与围类的变量aa的名字重复
        
        public InnerClass(){
            this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
            initInnerClass();
        }
        
        public  class InnerInnerCalss2{//成员内部类中的成员内部类
            protected double aa = OuterClass.this.aa;//最外层的外围类的成员变量
        }//InnerInnerCalss2
    }//InnerClass

总结

类 型	访问修饰符	声明静态成员	绑定外围类
静态内部类	四种访问修饰符	可以声明	不绑定
成员内部类	四种访问修饰符	除 final static 的变量外，其余静态成员都不行	绑定
局部内部类	不可以声明	不可以声明	取决于此内部类的声明环境
局部内部类	不可以声明	不可以声明	取决于此内部类的声明环境

为什么在Java中需要内部类

1. 每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，

2. 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

3. 方便编写事件驱动程序

4. 方便编写线程代码