在本文中，我们将讨论Java重载和覆盖之间的区别。如果您不熟悉这些术语，请参考以下文章：
 
Java中的重载与重载
 
重载在编译时发生，而重载在运行时发生：重载方法调用与其定义的绑定已在编译时发生，但是重载方法调用对其定义的绑定在运行时发生。
 
静态方法可以重载，这意味着一个类可以具有多个同名的静态方法。静态方法不能被覆盖，即使您在子类中声明了相同的静态方法，也与父类的相同方法无关。
 
最基本的区别是重载是在同一个类中完成的，而要覆盖基类和子类则是必需的。重写就是为父类的继承方法提供特定的实现。
 
静态绑定用于重载方法，动态绑定用于重载/覆盖方法。
 
性能：与覆盖相比，重载可提供更好的性能。原因是重写的方法的绑定是在运行时完成的。
 
私有方法和最终方法可以重载，但不能被覆盖。这意味着一个类可以具有多个同名的私有/最终方法，但是子类不能覆盖其基类的私有/最终方法。
 
在方法重载的情况下，方法的返回类型无关紧要，可以相同也可以不同。但是，如果方法被重写，则重写方法可以具有更特定的返回类型(请参阅this)。
 
执行方法重载时，参数列表应该不同。参数列表应与方法覆盖中的相同。
 
重载示例
 
//A class for adding upto 5 numbers
 
class Sum
 
{
 
int add(int n1, int n2)
 
{
 
return n1+n2;
 
}
 
int add(int n1, int n2, int n3)
 
{
 
return n1+n2+n3;
 
}
 
int add(int n1, int n2, int n3, int n4)
 
{
 
return n1+n2+n3+n4;
 
}
 
int add(int n1, int n2, int n3, int n4, int n5)
 
{
 
return n1+n2+n3+n4+n5;
 
}
 
public static void main(String args[])
 
{
 
Sum obj = new Sum();
 
System.out.println("Sum of two numbers: "+obj.add(20, 21));
 
System.out.println("Sum of three numbers: "+obj.add(20, 21, 22));
 
System.out.println("Sum of four numbers: "+obj.add(20, 21, 22, 23));
 
System.out.println("Sum of five numbers: "+obj.add(20, 21, 22, 23, 24));
 
}
 
}
 
输出：
 
Sum of two numbers: 41
 
Sum of three numbers: 63
 
Sum of four numbers: 86
 
Sum of five numbers: 110
 
在这里，我们有4个相同方法的版本add。我们在add()这里重载该方法。
 
覆盖示例
 
package beginnersbook.com;
 
class CarClass
 
{
 
public int speedLimit()
 
{
 
return 100;
 
}
 
}
 
class Ford extends CarClass
 
{
 
public int speedLimit()
 
{
 
return 150;
 
}
 
public static void main(String args[])
 
{
 
CarClass obj = new Ford();
 
int num= obj.speedLimit();
 
System.out.println("Speed Limit is: "+num);
 
}
 
}
 
输出：
 
Speed Limit is: 150
 
这里speedLimit()的class方法Ford是覆盖speedLimit()class方法的CarClass。
 
本文同步分享在 博客“_陈哈哈”(CSDN)。
 
如有侵权，请联系 support@oschina.cn 删除。
 
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

 
说到java中的重载和覆盖呢，大家都很熟悉了吧，但是呢我今天就要写这个。
 
本文主题：
 
一.什么是重载
 
二.什么是覆盖
 
三.两者之间的区别
 
重载(overload)：
 
在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
 
即当函数同名时，只看参数列表。和返回值类型没关系。
 
重载使用的时候需要注意：
 
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序。
 
2、方法的异常类型和数目不会对重载造成影响。
 
3、对于父类来说，子类可以重载与继承父类中的方法同名的方法，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
 
覆盖(override):
 
当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖。
 
什么时候使用覆盖呢？
 
当子类继承父类时，父类的功能内容需要修改时，可以通过覆盖来实现
 
在方法覆盖时，注意两点：
 
1、子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。
 
2、覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)YES
 
3、被final修饰的方法是一个最终方法，不可以被覆盖。
 
4、子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。
 
重载和覆盖的区别：
 
1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
 
