内部类



内部类：把类定义在其他类的内部。
  1.内部类的访问特点：
     a.内部类可以直接访问外部类的成员，包括私有
     b.外部类要访问内部类的成员，必须创建对象
 
 
  2. 内部类的位置：
   成员位置：在成员位置定义的类，被称为成员内部类
   局部位置：在局部位置定义的类，被称为局部内部类
  
  
  3. 内部类的分类：
      A.成员内部类：
      a. 如何直接访问内部类的成员
    外部类名.内部类名 对象名 = 外部类对象.内部对象名
     //如：  Outer.Inner oi = new Outer().new Inner();
    
    class Outer{
     private int num = 10;
     class Inner(){
        public void show(){
       System.out.println(num);
       }
     }
    }
    class Test{
     public static void main(String[] args){
       Outer.Inner oi = new Outer().new Inner();
       oi.show();
     }
    }
    b.成员内部类的修饰符：
      private： 为了保证数据线的安全性
      static： 为了方便访问数据
      静态内部类只能访问外部类的静态成员
      静态内部类可修饰的方法：
        静态方法，非静态方法
    注意：成员内部类被静态修饰后的访问方式：
       外部类名.内部类名 对象名 =new 外部类名.内部类名;
       Outer.Inner oi = new Outer.Inner();
        静态内部类可修饰的静态方法的另一种访问方式:
       外部类名.内部类名.show();
       Outer.Inner.show();
  
   面试题： 依次输出30、20、10
 class Outer{
     public int num = 10;
  class Inner{
   public int num = 20;
   public void show(){
      int num = 30;
       System.out.println(num);   //30
       System.out.println(this.num);  //20
       System.out.println(Outer.this.num);  //10   方式二：syso(new Outer().num);
   }
  }
   }
  
  class Test{
    public static void main(String[] args){
        Outer.Inner oi = new Outer().new Inner();
         oi.show();
   } 
   }
  

  B.局部内部类：
   a. 可以直接访问外部类的成员
   b. 在局部位置，可以创建内部类的对象，通过对象调用内部类的方法，来使用局部内部类功能
   c. 局部内部类访问局部变量的注意事项：
       局部内部类访问局部变量时，必须使用final修饰。
       因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，
    还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，
    这样，在堆内存里面存储的其实是一个常量值。 
   
    class Outer {
   private int num1  = 10;
   
   public void method() {
    
    final int num2 = 20;
    class Inner {
     public void show() {
      System.out.println(num1);
      System.out.println(num2);//20
     }
    }
    
    //System.out.println(num2);
    
    Inner i = new Inner();
    i.show();
   }
  }

  class Test {
   public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
   }
  }
   
  C.匿名内部类：
    前提：存在一个类或者接口
    这里的类可以是具体的类也可以是抽象类
    格式：
      new  类名或者接口名(){
      重写的方法;
     
    }
    本质是：
    是一个继承了该类或者实现了该接口的子类匿名对象。 
  interface Person{
   public abstract void study();
  }
  class PersonDemo{
   public void method(Person p){
     p.study();
   }
  }

  public class Test{
   public static void main(String[] args){
     PersonDemo pd = new PersonDemo();
     pd.method(new Person(){
    public void study(){
    syso("good good study ,day day up");
    }
    
     });
   
   }
  }