Java方法的重写
b站学习视频以及笔记-尚硅谷_Java零基础教程
1. 什么是方法的重写(override 或 overwrite)?
子类继承父类以后,可以对父类中同名同参数的方法,进行覆盖操作.
2. 应用:
重写以后,当创建子类对象以后,通过子类对象调用子父类中的同名同参数的方法时,实际执行的是子类重写父类的方法。
3.举例:
public class Circle {
private double radius;//半径
public Circle(){
radius = 1.0;
}
//
public Circle(double radius){
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
//返回圆的面积
public double findArea(){
return Math.PI * radius * radius;
}
}
public class Cylinder extends Circle{
private double length;//高
public Cylinder(){
length = 1.0;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
//返回圆柱的体积
public double findVolume(){
// return Math.PI * getRadius() * getRadius() * getLength();
return super.findArea() * getLength();
}
@Override
public double findArea() {//返回圆柱的表面积
return Math.PI * getRadius() * getRadius() * 2 +
2 * Math.PI * getRadius() * getLength();
}
}
public class CylinderTest {
public static void main(String[] args) {
Cylinder cy = new Cylinder();
cy.setRadius(2.1);
cy.setLength(3.4);
double volume = cy.findVolume();
System.out.println("圆柱的体积为:" + volume);
//没有重写findArea()时:
// double area = cy.findArea();
// System.out.println("底面圆的面积:" + area);
//重写findArea()以后:
double area = cy.findArea();
System.out.println("圆柱的表面积:" + area);
System.out.println("******************");
Cylinder cy1 = new Cylinder();
double volume1 = cy1.findVolume();
System.out.println("圆柱的体积为:" + volume1);
}
}
输出结果:
4.重写的规则:
方法的声明: 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
//方法体
}
约定俗称:子类中的叫重写的方法,父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况:子类不能重写父类中声明为private权限的方法
③ 返回值类型:
父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型,则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如:double),则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(具体放到异常处理时候讲)
子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写,要么都声明为static的(不是重写)。
public class Person {
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
void eat(){
System.out.println("吃饭");
}
public void walk(int distance){
System.out.println("走路,走的距离是:" + distance + "公里");
show();
eat();
}
private void show(){
System.out.println("我是一个人");
System.out.println(name+"to"+age);
}
public Object info(){
return null;
}
public double info1(){
return 1.0;
}
}
public class Student extends Person{
String major;
public Student(){
}
public Student(String major){
this.major = major;
}
public void study(){
System.out.println("学习。专业是:" + major);
}
//对父类中的eat()进行了重写
public void eat(){
System.out.println("学生应该多吃有营养的食物");
}
//对父类中的show()进行了重写
public void show(){
System.out.println("我是一个学生");
}
public String info(){
return null;
}
// public int info1(){
// return 1;
// }
//对父类中的walk()进行了重写
public void walk(int distance){
System.out.println("重写的方法");
}
}
public class PersonTest {
public static void main(String[] args) {
// 父类实现自己的方法
Person p1 = new Person();
p1.eat();
p1.walk(12);
System.out.println("**************");
// 子类对象实现方法
Student s = new Student("计算机科学与技术");
s.eat();//子类对父类进行了重写
s.walk(10);//子类对父类进行了重写
s.study();//子类的特有方法
}
}
输出结果:
5.面试题:区分方法的重写和重载?
答:
① 二者的概念:
② 重载和重写的具体规则
③ 重载:不表现为多态性 。
重写:表现为多态性。
重载,是指允许存在多个同名方法,而这些方法的参数不同。编译器根据方法不同的参数表,对同名方法的名称做修饰。对于编译器而言,这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的,即子类可以重载父类的同名不同参数的方法。
所以:对于重载而言,在方法调用之前,编译器就已经确定了所要调用的方法,这称为“早绑定”或“静态绑定”;
而对于多态,只等到方法调用的那一刻,解释运行器才会确定所要调用的具体方法,这称为“晚绑定”或“动态绑定”。
重写:表现为多态性。
引用一句Bruce Eckel的话:“不要犯傻,如果它不是晚绑定,它就不是多态。”