java内部类通常分为普通内部类、方法内部类、静态内部类、匿名内部类，这里分别讲解。

一、普通内部类：(内部类是外部类的一个成员 但是也是一个类)
(不能定义静态内容只能定义静态常量且常量要赋字面值)
1、外部类成员访问内部类的成员：创建内部类实例

public class TestInner {
			public static void main(String[] args) {
				new Outer().method();
			}
		}
		class Outer{
			String name;
			int age;
			public void method() {
				System.out.println("外部内成员方法");
				Inner inner = new Inner();
				System.out.println("输出内部类num="+inner.num);
			}
			class Inner{
				int num = 10;
			}
		}
2、其他类访问内部类：
		a.创建内部类对象：创建时要求必须保证外部类对象存在 	
		b.外部类.内部类 变量名= new 外部类().new 内部类();
		Outer.Inner inner = new Outer().new Inner();
	 3、内部类访问外部类成员：
	      a.要是内部类中成员名字和外部内成员名字相同，直接使用就是就近原则，
	        如果需要使用外部类成员，用外部类名.this.成员变量名
	        例如：
class Outer{
					int num = 10;
					class Inner{
					  int num = 20;
					  System.out.println(Outer.this.num);//这就是调用外部类的同名成员
					}
				}

二、方法内部类
1.见名知其意，这个内部类是在方法中的，所以这个类是局部变量，具有局部变量的特性， 局部变量不能用static关键字修饰：

class Outer2{
	int age;
	String name;
	public void method(){//static不能修饰局部变量。
	    class Inner{//首次这个类是这个方法里面的，只能是一个局部变量。
	       int num = 9;
	    }
	}
}
2、外界类不能访问方法内部类，换句话说，成员方法中的内容是不能被访问的，方法中的内容需要访问方法内部类，也是创建
  对象的方式访问。
3、方法内部类可以缩减内存开销，因为局部变量生命周期短。

三、静态内部类
1、静态内部类需明确的是它是一个外部类的静态成员，同时是一个类。
2、外部类成员访问静态内部类时：
a.访问静态内部类的非静态成员，创建实例对象
b.访问静态内部类的静态成员，直接通过类名.

class Outer3{
	
	public void method() {
		System.out.println(Inner.num);//非静态
		System.err.println(new Inner().temp);//静态
	}
	static class Inner{
		static int num = 20;
		int temp = 40;
	}
}
3、静态内部类访问外部类的成员
  a.非静态成员，创建外部类实例对象访问
  b.静态成员，直接用
  c.提示：成员变量和成员方法一样，方法自行验证。
class Outer3{
	static int num1 = 10;
	int num2 = 20;
	static class Inner{
		public void inMethod() {
			System.out.println(num1);
			System.out.println(new Outer3().num2);
		}
	}
}
4、外界类访问静态内部类中的内容
  a.访问静态内部类的静态内容
     外部类名.内部类名.静态成员名
  b.访问非静态内部类的非静态内容（创建一个静态内部类实例）
     外部类名.内部类名().静态成员名
public class Test {
	public static void main(String[] args) {
		System.out.println(Outer3.Inner.temp2);
		System.out.println(new Outer3.Inner().temp1);
	}
}
class Outer3{
	static class Inner{
		int temp1 = 21;
		static int temp2 = 11;
	}
}

四、匿名内部类
1、可以用来创建接口的实现类对象或抽象类的子类对象
而这些对象只需要被使用一次，用匿名内部类实现，使
用完就可以被回收，减少内存压力。
2、使用方法：
new 接口/抽象类(){
重写所有的抽象方法;
};
3、不使用匿名内部类和使用匿名内部类的代码区别
a.不使用匿名内部类代码：

public class Test{
	public static void main(String[] args) {
		Animal animal = new Dog();
		animal.run();
	}
}
interface Animal{
	public void run();
}
class Dog implements Animal{
	
	@Override
	public void run() {
		System.out.println("狗会跑步！！！");
	}
}
b.使用匿名内部类代码：
public class Test{
	public static void main(String[] args) {
		Animal animal = new  Animal{
			@Override
			public void run() {
				System.out.println("狗会跑步！！！");
			}
		};
		animal.run();
	}
}
interface Animal{
	public void run();
}