黑马程序员技术交流社区

标题: 关于继承的问题 [打印本页]
作者: 傲鸽    时间: 2013-6-23 22:20
标题: 关于继承的问题
本帖最后由 Super_Class 于 2013-6-24 18:22 编辑
  1. package cn.itcast.test;

  3. public class Test04 {
  4.         public static void main(String[] args) {
  5.                 Shap s[]=new Shap[3];
  6.                 s[0]=new Rect(8,0);
  7.                 s[1]=new Rect(5.0,6.0);
  8.                 s[2]=new Rect(new Rect(12.0,4.0));
  9.                 for (int i = 0; i < s.length; i++) {
  10.                         System.out.println("s["+i+"]area="+s[i].area());
  11.                 }
  12.                
  13.         }
  14.                
  15. }

  17. abstract class Shap{
  18.         private double w,h;
  19.         
  20.         Shap(double i) {
  21.                 w=h=i;
  22.         }
  23.         
  24.         Shap(double i,double j){
  25.                 w=i;
  26.                 h=j;
  27.         }
  28.         
  29.         Shap(Shap s){
  30.                 w=s.w;
  31.                 h=s.h;
  32.         }
  33.         
  34.         double getw(){
  35.                 return w;
  36.         }
  37.         
  38.         double geth(){
  39.                 return h;
  40.         }
  41.         
  42.         abstract double area();
  43. }

  45. class Rect extends Shap{
  46.         Rect(double i){
  47.                 super(i);
  48.         }
  49.         
  50.         Rect(double i,double j){
  51.                 super(i,j);
  52.         }
  53.         
  54.         Rect(Rect r){
  55.                 super(r);
  56.         }
  57.         
  58.         double area(){
  59.                 return getw()*geth();
  60.         }
  61.         
  62. }
复制代码
继承这里总有点懵，请问这个输出结果是什么，并写一下分析过程，要详细些，谢谢
作者: 8047107    时间: 2013-6-23 22:51
  1. public class Demo1 {
  2.         public static void main(String[] args) {
  3.                 Shap s[]=new Shap[3];//1,定义一个3个元素的数组 里面元素是shap类型的
  4.                 s[0]=new Rect(8,0);         //2,第一个元素是shap子类Rect的,多态的形式
  5.                 s[1]=new Rect(5.0,6.0);         //5,第二个元素了,一样的步骤,w=5.0 , h=6.0
  6.                 s[2]=new Rect(new Rect(12.0,4.0));         //6,第三个元素, 先有Rect的对象,w=12.0 , h=4.0
  7.                                                                                                          
  8.                 for (int i = 0; i < s.length; i++) {
  9.                         System.out.println("s["+i+"]area="+s[i].area());
  10.                 }                                                                                        //9,循环i=0,1,2三次. s[i]是个对象
  11.                                                                                                         //s[i].area()是调用Rec里面的area方法,也是覆写了父类的
  12.                                                                                                         //返回double类型的.
  13.                                                                                                         //i=0时,w=8.0  h=0.0   打印s[0]area=0.0
  14.                                                                                                         //i=1时,w=5.0  h=6.0   打印s[0]area=30.0
  15.                                                                                                         //i=2时,w=12.0 h=4.0   打印s[0]area=48.0
  16.                
  17.         }
  18.                
  19. }

  21. abstract class Shap{
  22.         private double w,h;
  23.         
  24.         Shap(double i) {
  25.                 w=h=i;
  26.         }
  27.         
  28.         Shap(double i,double j){           //4,w=8.0  h=0.0,
  29.                 w=i;
  30.                 h=j;
  31.         }
  32.         
  33.         Shap(Shap s){
  34.                 w=s.w;                                  //8,这里了,w=12.0 ,h=4.0
  35.                 h=s.h;
  36.         }
  37.         
  38.         double getw(){
  39.                 return w;
  40.         }
  41.         
  42.         double geth(){
  43.                 return h;
  44.         }
  45.         
  46.         abstract double area();
  47. }

  49. class Rect extends Shap{
  50.         Rect(double i){
  51.                 super(i);                         
  52.         }
  53.         
  54.         Rect(double i,double j){         //3,new Rect(8,0)调用父类的构造方法
  55.                 super(i,j);
  56.         }
  57.         
  58.         Rect(Rect r){                          //7,作为对象r传入这里.
  59.                 super(r);
  60.         }
  61.         
  62.         double area(){
  63.                 return getw()*geth();
  64.         }
  65.         
  66. }
复制代码
这只是我自己的理解啊.我也是菜鸟,觉得关系挺乱的.有点晕.只是我的个人理解.巧合的是跟结果一致~~
坐等大神回复~
互相学习哈!
作者: 280270738    时间: 2013-6-24 00:00
创建一个数组里面存储了3个元素，调用Rect类的构造方法并赋值给数组的三个元素。最后打印长方形的面积。over！

作者: 杨增坤    时间: 2013-6-24 15:39
首先结果是：
s[0]area=0.0
s[1]area=30.0
s[2]area=48.0
解释：

public class Test04 {
       public static void main(String[] args) {
               Shap s[]=new Shap[3];//定义了一个抽象类数组
               s[0]=new Rect(8,0);//给第一个数组元素赋值  解释参考2
               s[1]=new Rect(5.0,6.0);   //给第二个数组元素赋值  解释参考3
               s[2]=new Rect(new Rect(12.0,4.0));  //给第三个数组元素赋值  解释参考4
                for (int i = 0; i < s.length; i++) {
                       System.out.println("s["+i+"]area="+s[i].area());//调用数组元素中的方法并且输出其值
               }         
       }
}
1.s是抽象类Shap的数组，类Rect继承抽象类Shape，
2.s[0]=new Rect(8,0);这是实力化了一个Rect类的对象  调用的是含有两个参数的构造函数，就是把数值8和0赋给了 s[0]的w和h    s[0].area());方法结果是：8*0=0;
3.  s[1]=new Rect(5.0,6.0);   和解释2一样 s[0].area());方法结果是：5.0*6.0=30.0
4.s[2]=new Rect(new Rect(12.0,4.0));  调用的是参数是shap对象的构造函数参数是其子类的对象，把子类对象的属性值赋给了s[2]元素的属性  new Rect(12.0,4.0));  调用的是参数是两个的构造函数
结果是：12.0*4.0=48.0
希望对你有帮助  
3.




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2