Java-InnerClass-05

 

/**//*Destination.java:*/
public interface Destination...{
    String readLabel();
}

/**//*Contents.java:*/
public interface Contents...{
    int readValue();
}

/**//*Wrapping.java:*/
public class Wrapping...{
    private int value;
    Wrapping(int value)...{this.value = value;}
    public int readValue()...{return value;}
}

在方法和作用域内的内部类
在方法的作用域内创建一个完整的类,称为局部内部类.
Pdestination类是getDestination()方法的一部分,而不是Method_Parcel类的一部分.所以在getDestination()之外不能访问Pdestination.
return语句是向上转型,返回的是Destination的引用,它是Pdestination的基类.

class Method_Parcel...{
    public Destination getDestination(String label)...{
        class Pdestination implements Destination...{
            private String label;
            private Pdestination(String toWhere)...{label = toWhere;}
            public String readLabel()...{return label;}
        }
        return new Pdestination(label);
    }
}
class TestMethod_Parcel...{
    public static void main(String[] args) ...{
        Method_Parcel _par = new Method_Parcel();
        Destination des = _par.getDestination("WuHan");
    }
}

匿名内部类getDestination()方法将返回值的生成与表示这个返回值的类的定义结合在一起!
这种语法指的是:创建一个继承自Contents的匿名类的对象,通过new表达式返回的引用被自动向上转型为对Contents的引用.

class AnonymousParcel...{
    public Contents getContents1(int value)...{
        return new Contents()...{
            private int value;
            public int readValue()...{return value;}
        };
    }
    /**//*上诉代码等同于以下代码：*/
    public Contents getContents2(int value)...{
        class Pcontents implements Contents...{
            private int value;
            public int readValue()...{return value;}
        }
        return new Pcontents();
    }
    /**//*上诉例子使用了缺省的构造器来生成Contents*/
}
class TestAnonymousParcel...{
    public static void main(String[] args) ...{
        AnonymousParcel _par = new AnonymousParcel();
        Contents des1 = _par.getContents1(0);
        Contents des2 = _par.getContents2(0);
    }
}

/**//*匿名内部类中需要一个有参数的构造器:只需简单的传递参数给基类的构造器即可.此例将value传给new Wrapping(value).
 *匿名内部类末尾的分号并不是用来标记此内部类结束的,而是标记表达式的结束,只不过这个表达式正巧包含了匿名内部类罢了.
 */
class ConstractorParcel...{
    public Wrapping getWrapping(int value)...{
        return new Wrapping(value)...{
            public int readValue()...{return super.readValue();}
        };
    }
}
/**//*在匿名内部类中定义字段时,还能够对其执行初始化操作.
 *如果希望匿名内部类使用一个在其外部定义的成员,那么编译器会要求其参数引用是final的(很好理解,对匿名类的字段初始化,当然要用final数据).
 *方法内部类：内部类只能访问方法内&&内部类外的final成员.
 */
class Para_Parcel1...{
    public Destination getDestination(final String toWhere)...{
        return new Destination()...{
            private String label = toWhere;
            public String readLabel()...{return label;}
        };
    }
}
class Para_Parcel2...{
    public Destination getDestination(String label)...{
        final int x = 1;
        class Pdestination implements Destination...{
            private String label;
            private Pdestination(String toWhere)...{label = toWhere;}
            public String readLabel()...{return label;}
            public void display()...{System.out.println(x);}
        }
        return new Pdestination(label);
    }
}
/**//*如果只给一个字段赋值,上例方法很好.但如果想做类似构造器的初始化行为,该怎么办?(匿名类不可能有构造器,因为它根本没有名字):通过实例初始化可实现.
 *对于匿名类而言,实例初始化的实际效果就是构造器.*/
abstract class Base...{
    Base(int i)...{System.out.println("Base constructor, i = " + i);}
    public abstract void f();
}
class AnonymousConstructor...{
    public static Base getBase(int i)...{
        return new Base(i)...{
            ...{
                System.out.println("Inside instance initializer");
            }
            public void f()...{System.out.println("In anonymous f()");}
        };
    }
    public static void main(String[] args) ...{
        Base base = getBase(10);
        base.f();
    }
}
/**//*上例不要求i是final的,因为i被传递给匿名类的基类的构造器,它并不会在匿名类内部被直接调用.
 *下例亦为实例初始化.getDestination()的参数必须是final的,因为它们是在匿名类内部使用的.
 */
class AnonymousConstructor_Parcel...{
    public static Destination getDestination(final String toWhere,final float price)...{
        return new Destination()...{
            private String label;
            private int cost;
            ...{
                label = toWhere;
                cost = Math.round(price);
                if(cost>100)
                    System.out.println("over budget");
            }
            public String readLabel()...{return label;}
        };
    }
    public static void main(String[] args) ...{
        Destination des = getDestination("Tibet",120.34f);
    }
}