重写和多态

方法重写

• 为什么要使用方法重写？
  
  调用父类的print()方法，不能显示Dog的strain信息和Peguin的sex信息

子类重写父类的方法

什么是方法重写

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

方法重写的规则

在继承的情况下，子类的方法满足一下条件：

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

方法重写与方法重载的比较

Object类

Object类的equals()方法

• 比较两个对象是否是同一个对象，是则返回true；操作符==

//重写equals方法
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if (obj instanceof pet){
            pet p = (pet) obj;
            //自定义比较规则
            //如果宠物的名称相同则认为是用一个对象
            if (!this.name.equals(p.name)){
                return false;
            }else if (this.health!=p.health){
                return false;
            }else if (this.love!=p.love){
                return false;
            }
        }
        return true;
    }

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

多态

什么是多态

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

• 多态：同一个引用类型，使用不同的实例而执行不同操作

为什么使用多态

频繁修改代码，代码可扩展性、可维护性差，使用多态优化

使用多态后的代码块

多态的使用一

• 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("吃药、疗养");
    }
}

• 主人类

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); //父类引用，子类对象

多态的使用二

• 编写XXX类继承Pet类（旧方案也需要）
• 创建XXX类对象（旧方案也需要）
• 其他代码不变（不用修改Master类）
• 方法重写是实现多态的基础

多态的使用三

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

public abstract class Pet {		
} 

抽象

抽象类

• abstract关键字修饰类
• 抽象类不能实例化

抽象方法

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

转型

向上转型

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

向上转型：父类的引用指向子类对象，自动进行类型转换

向下转型

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

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

instanceof

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

pet p = m.getPet("penguin");
if (p instanceof Penguin){
    Penguin penguin = (Penguin)p;
    penguin.swim();
}