一、定义

1.在一个类的内部进行其他类结构的嵌套的操作。

例：

class Outer{
    private String msg = "Hello World!";
    //定义一个内部类
    //*******************************************************
    class Inner{
        public void print(){
            System.out.println(msg);  //访问外部类私有属性
        }
    }
    //*******************************************************
    //外部类方法
    public void fun(){
    //在外部类内部创建内部类对象
        Inner in = new Inner(); //内部类对象
        in.print();   //调用内部类方法
    }
}
public class Test4{
    public static void main(String[] args){
        Outer out = new Outer();//外部类对象
        out.fun();//外部类方法
    }
}

二、分类

  1.成员内部类(成员方法)
          a.成员内部类不能存在任何static变量或方法，可以访问外部类的静态域
          b.成员内部类是依附外部类的，只有先创建了外部类才能创建内部类
  2.静态内部类（静态方法）
          a.静态内部类的创建不需要依赖外部类，可以直接创建
          b.静态内部类不可以使用任何外部类的static域（包含属性与方法），但可以存在自己       
             的成员变量
  3.方法内部类
    要求：a. 局部内部类不允许使用访问权限修饰符 public、 private、 protected 均不允许 
         b. 局部内部类对外部完全隐藏，除了创建这个类的方法可以访问它其他的地方是
            不允许访问的。
         c. 局部内部类要想使用方法形参，该形参必须用final声明(JDK8将形参变为隐式
            final声明).
  4.匿名内部类（landba表达式前身）
     没有名字的方法内部类，它符合方法内部类的所有约束.除此之外，还有两个自己的特点：
         a. 匿名内部类必须继承一个抽象类或者实现一个接口
         b.匿名内部类是没有构造方法的，因为它没有类名。

三、创建内部类语法（在外部类外部）

1.创建非静态内部类
       外部类.内部类    内部类引用 = new  外部类().new    内部类();
       Outter.Inner in = new Outter().new Inner();
2.创建静态内部类：
       外部类.内部类    内部类引用 = new  外部类.内部类();
       Outter.Inner  in = new Outter.Inner();

四、内部类的优点和缺点

1. 内部类与外部类可以方便的访问彼此的私有域（包括私有方法，私有属性）
2. 内部类是另外另外一种封装（保护性），对外部的其他类隐藏（心脏包在人身体内部）。
3. 内部类可以实现 java 单继承的局限
   内部类的缺点：结构复杂

五、内部类与外部类的关系

1.对于非静态内部类，内部类的创建需要依赖外部类对象，在没有外部类实例之前无法创建非静态内部类
2.内部类是一个相对独立的个体，与外部类没有is - a关系
3.内部类可以直接房访问外部类的元素（包含私有域），但是外部类不可以直接访问内部类元素，需要通过内部类的引用间接访问

源码

1. 静态内部类

class Outer{
    private static String msg = "Hello World!";
    //定义一个内部类
    //*******************************************************
    static class Inner{
        public void print(){
            System.out.println(msg);  //调用msg
        }
    }
    //*******************************************************
    //外部类方法
    public void fun(){
        Inner in = new Inner(); //静态内部类对象
        in.print();   //调用静态内部类方法
    }
}
public class Test4{
    public static void main(String[] args){
        Outer out = new Outer();//外部类对象
        out.fun();//外部类方法
    }
}    

2.方法内部类

  class Outer{
    private int num;
    //外部类方法
    public void fun(final int test){
         //定义一个方法内部类
         //*******************************************************
        class Inner{
            public void print(){
                num++;
                System.out.println(num);  
                System.out.println(test);
            }
        //*******************************************************
        }
    Inner in = new Inner();//在方法内部定义方法内部类对象
    in.print();  //
    }
}
public class Test4{
    public static void main(String[] args){
        Outer out = new Outer();//外部类对象
        out.fun(20);//外部类方法
    }
}    

3.匿名内部类

interface MyInterface{
    void test();
}
class Outer{
    public void fun(final int temp){
        new MyInterface(){
            public void test(){
                System.out.println("匿名内部类！"+temp);
            }
        }.test();
    }
}
public class Test4{
    public static void main(String[] args){
        Outer out = new Outer();//外部类对象
        out.fun(20);//外部类方法
    }
}   

4.用内部类来实现”多继承”

class A {
    private String name = "A类的私有域";
    public String getName() {
        return name;
    }
}
class B {
    private int age = 20;
    public int getAge() {
        return age;
    }
}
class Outter {
    private class InnerClassA extends A {
        public String name() {
            return super.getName();
        }
    }
    private class InnerClassB extends B {
        public int age() {
            return super.getAge();
        }
    }
    public String name() {
        return new InnerClassA().name();
    }
    public int age() {
        return new InnerClassB().age();
    }
}
public class Test4 {
    public static void main(String[] args) {
        Outter outter = new Outter();
        System.out.println(outter.name());
        System.out.println(outter.age());
    }
}