Java方法重写与方法重载

继承和多态都是面向对象程序设计的特点。使用继承可以在一个父类的基础上再创建一个子类，这个子类不但拥有父类已有的属性和方法，还可以创建属于自己的属性和方法。由于子类和父类之间的关系，从而引出了方法重写和方法重载的问题。方法重写及方法重载在继承和多态性方面的应用中会存在很多问题，这些概念很容易混淆，掌握重写和重载的区别对学会使用多态的方式编写程序、提高程序的可维护性奠定了基础。
一、方法重写(0veriding)
如何定义重写：在Java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。重写体现了Java优越
如果子类可以继承父类的某个实例方法，那么子类就有权利重写这个方法。是指：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。
目的：子类可以通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以吧父类的状态和行为改变为自身的状态和行为。
限制：重写父类方法是，不可以降低方法的访问权限。
示例：
class A{
void addClass(int a , int b,int c){
int sum = a + b + c;
if(sum>3){
System.out.print("sum>3");
}else{
System.out.print("sum<=3");
}
}
}
class B extends A{
void addClass(int a , int b,int c){
int sum = a + b + c;
if(sum>6){
System.out.print("sum>6");
}else
{
System.out.print("sum<=6");
}
}
}
public class C{
public static void main(String [] args){
B b = new B();
b.addClass(1,1,1);
b.addClass(1,2,3);//升级判断方法，主要运用
}
}
性，重写是建立在继承关系上，它使语言结构更加丰富。在Java中的继承中，子类既可以隐藏和访问父类的方法，也可以覆盖继承父类的方法。在Java中覆盖继承父类的方法就是通过方法的重写来实现的。
所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。这样，就可以实现对父类方法的覆盖。例如：下面的代码实现了方法的重写。
class Person//定义父类
fpublic void print(){//父类中的方法
System.out.println( 父类Person的print方法! );
}
}
class Student extends Person//定义子类继承Person类
{public void print(){//方法的重写
System.out.println( 子类Student的print方法! );
}
}
public class 0verrideExampleO1
{public static void main(String args[])
{Student s=new Student();
S.print();
}
}
运行结果：子类Student的print方法!
可以看出，当子类重写了父类中的print()方法后，使用S调用的是子类的print()方法，父类中的print()方法被覆盖了。也就是说，如果现在子类将父类中的方法重写了，调用的时候肯定是调用被重写过的方法，那么如果现在一定要调用父类中的方法该怎么办呢?此时，通过使用.. super关键就可以实现这个功能，super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。
例如:
Class Person
{public void print () {
System.out.println( 父类Person的print方法! );
}
}
class Student extends Person
{public void print () {
super.print(：//访问父类中被子类覆写过的方法
System.out.println(" 子类Student的print方法!" );
}
}
public class OverrideExample02
{public static void main(String args[])
{Student s=new Student();
S.print();
}
}
运行结果：父类Person的print方法!
子类Student的print方法 !
如果要使用super关键字不一定非要在方法重写之后使用，
也可以明确地表示某个方法是从父类中继承而来的。使用super
只是更加明确的说，要从父类中查找，就不在子类查找了。
当子类需要修改父类的一些方法进行扩展，增大功能，我们常常把这样的一种操作方法称之为重写。
子类继承父类或实现接口。子类重写父类或接口中的方法，必须方法名、返回值、参数列表一致。子类中重写的方法的修饰符必须不能比父类的方法高。
重写的例子
public class Fu {
public void fuMethod(String content) {
System.out.println("父类：" + content);
}
}
public class Zi extends Fu {@Override
br/>@Override
System.out.println("子类" + content);
}
}
二、重写规则
在重写方法时，需要遵循以下的规则：
(一)  父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。..
(二)  父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。..
(三)  Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。访问权限大小关系为：
编写过Java程序的人就知道，父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。例如:
class Person
{public void print()(//public访问权限
System.out.println( "父类Person的print方法! ");
}
}
Class Stedent extends Person
{private void print()(//重写方法降低了访问权限，错误
System.out.println( "子类Student的print方法!" );
}
}
(四)  由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。
(五)  在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。
同样的道理，如果子类中创建了一个成员变量，而该变量和
父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此
概念一般很少有人去研究它，因为意义不大。
三、方法重载(Overloading)
(一)  如何定义重载。方法的重写和重载只有一个字不同，很多初学者认为这两者十分相似，其实不然。方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。
一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，或者是参数的个数或者类型不同。方法的返回类型和参数的名字不参与比较，也就是说如果两个方法的名字相同，即使类型不同，也必须保证参数不同。
示例：
class A{
int computer(int a,int b){
return a + b;
}
double computer(double a ,int b ){
return a*b;
}
}
public class E{
public static void main(String [] args){
A a = new A();
System.out.print(a.computer(10,26));//输出36
System.out.print(a.computer(10.0,26));//输出260.0
}
}
所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。下面通过一个实例来分析。
重载的定义和使用方法。
Class Person {
{String name;
int age;
void print(){
System.out.println("姓名：" +name+"年龄：" +age);
}
void print(String a，int b){
System.out.println("姓名：" +a+"年龄："+b);
void print(String a，int b，intC){
System.out.println("姓名："+a+"年龄：" +b+"ID号：" +c);
}
void print(String a，int b，doubleC){
System.out.println("姓名："+a+"年龄：" +b+"ID号："+c);
}
}
public class OverLoadExampleOL
{publicstaticvoidmain(String args[])
{Personpl=newPerson();
p1.nanle="李明";
p1.age=22;
p1.print();
p1.print("王小早",19);
p1.print("金波",18,100325);
p1.print("婉宁",25,110903);
}
}
在上面的程序中，可以看到Person类中有多个名为 void print的方法，这就是方法的重载。执行程序，运行结果如下：
姓名：李明年龄：22
姓名：王小早年龄：l9
姓名：金波年龄：18ID号：10 00325
姓名：婉宁年龄：25ID号：110903
在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法重载规则。重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根
据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型和.. (或)个数来决定实际调用XM返佣www.fx61.com/brokerlist/xm.html的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。虽然每个重载方法可以有不同的返回类型，
但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。例如，不同的参数类型，不同的参数个数，不同的参数顺序。当然，同一方法内的几个参数类型必须不一样，例如可以是 fun(int，float)，但是不能为 fun(int，int)。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。..
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。
6.可以抛出不同的异常。
答：在同一个类中，方法名一样，但是参数列表不一样的方法，称为方法的重载。
​ 参数列表不同，有以下三种情况：
​ a、参数个数不一样
​ b、参数类型不一样
​ c、参数顺序不一样
方法重载的例子：设计比较俩个数据是否相等，兼容全整数类型byte、short、int、long
public class OverLoad {
public static void main(String[] args) {
int s1 = 10;
int s2 = 10;
System.out.println(compare(s1,s2));
}
public static boolean compare(byte s1,byte s2){
System.out.println("byte...");
return s1==s2;
}
public static boolean compare(short s1,short s2){
System.out.println("short...");
return s1==s2;
}
public static boolean compare(int s1,int s2){
System.out.println("int...");
return s1==s2;
}
public static boolean compare(long s1,long s2){
System.out.println("long...");
return s1==s2;
}
}
会根据传入的参数类型不同，寻找对应的方法。
判断是否为重载：只看方法名，参数列表(个数，类型，顺序)。方法名一样，参数列表不一样。
四、方法重写与方法重载的区别
通过上面例子的分析，我们可以将方法重写和重载的区别总
结成这样一个表格，如下：
区别点
重载
重写（覆写）
英文
Overloading
Overiding
定义
方法名称相同，参数的类型或个数不同
方法名称、参数类型、返回值类型全部相同
对权限没有要求
被重写的方法不能拥有更严格的权限
范围
发生在一个类中
发生在继承类中
方法重载：在同一个类中，方法的方法名相同，但参数个数、顺序或参数类型不同；
方法重载例：
public class Student{
public void Name(){}
public void Name(int a){}
public void Name(int a,String b){}
public void Name(String b,int a){}
}
错误方法重载
public class Student{
public void Name(){}
public String Name(){return “你好”}
}
方法重载与返回值类型无关，上面代码会报错；
方法重写：在子类继承父类时，子类中存在与父类同名的方法，这时子类中的方法就重写了父类中方法；
重写注意：
1.子类与父类的方法名与方法参数列表要一致
2.子类的访问权限修饰符必须要大于或等于父类的权限访问修饰符
3.子类方法抛出的异常要小于父类方法抛出的异常
方法重写例
public class Father{
public void showAge(){
System.out.println("父亲");
}
}
public class Son extends Father{
public void showAge(){
System.out.println("儿子")
}
public static void main(String[] args){
Son son=new Son();
son.showAge();
}
}
上面代码运行结果是：儿子，如果把Son中的showAge方法去掉，运行结果为：父亲；重写后如果想再次调用父类中的方法，可以使用super关键字；
在面向对象程序设计的思想中，类的继承和多态性主要就是体现在子类重写父类的方法。而构造方法的重载作为方法重载的一个典型特例，可以通过重载构造方法来表达对象的多种初始化行为。灵活的运用方法重写与方法重载，不仅能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。用好重写和重载
可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般。

荔城网站建设公司成都创新互联公司,荔城网站设计制作，有大型网站制作公司丰富经验。已为荔城上千提供企业网站建设服务。企业网站搭建\外贸营销网站建设要多少钱，请找那个售后服务好的荔城做网站的公司定做！