InnerClass内部类

1，内部类概述

• 定义：把A类定义在B类内部，则A类是内部类。如下所示：

• class Outer1{外部类
      String name1;
      public void show(){
          System.out.println("Outer1.show()"+new Inner1().name);
      }
      class Inner1{//内部类
          String name;
          public void fun(){
              System.out.println("Outer1.Inner1.fun()"+name1);
          }
      }
  }

• 内部类的访问特点
  • 内部类可以直接访问外部类的成员，包括私有。
  • 外部类要访问内部类的成员或功能，则必须创建内部类的对象。
• 按照内部类在类中定义的位置不同，可以分为如下两种格式：
  • 成员位置(成员内部类)
  • 局部位置(局部内部类)

2，成员内部类

• 一般内部类就是不让外部访问的，但并不是不可以被访问（但你非得。。。）
• 被静态修饰的成员内部类只能访问外部类的静态成员
• 内部类被静态修饰后的方法
  • 非静态方法：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  • 静态方法  ：上面创建的对象访问，或者 外部类名.内部类名.方法名();（类比，被静态修饰的类既可以直接通过类名访问其成员变量，也可以通过new出对象来访问）

• //成员内部类的以上所有情况
  class Outer1{
      private String name1;
      static String string;
      class Inner2{
          public void show(){
              //内部类可以直接访问外部类的所有成员
              System.out.println("Outer1.show()"+name1);
          }
      }
      
      static class Inner1{
          String name;
          public void fun(){//被静态修饰的内部类，只能访问外部类的静态成员
              //因为静态修饰的类，一开始就会被加载进来，所以如果内部有外部成员，则必须是静态的
              System.out.println("Outer1.Inner1.fun()"+name1);//访问外部非静态成员出错
              System.out.println("Outer1.Inner1.fun()"+string);//访问外部静态成员正确
          }
      }
  }

• 面试的例子，如下

• class Outer1 {
      public int num = 10;
      class Inner {
          public int num = 20;
          public void show() {
              int num = 30;
              System.out.println(num);
              System.out.println(this.num);
              System.out.println(Outer1.this.num );
          }
      }
  }
  //在控制分别输出：30，20，10
  public class TestMain2 {
  
      public static void main(String[] args) {
          // TODO Auto-generated method stub
          
          Outer1.Inner inner = new Outer1().new Inner();
          inner.show();
          
  
      }
  
  }

   

3，局部内部类　

• 局部内部类访问局部变量时，局部变量必须被final修饰（JDK1.8中局部变量可以不被final显式修饰，但还是有final属性的亲测正确。）
• 原因：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
• 局部内部类只能在局部方法内部使用。详细代码如下

  • class Outer1{
        private String name1;
        static String string;
        
        public void show(){
            int imkk=0;//局部变量
            String string = "OK?";
            class Inner2{//局部内部类
                public void show(){
                    System.out.println("Outer1.show()"+string);//
                    System.out.println("Outer1.show()"+imkk);//编译失败是因为i不是final修饰的，JDK1.8可以通过
    　　　　          i=3;//会提示错误，说明还是有final属性的。
    
                }
            }
            new Inner2().show();    
        }
    }
    
    public class TestMain1 {
        String name;
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Outer1 outer1 = new Outer1();
            outer1.show();
        }
    }

4，匿名内部类

• 就是内部类的简化写法（在安卓开发中常用匿名内部类，节省内存空间）
• 前提：存在一个类或者接口（这里的类可以是具体类也可以是抽象类。）
• 格式：new 类名或者接口名() {重写方法;}
• 本质：是一个继承了类或者实现了接口的子类匿名对象
• 例子如下所示：

• //匿名内部类
  interface Listener{//接口
      
      public void func1();
      public void func2();
  
  }
  
  public class TestMain3_niming {
  
      public static void main(String[] args) {
          // TODO Auto-generated method stub
          new  Listener() {
              @Override
              public void func1() {
                  System.out.println("func1");
               }            
              @Override
              public void func2() {
                  System.out.println("func2");
               }        
          } ;
      }
  }