一：静态内部类：又叫静态嵌套类，静态内部类就是个独立的类，它不持有外部类的对象，自己完全可以独立存在。
之所以要弄这么个东西，只是起到一个注释的效果，而且这个注释可静态检查。
比如有A，B两个类，B有点特殊，虽然可以独立存在，但只被A使用。
这时候怎么办？如果把B并入A里，复杂度提高，搞得A违反单一职责。如果B独立，又可能被其他类（比如同一个包下的C）依赖，不符合设计的本意。所以不如将其变成A.B，等于添加个注释，告诉其他类别使用B了，它只跟A玩。
所以可以说它是为了简化类结构，提高代码封装性而存在
静态内部类的好处
- 静态内部类不持有外部类的引用，可以完全独立存在，不跟外部类同生共死。
- 普通内部类不能声明static的方法和变量：
注意这里说的是变量，常量（也就是final static修饰的属性）还是可以的，而静态内部类形似外部类，没有任何限制。
二：非静态内部类：依赖外部类而存在，它持有外部类的对象。
我在你内部就是我是你的一部分，我了解你，我知道你的全部，没有你就没有我。（所以内部类对象是以外部类对象存在为前提的）
非静态内部类的好处，为什么要使用它？
- 内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性
public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}
在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性。
- 内部类持有外部类的引用，与外部类同生共死。内部类甚至可以访问外部类的私有变量。这就为我们在设计时提供了更多的思路和捷径。
- 可以避免修改接口而实现同一个类中两种同名方法的调用
首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法的不就行了吗？
- 可以实现多重继承。
这个特点非常重要，个人认为它是内部类存在的最大理由之一。正是由于他的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。
名字类。有个字段名字
public class Name {
public String name()
{
return "xiaoming";
}
}
年龄类
public class Age {
public int age(){
return 25;
}
}
Person 类，
- 它两个内部类：
- PersonName ， 继承自Name；
- PersonAge ，继承自Age.
- 有两个方法：
- getName(), 返回人的姓名
- getAge()返回人的年龄
public class Person{
//内部类PersonName 继承自Name
private class PersonName extends Name{
public String name(){
return super.name();
}
}
// 内部类PersonAge，继承自Age
private class PersonAge extends Age{
public int age() {
return super.age();
}
}
//方法getName
public String getName(){
return new PersonName ().name();
}
//方法getAge
public int getAge(){
return new PersonAge().age();
}
//Main方法
public static void main(String args[]) {
Peson person=new Person();
System.out.println("姓名:"+person.getName());
System.out.println("年龄:"person.getAge());
}
}
解释：这样person相当于继承了Name类，又继承了Age类。实现了多继承。同样我们这里也看出来内部类的特点，实现封装性，因为我们从外部都看不出来，继承了这两个类。
如有错误，欢迎指正。转载请在文章明显处注明，谢谢！
