重载构造函数

•
与方法一样,构造函数也可以被重载,这样就可以用不同方法来构造对象了,如下面的程序所示:
  1. public class test2
  2. {
  3. // @param args
  4. public static void main(String args[])
  5. {
  6. MyClass my1 = new MyClass();
  7. MyClass my2 = new MyClass(1);
  8. MyClass my3 = new MyClass(3.14);
  9. }
  10. }
  11. class MyClass
  12. {
  13. MyClass()
  14. {
  15. System.out.println("Inside MyClass()");
  16. }
  18. MyClass(int i)
  19. {
  20. System.out.println("Inside MyClass(int)");
  21. }
  23. MyClass(double d)
  24. {
  25. System.out.println("Inside MyClass(double)");
  26. }
  27. }
public class test2
{
    // @param args
    public static void main(String args[])
    {
     MyClass my1 = new MyClass();
     MyClass my2 = new MyClass(1);
     MyClass my3 = new MyClass(3.14);
    }
}
class MyClass
{
    MyClass()
    {
        System.out.println("Inside MyClass()");
    }
    
    MyClass(int i)
    {
        System.out.println("Inside  MyClass(int)");
    }
    
    MyClass(double d)
    {
        System.out.println("Inside  MyClass(double)");
    }
}
输出:
  1. Inside MyClass()
  2. Inside MyClass(int)
  3. Inside MyClass(double)
Inside MyClass()
Inside MyClass(int)
Inside MyClass(double)
MyClass()有3个重载版本,每一个都会构造一个不同的对象.执行new时,他就根据指定的形参来调用合适的构造函数.通过重载类的构造函数,可以为类的用户提供灵活的构造对象的方法.
最常见的重载构造函数的原因就是允许一个对象初始化另一个对象.例如,下面是使用Summation类计算整数值总和的程序:
  1. public class test2
  2. {
  3. // @param args
  4. public static void main(String args[])
  5. {
  6. Summation s1 = new Summation(5);
  7. Summation s2 = new Summation(s1);
  9. System.out.println("s2.sum : "+s2.sum);
  10. }
  11. }
  12. class Summation
  13. {
  14. int sum;
  16. Summation(int num)
  17. {
  18. sum = 0;
  19. for(int i=1;i<=num;i++) sum +=i;
  20. }
  22. Summation(Summation ob)
  23. {
  24. sum = ob.sum;
  25. }
  26. }
public class test2
{
    // @param args
    public static void main(String args[])
    {
     Summation s1 = new Summation(5);
     Summation s2 = new Summation(s1);
     
     System.out.println("s2.sum : "+s2.sum);
    }
}
class Summation
{
    int sum;
    
    Summation(int num)
    {
        sum = 0;
        for(int i=1;i<=num;i++) sum +=i;
    }
    
    Summation(Summation ob)
    {
        sum = ob.sum;
    }
}
输出:
  1. s2.sum : 15
s2.sum : 15
如本例所示,提供构造函数来使用一个对象初始化另一个对象的效率是非常高的.对于本例,当构造S2时,没有必要重新求和.当然,即使在效率不是问题的时候,提供一个生成对象副本的构造函数也是非常有用的.