java中重载和覆盖(又称重写)的区别

初次见到这两个单词并没有什么特别的感觉,但是时间长了,却发现书上一会儿用override,一会儿又用overload,搞得我的迷迷糊。于是就做了个总结,希望能对和我一样对这两个概念模糊不清的网友有一个帮助。 
override 可以翻译为覆盖,从字面就可以知道,它是覆盖了一个方法并且对其重写,以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现,在接口中一般只是对方法进行了声明,而我们在实现时,就需要实现接口声明的所有方法。除了这个典型的用法以外,我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点: 
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果; 
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致; 
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类; 
4、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。 
overload对我们来说可能比较熟悉,可以翻译为重载,它是指我们可以定义一些名称相同的方法,通过定义不同的输入参数来区分这些方法,然后再调用时,VM就会根据不同的参数样式,来选择合适的方法执行。在使用重载要注意以下的几点: 
1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int, float), 但是不能为fun(int, int)); 
2、不能通过访问权限、返回类型、抛出的异常进行重载; 
3、方法的异常类型和数目不会对重载造成影响; 
4、对于继承来说,如果某一方法在父类中是访问权限是priavte,那么就不能在子类对其进行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。 
下面是对override和overload的测试程序,其中注释中的内容都是会产生编译错误的代码,我们将注释去掉,看看在编译时会产生什么效果。 
// 对overload测试的文件:OverloadTest.java 
public class OverloadTest { 
// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。 
public void fun(){ 
System.out.println("method fun in OverloadTest, no parameter"); 
}

public void fun(float f) { 
System.out.println("method fun in OverloadTest, parameter type: float"); 
}

public void fun(int i){ 
System.out.println("method fun in OverloadTest, parameter type: int"); 
}

public void fun(int i1, int i2) { 
System.out.println("method fun in OverloadTest, parameter type: int, int"); 
}

// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。 
// 需要注意:这里的参数肯定不是相同的类型,否则的顺序的先后就毫无意义。 
public void fun1(int i, float f) { 
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float"); 
}

public void fun1(float f, int i) { 
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int"); 
}

// 下面的两个方法用来验证方法抛出的异常对于重载的影响. 
// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。 
public void fun2() throws TestException { 
System.out.println("fun2 in OverloadTest, exception: TestException"); 
}

public void fun2(int i) throws TestException, TestException1 { 
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1"); 
}

public void fun2(float f) throws Exception { 
System.out.println("fun2 in OverloadTest, exception: Exception"); 
}

// 不能通过抛出的异常类型来重载fun方法。 
//public void fun(int i) throws Exception { 
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception"); 
//}

// 不能通过返回值重载fun方法。 
//public boolean fun(int i) throws Exception { 
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean"); 
// return true; 
//}

private void fun3() { }

// 不能通过不同的访问权限进行重载 
public void fun3() { }

public static void main(String[] args) { 
// 这里只是定义了OverloadTest的实例,所以test不会调用 
// OverloadTest1中的方法。 
OverloadTest test = new OverloadTest1(); 
// 这里定义了OverloadTest1的实例,因为OverloadTest1是OverloadTest 
// 的子类,所以test1会调用OverloadTest中的方法。 
OverloadTest1 test1 = new OverloadTest1();

try { 
int i = 1, j = 2, m = 3;

// 这里不会调用OverloadTest1的fun方法 
// test.fun(i, m, j); 
test1.fun(i, j, m); 
test1.fun(); 
// 这个调用不会执行,因为fun3()在OverloadTest中访问权限是priavte 
//test1.fun3(); 
test1.fun3(i); 
} catch(Exception e) { } 

}

class OverloadTest1 extends OverloadTest{ 
// 在子类中重载fun 
public void fun(int i, int m, int n) { 
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int"); 
}

// 这个不是对父类中方法的重载,只是一个新的方法。 
public void fun3(int i) { 
System.out.println("fun2 in OverloadTest1"); 

}

// 对override测试的文件:OverrideTest.java 
public class OverrideTest { 
public void fun() throws TestException { 
System.out.println("method fun in OverrideTest"); 
}

private void fun1() { 
System.out.println("method fun1 in OverrideTest"); 
}

public static void main(String[] args) { 
OverrideTest test = new OverrideTest1(); 
try { 
test.fun(); 
test.fun1(); 
} catch(Exception e) { } 

}

class OverrideTest1 extends OverrideTest{ 
// 以下正常Override 
public void fun() throws TestException2 { 
System.out.println("fun in OverrideTest1"); 
}

// 不能Override父类中的方法,因为它定义了不同的异常类型和 
// 返回值。 
//public int fun() throws TestException1 { 
// System.out.println("method fun in Test"); 
// return 1; 
//}

// 不能Override父类中的方法,因为它抛出了比父类中非法范围 
// 更大的异常。 
//public void fun() throws Exception { 
// System.out.println("fun in OverrideTest1"); 
//}

// 这个方法并没有Override父类中的fun1方法,因为这个方法在 
// 父类是private类型,所以这里只是相当于定义了一个新方法。 
public void fun1() { 
System.out.println("method fun1 in Test"); 

}

class TestException extends Exception{ 
public TestException(String msg) { 
super(msg); 

}

class TestException1 extends TestException { 
public TestException1(String msg) { 
super(msg); 

}

class TestException2 extends TestException { 
public TestException2(String msg) { 
super(msg); 

}

时间: 2024-10-14 19:59:10

java中重载和覆盖(又称重写)的区别的相关文章

java的重载、覆盖和隐藏的区别

重载:方法名相同,但参数不同的多个同名函数 注意:1.参数不同的意思是参数类型.参数个数.参数顺序至少有一个不同 2.返回值和异常以及访问修饰符,不能作为重载的条件(因为对于匿名调用,会出现歧义,eg:void a ()和int a() ,如果调用a(),出现歧义) 3.main方法也是可以被重载的 覆盖:子类重写父类的方法,要求方法名和参数类型完全一样(参数不能是子类),返回值和异常比父类小或者相同(即为父类的子类),访问修饰符比父类大或者相同 两同两小一大  注意:子类实例方法不能覆盖父类的

java中重载、覆盖和隐藏三者的区别分析

重载:方法名相同,但参数不同的多个同名函数 注意:1.参数不同的意思是参数类型.参数个数.参数顺序至少有一个不同 2.返回值和异常以及访问修饰符,不能作为重载的条件(因为对于匿名调用,会出现歧义,eg:void a ()和int a() ,如果调用a(),出现歧义) 3.main方法也是可以被重载的 覆盖:子类重写父类的方法,要求方法名和参数类型完全一样(参数不能是子类),返回值和异常比父类小或者相同(即为父类的子类),访问修饰符比父类大或者相同 两同两小一大  注意:子类实例方法不能覆盖父类的

C++中重载、覆盖与隐藏的区别(转)

本文摘自林锐博士的<高质量C++/C编程指南>. 成员函数的重载.覆盖(override)与隐藏很容易混淆,C++程序员必须要搞清楚概念,否则错误将防不胜防. 1. 重载与覆盖 成员函数被重载的特征: (1)相同的范围(在同一个类中): (2)函数名字相同: (3)参数不同: (4)virtual关键字可有可无. 覆盖是指派生类函数覆盖基类函数,特征是: (1)不同的范围(分别位于派生类与基类): (2)函数名字相同: (3)参数相同: (4)基类函数必须有virtual关键字. 在下例中,函

java中重载与重写浅析

java中重载与重写浅析 Overloading (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段.多个同名函数同时存在,具有不同的参数个数/类型. 重载Overloading是一个类中多态性的一种表现. (2) Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义. 调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性. (3) 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以

Java技术_Java千百问(0038)_java中重载和覆盖有什么关系

点击进入_更多_Java千百问 1.什么是重载 java的重载,简单说,就是方法有同样的名称,但是参数不相同.这样的同名不同参数的方法之间,互相称之为重载方法. 需要注意的是: 1. 方法名相同. 2. 参数不同,这里是说对应位置的参数类型至少有一个不同,当然List和List都是List,算作相同. 3. 返回值可以不同,可以相同. 例子: "` public class Test{ public void a() { System.out.println("a()");

C++中成员函数的重载、覆盖和隐藏的区别

转载请注明,原创地址:点击打开链接   http://blog.csdn.net/u010587274/article/details/38928561 个人微信公众号:tanzi_888 (潭子技术圈) C++中成员函数的重载.覆盖和隐藏的区别: 1 重载(overload): 是函数名相同,参数列表不同 重载只是在类的内部存在.但是不能靠返回值类型来判断.1.1)相同的范围(在同一个类中)1.2)函数名字相同1.3)参数不同 1.4)Virtual关键字可有可无 2  覆盖 (overrid

Java中final、finally、finalize的区别(转)

Java中final.finally.finalize的区别与用法,困扰了不少学习者,下面我们就这个问题进行一些探讨,希望对大家的学习有所帮助. 方法/步骤 1 简单区别: final用于声明属性,方法和类,分别表示属性不可交变,方法不可覆盖,类不可继承. finally是异常处理语句结构的一部分,表示总是执行. finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,供垃圾收集时的其他资源回收,例如关闭文件等. END 方法/步骤2 1 中等区别: 虽然这三

【转】彻底弄懂Java中的equals()方法以及与&quot;==&quot;的区别

彻底弄懂Java中的equals()方法以及与"=="的区别 一.问题描述:今天在用Java实现需求的时候,发现equals()和“==”的功能傻傻分不清,导致结果产生巨大的偏差.所以,我决定花费时间把equals()和“==”的功能彻底弄懂,前事不忘后事之师嘛,分享给大家,希望对大家理解equals()和“==”的功能有所帮助. 二.分析探索解决问题的方法:1.Object 中的equals()方法: (1)通过查找API,说明如下: equalspublic boolean equ

JAVA中 String 、StringBuffer和StringBuilder 的区别

String 内容定义成 final char[],只能在属性和构造函数中赋值,其它地方不能改变 :String 覆盖实现了 equals . StringBuffer 内容定义成了 char[] ,但没实现 equals. String 和 StringBuffer 的区别是: 1.String 通过构造新的String 实现可变字符串,而 StringBuffer 通过改变内部的内容属性来实现可变字符串. 2.new String("ABC").equals("ABC&q