Java内部类

内部类

定义在另一个类中的类称之为内部类，典型的应用是外部类将有一个方法，它返回一个内部类的引用。

public class Test {
    public static void main(String[] args){
        Outer o = new Outer();
        Outer.Inner i = o.showInner();     //OuterName.InnerName表示内部对象类型
        System.out.println(i.getName());
    }
}


class Outer{
    class Inner{
        private String name;
        Inner(){
            name = "sakura";
        }

        public String getName() {
            return name;
        }
    }

    Inner showInner(){
        return new Inner();   //外部类的方法，返回一个内部对象的引用
    }
}

内部类有外部类所有成员的访问权限。 事实上，某个外部类对象创建了一个内部类对象是，该内部类对象会秘密捕获一个指向外部类对象的引用，在访问外部类成员时，将用那个引用访问。

1）在外部创建内部类对象时声明内部类对象类型为      //OuterClassName.InnerClassName

2）在外部创建内部类对象需要引用外部类对象，构造语法为      //OuterObjectName.new InnerClassName(parameters)

3）生成外部类对象的引用：外部类名称紧跟圆点紧跟this      //OuterClassName.this

public class Test {
    public static void main(String[] args){
        Outer o = new Outer();
        Outer.Inner i = o.new Inner();   //1)和2)
    }
}


class Outer{
    private String name = "sakura";
    Outer(){
    }

    public String getName() {
        return name;
    }

    public class Inner{
        Inner(){
            System.out.println(Outer.this.getName());   //3)
        }
    }
} 

局部内部类

1）局部内部类不能用public 或private 访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。

2）局部内部类对外界完全隐藏，只有所在方法可以知道它的存在。

3）它们不仅能够访问包含它们的外部类， 还可以访问局部变量。不过， 在jdk8之前，那些局部变量必须事实上为final。

public class OuterClass
{
    private String str = "OutStr";
    public void OuterMethod(String str1)
    {
        System.out.println("OuterMethod");
        class InnerClass      //局部内部类
        {
            public InnerClass() {}
            public void InnerMethod()
            {
                System.out.println("InnerMethod");
            }
            public void InnerShow()
            {
                System.out.println(str);
                System.out.println(str1);
                InnerMethod();
            }
        }
        InnerClass inner = new InnerClass();
        inner.InnerMethod();
        inner.InnerShow();
    }


    public static void main(String[] args)
    {
        OuterClass test = new OuterClass();
        test.OuterMethod(test.str);
    }
}

匿名内部类

1）匿名类有两种实现方式：

　　继承一个类，重写其方法。

　　实现一个接口（可以是多个），实现其方法。

new SuperType(construction parameters)
{
    inner class methods and data
}


new InterfaceType
{
    methods and data
}

匿名内部类实现接口

public class Test {
    public Contents contents(){
        return new Contents(){ //匿名内部类，实现接口
            int i = 0;
            public int value(){return i;}
        };
    }
    public static void main(String[] args){
        Test t = new Test();
        Contents c = t.contents();
    }
}

interface Contents{
    int value();
}

匿名内部类继承父类

public class Test {
    public Wrapping wrappering(int x){
        return new Wrapping(x){ //匿名内部类,继承父类
            public int value(){
                return super.value();
            }
        };
    }

    public static void main(String[] args){
        Test t = new Test();
        Wrapping w = t.wrappering(10);
    }
}

class Wrapping{
    private int i;
    public Wrapping(int x){ i=x;}
    public int value(){return i;}
}

2）匿名内部类没有构造器，但可以有构造体

public class Test {
    public Contents contents(){
        return new Contents(){ //匿名内部类
            int i;
            {   //构造体
                i = 0;
                System.out.printf("i:" + i);
            }
            public int value(){return i;}
        };
    }
    public static void main(String[] args){
        Test t = new Test();
        Contents c = t.contents();
    }
}

interface Contents{
    int value();
}

静态内部类

1）有时候， 使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。为此，可以将内部类声明为static（静态内部类）, 以便取消产生的引用。

2）静态内部类不能访问非静态的外部类对象；创建静态内部类对象不需要通过外部类对象。

3）静态内部类可以有静态域和方法。

public class Test {
    public static void main(String[] args){
        Outer o = new Outer();
        Outer.Inner i = new Outer.Inner();   //直接通过类名创建，对比于 o.new Inner();
    }
}


class Outer{
    private String name = "sakura";
    Outer(){
    }

    public String getName() {
        return name;
    }

    public static class Inner{
        static int id = 20151003;    //静态域ok
        static String show_id(){     //静态方法ok
            return ""+id;
        }
        Inner(){
            //System.out.println(Outer.this.getName());  报错，无法访问外部类成员
        }
    }
}

继承内部类

class withinner{
    withinner(){
    }
    class inner{
    }
}

public class Test extends withinner.inner{
    Test(withinner w){
        w.super(); //外部类引用.super()
    }


    public static void main(String[] args) {
        Test t = new Test(new withinner());
    }
}

每个内部类都能独自得实现一个接口，不管它的外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。