Go语言视频零基础入门到精通

javalearner

在java 中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded ），这个过程称为方法重载（method overloading ）。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java 最激动人心和最有用的特性之一。      当一个重载方法被调用时，Java 用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时，参数与调用参数匹配的方法被执行。 下面是一个说明方法重载的简单例子：  
      
      
        
         
        

        
        
      
     
   

1. // Demonstrate method overloading.
   
2. class OverloadDemo {
   
3. void test() {
   
4.    System.out.println("No parameters");
   
5. }
   
6. // Overload test for one integer parameter.
   
7. void test(int a) {
   
8.   System.out.println("a: " + a);
   
9. }
   
10. // Overload test for two integer parameters.
    
11. void test(int a, int b) {
    
12.   System.out.println("a and b: " + a + " " + b);
    
13. }
    
14. // overload test for a double parameter
    
15. double test(double a) {
    
16.   System.out.println("double a: " + a);
    
17. return a*a;
    
18. }
    
19. }
    
20. class Overload {
    
21. public static void main(String args[]) {
    
22.    OverloadDemo ob = new OverloadDemo();
    
23.    double result;
    
24.    // call all versions of test()
    
25.    ob.test();
    
26.    ob.test(10);
    
27.    ob.test(10,20);
    
28.    result = ob.test(123.25);
    
29.    System.out.println("Result of ob.test(123.25): " + result);
    
30. }
    
31. }
    

复制代码

该程序产生如下输出：
    No parameters
    a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
  
       从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double 型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。
    当一个重载的方法被调用时，Java 在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些情况下，Java 的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：
   
   

1. // Automatic type conversions apply to overloading.
   
2. class OverloadDemo {
   
3. void test() {
   
4.   System.out.println("No parameters");
   
5. }
   
6. // Overload test for two integer parameters.
   
7. void test(int a，int b) {
   
8.   System.out.println("a and b: " + a + " " + b);
   
9. }
   
10. // overload test for a double parameter
    
11. void test(double a) {
    
12.    System.out.println("Inside test(double) a: " + a);
    
13.   }
    
14. }
    
15. class Overload {
    
16. public static void main(String args[]) {
    
17.     OverloadDemo ob = new OverloadDemo();
    
18.     int i = 88;
    
19.     ob.test();
    
20.     ob.test(10，20);
    
21.     ob.test(i); // this will invoke test(double)
    
22.     ob.test(123.2); // this will invoke test(double)
    
23. }
    
24. }
    

复制代码

?  
    该程序产生如下输出：
    No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
  
        在本例中，OverloadDemo 的这个版本没有定义test(int) 。因此当在Overload 内带整数参数调用test()时，找不到和它匹配的方法。但是，Java 可以自动地将整数转换为double 型，这种转换就可以解决这个问题。因此，在test(int) 找不到以后，Java 将i扩大到double 型，然后调用test(double) 。当然，如果定义了test(int) ，当然先调用test(int) 而不会调用test(double) 。只有在找不到精确匹配时，Java 的自动转换才会起作用。
          方法重载支持多态性，因为它是Java 实现“一个接口，多个方法”范型的一种方式。要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中，函数abs( )返回整数的绝对值，labs( ) 返回long 型整数的绝对值( )，而fabs( )返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java 中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java 的标准的类库包含一个绝对值方法，叫做abs ( )。这个方法被Java 的math 类重载，用于处理数字类型。Java 根据参数类型决定调用的abs()的版本。
         重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action ）。为特定环境选择正确的指定（specific ）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用操作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。
    当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种操作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的操作。
     构造函数重载
        除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们看一下这个Box类例子。
    class Box {
     double width;
     double height;
     double depth;  
    // This is the constructor for Box.  
    Box(double w，double h，double d) {
       width = w;
     height = h;
     depth = d;
    }  
    // compute and return volume
double volume() {
    return width * height * depth;
  }
}  
    在本例中，Box() 构造函数需要三个自变量，这意味着定义的所有Box对象必须给Box() 构造函数传递三个参数。例如，下面的语句在当前情况下是无效的：
    Box ob = new Box();  
    因为Box( )要求有三个参数，因此如果不带参数的调用它则是一个错误。这会引起一些重要的问题。如果你只想要一个盒子而不在乎 (或知道)它的原始的尺寸该怎么办？或，如果你想用仅仅一个值来初始化一个立方体，而该值可以被用作它的所有的三个尺寸又该怎么办？如果Box 类是像现在这样写的，与此类似的其他问题你都没有办法解决，因为你只能带三个参数而没有别的选择权。
    幸好，解决这些问题的方案是相当容易的：重载Box 构造函数，使它能处理刚才描述的情况。下面程序是Box 的一个改进版本，它就是运用对Box构造函数的重载来解决这些问题的：
     
   

1. /* Here，Box defines three constructors to initialize the dimensions
2. of a box various ways.
   
3. */
   
4. class Box {
   
5.   double width;
   
6.   double height;
   
7.   double depth;
   
8. // constructor used when all dimensions specified
   
9.   Box(double w，double h，double d) {
   
10.     width = w;
    
11.     height = h;
    
12.     depth = d;
    
13. }
    
14. // constructor used when no dimensions specified
    
15.   Box() {
    
16.    width = -1; // use -1 to indicate
    
17.    height = -1; // an uninitialized
    
18.    depth = -1; // box
    
19.   }
    
20. // constructor used when cube is created
    
21.    Box(double len) {
    
22.     width = height = depth = len;
    
23.    }
    
24. // compute and return volume
    
25.   double volume() {
    
26.     return width * height * depth;
    
27.   }
    
28. }
    
29. class OverloadCons {
    
30.   public static void main(String args[]) {
    
31.     // create boxes using the various constructors
    
32.      Box mybox1 = new Box(10，20，15);
    
33.      Box mybox2 = new Box();
    
34.      Box mycube = new Box(7);
    
35.      double vol;
    
36.     // get volume of first box
    
37.      vol = mybox1.volume();
    
38.      System.out.println("Volume of mybox1 is " + vol);
    
39.    // get volume of second box
    
40.      vol = mybox2.volume();
    
41.      System.out.println("Volume of mybox2 is " + vol);
    
42.    // get volume of cube
    
43.       vol = mycube.volume();
    
44.       System.out.println("Volume of mycube is " + vol);
    
45.    }
    
46. }
    
47. 该程序产生的输出如下所示：

复制代码

    Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
  
    在本例中，当new执行时，根据指定的自变量调用适当的构造函数。