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

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