class Point
{        
        double a,b,c;
        Point(double a1,double b1,double c1)
        {         
                a = a1;         b = b1;         c = c1;        
        }
        void setA(double a1)
        {         
                a = a1;        
        }        
        void setB(double b1)
        {        
                b = b1;        
        }        
        void setC(double c1)
        {        
                c = c1;        
        }
        double getDistance(Point p)
        {         
                return (a-p.a)*(a-p.a)+(b-p.b)*(b-p.b)+(c-p.c)*(c-p.c);        
        }
}

public class TestPoint
{        
        public static void main(String[] args)
        {
                Point p = new Point();        
                Point p1 = new Point(2.2,2.2,2.2);        
                System.out.println(p.getDistance(p1));
        }
}

赵俊杰 发表于 2012-8-6 19:57
class Point
{        
        double a,b,c;

我报的是 实际参数列表和形式参数长度不同。的错误
构造了一个有参函数，那Point为什么还要想要弄无参的呢？只要里面加个值就行了啊，你就是加
(0,0,0)也行，只要不是空参数，null就可以

   Point(double a1,double b1,double c1)
        {         
                a = a1;         b = b1;         c = c1;        
        }
因为你在这里已经定义了一个有3个参数的构造方法，因此就不会再自动给你定义一个无参构造方法。
你在测试类里想通过Point p = new Point();来创建一个对象P，因为他是通过new point()这个无参构造方法来创建P对象的。所以他找不到Point()无参构造方法，自然就会在这里报错。
因为你在Point｛｝类里定义了一个Point(double a1,double b1,double c1){}构造方法，所以Point p1 = new Point(2.2,2.2,2.2)对象可以成功创建。

对象的构建要看是否存在构造方法：类名  对象名 = new 构造方法名();定义的有构造方法就能成功创建对象，没有就会失败。         

class Point
{        
        double a,b,c;
        Point(double a1,double b1,double c1)
        {         
                a = a1;         b = b1;         c = c1;        
        }  //有参构造函数      
   void setA(double a1)
        {         
                a = a1;        
        }        
        void setB(double b1)
        {        
                b = b1;        
        }        
        void setC(double c1)
        {        
                c = c1;        
        }
        double getDistance(Point p)
        {         
                return (a-p.a)*(a-p.a)+(b-p.b)*(b-p.b)+(c-p.c)*(c-p.c);        
        }
}

public class TestPoint
{        
        public static void main(String[] args)
        {
                Point p = new Point();        
                Point p1 = new Point(2.2,2.2,2.2);        
                System.out.println(p.getDistance(p1));
        }
}

你已经主动构造了一个有参函数，编译器就不再帮你做无参函数了。因此Point类其实只有一个有参构造函数。
所以，Point p1 = new Point(2.2,2.2,2.2); 正确。而Point p1 = new Point();因Point其实不存在"无参构造函数"，所以错误。

Point p = new Point();        
你的构造函数啊！！！
class Point
{        
        double a,b,c;
        Point(double a1,double b1,double c1)
        {         
                a = a1;         b = b1;         c = c1;        
        }
你写了一个构造函数，里边有三个参数。但是下边你new出来的 p对象并没有传参。
class Point
{        
        double a,b,c;
        Point(double a1,double b1,double c1)
        {         
                a = a1;         b = b1;         c = c1;        
        }
        Point()
        {         
                     
        }
        void setA(double a1)
        {         
                a = a1;        
        }        
        void setB(double b1)
        {        
                b = b1;        
        }        
        void setC(double c1)
        {        
                c = c1;        
        }
        double getDistance(Point p)
        {         
                return (a-p.a)*(a-p.a)+(b-p.b)*(b-p.b)+(c-p.c)*(c-p.c);        
        }
}
在重写一个构造函数记不会出错误了。

你已经定义了一个带参构造函数，就不会再有系统隐式的构造参数了，除非你再自己定义
楼主你写这个程序干吗用啊