方法重载与方法覆写的区别

重载和重写的区别1，重载(Overloading)（1）方法重载是让类以统一的方式处理不同类型数据的一种手段。

多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading 是一个类中多态性的一种表现。

（2）Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法,这就是多态性。

（3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。

无法以返回型别作为重载函数的区分标准。

下面是重载的例子：packagec04.anwer;//这是包名//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用thi关键字调用不同的bark方法。

不同的重载方法bark是根据其参数类型的不同而区分的。

//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。

packagec04.anwer;publicclaDog{Dog(){thi.bark();}voidbark()//bark()方法是重载方法{Sytem.out.println("nobarking!");thi.bark("female",3.4);}voidbark(Stringm,doublel)//注意：重载的方法的返回值都是一样的，{Sytem.out.println("abarkingdog!");thi.bark(5,"China");}voidbark(inta,Stringn)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分{Sytem.out.println("ahowlingdog");}publictaticvoidmain(String[]arg){Dogdog=newDog();//dog.bark();//dog.bark("male","yellow");//dog.bark(5,"China");2，重写（Overriding）（1）父类与子类之间的多态性，对父类的函数进行重新定义。

⽅法的重载与重写区别（1）⽅法重载是让类以统⼀的⽅式处理不同类型数据的⼀种⼿段。

多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading是⼀个类中多态性的⼀种表现。

（2）的⽅法重载，就是在类中可以创建多个⽅法，它们具有相同的名字，但具有不同的参数和不同的定义。

调⽤⽅法时通过传递给它们的不同参数个数和参数类型来决定具体使⽤哪个⽅法, 这就是多态性。

（3）重载的时候，⽅法名要⼀样，但是参数类型和个数不⼀样，返回值类型可以相同也可以不相同。

⽆法以返回型别作为重载函数的区分标准。

下⾯是重载的例⼦：package c04.answer;//这是包名//这是这个程序的第⼀种编程⽅法，在main⽅法中先创建⼀个Dog类实例，然后在Dog类的构造⽅法中利⽤this关键字调⽤不同的bark⽅法。

不同的重载⽅法bark是根据其参数类型的不同⽽区分的。

//注意：除构造器以外，编译器禁⽌在其他任何地⽅中调⽤构造器。

package c04.answer;public class Dog {Dog(){this.bark();}void bark()//bark()⽅法是重载⽅法{System.out.println(\"no barking!\");this.bark(\"female\", 3.4);}void bark(String m,double l)//注意：重载的⽅法的返回值都是⼀样的，{System.out.println(\"a barking dog!\");this.bark(5, \"China\");}void bark(int a,String n)//不能以返回值区分重载⽅法，⽽只能以“参数类型”和“类名”来区分{System.out.println(\"a howling dog\");}public static void main(String[] args){Dog dog = new Dog();//dog.bark(); [Page]//dog.bark(\"male\", \"yellow\");//dog.bark(5, \"China\"); 然后我们再来谈谈重写（Overriding）（1）⽗类与⼦类之间的多态性，对⽗类的函数进⾏重新定义。

⽅法重载和⽅法覆写
1、⽅法重载
在⼀个类中，我们可以定义多个⽅法。

如果有⼀系列⽅法，它们的功能都是类似的，只有参数有所不同，那么，可以把这⼀组⽅法名做成同名⽅法，例如：
这种⽅法名相同，但各⾃的参数不同，称为⽅法重载（Overload）。

注意：⽅法重载的返回值类型通常都是相同的。

⽅法重载的⽬的是，功能类似的⽅法使⽤同⼀名字，更容易记住，因此，调⽤起来更简单。

2、⽅法覆写
在继承关系中，⼦类如果定义了⼀个与⽗类⽅法签名完全相同的⽅法，被称为覆写（Override）。

Override和Overload不同的是，如果⽅法签名如果不同，就是Overload，Overload⽅法是⼀个新⽅法；如果⽅法签名相同，并且返回值也相同，就是Override。

注意：⽅法名相同，⽅法参数相同，但⽅法返回值不同，也是不同的⽅法。

在Java程序中，出现这种情况，编译器会报错。

加上@Override可以让编译器帮助检查是否进⾏了正确的覆写。

希望进⾏覆写，但是不⼩⼼写错了⽅法签名，编译器会报错。

方法重载和重写的区别首先，我们来看看方法重载和重写的定义。

方法重载（Method Overloading）指的是在同一个类中，方法名相同但参数列表不同的多个方法，它们具有相同的方法名，但是参数类型、参数个数或者参数顺序不同。

而方法重写（Method Overriding）指的是子类重新定义父类中已有的方法，方法名、参数列表必须完全相同，返回类型可以相同也可以不同，访问修饰符不能比父类中的方法的访问修饰符更严格。

其次，我们来看看方法重载和重写的实现。

方法重载是在同一个类中实现的，通过改变方法的参数列表来实现，编译器根据参数列表的不同来区分不同的方法。

而方法重写是在继承关系中实现的，子类重新定义父类中已有的方法，通过@Override注解来告诉编译器这是一个重写的方法。

接着，我们来看看方法重载和重写的效果。

方法重载是在编译期进行绑定的，根据方法的参数列表来选择调用哪个方法，属于静态绑定。

而方法重写是在运行期进行绑定的，根据对象的实际类型来选择调用哪个方法，属于动态绑定。

综上所述，方法重载和重写虽然都是对方法进行改写，但是在定义、实现和效果上有着明显的区别。

方法重载是在同一个类中实现的，通过改变方法的参数列表来实现，属于静态绑定；而方法重写是在继承关系中实现的，子类重新定义父类中已有的方法，属于动态绑定。

在实际编程中，需要根据具体的需求来选择使用方法重载还是方法重写，以达到更好的效果和设计。

总之，方法重载和重写是面向对象编程中常见的两个概念，它们在定义、实现和效果上有着明显的区别。

了解方法重载和重写的区别对于编程的正确实践和程序设计具有重要意义，希望本文能够帮助读者更好地理解和应用这两个概念。

方法重载与覆盖的区别方法重载（Overload）和方法覆盖（Override）是面向对象编程中常见的概念，它们分别用来描述不同的方法实现方式。

虽然它们都涉及到与方法的多态性有关，但是它们在具体实现和应用上有一些明显的区别。

首先，让我们来了解一下方法重载。

方法重载是指在同一个类中可以定义多个名称相同的方法，但它们的参数列表不同。

也就是说，方法的签名（即方法名和参数列表）必须不同，可以是参数的类型不同，参数的个数不同，或者参数的顺序不同。

当调用这些方法时，编译器根据实际传入参数的类型和个数，或者参数的顺序来确定到底调用哪一个方法。

举个简单的例子：javapublic class Test {public void print(int i) {System.out.println("int：" + i);}public void print(double d) {System.out.println("double：" + d);}}在上面的例子中，Test类中定义了两个名字相同但参数列表不同的print方法，分别是一个接收int类型的参数，另一个接收double类型的参数。

在调用这些方法时，编译器可以根据传入的具体参数类型来确定调用哪一个方法。

这就是方法重载的概念。

接着，让我们来了解一下方法覆盖。

方法覆盖是指子类可以重写父类的方法，即在子类中定义一个与父类方法签名相同的方法。

在进行方法覆盖时，子类方法的签名必须与父类中的方法签名一致，包括方法名、参数列表和返回类型。

此外，子类的访问修饰符可以放大父类的修饰符，但不能变为更严格的，比如如果父类是public，子类就可以是public或protected，但不能是private。

举个例子：javaclass Animal {public void eat() {System.out.println("Animal is eating");}}class Dog extends Animal {public void eat() {System.out.println("Dog is eating");}}在上面的例子中，Dog类继承自Animal类，并且重写了父类的eat方法。

方法覆盖和方法重载1.方法重载先看一个例题：编译下面程序，运行结果是什么？public class TestOverload {public static void main(String[] args) {Overload overload=new Overload();overload.print(null);}}class Overload{public void print(String some){System.out.println("String version print");}public void print(Object obj){System.out.println("Object version print");}}请选择正确的答案：（b）（a）编译错误（b）编译正确，打印String version print。

（c）编译正确，打印Object version print。

（d）编译正确，什么也不打印解析：当new执行时，将根据执行的自变量调用适当的构造函数，null作为一个特殊的参数匹配为String对象。

在Java中，同一个类中的两个或两个以上的方法可以有同一个名字，但只要他们的参数声明不同即可，这种情况被称为重载（overload）。

方法重载是Java实现多态性的一种方式。

㈠普通方法重载当一个重载方法被调用时候，Java用参数的类型或参数的数量来表明实际调用的重载方法的版本。

因此，每个重载方法的参数的类型或者参数的数量必须是不同的。

虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所调用的是哪个方法。

当Java调用一个重载方法时，原参数与调用参数匹配的方法被执行。

下面是一个说明方法重载的简单例子，示例代码如下：public class TestOverloadDemo {public static void main(String[] args) {OverloadDemo od=new OverloadDemo();double result;//调用所有版本的test方法od.test();od.test(10);od.test(10, 20);result=od.test(123.25);System.out.println("Result of od.test(123.25)"+result);}}class OverloadDemo{void test(){System.out.println("No parameters");}//方法重载，增加一个int类型参数void test(int a){System.out.println("a:"+a);}//方法重载:两个参数void test(int a,int b){System.out.println("a and b:"+a+" "+b);}//方法重载:一个double类型的参数double test(double a){System.out.println("a:"+a);return a*a;}}该程序的运行结果如下：No parametersa:10a and b:10 20a:123.25Result of od.test(123.25)15190.5625从上述程序可见，test（）被重载了4次。

1.父类：public virtual string ToString(){return "a";}子类：public override string ToString(){return "b";}2.同一类中或父子关系类中皆可：public string ToString(){return "a";}public string ToString(int id){return id.ToString();}override是用于重写基类的虚方法,这样在派生类中提供一个新的方法重载是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制很本质的区别就是看函数特征：覆写（Override）的两个函数的函数特征相同，重载（Overload）的两个函数的函数名虽然相同，但函数特征不同。

函数特征包括函数名，参数的类型和个数。

Override 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。

比如：Derived继承了Base，Base里面有void A(int a)那么如果你Derived里面觉得A写得不好或不适合这个类，你想重新再写一遍A里的代码，那么就写override void A(int a)这样，原来的那个函数就被你新写的这个覆盖掉了。

Overload 是重载，就是说函数名相同，函数特征不同，系统会根据你提供的参数来调相应的函数。

比如：void A(int a)和void A(int a,int b)如果你用的是A(1)那么调的是第一个，如果是A(1,1)那么调的是第二个。

=================================================1. override-----------使用override 修饰符来修改方法、属性、索引器或事件。

14. 面向对象高级（02）本季先重点回顾了方法的重载与覆写、super与this关键字的区别。

之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又为读者讲解了JAVA中继承的图形表示。

blog: [零基础学JAVA]Java SE面向对象部分-14.面向对象高级（02） 2009-01-11本季先重点回顾了方法的重载与覆写、super与this关键字的区别。

之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又讲解了JAVA中继承的图形表示。

上季内容回顾：1、继承的使用和概念，继承的各种限制2、子类对象的实例化过程3、方法覆写4、super的使用有两个题目在面试中经常会涉及到哈~~~面试一：解释一下方法的覆写与方法的重载的区别：面试二：super与this的区别属性覆写（较少使用）我们来简单验证下哈class A{String name = "redking";};class B extends A{//子类定义了一个和父类中相同的name属性String name = "Michael";{//与System.out.println();效果相同System.out.println(name);}};public class Demo01{public static void main(String args[]){B b = new B();b.print();}};程序打印了在子类中定义的name属性：Michael如果要打印父类中的name属性，我们可以修改成class A{String name = "redking";};class B extends A{//子类定义了一个和父类中相同的name属性String name = "Michael";public void print(){//与System.out.println();效果相同System.out.println(name);//如果要打印父类中的name属性，我们可以修改成 System.out.println();}};public class Demo01{public static void main(String args[]){B b = new B();}};父类中的name属性输出了哈~这就叫属性的复写属性一般情况下都要求被封装的，被封装之后肯定子类是无法看见父类中的内容，所以根本就无法覆写。