方法重写
方法的重写或方法的覆盖(overriding)
子类根据需求对从父类继承的方法进行重新编写,重写时,可以用super.方法的方式来保留父类的方法,构造方法不能被重写。
方法重写规则
- 在子类与父类之间
- 方法名相同
- 参数列表相同(参数个数和类型相同)
- 返回值类型相同或者是其子类
- 访问权限不能严于父类
其他注意事项
- 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
- 子类可以定义与父类同名的静态方法,以便在子类中隐藏父类的静态方法(注:静态方法中无法使用super)
- 父类的私有方法不能被子类覆盖
- 不能抛出比父类方法更多的异常
方法重写示例
// 父类
class Animal {
// 父类的方法
void makeSound() {
System.out.println("Some sound");
}
}
// 子类
class Dog extends Animal
@Override
void makeSound() {
System.out.println("Bark");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog(); // 向上转型
myDog.makeSound(); // 输出: Bark
}
}
使用
@Override
注解可以帮助编译器检查子类的方法是否真的重写了父类的方法。如果没有正确重写,编译器会提示错误。
方法重写 vs 方法重载
比较项 | 位置 | 方法名 | 参数表 | 返回值 | 访问修饰符 |
---|---|---|---|---|---|
方法重写 | 子类 | 相同 | 相同 | 相同或是其子类 | 不能比父类更严格 |
方法重载 | 同类 | 相同 | 不相同 | 无关 | 无关 |
Object
Object
类是超类(基类),是所有类的父类,Java
中所有的类都直接或者间接继承 object
public class Pet extends Object {
// ......
}
Object
类被子类经常重写的方法
方法 | 说明 |
---|---|
toString() | 返回当前对象本身的有关信息,按字符串对象返回 |
equals() | 比较两个对象是否是同一个对象,是则返回true |
hashCode() | 返回该对象的哈希代码值 |
getClass() | 获取当前对象所属的类信息,返回Class对象 |
equals()
(1)Object
类的equals()
方法与操作符==
没区别
(2)当有特殊需求,如认为属性相同即为同一对象时,需要重写 equals()
(3)Java.lang.String
重写了 equals()
方法,把 equals()
方法的判断变为了判断其值
重写 equals()
方法
@Override
public boolean equals(Object obj){
if (this == obj) {
return true;
}
if (obj instanceof Student) {
Student other = (Student) obj;
return Id.equals(other.Id) && name.equals(other.name);
}
return false;
}
多态
多态:同一个引用类型,使用不同的实例而执行不同操作
使用多态优化可解决的问题:频繁修改代码,代码可扩展性、可维护性差
使用多态优化前的代码
//给狗看病
public void cure(Dog dog) {
if (dog.getHealth() < 50) {
dog.setHealth(60);
System.out.println("打针、吃药");
}
}
//给企鹅看病
public void cure(Penguin penguin){
if (penguin.getHealth() < 50) {
penguin.setHealth(70);
System.out.println("吃药、疗养");
}
}
使用多态优化后的代码
// pet类(父类)
public class Pet {
public void toHospital() {} // toHospital()不需要有具体的实现,此可以将其定义为抽象方法,Pet类声明为抽象类(实例化Pet毫无意义)
}
// Dog类(子类)
public class Dog extends Pet {
public void toHospital() {
this.setHealth(60);
System.out.println("打针、吃药");
}
}
// Penguin类(子类)
public class Penguin extends Pet {
public void toHospital() {
this.setHealth(70);
System.out.println("吃药、疗养");
}
}
// Master类
public class Master {
public void cure(Pet pet) {
if (pet.getHealth() < 50)
pet.toHospital();
}
}
// 测试方法
public static void main(String[] args) {
Master master = new Master();
Pet dog = new Dog(); // 向上转型
Pet penguin = new Penguin();
master.feed(dog);
master.feed(penguin);
}
再某新类看病时,只需编写该类继承Pet类(旧方案也需要),创建该类对象(旧方案也需要) 。而其他代码不变,即不用修改 Master
类
方法重写是实现多态的基础
使用父类作为方法的形参,是
Java
中实现和使用多态的主要方式使用父类作为方法的返回值,也是
Java
中实现和使用多态的主要方式
向上转型
父类的引用指向子类对象。
子类转父类,自动类型转换
<父类型> <引用变量名> = new <子类型>();
//测试方法
Pet pet = new Dog();
// 相当于:Dog dog = new Dog(); Pet pet = dog;
pet.setHealth(20);
Master master = new Master();
master.cure(pet);
-
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法
-
此时通过父类引用变量无法调用子类特有的方法
-
如果需要调用子类特有的方法,可以通过向下转型
向下转型
将一个指向子类对象的父类引用赋给一个子类的引用。
父类转子类,强制类型转换
<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
Dog dog = (Dog) pet; // 将 pet 转换为 Dog 类型
dog.catchingFlyDisc(); // 执行 Dog 特有的方法
在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换异常。可以通过Java提供的 instanceof 运算符来进行类型的判断,从而减少在向下转型的过程中,没有转换为真实子类类型的类型转换异常
instanceof
Java 中的一个运算符,用于检查对象是否是某个类或接口的实例。
语法:对象 instanceof 类名
,如果对象是该类的实例或其子类的实例,表达式返回 true,否则返回 false。
使用 instanceof 时,对象的类型必须和 instanceof 后面的参数所指定的类在继承上有上下级关系
使用场景
public void cure(Pet pet){
// 判断 pet 中是 dog 还是 penguin
if(pet instanceof Dog){
Dog dog = (Dog) pet;
dog.feed();
}else if(pet instanceof Penguin){
Penguin penguin = (Penguin) pet;
penguin.feed();
}
}