方法的重写与多态

方法重写与多态

什么是方法重写

• 方法的重写或方法的覆盖(overriding)
  • 子类根据需求对从父类继承的方法进行重新编写
  • 重写时,可以用super.方法的方式来保留父类的方法
  • 构造方法不能被重写

方法重写的规则

• 方法名相同
• 参数列表相同
• 返回值类型相同或者是父类方法返回值类型的子类
• 访问权限不能严于父类
• 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
• 子类可以定义与父类同名的静态方法,以便在子类中影藏父类的静态方法(注:静态方法中无法使用super)
• 父类的私有方法不能被子类覆盖
• 不能抛出比父类方法更多的异常

方法重写vs方法重载

比较项	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

Object类

- Object类是所有类的父类

    public class Pet extrnds Object{
        ......
    }

-Object类被子类经常重写的方法

方法	说明
toString()	返回当前对象本身的有关信息,按字符串对象返回
equals()	比较两个对象是否是同一个对象,是则返回true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息,返回Class对象

-Object类的equals()方法

• 比较两个对象是否是同一个对象,是则返回true
• 操作符==
  • 简单数据类型,直接比较值。如1==2
  • 引用类型,比较两者是否为同一对象

(1) Object类的equals()方法与==没区别
(2) 当有特殊需求,如认为属性相同即为同一对象时,需要重写equals()
(3) Java.lang.String重写了equals()方法,把equals()方法的判断变为了判断其值

重写equals()

• 需求说明
  • 重写比较规则,判断两名学员(Student)是否为同一对象
    • Student相关属性
      • Id(学号) 、name(姓名) 、age(年龄)
    • 如果两名学员的学号以及姓名相同,则为同一对象
      instanceof用于判断一个引用类型所引用的对象是否是一个类的实例

多态

为什么使用多态

- **如下主人类中给宠物看病的方法,如果又需要给XXX宠物看病,怎么办?**

//给狗看病
    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("吃药","疗养");
        }
    }

• 添加XXX类,继承Pet类
• 修改主人类,添加给XXX看病的方法

频繁修改代码,代码可扩展性、可维护性差

使用多态优化

• 生活中的多态
  

• 同一种事物,由于条件不同,产生的结果也不同

• 多态:同一个引用类型,使用不同实例而执行不同操作

多态的使用-1

• 使用多态优化后的代码

    //Dog类
    public class Dog extends Pet{
        public void toHospital(){
            this.setHealth(60);
            System.out.println("打针、吃药");
        }
    }

    //pengunin类
    public class Penguin extends Pet{
        Public void toHospital(){
            this.setHealth(70);
            System.out.println("吃药、疗养");
        }
    }

    //主人类
    Public class Master{
        Public void cure(Pet pet){
            if(pet.getHealth()<50){
                pet.toHospital();
            }
        }
    }

    //测试方法
    Pet pet=new Dog();
    Master master=new Master();
    master.cure(pet);//父类引用、子类对象

多态的使用-2

• 又要给XXX看病时,只需
  • 编写XXX类继承Pet类(旧方案也需要)
  • 创建XXX类对象(旧方案也需要)
  • 其他代码不变(不用修改Master类)
    方法重写 是实现多态的基础

多态的使用-3

• Pet类的toHospital()如何实现呢?
  • toHospital()不需要有具体的实现
  • 抽象方法
  • Pet类声明为抽象类
  • 实例化Pet毫无意义

    public abstract class Pet{

    }

抽象方法

• 以下代码有什么问题?

    public abstract class Pet{
        public void toHospital(){ //每个类的实现不同

        }
    }

• 抽象方法

public abstract void print();

- 抽象方法没有方法体
- 抽象方法必须在抽象类里
- 抽象方法必须在子类中被实现,除非子类是抽象类

转型

向上转型

    //测试方法
    Pet pet=new Dog();
    pet.setHealth(20);
    Master master=new Master();
    master.cure(pet);

<父类型><引用变量名>=new<子类型>();

• 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法
• 此时通过父类引用变量无法调用子类特有的方法

向下转型

• 如果需要调用子类特有的方法,怎么办?

    Dog dog=(Dog)pet;//将Pet转换为Dog类型
    dog.catchingFlyDisc();//执行Dog特有的方法

向下转型:将一个指向子类对象的父类引用赋给一个子类的引用,即:父类类型转换为子类类型。需强制类型转换

<子类型><引用变量名>=(<子类型>)<父类型的引用变量>;

• 在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换异常

instanceof

• 如何减在向下转型的过程中,没有转换为真实子类类型的类型转换异常?

Java中提供了 instanceof 运算符来进行类型的判断

使用 instanceof 时,对象的类型必须和 instanceof 后面的参数所指定的类在继承上有上下级关系

多态的应用

• 回顾之前代码中的主人类(Master)

    //为宠物看病
    public void cure(Pet pet){
        if(pet.getHealth()<50){
            pet.toHospital();
        }
    }

    //测试方法
    Pet pet=new Dog();
    pet.setHealth(20);
    Master master=new Master();
    master.cure(pet);

使用父类作为方法的形参,是Java中实现和使用多态的主要方式
使用父类作为方法的返回值,也是Java中实现和使用多态的主要方式