内部类

使用方式：
外部类方法中使用与其他相同
外部类方法返回内部类引用
可以访问外围类的所有元素，包括private修饰的
10.3.this .new语法
.this 在内部类需要生成外部类的引用
.new 在另一个类中创建内部类对象
Outer outer=new Outer（）；
Outer.Inner inner=outer.new Inner();
静态内部类不需要对外部对象的引用
10.4向上转型
内部类是private 修饰的，其他类不能访问，可以使该内部类实现某一接口，在外围类提供方法生成内部类对象的引用，向上转型为接口类型，其他对象可以访问接口的公共方法

public class Outer{
    class Inner{
        private String lable;
        Inner(String whereTo){
            lable=whereTo;
        }   
    }
    public Inner inner(String s){
            return new Inner(s);
        }
     public static void main(String[] args){

            // Outer.Inner inner=new Outer.Inner("陈蒙");
            Outer outer=new Outer();
//外部类非静态方法创建内部类对象，必须使用OuterClassNmae.InnerClassName
            Outer.Inner inner=outer.inner("陈蒙");      
         }
}

10.6匿名内部类：创建对象是插入一个对象的定义
public class Parcel7 {
//Contents是一个接口
public Contents contents(){
return new Contents(){
private int i=11;
public int value(){
return i;
}
};
}
public static void main(String[] args){
Parcel7 p=new Parcel7();
Contents c=p.contents();
}
}

相等的形式，是其简化
public class Parcel7b {
class MyContents implements Contents{
private int i=11;
public int value(){
return i;
}
}
public Contents contents(){
return new MyContents();
}
public static void main(String[] args){
Parcel7b p=new Parcel7b();
Contents c=p.contents();
}
}

定义匿名内部类，希望引用外部定义的对象，编译器要求参数是final
匿名内部类不可能有命名构造器，实例初始化可以为匿名内部类创建构造器效果，只能有一个这样的构造器，实例初始化方法不能重载

10.7嵌套类：
使用情况：内部类对象与外围类之间不需要联系
形式：内部类声明为static
与普通内部类的区别：
1普通内部类对象隐示保留了指向外为对象的引用，嵌套类没有
2创建嵌套类的对象，不需要外围类的对象
3不能从嵌套类的对象访问非静态的外围类对象
4可以包含static数据和static字段，嵌套类
public class Parcel11 {
//嵌套类
private static class ParcelContents implements Contents{
private int i=11;
public int value(){
return i;
}
}

protected static class ParcelDestination implements Destination{
    private String label;
    private ParcelDestination(String whereTo){
        label=whereTo;
    }
    public String readLabel(){return label;}
    public static void f(){}
    static int x=10;

//嵌套类中包含嵌套类
static class AnotherLevel{
public static void f(){}
static int x=10;
}
}
public static Destination destination(String s){
return new ParcelDestination(s);
}
public static Contents contents(){
return new ParcelContents();
}
public static void main(String[] args){
//直接创建嵌套类的对象，不需要外围类的this.
Contents c=contents();
Destination d=destination(“Tasmania”);
}
}

接口内部的类
放到接口中的任何类自动都是 public static
可以在内部类中实现外围接口

10.8为什么需要内部类
每个内部类都能独立地继承自一个（接口的）实现，无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响
extends关键字只能实现继承一个类
“多重继承”，允许继承多个非接口类型
1）可以有多个实例，每个实例都有自己的状态信息，与外围类信息相互独立
2）在单个外围类中，可以让多个内部类以不同方式实现同一个接口，或继承同一个类
3）创建内部类对象的时刻并不依赖于外围对象的创建
4）是一个独立的实体
典型实现：
1闭包：内部类+接口
一个接口与一个基类拥有相同的方法（方法名），含义完全不同，类1继承基类，在类1中定义内部类，该内部类实现该接口，保留各自的用途
2控制框架
内部类继承Event，实现不同的action
可以访问外围类的任意成员

10.9内部类的继承
指向外围类的“秘密的”引用必须被初始化
必须在构造器中使用如下语法：
enclosingClassReference.super()
如果内部类有一个非默认的构造器
Student(Mother m,String name,int a){
m.super(name);
age=a;
}

class Mother{
    class Child{
        String name;
        public Child(String a){
            name=a;
        }
    }
}
public class Person {
    class Student extends Mother.Child{
        int age;
        Student(Mother m,String name,int a){
            m.super(name);
            age=a;
        }
    }
    public static void main(String[] args){
        Person p=new Person();
        Mother mother=new Mother();
        Person.Student s=p.new Student(mother,"chenmeng",18);
        System.out.println("姓名"+s.name);
        System.out.println("age"+s.age);
    }

}

继承某个外围类，并不会覆盖内部类，两个内部类是独立的，各自在自己的命名空间内，也可以使内部类明确地继承某个内部类
10.11 局部内部类
在代码块、方法体中创建
与匿名内部类的区别：
1先定义内部类，再返回该内部类的引用；匿名内部类在创建对象的时候定义内部类
2创建多个内部类对象，匿名内部类只能通过实例初始化提供一个构造器效果，实例初始化不能被覆盖