方法重写与方法重载

继承和多态都是面向对象程序设计的特点。使用继承可以在一个父类的基础上再创建一个子类,这个子类不但拥有父类已有的属性和方法,还可以创建属于自己的属性和方法。由于子类和父类之间的关系,从而引出了方法重写和方法重载的问题。方法重写及方法重载在继承和多态性方面的应用中会存在很多问题,这些概念很容易混淆,掌握重写和重载的区别对学会使用多态的方式编写程序、提高程序的可维护性奠定了基础。

一、方法重写(0veriding)
如何定义重写:在Java程序中,类的继承关系可以产生一个子类,子类继承父类,它具备了父类所有的特征,继承了父类所有的方法和变量。子类可以定义新的特征,当子类需要修改父类的一些方法进行扩展,增大功能,程序设计者常常把这样的一种操作方法称为重写,也叫称为覆写或覆盖。重写体现了Java优越
性,重写是建立在继承关系上,它使语言结构更加丰富。在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

只是更加明确的说,要从父类中查找,就不在子类查找了。

二、重写规则
在重写方法时,需要遵循以下的规则:

(一)  父类方法的参数列表必须完全与被子类重写的方法的参数列表相同,否则不能称其为重写而是重载。..
(二)  父类的返回类型必须与被子类重写的方法返回类型相同,否则不能称其为重写而是重载。..
(三)  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 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用参数的类型和.. (或)个数来决定实际调用的重载方法。因此,每个重载方法的参数的类型或个数必须是不同。虽然每个重载方法可以有不同的返回类型,
但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法是,参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:

1.在使用重载时只能通过不同的参数列表,必须具有不同的参数列表。例如,不同的参数类型,不同的参数个数,不同的参数顺序。当然,同一方法内的几个参数类型必须不一样,例如可以是 fun(int,float),但是不能为 fun(int,int)。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。..
4.可以有不同的返回类型,只要参数列表不同就可以了。
5.可以有不同的访问修饰符。

6.可以抛出不同的异常。

四、方法重写与方法重载的区别
通过上面例子的分析,我们可以将方法重写和重载的区别总
结成这样一个表格,如下:

区别点

重载

重写(覆写)

英文

Overloading

Overiding

定义

方法名称相同,参数的类型或个数不同

方法名称、参数类型、返回值类型全部相同

对权限没有要求

被重写的方法不能拥有更严格的权限

范围

发生在一个类中

发生在继承类中

 

五、结束语
在面向对象程序设计的思想中,类的继承和多态性主要就是体现在子类重写父类的方法。而构造方法的重载作为方法重载的一个典型特例,可以通过重载构造方法来表达对象的多种初始化行为。灵活的运用方法重写与方法重载,不仅能减少编码的工作量,也能大大提高程序的可维护性及可扩展性。用好重写和重载
可以设计一个结构清晰而简洁的类,可以说重写和重载在编写代码过程中的作用非同一般。

参考文献:
(1)李宁 《Java中的方法重写与方法重载》--科技信息出版社
(2)谭贞军 《ava核心开发技术从入门到精通》 --电子工业出版社


