一、基本概念
内部类：将一个类定义在另一个类里面，那么里面这个类就称为内部类（内置类，嵌套类）
根据内部类定义在外部类中的位置可分为：
 （1）成员内部类：内部类所处位置与外部类的成员变量、成员方法并列，相当于外部类的一个成员(类）
 （2）局部内部类：内部类所处位置在外部类的某个成员方法体内，相当于成员方法的一个局部量(类）
作用：
  （1）在某种程度上实现多重继承，若B类嵌套定义在A类之内，是A类的一个内部类，则在A派生C类时，C类可以继承A类的成员，也因B是A类的成员类，故也被C类继承。
  （2）对外而言，内部类可以实现信息隐藏
  （3）可以避免修改接口而实现同一个类中两种同名方法的调用
二、成员内部类
示例1：
interface Overtime{
       void prepareLesson();
       void checkHomework();
}
class Teacher{
      void work(){
          System.out.println("传道受业，教书育人！");
      }
     private class ExtraWork implements Overtime{
            public void prepareLesson() {
                 System.out.println("抓紧时间，认真备课！");
             }
            public void checkHomework() {
                   System.out.println("抓紧时间，改好作业！");
            }      
     }
     ExtraWork prepare(){
                  return new ExtraWork();
     }
}  
public class Test {
    public static void main(String[] args) {
        Teacher t=new Teacher();
        Overtime w=t.prepare();
        w.prepareLesson();
        w.checkHomework();
  }
}
   我们在Teacher类中嵌套定义了一个private访问权限的ExtraWork类（内部类），实现了Overtime接口的两个方法。在后面的main方法里，直接用Overtime w进行操作、调用接口方法实现相应功能。在Test类的main方法中，我们甚至连这个内部类的名字都没有看见！----实现了信息隐藏，也即封装性。
   当然，在外部类作用范围之外调用内部类的方法，需要在外部类中定义一个返回值为内部类类型的成员方法。上例中的prepare()方法就是这么做的。由于内部类ExtraWork的访问权限定义为private，所以在外部类之外是不可以直接访问该类的。

示例2：
class Outer{
     private String str="Java学习笔记";  //定义外部类的私有属性
     public class Inner {    //声明内部类
   public void getStr(){    //定义内部类的方法
     System.out.println(str);
   }
     }
     public void getInfo(){            //从外部类调用内部类的方法
        Inter in= new Inter();        //创建内部类实例
         in.getStr();
     }
}
public class InnerClassDemo01 {
    public static void main(String[] args) {
          Outer out=new Outer(); //创建外部类的实例
  out.getInfo(); //调用外部类的方法
 // Outer.Inner oin=new Outer().new Inner();//通过匿名外部示例创建内部类实例
            Outer.Inner oin=out.new Inner();//通过外部类示例out来创建内部类的实例  
oin.getStr();//调用内部类的方法
      }
}
   当内部类不是private访问权限时，可以在外部类之外创建内部类实例，通过内部类实例访问其方法。
   语法格式： 外部类名.内部类名   内部类引用对象=外部类实例.new 内部类();
总结：成员内部类可以访问外部类的成员，内部类方法需要创建内部类实例对象去调用。
示例3：外部类成员变量、内部类成员变量和内部类方法局部变量同名是的区分
class OutClass {
    private int age = 12;     
    class InClass {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Out.this.age);
        }
    }
}


三、静态内部类
   当成员内部类前有关键词static时，该成员内部类就是一个静态(成员)内部类。   
示例4：
 class OutClass {
    private static int age = 12;     
    static class InClass {
        public void print() {
            System.out.println(age);
        }
    }
} 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.print();
    }
}
 总结：静态成员内部类只能访问外部类的静态成员。
      在外部类之外创建静态内部类实例语法格式：外部类名.内部类名  内部类引用对象=new 外部类名.内部类();


四、方法内部类(局部内部类)
   内部类所处位置在外部类的某个成员方法体内，相当于成员方法的一个局部量(类）
示例5：
   定义一个学生课程成绩管理类，为每个学生统计成绩使用：
   基本属性：课程名，课程考试成绩，课程平时成绩，加权值。
   基本方法：设置课程名，设置成绩，设置加权值，输出课程信息（课程名称和总成绩）
class  CourseGrade{
  String courseName;
  double examGrade;
  double usualGrade;
  double ratio;
  void setName(String name){courseName=name;}
  void setGrade(double egrade,double ugrade){examGrade=egrade;uaualGrade=ugrade;} 
  void setRatio(double ratio){this.ratio=ratio;}
  void print(){
      class CalGrade{
          double cal(){
             return examGrade*ratio+usualGrade*(1-ratio);
          }
      }
      System.out.println("课程名称："+courseName);
      System.out.println("课程总成绩："+new CalGrade().cal());
  }
}
总结：方法内部类可以访问外部类的成员。
      但却只能访问方法的final局部变量包含形参，因为当方法被调用运行完毕之后，局部变量就已消亡了。
      而内部类对象可能还存在（直到没有被引用时才会消亡）此时就会出现内部类要访问一个不存在的局部变量。


 示例6：
class Out{
    private int age=12;
    public void Print(final int x){
          class In{
                public void inPrint() {
                           System.out.println(x);  //可以访问外部类成员变量
                          System.out.println(age); //只能访问方法的final局部变量，包括形参
                }
           }
           new In().inPrint();
   }
}


五、匿名内部类
1、匿名内部类其实就是内部类的简写格式
2、定义匿名内部类的前提：
         内部类必须继承一个类或者实现接口
3、匿名内部类的格式
new 父类或者接口（）{  定义子类的内容  }
4、其实匿名内部类就是一个匿名子类对象，可以理解为带内容的对象。
5、匿名内部类中定义的方法尽量不超过2个，当有多个方法时，可以通过匿名内部类中的构造代码块进行调用。
   通过匿名内部类的匿名子类对象只能调用一个方法。
示例7：
interface CalGrade{
   double cal();
}
class  CourseGrade{
  //.......示例5代码省略部分
  void print(){      
      System.out.println("课程名称："+courseName);
      System.out.println("课程总成绩："+new CalGrade(){
 public double cal(){
             return examGrade*ratio+usualGrade*(1-ratio);
          }
      }.cal());
  }
}