CSDN博客

img Nepalon

Java编程思想(2nd)学习笔记(8)-2

发表于2003/10/28 23:47:00  1044人阅读

二.     Inner classes(内隐类)

1.  内隐类的基本用法

1)        如果要在外围classnon-static函数之外产生一个inner class对象,得以OuterClassName.InnerClassName的形式指定该对象的型别。而在non-static函数内则不用。

public class ExplicitStatic{

    class Contents{

        private int i = 11;

        public int value() { return i; }

    }

    class Destination{

        private String label;

        Destination(String whereTo){

            label = whereTo;

        }

        String readLabel() { return label; }

    }

    public Destination to(String s){

    //outer classnon-static函数中可直接产生inner class对象

        return new Destination(s); //1

    }

    public Contents cont(){

        return new Contents(); //1

    }

    public void ship(String dest){

//outer classnon-static函数中可直接通过InnerClassName

//来指定对象型别

        Contents c = cont();

        Destination d = to(dest);

        System.out.println(d.readLabel());

    }

    public static void main(String[] args){

        ExplicitStatic p = new ExplicitStatic();

        p.ship("Tanzania");

        ExplicitStatic q = new ExplicitStatic();

   //outer class的非non-static函数内产生inner class对象

        ExplicitStatic.Contents c = q.cont();

        ExplicitStatic.Destination d = q.to("Borneo");

  //不能在static函数直接生成inner class对象

// new Contents();

    }

}

2)        对于non-static inner class,在外围classnon-static函数可以通过new产生一个inner class对象,如上面的(1)处。但要在非non-static函数产生一个inner class对象,则一定要关联到其enclosing class的某个对象。

3)        inner class的向上转型

当把一个inner class对象向上转型成为interface时,我们得到的只是一个reference

interface Destination{

    String readLabel();

}

interface Contents{

    int value();

}

class Parcel3{

    private class PContents implements Contents{

        private int i = 11;

        public int value() { return i; }

    }

    protected class PDestination implements Destination{

        private String label;

        PDestination(String whereTo){

            label = whereTo;

        }

        public String readLabel() { return label; }

    }

    public Destination to(String s){

        return new PDestination(s);

    }

    public Contents cont(){

        return new PContents();

    }

}

public class ExplicitStatic{   

    public static void main(String[] args){

        Parcel3 p = new Parcel3();

        //inner class对象向上转型

        Contents c = p.cont();

        Destination d = p.to("Borneo");       

    }

}

虽然我们不能在ExplicitStatic class无法调用Pcontents class,但我们把一个Pcontents class对象向上转型为Contents,就可对之进行调用。

4)        inner class的作用域为定义该inner classscope内。但inner class可在它的作用域之外被继承(见4)。

interface Contents{

    int value();

}

class Parcel3{

    //PContents1 class的作用域为Parcel3 class

    private class PContents1 implements Contents{

        private int i = 11;

        public int value() { return i; }

    }

    public Contents cont1(){

        return new PContents1();

    }

    public Contents cont2(){

        //PContents2 class的作用域为函数cont2

        class PContents2 implements Contents{

            private int i = 11;

            public int value() { return i; }

        }

        return new PContents2();

    }

    //不能在函数cont2外使用PContents2 class

    /*

    public Contents cont22(){

        return new PContents2();

    }

    */

    public Contents cont3(boolean b){

        if(b){

            //PContents3 class的作用域为当前if

            class PContents3 implements Contents{

                private int i = 11;

                public int value() { return i; }

            }

            return new PContents3();

        }

        //不能在if外使用PContents3 class

        //return new PContents3();

        return null;

    }

}

public class ExplicitStatic{   

    public static void main(String[] args){

        Parcel3 p = new Parcel3();

        Contents c1 = p.cont1();

        Contents c2 = p.cont2();

        Contents c3 = p.cont3(true);

    }

}

2.  内隐类与外围enclosing  class的连接关系

2.1 non-static inner class

1)        inner class可以访问enclosing class的所有成员(包括private成员),就像inner class自己拥有这些成员一样。即inner class天生具有对enclosing class的所有成员的访问权力。

2)        Inner class对象被产生时,一定要关联到其enclosing class的某个对象(这个enclosing class对象就是Inner class对象的制造者)。建构inner class对象的同时,得有其enclosing class对象的reference才行。

原因:因为inner class可以访问enclosing class的所有成员,那么当产生一个inner class时,编译器会自动为inner class对象添加一个指向enclosing class对象的reference(这个reference是隐藏的)。所以Inner class被产生时,一定要关联到其enclosing class的某个对象。

3)        同一个enclosing class对象产生出来的inner class对象访问的是同一个enclosing class对象中的成员。

interface Destination{

    String readLabel();

}

interface Contents{

    int value();   

}

class Parcel3{

    int i1 = 10;

    private String s1 = "Parcel3_";

    Parcel3(String s){

        s1 += s;

    }

    private class PContents implements Contents{

        //可调用enclosing class的成员 1

        private int i2 = i1;

        private String s2 = s1;

        PContents(int num){

         System.out.println("" + num + " i2 = " + i2 + "s2 = " + s2);

        }

        public int value() { return 1; }

    }

    public Contents cont(int i){

        return new PContents(i);

    }

}

public class ExplicitStatic{   

    public static void main(String[] args){

        Parcel3 p1 = new Parcel3("1");

        Contents c1 = p1.cont(1);       

        Contents c2 = p1.cont(2);

        Parcel3 p2 = new Parcel3("2");

        c2 = p2.cont(3);

        c2 = p1.cont(4);

    }

}

结果为:

1 i2 = 10s2 = Parcel3_1

2 i2 = 10s2 = Parcel3_1

3 i2 = 10s2 = Parcel3_2

4 i2 = 10s2 = Parcel3_1

在(1)在inner class调用了enclosing class的成员。结果表明,同一个enclosing class对象p1产生的inner class对象调用的是同一个enclosing class对象中的成员,如结果中的124

              2.2  Static inner classes(静态内隐类)

1)  产生Static inner classes对象时,不需要同时存在一个enclosing class对象

2)  只能在Static inner classes对象中访问enclosing class中的静态成员。

interface Contents{

    int value();   

}

class Parcel1{

private static String s1 = "Parcel3_";

private String s11 = “Parcel3_”;

    Parcel1(String s){

        s1 += s;

    }

protected static class PContents implements Contents{

//只能访问enclosing class中的s1

        String s2 = s1;

//s11不是static成员,不能访问

//String 22 = s11;

        PContents(int num){

            System.out.println("" + num + "s2 = " + s2);

        }

        public int value() { return 1; }

    }

    public static  Contents cont(int i){

        return new PContents(i);

    }

}

public class ExplicitStatic{   

    public static void main(String[] args){

        Parcel1 p1 = new Parcel1("1");

        Contents c1 = p1.cont(1);  

        c1 = Parcel1.cont(2);  //1

        Parcel1 p2 = new Parcel1("2");

        c1 = p2.cont(3);

        c1 = Parcel1.cont(4); //1

    }

}

因为内隐类Pcontents class是静态的,所以在(1)处不通过enclosing class对象而是通过静态函数来直接产生其对象。

2.3       无论inner class被嵌套置放的层次有多深,且所有outer class的成员都可

被它访问。

class MNA{

    private void f() {}

    class A{

        private void g() {}

        class B{

            void h(){

                g();

                f();

            }

        }

    }

}      

0 0

相关博文

我的热门文章

img
取 消
img