内部类的定义：
内部类就是定义在另一个类里面的类。反之，包含内部类的类称为外部类。
我们为什么要使用内部类呢？
1.外部类能给内部类提供更好的封装，把内部类隐藏在外部类之内，不允许同一个包中的其他类去访问。
2.内部类能直接访问外部类的所有数据，包括私有数据。
3.内部类实现的功能，外部类也能使用。
内部类分为：
1.成员内部类
2.静态内部类
3.方法内部类
4.匿名内部类
下面在下就详细说说这个4中内部类：
1.成员内部类：
在其外部类中被定义，与成员变量，方法并列。
package org.member.innerclass;
public class Big {
//定义一个整形变量
private int i = 10;
//定义一个整形变量
private int k = 20;
//定义一个静态整形变量
private static int j = 30;
//定义一个方法
public void method1() {
System.out.println( "method1..." );
}
//定义一个静态方法
public static void method2() {
System.out.println( "method2..." );
}
//定义成员内部类
class Small {
//内部类和外部类的成员变量能够共存的
//定义一个整形变量
private int i = 11;
//定义内部的方法
public void innerMethod() {
//输出内部整形变量i的值
System.out.println( "内部类i的值 = " + i );
//这里指定的是内部类的整形变量i
System.out.println( "内部类i的值 = " + this.i );
//输出外部类整形变量i
System.out.println( "外部类i的值 = " + Big.this.i );
//直接输出外部类的静态整形变量
System.out.println( "静态变量j = " + j );
//内部类和外部类没有同名的变量，则直接用变量名访问外部类变量
System.out.println("外部类k的值 = " + k );
//内部类访问外部类的方法
method1();
//内部类访问外部类的静态方法
method2();
}
}//在方法内访问内部类
public void method3() {
//实例化一个内部类
Small small = new Small();
//调用其方法
small.innerMethod();
}
//外部类的静态方法访问内部类
//与外部类访问内部类一样
public static void method4() {
//首先得实例化一个外部类
Big big = new Big();
//然后实例化内部类
Small small = big.new Small();
//调用内部类的方法
small.innerMethod();
}
public static void main(String[] args) {
//想要创建内部类，就必须使用一个外部类来引用创建
Big big = new Big();
Big.Small small = big.new Small();
small.innerMethod();
//通过外部类的方法来创建内部类
big.method3();
}
}
2.静态内部类
静态内部类跟成员内部类不同，它没有隐含的保存一个引用，指向创建它的外部类，它不需要与外部类有联系，它只是嵌套在外部类中，所以我们也称它为”嵌套类“。
”嵌套类“意味着：
1.并不需要外部类来创建嵌套类对象。
2.不能从嵌套类对象中访问非静态的外部类。
package org.static1.innerclass;
public class Big {
//定义一个静态整形变量
private static int i = 10;
//定义一个整形变量
private int j = 20;
//外部类的静态方法
public static void method1() {
System.out.println( "静态method1方法" );
}
//外部类的方法
public void method2() {
System.out.println( "method2方法" );
}
//静态内部类
static class Small2 {
//定义一个静态整形变量
private static int inner_i = 30;
//定义一个整形变量
private int inner_j = 40;
//静态内部类的静态方法只能调用静态变量和静态方法
//静态内部类的静态方法
public static void innerMethod() {
//静态内部类的静态方法只能输出静态变量
System.out.println( "静态整形变量inner_i = " + inner_i );
//输出外部类的静态变量
System.out.println( "外部类的静态变量i = " + i );
//调用外部类的静态方法
method1();
}
//静态内部类的方法
public void innerMethod2() {
//内部类的非静态方法输出非静态变量
System.out.println( inner_j );
//静态内部类不能调用外部类的非静态方法和非静态变量
// method2();
// System.out.println( j );
}
}
//外部类的方法
public static void method3() {
//外部类访问静态内部类的的静态变量
System.out.println( "inner_i = " + Small2.inner_i );
//外部类访问静态内部类的的静态方法
Small2.innerMethod();
//外部类访问内部类的非静态变量
//先得实例化一个内部类对象
Small2 small2 = new Small2();
System.out.println( "inner_j = " + small2.inner_j );
//外部类访问内部类的非静态方法
small2.innerMethod2();
}
//main方法
public static void main(String[] args) {
Small2.innerMethod();
//静态内部类是不需要外部类的引用来创建对象的
Small2 small2 = new Small2();
small2.innerMethod2();
}
}
3.局部内部类
在方法中定义的类，我们称为局部内部类。与局部变量类似，局部内部类不能有访问修饰符，但是它可以访问当前代码块内的常量，和此外部类所有的成员。
package org.local.innerclass;
public class Big {
//定义整形变量
private int i = 10;
//整形变量
private int out_j = 20;
//定义一个方法
public void method() {
//定义局部整形常量
final int i = 15;
//定义局部整形变量
int j = 25;
//局部内部类
class Small {
//可以定义与外部类一样的变量名
int i = 100;
//不能定义静态变量
// static int m = 10;
private void method() {
//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println( "out_j = " + out_j );
//输出局部内部类的成员变量
System.out.println( "i = " + i );
//输出外部类的成员变量
System.out.println( "Big.this.i = " + Big.this.i );
//该内部类可以访问局部变量
System.out.println( "j = " + j );
}
}
new Small().method();
}
public static void main(String[] args) {
Big big = new Big();
big.method();
}
}
4.匿名内部类
顾名思义，匿名内部类就是没有名字的内部类。
在一下情况使用匿名内部类比较合适：
.只用到类的一个实例。
.类在定义后马上能用到。
.类非常小。
.给类命名不会导致你的代码更容易被理解。
在使用匿名内部类，要记住一下几个原则：
.匿名内部类不能有构造方法。
.匿名内部类不能定义任何静态成员、方法、类。
.匿名内部类不能是public,protected,private,static。
.只能创建匿名内部类的一个实例.
.一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
.因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
package org.anonymous.innerclass;
public abstract class Doctor {
//定义方法
public void workInDay() {
System.out.println( "在医院上班" );
}
//定义抽象方法
public abstract void workInNight();
//main方法
public static void main(String[] args) {
//实例化Doctor类，而且必须重写workInNight抽象方法
Doctor doctor = new Doctor() {
//重写该方法
@Override
public void workInNight() {
System.out.println( "睡觉" );
}
};
//调用其方法
doctor.workInDay();
doctor.workInNight();
}
}
-----------------------
来源：https://www.cnblogs.com/hmake/p/6071369.html