黑马程序员——Java学习笔记--方法的重载(Overload)与重写(Override)

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

java 支持方法重载，这种机制为类似功能的方法提供了统一的名称，但可根据参数行的不同而自动调用对应的方法。

一个例子可以从String 类上提供的一些方法看到，像String的valueOf()方法就提供了多个版本。

[java]  view plain copy

1. static String valueOf(boolean b);  
2.         static String valueOf(char c);  
3.         static String valueOf(int i);  
4.         static String valueOf(double d);  

虽然调用的方法名称都是valueOf(),但是根据所传递的参数数据类型不同，会调用对应版本的方法来进行对应的动作。

例如若是String.valueOf(10)，因为10是int类型，所以会执行的方法是valueOf(int  i)的版本，而若是String.valueOf(10.12)

因为10.12是double类型，则会执行的方法是valueOf(double  d)的版本。

 

方法重载的功能使得程序设计人员能较少苦恼于方法名称的设计，以统一的名称来调用相同功能的方法。方法重载不仅可根据

传递参数的数据类型不同来调用对应的方法，参数行的参数个数也可以用来设计方法重载。

例如可以这么重载someMethod()方法

[java]  view plain copy

1. class A{  
2.     public void someMethod(){  
3.         //...  
4.     }  
5.     public void someMethod(int i){  
6.         //...  
7.     }  
8.     public void someMethod(float f){  
9.         //...  
10.     }  
11.     public void someMethod(int i,float f){  
12.         //...  
13.     }  
14. }  

要注意的是返回值类型不可用作为方法重载的区别根据。例如如下的方法重载是不正确的。

[java]  view plain copy

1. class A{  
2.     public int someMethod(int i){  
3.         return 0;  
4.     }  
5.     public double someMethod(int i){  
6.         return 0.0;  
7.     }  
8. }  

 

重写

在继承的关系中也存在着方法重写的概念，所谓的方法重写就是指子类定义了与父类中同名的方法，但是在方法覆写时必须考虑到权限即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限。

[java]  view plain copy

1. class Person{  
2.     void say(){  
3.         System.out.println("person");  
4.     }  
5. }  
6. class Student extends Person{  //定义继承关系  
7.     public void say(){         //重写父类方法  
8.         System.out.println("student");  
9.     }  
10. }  

以上代码是正确的操作，下面看一个不正确的。

[java]  view plain copy

1. class Person{  
2.     public void say(){  
3.         System.out.println("person");  
4.     }  
5. }  
6. class Student extends Person{  //定义继承关系  
7.     void say(){         //错误的，降低了访问权限  
8.         System.out.println("student");  
9.     }  
10. }  

问题：如果现在将父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？

[java]  view plain copy

1. class Person{  
2.     private void say(){  
3.         System.out.println("person");  
4.     }  
5.     public void fun(){   //定义一个public方法  调用say()  
6.         this.say();  
7.     }  
8. }  
9. class Student extends Person{  //定义继承关系  
10.     void say(){          
11.         System.out.println("student");  
12.     }  
13. }  
14.   
15. public class T {  
16.     /** 
17.      * @param args 
18.      */  
19.     public static void main(String[] args) {  
20.         // TODO Auto-generated method stub  
21.         Person p = new Student();  
22.         p.fun();  //输出为person   并未重写   
23.     }  
24. }  

此时方法并没有被重写，而是相当于在子类中又重新定义了一个方法出来。