class Cricle{
        private static double pi=3.14;
        private static double r;
        public Cricle(double r){
                this.r=r;
        }
        public static double compate(Cricle []c){
                int a=c.length;
                double max=c[0].r;//这个怎么解释呀，属于哪个知识点呀，以前没接触过
                for(int i=0;i<a;i++){
                        if(max<c[i].r)
                                max=c[i].r;
                }
                return max;
        }
}
public class ExceptionTest3{
        public static void main(String args[]){
                Cricle s[]=new Cricle[3];
                s[0]=new Cricle(1.0);
                s[0]=new Cricle(2.0);
                s[0]=new Cricle(3.0);
                System.out.println(Cricle.compate(s));
               
        }
}

double max=c[0].r;         //    对象.静态属性      

1. class Cricle{
   
2.         private static double pi=3.14;
   
3.         private static double r;
   
4.         public Cricle(double r){
   
5.                 this.r=r;
   
6.         }
   
7.         public static double compate(Cricle []c){
   
8.                 int a=c.length;
   
9.                 double max=c[0].r;                                                //将数组中，序号为0的对象的变量r的值赋给max;
   
10.                 for(int i=0;i<a;i++){
    
11.                         if(max<c[i].r)
    
12.                                 max=c[i].r;
    
13.                 }                                                                                //比较max的值和各象的r值，如果r的值较大，就将r赋值到max;
    
14.                 return max;                                                                //返回max;
    
15.         }
    
16. }
    
17. public class ExceptionTest3{
    
18.         public static void main(String args[]){
    
19.                 Cricle s[]=new Cricle[3];                                //创建对象数组；
    
20.                 s[0]=new Cricle(1.0);
    
21.                 s[0]=new Cricle(2.0);       
    
22.                 s[0]=new Cricle(3.0);                                        //通过有参构造函数，为对象数组初始化；
    
23.                 System.out.println(Cricle.compate(s));        //对象数组做参数，调用Cricle类中的compate方法,并打印返回结果；
    
24.                
    
25.         }
    
26. }
    
27. //总的来说，这段代码实现创建三个圆，并通过调用compate函数比较它们的半径，然后将最大的半径值打印出来。

复制代码

double max=c[0].r;
c[0]就是s[]这个数组中的一个Circle对象。c[0].r 就是它的半径。

double max=c[0].r;//左边的是声明了一个double 类型的变量 Max 右边是 c[0] 是一个对象. c[0].r是调用该类中的静态成员变量r(类名.变量名)

我的觉的上面回答的都很好。

编程学徙 发表于 2014-6-9 12:43

对象数组都用哪些作用呀，

Cricle 对象的属性，表示圆的半径，楼主先把面向对象看看吧

在成员方法compate中传入参数“Circle类型的数组引用”c，c[0]表示保存在数组中的一个Circle对象，c[0].r表示该对象的成员“private static double r”

宋大人-专注 发表于 2014-6-10 08:52
对象数组都用哪些作用呀，

所谓对象数组，就是以对象为元素的数组。主要用于对批量对象的统一管理。我就知道这一点点……

二楼正解~

编程学徙 发表于 2014-6-10 11:12
所谓对象数组，就是以对象为元素的数组。主要用于对批量对象的统一管理。我就知道这一点点…… ...

还行，挺好的，这是我比较满意的