首页 > 编程语言 > 详细

【java in think】内部类其他部分

时间:2015-03-24 10:50:36      阅读:167      评论:0      收藏:0      [点我收藏+]

内部类的继承

class Outer2
{
    class SubOuter2
    {

    }
}

public class InnerDemo2 extends Outer2.SubOuter2
{

    public InnerDemo2(Outer2 outer2)
    {
        outer2.super();
    }

    public static void main(String[] args)
    {
        InnerDemo2 innerDemo2 = new InnerDemo2(new Outer2());
    }

}

只继承外部类的时候,构造器要有父类的对象,然后调用父类对象调用父类构造器,这样子类才能构造初始化。

 1 class Outer
 2 {
 3     class SubOuter
 4     {
 5         private int i = 10;
 6 
 7         public SubOuter(int i)
 8         {
 9             super();
10             this.i = i;
11         }
12 
13     }
14 }
15 
16 public class InnerDemo
17 {
18 
19     class SubInner extends Outer.SubOuter
20     {
21 
22         public SubInner(Outer outer, int i)
23         {
24             outer.super(i);
25 
26         }
27 
28     }
29 
30     public static void main(String[] args)
31     {
32         Outer outer = new Outer();        
33         InnerDemo innerDemo = new InnerDemo();
34         InnerDemo.SubInner subInner = innerDemo.new SubInner(outer, 12);
35 
36     }
37 
38 }

继承一个类的内部类。若是无参数时,只需把被继承的类的对象传到构造器中,有参数时也必须传入参数,然后先调用被继承的类的构造器,这样才能自身初始化。

创建内部类对象时,必须要先创建被继承的类的对象与自身外部类对象,然后进行初始化。

 1 class Egg
 2 {
 3     private Yolk yolk;
 4 
 5     protected class Yolk
 6     {
 7         public Yolk()
 8         {
 9             System.out.println("Egg.Yolk 被初始化了");
10         }
11     }
12 
13     public Egg()
14     {
15 
16         System.out.println("Egg 被初始化了");
17         this.yolk = new Yolk();
18     }
19 }
20 
21 public class InnerDemo extends Egg
22 {
23 
24     public class Yolk
25     {
26         public Yolk()
27         {
28             System.out.println("InnerDemo.Yolk 被初始化了");
29         }
30     }
31 
32     public static void main(String[] args)
33     {
34         InnerDemo innerDemo = new InnerDemo();
35         Yolk yolk2 = innerDemo.new Yolk();
36     }
37 
38 }

输出结果:

Egg 被初始化了
Egg.Yolk 被初始化了


InnerDemo.Yolk 被初始化了

可以看出来,内部类不能被覆盖,在new InnerDemo()时,就把父类以及其内部类的构造器都调用了,说明这两个内部类时两个独立地实体,互不干扰。

但假如让内部类继承父类的内部类,情况如下:

 1 class Egg
 2 {
 3     private Yolk yolk;
 4 
 5     protected class Yolk
 6     {
 7         public Yolk()
 8         {
 9             System.out.println("Egg.Yolk 被初始化了");
10         }
11     }
12 
13     public Egg()
14     {
15 
16         System.out.println("Egg 被初始化了");
17         this.yolk = new Yolk();
18     }
19 }
20 
21 public class InnerDemo extends Egg
22 {
23 
24     public class Yolk extends Egg.Yolk
25     {
26         public Yolk()
27         {
28             System.out.println("InnerDemo.Yolk 被初始化了");
29         }
30     }
31 
32     public static void main(String[] args)
33     {
34         InnerDemo innerDemo = new InnerDemo();
35         Yolk yolk2 = innerDemo.new Yolk();
36     }
37 
38 }

输出结果如下:

Egg 被初始化了
Egg.Yolk 被初始化了


Egg.Yolk 被初始化了
InnerDemo.Yolk 被初始化了

 可以看到,在创建内部类对象时,比上一次的结果多了一次父类内部类的构造器调用。这说明只有通过继承才可以覆盖。

【java in think】内部类其他部分

原文:http://www.cnblogs.com/linlin-meimei/p/4361888.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!