1. package cn.itcast.test;
   
2. 
   
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. }
    
16. 
    
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. }
    
44. 
    
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. }
    

复制代码

继承这里总有点懵，请问这个输出结果是什么，并写一下分析过程，要详细些，谢谢

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. }
    
20. 
    
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. }
    
48. 
    
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. }
    

复制代码

这只是我自己的理解啊.我也是菜鸟,觉得关系挺乱的.有点晕.只是我的个人理解.巧合的是跟结果一致~~
坐等大神回复~
互相学习哈!

创建一个数组里面存储了3个元素，调用Rect类的构造方法并赋值给数组的三个元素。最后打印长方形的面积。over！

首先结果是：
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.