代码第16行中的radius 怎么解释   cir[x].radius>cir[max].radius  谁能帮我解释下

1. /*满头雾水*/
   
2. 
   
3. class Circle
   
4. {
   
5.         private static double pi = 3.14;
   
6.         private double radius;
   
7.         public Circle(double r)
   
8.         {
   
9.                 radius = r;
   
10.         }
    
11.         public static double compare(Circle[] cir)
    
12.         {        //程序代码  这里本来是让补足代码得  其实就是求数组中得最大值
    
13.                 int max = 0;
    
14.                 for (int x= 1; x<cir.length;x++)
    
15.                 {
    
16.                         if(cir[x].radius>cir[max].radius)//问题就在这  cir[x].radius  我不能理解
    
17.                                 max = x;
    
18.                 }
    
19.                 return cir[max].radius;
    
20.         }
    
21. }
    
22. class         Test
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26.                 Circle cir[]=new Circle[3];
    
27.                 cir[0] = new Circle(1.0);
    
28.                 cir[1] = new Circle(2.0);
    
29.                 cir[2] = new Circle(4.0);
    
30.                 System.out.println("最大半径值是："+Circle.compare(cir));
    
31.         }
    
32. }

复制代码

你可以理解基本数据类型数组，是因为你对基本数据类型熟一点，
数组不光是基本数据类型的元素才可以组成数组，
数组是相同类型元素的组合，在你的例子中的数组就为一个非基本数据类型数组，而是一堆对象组成的一个数组
数组中我们通过角标索引获得元素，这里我们获得的元素就是一些对象，
有了这些对象我们是不是就可以通过对象获得他们相应的属性，
然后就Over了

这个还是很简单的，写了一个circle类，这个类有一个有参的构造函数，用于在new一个Circle的时候将这个圆的半径值传过去，              另外你的PI，在Math这个类中有一个Math.PI的静态常量，不用你自己去定义一个pi的值得           最后 if(cir[x].radius>cir[max].radius) {  max = x;}这个语句很好理解啊，你将所有的圆以一个数组的形式传递到compare这个静态函数中。然后给max一个初始值为0，然后判断数组中的第1号元素与第Max（依旧是0）号元素的大小关系，如果cir[1]的半径 > cir[0]的半径成立的话，那么就把max赋值为1，这样依次循环，重复道最后，就能够找到这当中的最大的那个半径了

1. public class TheMaxCircle {
   
2. 
   
3.         /**
   
4.          * 半径最大值
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 Circle[] circles = new Circle[3];
   
8.                 circles[0] = new Circle(1);
   
9.                 circles[1] = new Circle(2);
   
10.                 circles[2] = new Circle(4);
    
11.                 System.out.println("最大半径：" + Circle.compare(circles));
    
12.         }
    
13. 
    
14. }
    
15. 
    
16. class Circle {
    
17.         private double radius;// 定义半径
    
18. 
    
19.         public Circle(double radius) {
    
20.                 // 定义无参构造方法，参数为半径radius
    
21.         }
    
22. 
    
23.         public static double compare(Circle[] circles) {
    
24.                 int max = 0;// 假设最大值索引为0
    
25. 
    
26.                 // 循环遍历半径数组
    
27.                 for (int i = 0; i < circles.length; i++) {
    
28. 
    
29.                         /*
    
30.                          * 依次判断每个半径大小，求出最大值
    
31.                          * circles[i].radius表示半径数组中索引为i的半径，例如circles[0].radius就是数组索引为0的第一个半径
    
32.                          * circles[max].radius表示半径数组中假设的最大半径，默认索引从0开始，即第一位就和各个位半径比较大小
    
33.                          * circles[i].radius > circles[max].radius，遍历到索引为i的半径，比最大半径还要大
    
34.                          * 那么就把这个索引i记住，并赋值给当前最大半径的索引max 通过循环遍历,一一比较，当循环结束时，自然就找到真正的最大半径max
    
35.                          * 数组中通过索引快速访问数组中的值，即得到最大半径
    
36.                          */
    
37.                         if (circles[i].radius > circles[max].radius) {
    
38.                                 max = i;// 求出最大索引
    
39.                         }
    
40.                 }
    
41. 
    
42.                 return circles[max].radius;// 返回最大半径
    
43.         }
    
44. }

复制代码

1. public static double compare(Circle[] cir)/*这里传入的是Circle类型的数组,名字叫cir,
   
2. 
   
3. 那么cir[x]等就表示一个Circle类型的对象*/
   
4.         {        //程序代码  这里本来是让补足代码得  其实就是求数组中得最大值
   
5.                 int max = 0;
   
6.                 for (int x= 1; x<cir.length;x++)
   
7.                 {
   
8.                         if(cir[x].radius>cir[max].radius)/*这里(cir[x].radius代表cir[x]这个对象的radius属性这里就是比较cir数组中x角标和max角标对应的对象的radius属性*/
   
9.                                 max = x;
   
10.                 }
    
11.                 return cir[max].radius;
    
12.         }

复制代码

其实这个问题主要还是理解对象的概念，
                Circle cir[]=new Circle[3];
                cir[0] = new Circle(1.0);
                cir[1] = new Circle(2.0);
                cir[2] = new Circle(4.0);

这些内容说明cir[]是Circle的对象，16行的  cir[x].radius>cir[max].radius就是Circle类的对象调用Circle类的变量radius，又因为cir[0]=new Circle(1.0)   所以cir[0].radius = 1.0,同理cir[1].radius = 2.0    cir[2].radius = 4.0         16行的   if(cir[x].radius>cir[max].radius)  就是找出最大值

Circle cir[]=new Circle[3]
此处创建一个数组，数组中存储的元素师Circle的对象
所以cir[index]表示数组中的元素，即Circle对象
所以cir[index].radius表示通过对象来使用类中的成员

赵彦丰 发表于 2014-3-18 17:41
哦   可能今天有点晕

慢慢来，我以前学这个的时候。。也很纠结。别人可以搞定，自己也不会差劲，你得自己多努力，不会多问。。我表达的也不是很规范，只是希望通俗点，你能懂就行。。

赵彦丰 发表于 2014-3-18 17:39
public Circle(double r)
        {
                radius = r;

可以  不过是double类型的

董振冬 发表于 2014-3-18 17:26
cir[]是数组，cir[x]   x是变量，代表数组中几个常量，x可以是mian方法中  cir[]中1，2或者是4，max是数组 ...

哦   可能今天有点晕

osully 发表于 2014-3-18 17:27
这有什么不能理解的

一步一步的理解如下:

public Circle(double r)
        {
                radius = r;
        }

我可以这么理解么 cir[0].radius=1    cir[1].radius=2  cir[1].radius=4

这有什么不能理解的

一步一步的理解如下:
根据数组Circle cir[]=new Circle[3];
知道cir[x] 是 Circle对象
该对象调用自己的radius属性
属性是构造函数传进来赋值的

所以cir[x].radius 其实就是new Circle(1.0); 括号里的值

cir[]是数组，cir[x]   x是变量，代表数组中几个常量，x可以是mian方法中  cir[]中1，2或者是4，max是数组中假设的一个最大值，如果cir[x].radius>cir[max].radius，那么就让最大值max等于变量x，直到获取到最大的x  比如4，就能获取到最大值了