至此，我们已基本理解了内部类的典型用途。对那些涉及内部类的代码，通常表达的都是“单纯”的内部类，非常简单，且极易理解。然而，内部类的设计非常全面，不可避免地会遇到它们的其他大量用法――假若我们在一个方法甚至一个任意的作用域内创建内部类。有两方面的原因促使我们这样做：
　　
　　(1) 正如前面展示的那样，我们准备实现某种形式的接口，使自己能创建和返回一个句柄。
　　
　　(2) 要解决一个复杂的问题，并希望创建一个类，用来辅助自己的程序方案。同时不愿意把它公开。
　　
　　在下面这个例子里，将修改前面的代码，以便使用：
　　
　　(1) 在一个方法内定义的类
　　
　　(2) 在方法的一个作用域内定义的类
　　
　　(3) 一个匿名类，用于实现一个接口
　　
　　(4) 一个匿名类，用于扩展拥有非默认构建器的一个类
　　
　　(5) 一个匿名类，用于执行字段初始化
　　
　　(6) 一个匿名类，通过实例初始化进行构建（匿名内部类不可拥有构建器）
　　
　　所有这些都在innerscopes包内发生。首先，来自前述代码的通用接口会在它们自己的文件里获得定义，使它们能在所有的例子里使用：
　　
　　//: destination.java
　　package c07.innerscopes;
　　
　　interface destination {
　　　string readlabel();
　　} ///:~
　　
　　由于我们已认为contents可能是一个抽象类，所以可采取下面这种更自然的形式，就象一个接口那样：
　　
　　//: contents.java
　　package c07.innerscopes;
　　
　　interface contents {
　　　int value();
　　} ///:~
　　
　　尽管是含有具体实施细节的一个普通类，但wrapping也作为它所有衍生类的一个通用“接口”使用：
　　
　　//: wrapping.java
　　package c07.innerscopes;
　　
　　public class wrapping {
　　　private int i;
　　　public wrapping(int x) { i = x; }
　　　public int value() { return i; }
　　} ///:~
　　
　　在上面的代码中，我们注意到wrapping有一个要求使用自变量的构建器，这就使情况变得更加有趣了。
　　
　　第一个例子展示了如何在一个方法的作用域（而不是另一个类的作用域）中创建一个完整的类：
　　
　　//: parcel4.java
　　// nesting a class within a method
　　package c07.innerscopes;
　　
　　public class parcel4 {
　　　public destination dest(string s) {
　　　　class pdestination
　　　　　　implements destination {
　　　　　private string label;
　　　　　private pdestination(string whereto) {
　　　　　　label = whereto;
　　　　　}
　　　　　public string readlabel() { return label; }
　　　　}
　　　　return new pdestination(s);
　　　}
　　　public static void main(string[] args) {
　　　　parcel4 p = new parcel4();
　　　　destination d = p.dest("tanzania");
　　　}
　　} ///:~
　　
　　pdestination类属于dest()的一部分，而不是parcel4的一部分（同时注意可为相同目录内每个类内部的一个内部类使用类标识符pdestination，这样做不会发生命名的冲突）。因此，pdestination不可从dest()的外部访问。请注意在返回语句中发生的上溯造型――除了指向基础类destination的一个句柄之外，没有任何东西超出dest()的边界之外。当然，不能由于类pdestination的名字置于dest()内部，就认为在dest()返回之后pdestination不是一个有效的对象。
　　
　　下面这个例子展示了如何在任意作用域内嵌套一个内部类：
　　
　　//: parcel5.java
　　// nesting a class within a scope
　　package c07.innerscopes;
　　
　　public class parcel5 {
　　　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("slip");
　　　　　string s = ts.getslip();
　　　　}
　　　　// can't use it here! out of scope:
　　　　//! trackingslip ts = new trackingslip("x");
　　　}
　　　public void track() { internaltracking(true); }
　　　public static void main(string[] args) {
　　　　parcel5 p = new parcel5();
　　　　p.track();
　　　}
　　} ///:~
　　
　　trackingslip类嵌套于一个if语句的作用域内。这并不意味着类是有条件创建的――它会随同其他所有东西得到编译。然而，在定义它的那个作用域之外，它是不可使用的。除这些以外，它看起来和一个普通类并没有什么区别。
　　
　　下面这个例子看起来有些奇怪：
　　
　　//: parcel6.java
　　// a method that returns an anonymous inner class
　　package c07.innerscopes;
　　
　　public class parcel6 {
　　　public contents cont() {
　　　　return new contents() {
　　　　　private int i = 11;
　　　　　public int value() { return i; }
　　　　}; // semicolon required in this case
　　　}
　　　public static void main(string[] args) {
　　　　parcel6 p = new parcel6();
　　　　contents c = p.cont();
　　　}
　　} ///:~
　　
　　cont()方法同时合并了返回值的创建代码，以及用于表示那个返回值的类。除此以外，这个类是匿名的――它没有名字。而且看起来似乎更让人摸不着头脑的是，我们准备创建一个contents对象：
　　
　　return new contents()
　　
　　但在这之后，在遇到分号之前，我们又说：“等一等，让我先在一个类定义里再耍一下花招”：
　　
　　return new contents() {
　　private int i = 11;
　　public int value() { return i; }
　　};
　　
　　这种奇怪的语法要表达的意思是：“创建从contents衍生出来的匿名类的一个对象”。由new表达式返回的句柄会自动上溯造型成一个contents句柄。匿名内部类的语法其实要表达的是：
　　
　　class mycontents extends contents {
　　private int i = 11;
　　public int value() { return i; }
　　}
　　return new mycontents();
　　
　　在匿名内部类中，contents是用一个默认构建器创建的。下面这段代码展示了基础类需要含有自变量的一个构建器时做的事情：
　　
　　//: parcel7.java
　　// an anonymous inner class that calls the
　　// base-class constructor
　　package c07.innerscopes;
　　
　　public class parcel7 {
　　　public wrapping wrap(int x) {
　　　　// base constructor call:
　　　　return new wrapping(x) {
　　　　　public int value() {
　　　　　　return super.value() * 47;
　　　　　}
　　　　}; // semicolon required
　　　}
　　　public static void main(string[] args) {
　　　　parcel7 p = new parcel7();
　　　　wrapping w = p.wrap(10);
　　　}
　　} ///:~
　　
　　也就是说，我们将适当的自变量简单地传递给基础类构建器，在这儿表现为在“new wrapping(x)”中传递x。匿名类不能拥有一个构建器，这和在调用super()时的常规做法不同。
　　
　　在前述的两个例子中，分号并不标志着类主体的结束（和c++不同）。相反，它标志着用于包含匿名类的那个表达式的结束。因此，它完全等价于在其他任何地方使用分号。
　　
　　若想对匿名内部类的一个对象进行某种形式的初始化，此时会出现什么情况呢？由于它是匿名的，没有名字赋给构建器，所以我们不能拥有一个构建器。然而，我们可在定义自己的字段时进行初始化：
　　
　　//: parcel8.java
　　// an anonymous inner class that performs
　　// initialization. a briefer version
　　// of parcel5.java.
　　package c07.innerscopes;
　　
　　public class parcel8 {
　　　// argument must be final to use inside
　　　// anonymous inner class:
　　　public destination dest(final string dest) {
　　　　return new destination() {
　　　　　private string label = dest;
　　　　　public string readlabel() { return label; }
　　　　};
　　　}
　　　public static void main(string[] args) {
　　　　parcel8 p = new parcel8();
　　　　destination d = p.dest("tanzania");
　　　}
　　} ///:~
　　
　　若试图定义一个匿名内部类，并想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。这正是我们将dest()的自变量设为final的原因。如果忘记这样做，就会得到一条编译期出错提示。
　　
　　只要自己只是想分配一个字段，上述方法就肯定可行。但假如需要采取一些类似于构建器的行动，又应怎样操作呢？通过java 1.1的实例初始化，我们可以有效地为一个匿名内部类创建一个构建器：
　　
　　//: parcel9.java
　　// using "instance initialization" to perform
　　// construction on an anonymous inner class
　　package c07.innerscopes;