/*
内部类：外部类中再定义一个类，这个类作为外部类中的一个成员，并且依附于外部类而存在;
1.内部类可以直接访问外部类中的成员，包括私有;外部类要访问内部类，必须建立内部类对象
2.内部类可为静态，可用protected private修饰，而外部类不可以，外部类只能使用public ,default修饰
3.内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类，对于一个名为outer的外部类
    和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

内部类的优点：
1.内部类作为外部类的成员，可以访问外部类的私有成员或属性
2.用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限
3.隐藏一些不想让别人知道的操作

1.成员内部类：定义在外部类的成员位置上
作为外部类的一个成员存在，与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存，
在内部类中访问实例变量：this.属性
在内部类访问外部类的实例变量：外部类名.this.属性。
*/
class Outer{
//内部类可以直接访问外部类中成员，包括私有成员
private int age=24;
String name="lidaofu";
class Inner{
  int age=25;
  public void show(){
   System.out.println("name="+name);
   //内部类中访问自己的实例变量this.属性
   System.out.println("inner age="+this.age);
   //内部类中访问外部类的实例变量:外部类名.this.属性
   System.out.println("outer age="+Outer.this.age);
  }
}
public void method(){
  //内部类定义在外部类的成员位置上时，外部类访问内部类，必须先建立内部类对象
  Inner in=new Inner();
  in.show();
}
}
public class InnerTest{
public static void main(String[] args){
  Outer out=new Outer();
  out.method();
  //建立内部类对象
  Outer.Inner in=new Outer().new Inner();
  in.show();
}
}

/*
2.局部内部类：在方法中定义的内部类称为局部内部类
与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。
局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量（但此时要求外部类的局部变量必须为final）
在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。
要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。
*/

class Outer{
private int age=24;
String name="lidaofu";
public void show(){
  //局部内部类访问局部变量时，局部变量必须被final修饰
  final String sex="man";
  //具有局部变量所具有的特性
  class Inner{
   int age=23;
   public void out(){
    System.out.println("name="+Outer.this.name);
    System.out.println("Outer age="+Outer.this.age);
    //局部内部类不仅可以访问外部类的属性，还可以访问局部中的变量
    System.out.println("sex="+sex);
    System.out.println("Inner age="+age);
   }
  }
  //在外部类的方法中生成内部类对象，调用内部类中的方法
  Inner in=new Inner();
  in.out();
}
}
public class InnerTest{
public static void main(String[] args){
  //外部类无法直接生成局部内部类,必须通过生成外部类通过调用外部类的方法来调用内部类
  Outer out=new Outer();
  out.show();
}
}

/*
静态内部类：定义在外部类的成员位置上，被static所修饰
静态内部类只能访问外部类的静态成员。
生成一个静态内部类不需要外部类成员，静态内部类的对象可以直接生成：Outer.Inner in=new Outer.Inner()；
当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。
*/

class Outer{
private static int age=24;
static String name="lidaofu";
//被static所修饰，具有static所具有的特性(这里不可用private来修饰，不然在外部无法直接来创建内部类对象)
static class Inner{
  String sex="man";
  public void out(){
   //外部类和内部类中的变量不同名时，可以省略Outer.this.属性
   System.out.println("name="+name);
   //静态内部类只能访问被static修饰的外部类成员
   System.out.println("Outer age="+age);
   System.out.println("set="+sex);
  }
}
}
public class InnerTest{
public static void main(String[] args){
  //可以不用创建外部类而直接创建内部类对象
  Outer.Inner in=new Outer.Inner();
  in.out();
}
}

/*  
匿名内部类:匿名内部类是一种特殊的局部内部类，其实就是内部类的简写形式
定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
匿名内部类的格式：new 父类或者接口(){定义子类的内容}
匿名内部类中定义的方法最好不要超过3个
匿名内部类是唯一一种无构造方法类
因其为局部内部类，那么局部内部类的所有限制都对其生效
匿名内部类在编译的时候由系统自动起名Out$1.class
  */


interface Test{
public void out();
}
class Inner{
  String name="lidaofu";
  int age=24;

  public void show(){
  String sex="man";
  //匿名内部类,定义在局部变量上，具有局部内部类的特性
  Test t=new Test(){
   public void out(){
   System.out.println("name="+name);
   System.out.println("age="+age);
   //System.out.println("sex="+sex); 错误，这一句是无法通过编译的，因为sex没有被final所修饰
   }
  };
  t.out();
}
/*
  其实匿名内部类也可以定义在成员变量上，只要在用时，在外部类中定义个方法调用即可
  Test t=new Test(){
   public void out(){
    System.out.println("name="+name);
       System.out.println("age="+age);
   };
  }
  public void show(){
   t.out();
  }
  */

}
public class InnerTest{
public static void main(String[] args){
  Inner in=new Inner();
  in.show();
}
}

/*
注意事项：

    当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。
*/

楼主辛苦   总结的挺全面的  学习了