java允许在类的内部定义一个类，如果该内部定义的类没有用static修饰，该类就是一个内部类（用static修饰也可以认为是一种内部类，静态内部类）。内部类可以被认为是外部类的一个成员。
内部类的使用方法：
一、外部类内部定义一个内部类
二、外部类定义一个内部类类型的数据成员
三、外部类的构造器（或者其他方法）new一个内部类对象并赋给第二步的数据成员（也可以在外部类的对象方法中，创建一个内部类实例，并调用内部类方法）
四、外部类定义其他方法，使用第二步的数据成员调用内部类的方法。如果调用的内部类方法有参数的话，该外部类方法的参数种类、数量、顺序需与内部类对应方法相同
注：这是内部类被private修饰时的用法。如果没有修饰，可以通过外部类对象直接创建内部类对象。内部类对象可以调用外部类的成员。
eg:
class Person{
//定义一个内部类
private class Cup{
public void useCup(double w){
this.water=water-w;
}
public double getWater(){
return water;
}
private double water;
}
//通过构造器创建一个内部类对象并赋给myCup
public Person(String n){
myCup=new Cup();
this.name=n;
}
//创建drinkWater()方法，使用内部类对象调用useCup()、getWater()方法
public void drinkWater(double w){
myCup.useCup(w);
myCup.getWater();
}
//创建一个外部类类型的属性
private Cup myCup;
private String name;
//main方法使用上面的外部类
public Test{
public static void main(String[] args){
Person p=new Person("zhang");
p.drinkWater(0.9);
}
}
上面的例子中，内部类用private修饰，所以该内部类只能在外部类内部使用。当内部类没有用private修饰时，该类也可以从外部访问。
eg:
class Person{
//不用private修饰的内部类，此处类为默认访问权限（包访问权限）
class Cup{
代码块省略
}
。。。
代码块省略
}
public Test{
public static void main(String[] args){
Person p=new Person("zhang");
p.drinkWater(0.9);
Person.Cup cup=p.new Cup();//在外部创建内部类对象的方法。需要依托外部类对象创建。
}
}
闭包:
内部类对象直接创建时，必须基于外部类对象。也就是说创建时必须依附于一个外部类对象。内部类对象可以访问所依附的外部类对象的成员。从另一个角度说，内部类对象附带有所依附的外部类对象的环境信息。这就叫闭包。
eg:
class Person{
class Cup{
public String whoseCup(){
return name;//访问外包对象
}
}
public Person(String n){
this.name=n;
}
private String name;
}
public Test{
public static void main(String[] args){
Person me=new Person("张三");
Person him=new Person("李四");
Person.Cup firstCup=me.new Cup();
Person.Cup secondCup=him.new Cup();
System.out.println(firstCup.whoseCup());
System.out.println(secondCup.whoseCup());
}
}
static嵌套类
内部类也可以用static修饰，叫做static嵌套类。嵌套类可以直接创建，而不依托于外部类对象，同时，嵌套类对象不可访问外部类对象的成员。嵌套类也可以用private/public/protected修饰。
eg:
class Person{
static class Cup{
代码块
}
}
public class Test{
public static void main(String[] args){
Person.Cup cup=new Person.Cup();
cup.function(args);
}
}
从效果上看，嵌套static类拓展了类的命名空间(name space).
局部内部类
局部内部类类似局部变量，使用在外部类的方法中。
eg:
class Outter{
private int age;
public void method(){
class Inner{//外部类方法中定义一个内部类
private String name;
}
public void method1(){
方法体
}
Inner inner=new Inner();//实例化内部类
inner.method1();//内部类对象调动内部类方法
}
局部内部类的应用，在于通过创建一个外部类的实例化，然后用外部对象调用相应方法，该方法创建内部类对象，内部类对象调用内部类方法。
匿名内部类
讲述匿名内部类之前，先要弄清楚什么是匿名类。
匿名类是一种无类名的类，匿名类借助接口实现，并通常直接new一个对象。
eg:
interface Myint{
public void method();
}
class AnoClass{
public static void main(String[] args){
//借助接口创建一个匿名类的同事，new一个匿名类对象，并调用匿名类的方法
new Myint(){
private int age;
public void method(){
方法体
}
}.method();
//借助接口创建一个匿名类的同事，new一个匿名类对象，并用接口的应用指向该匿名类对象
Myint mi=new Myint(){
private int age;
public void method(){
方法体
}
}
}
}
下面再讲述一下匿名内部类，匿名内部类和局部内部类一样，也创建在外部类的方法中。
eg:
nterface Myint{
public void method();
}
class Outter{
private int age;
public void method(){
//在外部类的方法内部，借助接口创建一个匿名内部类的同时，实例化一个匿名内部类对象，并调用该对象的方法
new Myint(){
private int age;
public void method(){
方法体
}.method();
}
}
