在Java中内部类主要分为四种：静态内部类、成员内部类、方法内部类、匿名内部类。

非静态内部类包括：成员内部类、方法内部类、匿名内部类。

1.成员内部类

成员内部类内部不允许存在任何static变量或方法，正如成员方法中不能有任何静态属性 （成员方法与对象相关、静态属性与类有关）。

class Outer {
    private String name = "test";
    public static int age = 20;
    public int num = 9;
    class Inner  {
        // public static int num =10; // 在成员内部类不能存在静态属性
        public int num = 10;
        public void fun() {
            System.out.println(name); // 在成员内部类可以访问外部类的非静态属性
            System.out.println(age); // 以及静态属性
            System.out.println(num); // 10，有限访问内部属性
            System.out.println(this.num); // 10， 还是指内部类对象
            System.out.println(Outer.this.num); // 9，指的是外部类对象的属性
        }
    }
}
public class Test {
    public static void main(String [] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); // 成员内部类是依附外部类的，只有创建了外部类才能创建内部类。
        inner.fun();
    }
}

2.静态内部类

使用static修饰的内部类我们称之为静态内部类。

静态内部类和非静态内部类之间存在一个最大的区别：非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外围类，但是静态类没有。

没有这个引用就意味着：

  1.静态内部类的创建不需要依赖外部类可以直接创建。

  2.静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。

class Outer {
    public String name = "test";
    private static int age =20;
    public void method() {
        System.out.println("Call Outer method");
    }
    public static void method2() {
        System.out.println("Call Outer method2");
    }
    static class Inner {
        private String name = "hello";
        public static int num = 10;
        public void fun() {
            System.out.println(name); // 可以访问外部的非静态属性
            // System.out.println(Outer.this.name); // 不能访问外部类的非静态属性
            System.out.println(age);  // 可以访问外部类的静态属性
            System.out.println(num);  // 可以在静态内部类中，定义静态属性
            // method(); // 不能访问非静态的方法
            method2(); // 可以访问外部类静态的方法
        }
    }
}

public class Test {
    public static void main(String [] args) {
        Outer.Inner in = new Outer.Inner(); // 不依赖外部类，可以直接创建内部类的实例
        in.fun();
    }
}

3.方法内部类

定义在方法里的类被称为方法内部类。

1.方法内部类不允许使用访问权限修饰符（public、private、protected）。

2. 方法内部类对外部完全隐藏，除了创建这个类的方法可以访问它以外，其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)。

3. 方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）。

class Outer{
    public int num = 5;
    public static int age = 10;
    public void dispaly(final int temp) { // JDK8形参变为隐式final声明

        class Inner { // 方法内部类即嵌套在方法里面, 不能使用修饰符public protected private
            // public static int age = 10; // 不能定义静态属性
            // public static void method2() { // 不能定义静态方法
            //     System.out.println(" ");
            // }
            public void method() {
                System.out.println(num); // 可以使用外部类的非静态属性 & 方法
                System.out.println(age); // 可以使用外部的静态属性 & 方法
                System.out.println("Call method");
                // temp++; // 不能改变final类型的值
                System.out.println(temp); // 但是可以调用
            }
        }

        // 方法内部类在方法里面创建
        new Inner().method();
    }
}
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.dispaly(3);
    }
}

4.匿名内部类

匿名内部类是一个没有名字的方法内部类，因此特点与方法内部类完全一致，除此之外，还有自己的特点：
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名，因此没有构造方法。

package Inner;

// 声明一个接口
interface MyInterface {
    void test();     // 接口中方法没有方法体
    default void test2() { // 可以有默认方法
        System.out.println("***hello***");
    }
}

// 声明一个抽象类
abstract class Person {
    void play() {}

    void play2() {
        System.out.println("***play****");
    }
}

class Outer{
    private int num = 5;
    private static int age = 10;
    public void dispaly(int temp) {
        // 匿名内部类，匿名的实现了 MyInterface 接口
        // 隐藏的class声明
        MyInterface myInterface = new MyInterface() {
            public void test() {
                System.out.println(num); // 可以访问外部类的非静态属性 & 方法
                System.out.println(age); // 可以访问外部类的静态属性 & 方法
                System.out.println("匿名实现MyInterface接口");
                // temp++; // 同方法内部类
                System.out.println(temp);
            }
        };
        myInterface.test();
        myInterface.test2();

        MyInterface myInterface2 = () -> {  // 使用lambda表达式实现
            System.out.println("----------");
            System.out.println("匿名实现MyInterface接口");
        };
        myInterface2.test();
        myInterface2.test2();
    }

    public void display2(int temp) {
        Person person = new Person() {
            void play() {
                System.out.println("匿名实现抽象类Person");
            }
        };
        person.play();
        person.play2();
        // 抽象类不能使用lambda表达式方式实现
    }
}

public class Test {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.dispaly(3);
        out.display2(4);
    }
}

静态内部类和非静态内部类的区别总结：

再看内部类的定义：

可以将一个类的定义放在另一个类的内部，这就叫内部类。 -java编程思想

嵌套类：

如果不需要内部类对象与其外部类对象之间存在联系，则可以将内部类声明为static。这通常称为嵌套类。

注意：普通的内部类对象隐式的保留着一个引用，指向创建它的外围对象。

内部类的作用：

1.内部类使得多重继承的解决方案更加完整。虽然接口解决可部分问题，但是内部类有效的实现了多重继承。

也就是说：内部类允许继承多个非接口类型(类或者抽象类)。 

2.每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口）的实现，对应内部类都没有影响。

3.内部类可以有多个实例，每个实例有自己的状态信息，与外围类相互独立。

4.单个外围类中，可以让多个内部类以不同的方式实现统一接口，或者继承同一个类。

5.内部类没有令人迷惑的is-a的关系，是独立的实体。