Java内部类使用

内部类的种类与相关属性

1. 成员内部类

   含义：是普通的内部类，定义在一个类的内部

   属性：

   • 内部类访问外部类的属性或方法

     • 可以访问外部类的所有成员属性和成员方法（包括private成员和静态成员）

       //代码省略
       

     • 当内部类和外部类的变量或方法重名时，默认访问的是成员内部类的属性和方法

       //如果要访问外部类的属性或方法
       外部类.this.成员变量
       外部类.this.成员方法
       

   • 外部类访问内部属性或方法

     • 外部类必须创建一个成员内部类的对象，再通过此内部类对象的引用来访问成员内部类属性或方法

       public class A{
           public static void main(String args[]){
               B b = new B();
               b.getB();
           }
           class B{
               public void getB(){
                   System.out.println("print getB()");
               }
           }
       }
       

 - 成员内部类需要依附外部类而存在，如果C类想要使用A的内部类B，则必须创建一个外部类的对象

   ```java
   public class C{
    public static void main(String args[]){
           //第一种
        A a = new A();
           A.B b1 = a.new B();
           b.getB();
           //第二种(仅表达可以用单例方式获取)
           A.B b2 = a.getInstance();
    }
   }
   public class A{
       public B getInstance(){
           return new B();
       }
    class B{
        public getB(){
            System.out.println("print getB()");
           }
    }
   }
   ```

2. 局部内部类

   含义：定义在一个方法或者一个作用域里面的类

   属性：

   局部内部类与方法中的局部变量一样，不能有作用域（public，protected，private）及static

   仅限于方法内或者改作用域内

   //代码省略
   

3. 匿名内部类

   含义：定义一个类的同事对其进行实例化，与局部类相似，不同的是没有复制给某个变量

   属性：

   匿名内部类也是不能有访问修饰符（public，protected，private）和static修饰符的。

   匿名内部类可以访问外部类内所有成员

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

   匿名内部类不能访问外部类未加final修饰的变量（注意：JDK1.8即使没有用final修饰也可以访问）下文有具体解释

   • 衍生：匿名方法，匿名对象

     匿名函数：详见lambda表达式？

     匿名对象含义：即创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

     由于没有指定引用变量，所以只能使用一次，每次使用都会创建

     //创建一个普通对象
     A a = new A();
     //创建一个匿名对象
     new A();
     

4. 静态内部类

   含义：在一个类的里面定义一个通过static修饰的内部类

   属性：

   • 静态内部类调用外部类

     可以访问外部类静态成员变量或方法，并且作用域private也可

   • 外部类调用静态内部类

     外部类可以直接调用静态内部类

     public class C{
         public static void main(String args[]){
             //调用内部类的静态方法
             A.B.getMethodeB1();
             //调用内部类的非静态方法
             //间接访问需要创建内部类对象
             A.B b = new A.B();
             b.getMethodB2();
         }
     }
     class A{
         static class B{
             public static void getMethodB1(){
                System.out.println("print getMethodB1()");
             }
             public void getMethodB2(){
                System.out.println("print getMethodB2()");
             }
         }
     }
     

内部类作用与好处

1. 可以无条件的访问外部类的所有元素

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

3. 可以实现多重继承

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

4. 通过匿名内部类来优化简单的接口实现

内部类可能引入的问题

内部类的使用可能造成程序的内存泄漏：

如果一个匿名内部类没有被任何引用持有，那么匿名内部类对象用完就有机会被回收。

因为内部类持有指向外部类的引用，就会造成GC无法回收内部类或者外部类

匿名内部类引入问题

为什么匿名内部类访问局部变量必须要用final修饰？？

匿名内部类之所以可以访问局部变量，是因为在底层将这个局部变量的值传入到了匿名内部类中，并且以匿名内部类的成员变量的形式存在，这个值的传递过程是通过匿名内部类的构造器完成的。

final的修饰是为了保证数据的一致性：

对引用变量来说是引用地址的一致性，对基本类型来说就是值的一致性

 public class Hello$1 extends Thread {
    
    private String val$str;
    
    Hello$1(String paramString) {
        this.val$str = paramString;
    }
 
    public void run() {
        System.out.println(this.val$str);
    }
 
}

final修饰符对变量来说，深层次的理解就是保障变量值的一致性。为什么这么说呢？因为引用类型变量其本质是存入的是一个引用地址，说白了还是一个值（可以理解为内存中的地址值）。用final修饰后，这个这个引用变量的地址值不能改变，所以这个引用变量就无法再指向其它对象了。

回到正题，为什么需要用final保护数据的一致性呢？

因为将数据拷贝完成后，如果不用final修饰，则原先的局部变量可以发生变化。这里到了问题的核心了，如果局部变量发生变化后，匿名内部类是不知道的（因为他只是拷贝了局部变量的值，并不是直接使用的局部变量）。这里举个栗子：原先局部变量指向的是对象A，在创建匿名内部类后，匿名内部类中的成员变量也指向A对象。但过了一段时间局部变量的值指向另外一个B对象，但此时匿名内部类中还是指向原先的A对象。那么程序再接着运行下去，可能就会导致程序运行的结果与预期不同。

现在我们来谈一谈JDK8对这一问题的新的知识点。 在JDK8中如果我们在匿名内部类中需要访问局部变量，那么这个局部变量不需要用final修饰符修饰。 看似是一种编译机制的改变，实际上就是一个语法糖（底层还是帮你加了final）。但通过反编译没有看到底层为我们加上final，但我们无法改变这个局部变量的引用值，如果改变就会编译报错。

参考：

https://www.cnblogs.com/dolphin0520/p/3811445.html

https://blog.csdn.net/tianjindong0804/article/details/81710268