2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
 
3、覆盖要求参数列表相同；重载要求参数列表不同。
 
4、覆盖关系中，调用那个方法体，是根据对象的类型来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
 
以上就是小编为大家带来的深入理解java中的重载和覆盖全部内容了，希望大家多多支持脚本之家~

 
 
1. 首先搞明白覆盖是什么？
 
 
 
·        举个栗子
 
public class Main {
	public static void main(String[] args) {
		new Father().print();
		new Son().print();
	}
}

class Father{
	 public void print(){
		 System.out.println("father");
	 }
}
class Son extends Father{
	@Override
	public void print() {
		System.out.println("SON");
	}		
}
 
 
 
·        运行截图
 
 
 
 
 
该例中子类继承了父类，但重写了父类的方法，因此虽然是从父类中拿到的方法但重写之后与父类方法有了区别，因此称为覆盖（即子类方法覆盖了父类方法）
 
 
 
1. 重载是什么？
 
 
 
·        举个栗子
 
public class Main {
	public static void main(String[] args) {
		new Test().print();
		new Test().print(3);
		new Test().print(3,"双参");
	}
}

class Test{
	 public void print(){
		 System.out.println("无参");
	 }
	 public void print(int i){
		 System.out.println(i+" "+"单参");
	 }
	 public void print(int i,String j){
		 System.out.println(i+" "+j);
	 }
}
 
 
 
·        运行截图
 
 
 
 
该例子里写了多个print方法，但参数不同，因此可以运行，这也就是重载的含义，一个类中可以有多个同名不同参（参数列表不同）的方法。
 
 
 
从上述例子中可以看出覆盖和重载的一些区别，但还存在一些区别不再用代码验证了，具体如下
 
 
 
 
区别
 
 
覆盖
 
 
重载
 
 
实现上
 
 
子类对父类方法的重写
 
 
同一个类中建立多个同名方法
 
 
参数
 
 
与父类同名同参
 
 
与别的方法同名不同参
 
 
返回
 
 
子类与父类返回类型要一致
 
 
无此要求
 
 
权限
 
 
子类不能覆盖父类的private方法
 
无此要求
 
 
 
 
父类一个方法只能在子类覆盖一次
 
 
重载只要参数不同，可以多次
 
 
 
 
 
覆盖是针对父类方法的重写
 
 
同类中的方法均可重载
 
 
 
 
 
重写要求子类比父类抛出更少的异常
 
 
无此要求
 
 

重载(overload)和覆盖(overide)是 Java 多态性的不同表现方式。
 
重载是在一个类中多态性的一种表现，是指在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型。
 
在使用重载时，需要注意以下几点：
 1)重载是通过不同的方法参数来区分的，例如不同的参数个数、不同的参数类型或不同的参数顺序。
 2)不能通过方法的访问权限、返回值类型和抛出的异常类型来进行重载。
 3)对于继承来说，如果基类方法的访问权限为 privae，那么就不能在派生类对其重载；如果派生类也定义了一个同名的函数，这只是一个新的方法，不会达到重载的效果。
 
覆盖是指派生类函数覆盖基类函数。覆盖一个方法并对其重写，以达到不同的作用。
 在使用覆盖时需要注意以下几点：
 1)派生类中的覆盖方法必须要和基类中被覆盖的方法有相同的函数名和参数。
 2)派生类中的覆盖方法的返回值必须和基类中被覆盖白方法的返回值相同。
 3)派生类中的覆盖方法所抛出的异常必须和基类(或是其子类)中被覆盖的方法所抛出的异常一致。
 4)基类中被覆盖的方法不能为 private 否则其子类只是定义了一个方法，并没有对其覆盖。
 
重载与覆盖的区别主要有以下几个方面：
 1)覆盖是子类和父类之间的关系，是垂直关系；重载是同一个类中方法之间的关系，是水平关系。
 2)覆盖只能由一个方法或只能由一对方法产生关系；重载是多个方法之间的关系。
 3)覆盖要求参数列表相同；重载要求参数列表不同。
 4)覆盖关系中，调用方法体是根据对象的类型(对象对应存储空间类型)来决定；而重载中关系是根据调用时的实参表和形参表来选择方法体的。