内部类

非静态内部类

1.隐藏不想让别人知道的内容即：封装性

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");

<span style="white-space:pre">		//Goods.Content content  = p.new Content();
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//System.out.println(content.value());</span>
	}
}

在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回

翻译：一个类Goods中有内部类Content，GDestination,我想调用这两个内部类 就可以在Goods中创建方法，然后在main方法中调用了

在我调用的时候我都不知道我的内部类是什么就得到了想要的结果，所以内部类能很好的进行封装.注：如果内部类是public非静态的就可以用注释的方法来创建内部类。一定要先创建外部类的对象，然后再创建内部类

2.内部类对象可以访问创建外部类对象的内容，甚至包括私有变量

<pre name="code" class="java"><pre name="code" class="java"><span style="font-family: Arial; background-color: rgb(255, 255, 255);">	<span style="font-family: Arial;">非静态内部类对象有着指向其外部类对象的引用</span></span>

翻译：内部类Content 的value方法可以访问外部类的成员变量valueRate

静态内部类

和非静态内部类的区别

public class StaticGood {
	public static int valueRate = 2;

	public static class Content implements Contents {
		private int i = 11 * valueRate;

		public int value() {
			return i;
		}
	}

	public static 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();
	}

}

//访问静态内部类
StaticGood.Content content = new StaticGood.Content();
content.value();

1.静态内部类没有了指向外部的引用

翻译：直接可以像调用静态变量一样调用静态内部类

2.费静态内部类中不管是方法，变量必须都是非静态的

3.静态内部类调用外部类的变量必须是静态的如果不是那么就要new StaticGood().valueRate 来进行访问

局部内部类：可以在方法中创建内类

匿名内部类：

public class Goods3 {
public Contents cont() {
return new Contents() {//匿名内部类
private int i = 11;

public int value() {
return i;
}
};
}
} 

解释：这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。
在java的事件处理的匿名适配器中，匿名内部类被大量的使用。

注意：

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：
如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。 
在这个匿名内部类中使用初始化代码块。 

总结：内部类到底有什么作用

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法的不就行了吗？
的确，以此作为设计内部类的理由，实在没有说服力。
真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员

抱怨java中存在的一个问题 没有多继承。实际上，C++的多继承设计起来很复杂，

而java通过内部类加上接口，可以很好的实现多继承的效果。