Java内部类概述

Java内部类概述

成员内部类

1. 就像外部类总的一个成员，可以访问外部类中的所有参数和方法，但是外部类不能直接访问内部类的参数和方法

2. 成员内部类也可以设定访问权限修饰符，private、public、protected，缺省

3. 在成员内部类中不能有静态参数和静态方法

4. 成员内部类的实例化需要借助外部类的实例来实例，即

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

局部内部类

1. 顾名思义，这是在方法或者作用域中的类，所以不能有public、private等访问控制符修饰

匿名内部类

1. 匿名内部类是一种没有具体类名的类，但是是一种用的较多的内部类

2. 匿名内部类可以用于实现接口，继承类，并且实现其中的方法，例如

   public class Outter3 {
       public static void main(String[] args) {
           Animal animal = new Animal() {   //实现了接口Animal的匿名内部类
               @Override
               public String xiaoLaoFu() {
                   return "dai";
               }
           };
           System.out.println(animal.xiaoLaoFu());
   
           Temp2 temp2 = new Temp2() {    //匿名内部类继承Temp2
               @Override
               public String method3() {
                   return "被重写了的方法";
               }
           };
           System.out.println(temp2.method3());
       }
   }
   
   interface Animal {
       String xiaoLaoFu();
   }
   
   class Temp2 {
       public String method3() {
           return "temp2中的方法";
       }
   }
   

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

静态内部类

1. 静态内部类与成员内部类类似，但是其是static修饰的，所以同样的，静态内部类类似于外部类中的静态变量一样，可以直接访问外类类中的静态属性

2. 静态内部类的实例化不需要借助于外部类实例：

   class Outter4 {
       static String dabenxiang = "快跑呀";
   
       String dazhuzhu = "白花花";
   
       //静态内部类
       static class Inner4 {
   
           public void method() {
               System.out.println("静态内部类可以直接访问外部类中的静态变量：" + dabenxiang);
               //  System.out.println(dazhuzhu);  // 访问不到
               System.out.println("静态内部类中的方法!");
           }
       }
   
       public static void main(String[] args) {
           //静态内部类的实例化
           Inner4 inner4 = new Inner4();
           inner4.method();
           Outter4.Inner4 inner41 = new Outter4.Inner4();
       }
   }
   
   //    在其他类中实例化静态内部类
   class Temp {
       public static void main(String[] args) {
           Outter4.Inner4 inner4 = new Outter4.Inner4();
           inner4.method();
   
       }
   }
   

内部类的使用场景和好处

1. 使得多继承的解决方案变得完整，每个内部类都能独立的继承和实现接口，并且无论外部类是否已经继承或实现接口
2. 可以将存在一定逻辑关系的类组织在一起，同时可以对外界隐藏，例如事件驱动程序，线程运行

成员内部类也可以被继承，当成员内部类被继承的时候，其引用方式必须为 Outter.Inner,并且构造器中必须有指向外部类对象的引用，并通过这个引用调用super（） ：

class WithInner {
    class Inner{
         
    }
}
class InheritInner extends WithInner.Inner {
      
    // InheritInner() 是不能通过编译的，一定要加上形参
    InheritInner(WithInner wi) {
        wi.super(); //必须有这句调用
    }
  
    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner obj = new InheritInner(wi);
    }
}