概述
1.每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。可以避免修改接口而实现同一个类中两种同名方法的调用。
2.实现多重继承：在我们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
package insidecategory;
public class Example1 {
public String name() {
return "liutao";
}
}package insidecategory;
public class Example2 {
public int age() {
return 25;
}
}里面分别实现了两个内部类 test1,和test2 ，test1类又继承了Example1，test2继承了Example2，这样我们的类三MainExample就拥有了Example1和Example2的方法和属性，也就间接地实现了多继承。
package insidecategory;
public class MainExample {
private class test1 extends Example1 {
public String name() {
return super.name();
}
}
private class test2 extends Example2 {
public int age() {<br> return super.age();<br> }
}
public String name() {
return new test1().name();<br> }
public int age() {
return new test2().age();<br> }
public static void main(String args[]) {
MainExample mi=new MainExample();
System.out.println("姓名:"+mi.name());
System.out.println("年龄:"+mi.age());
}
}3.内部类提供了更好的封装，其他类如果要访问只能通过外围类访问，private 内部类提供了更好的封装，除了该外围类，其他类都不能访问
4.内部类可以很好的实现隐藏：一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
5.内部类拥有外围类的所有元素的访问权限
一般非静态内部类
一般非静态内部类，只有先创建了外围类才能够创建内部类
public class OuterClass {
private String str;
public void outerDisplay(){
System.out.println("outerClass...");
}
public class InnerClass{
public void innerDisplay(){
//使用外围类的属性
str = "ccchhh...";
System.out.println(str);
//使用外围类的方法
outerDisplay();
}
}
/*推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 */
public InnerClass getInnerClass(){
return new InnerClass();
}
public static void main(String[] args) {
// 注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.getInnerClass();
inner.innerDisplay();
}
}非静态内部类对象有着指向其外部类对象的引用
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Contents content = good.dest();
System.out.println(content.value());
}
}
interface Contents{
int value();
}
interface Destination{
String readLabel();
}
class Goods{
private int valueRate = 2;
private class Content implements Contents{
//一个内部类对象可以访问创建他的外部类对象的内容，甚至包括私有变量
private int i = 11 * valueRate;
public int value(){
return i;
}
}
protected class GDestination implements Destination{
private String label;
public GDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
public Content dest(){
return new Content();
}
public GDestination cont(String s){
return new GDestination(s);
}
}private 成员变量 valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把他乘上。我们发现，value（）可以访问valueRate,这也是内部类的一个好处，一个内部类对象可以访问创建他的外部类对象的内容，甚至包括私有变量！要想实现这个功能，内部类对象必须有指向外部类对象的引用。
静态内部类
和普通类一样，内部类也可以由静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部类的引用。这实际上和c++中的嵌套类很相像了
与一般内部类不同，在静态代码中不能够使用this操作，所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的实例变量，或与实例变量无关，则选择应用静态内部类
它的创建是不需要依赖于外围类的。
它不能使用任何外围类的非static成员变量和方法
静态内部类等同于外部类的静态属性，可以使用类名.的方式进行访问
访问静态内部类中的静态方法和成员方法与访问静态内部类的成员属性和静态属性相同，如果是成员方法，需要创建内部类的实例，如果是静态方法，可以通过类名.的方式进行调用。
静态内部类可以设置访问修饰符，与静态变量相同，注意，如果使用private修饰静态内部类，此内部类只有外部类可以访问，其他的类无法访问。
public class OuterClass {
private String sex;
public static String name = "chenssy";
/**
*静态内部类
*/
static class InnerClass1{
/* 在静态内部类中可以存在静态成员 */
public static String _name1 = "chenssy_static";
public void display(){
/*
* 静态内部类只能访问外围类的静态成员变量和方法
* 不能访问外围类的非静态成员变量和方法
*/
System.out.println("OutClass name :" + name);
}
}
/**
* 非静态内部类
*/
class InnerClass2{
/* 非静态内部类中不能存在静态成员 */
public String _name2 = "chenssy_inner";
/* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的 */
public void display(){
System.out.println("OuterClass name：" + name);
}
}
/**
* @desc 外围类方法
* @return void
*/
public void display(){
/* 外围类访问静态内部类：内部类. */
System.out.println(InnerClass1._name1);
/* 静态内部类 可以直接创建实例不需要依赖于外围类 */
new InnerClass1().display();
/* 非静态内部的创建需要依赖于外围类 */
OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
/* 方位非静态内部类的成员需要使用非静态内部类的实例 */
System.out.println(inner2._name2);
inner2.display();
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.display();
}
}
----------------
Output:
chenssy_static
OutClass name :chenssy
chenssy_inner
OuterClass name：chenssy匿名内部类
匿名内部类是没有访问修饰符的
匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法
public class OuterClass {
public InnerClass getInnerClass(final int num,String str2){
return new InnerClass(){
int number = num + 3;
public int getNumber(){
return number;
}
}; /* 注意：分号不能省 */
}
public static void main(String[] args) {
OuterClass out = new OuterClass();
InnerClass inner = out.getInnerClass(2, "chenssy");
System.out.println(inner.getNumber());
}
}
interface InnerClass {
int getNumber();
}
----------------
Output:注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
局部内部类
是嵌套在方法和作用域内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。
定义在方法里
public class Parcel5 {
public Destionation destionation(String str){
class PDestionation implements Destionation{
private String label;
private PDestionation(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
return new PDestionation(str);
}
public static void main(String[] args) {
Parcel5 parcel5 = new Parcel5();
Destionation d = parcel5.destionation("chenssy");
}
}定义在作用域内:
你不能再if(b)语句之外创建这个内部类的对象，应为这已经超出了他的作用域
public class Parcel6 {
private void internalTracking(boolean b){
if(b){
class TrackingSlip{
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip(){
return id;
}
}
TrackingSlip ts = new TrackingSlip("chenssy");
String string = ts.getSlip();
}
}
public void track(){
internalTracking(true);
}
public static void main(String[] args) {
Parcel6 parcel6 = new Parcel6();
parcel6.track();
}
}