<think>嗯,我现在需要理解Java中的方法重写方法重载之间的区别。首先,我得回忆一下这两个概念的基本定义。记得方法重载可能是在同一个类里,方法名相同但参数不同,而方法重写可能是在子类中覆盖父类的方法。不过具体细节可能记不太清楚,需要仔细梳理。 根据用户提供的引用内容,引用[1]提到方法重写方法重载Java中两个不同的概念,用于定义和使用方法,但有明显区别。引用[2]和引用[3]则更具体地指出,重写发生在子类中,而重载在同一个类中。此外,参数列表、返回类型以及访问权限等方面可能有不同要求。 首先,我应该明确两者的定义。方法重载Overloading)是指在同一个类中,多个方法有相同的名称,但参数列表不同(参数类型、数量或顺序不同)。返回类型可以不同,但仅返回类型不同不足以构成重载。例如,可能有多个构造方法,它们名称相同,但参数不同。 方法重写(Overriding)则是子类重新定义父类中的方法方法名、参数列表和返回类型必须相同,访问权限不能比父类更严格,并且不能抛出新的或更广泛的检查异常。这用于实现多态性,子类可以根据需要覆盖父类的实现。 接下来,我需要比较两者的区别。根据引用[3],区别包括:作用范围(同一类vs子类)、参数列表(必须不同vs必须相同)、返回类型(可以不同vs必须相同或协变)、访问权限(无限制vs不能更严格)、异常(无限制vs不能更广泛),以及静态方法能否被重载重写。例如,静态方法不能被重写,但可以被隐藏,而重载可以应用于静态和非静态方法。 然后,用法的不同。重载通常用于处理不同参数类型或数量的情况,提高可读性。比如System.out.println方法有多个重载版本,处理不同类型参数。重写用于实现多态,子类定制父类行为,如动物类的sound()方法在子类中有不同实现。 可能还需要举例说明,帮助理解。例如,重载的例子:同一个类中的add方法,参数数量不同。重写的例子:子类重写父类的toString()方法。 另外,需要注意一些容易混淆的地方。比如,仅改变返回类型不构成重载,必须参数不同。而重写时返回类型如果是引用类型,可以是父类返回类型的子类(协变返回类型)。 最后,总结两者的核心差异:重载是编译时多态,根据参数决定调用哪个方法重写运行时多态,根据对象类型决定调用哪个方法。正确区分它们对于编写可维护和符合预期的Java代码很重要。</think>### Java 方法重写方法重载的区别及用法 #### 一、核心区别总结 | **特性** | **方法重载 (Overload)** | **方法重写 (Override)** | |------------------------|-------------------------------------------------------|--------------------------------------------------------| | **作用范围** | 同一类或父子类(继承链中) | 仅子类中 | | **方法名** | 必须相同 | 必须相同 | | **参数列表** | 必须不同(类型、数量或顺序) | 必须相同 | | **返回类型** | 可以不同 | 必须相同(或协变返回类型,即子类返回父类方法的子类型) | | **访问权限** | 无限制 | 不能比父类方法更严格(如父类为`public`,子类不能为`private`) | | **异常类型** | 可以抛出任意异常 | 不能抛出比父类更宽泛的检查异常 | | **静态方法** | 可以重载 | 不能重写(静态方法属于类,可被“隐藏”) | | **多态性** | 编译时多态(根据参数类型决定调用) | 运行时多态(根据对象实际类型决定调用) | --- #### 二、详细解释用法 ##### 1. **方法重载 (Overload)** - **定义**:同一类中定义多个同名方法,但参数列表不同。 - **目的**:提供多种处理方式,增强代码可读性。 - **示例**: ```java public class Calculator { // 重载 add 方法 public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } } ``` - **注意事项**: - 仅返回类型不同不构成重载(如`int add()`和`double add()`会导致编译错误)。 - 静态方法也可重载。 ##### 2. **方法重写 (Override)** - **定义**:子类重新实现父类中已定义的方法方法名、参数、返回类型均相同)。 - **目的**:实现多态,定制子类特有行为。 - **示例**: ```java class Animal { public void sound() { System.out.println("动物叫声"); } } class Dog extends Animal { @Override // 使用注解明确标识重写 public void sound() { System.out.println("汪汪"); } } ``` - **注意事项**: - 使用`@Override`注解可帮助编译器检查重写是否正确。 - 子类方法访问权限不能低于父类(如父类是`protected`,子类可以是`public`或`protected`,但不能是`private`)。 - 协变返回类型允许子类方法返回父类方法返回类型的子类(例如父类返回`Object`,子类可返回`String`)。 --- #### 三、应用场景 1. **方法重载**: - 处理多种数据类型(如`System.out.println`支持`int`、`String`等)。 - 提供默认参数(通过不同参数数量实现)。 2. **方法重写**: - 实现接口或抽象类的具体功能。 - 覆盖`Object`类的通用方法(如`toString()`、`equals()`)。 --- #### 四、常见误区 - **重载继承无关**:父子类中同名不同参的方法属于重载而非重写。 - **静态方法不能重写**:若子类定义了父类相同的静态方法,仅是隐藏父类方法,调用时取决于引用类型。 - **私有方法无法重写**:父类私有方法对子类不可见,因此子类同名方法视为新定义。 --- #### 五、代码示例对比 ```java // 方法重载示例 class OverloadExample { void print(int x) { System.out.println("整数: " + x); } void print(String s) { System.out.println("字符串: " + s); } // 参数类型不同 } // 方法重写示例 class Parent { void show() { System.out.println("Parent"); } } class Child extends Parent { @Override void show() { System.out.println("Child"); } // 参数和返回类型相同 } ``` ---
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值