方法重写与多态

方法重写与多态

方法重写

方法的重写：子父类出现了一模一样的方法
注意:返回值类型可以是子父类

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

在继承的情况下，子类的方法满足以下条件：
1、方法名相同
2、参数列表相同
3、返回值类型相同，或者是父类返回值类型的子类
4、访问修饰符的权限不能小于父类
5、抛出的异常不能大于父类（严于）

区别：
练习：使用方法重写优化电子宠物系统，实现如下效果

public abstract class Pet {
    private String name;
    private int health;
    private int love=60;
    
    public Pet() {
    }
    
    public Pet(String name, int health, int love) {
        this.name = name;
        this.health = health;
        this.love = love;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getHealth() {
        return health;
    }
    
    public void setHealth(int health) {
    	if (health<0 || health>100) {
            System.out.println("健康值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health = 60;
        }
        this.health = health;
    }
    
    public int getLove() {
        return love;
    }
    
    public void setLove(int love) {
    	if (love<0 || love>100){
            System.out.println("亲密度的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love=60;
        }
        this.love = love;
    }
    
    public void show(){
        System.out.println("宠物的自白");
        System.out.println("我叫："+name+"健康值："+health+"亲密度："+love);

public class Dog extends Pet {
    private String strain;
    public Dog() {
    }
    public Dog(String name, int health, int love) {
        super(name, health, love);
    }
    public String getStrain(){
        return strain;
    }
    public void setStrain(String strain){
        this.strain=strain;
    }

public class TestDog {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.setName("阿黄");
        d.setHealth(60);
        d.setLove(60);
        d.setStrain("金毛");
        d.show();

重写equals：

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

多态

多态是同一个引用类型，使用不同的实例而执行不同操作，即同一种事物，由于条件不同，产生的结果也不同

使用多态的条件：频繁修改代码，代码可扩展性、可维护性差，这种情况下，可使用多态优化

示例：

public class Dog extends Pet {
public void toHospital(){
        if (getHealth()<50){
            setHealth(70);
            System.out.println("给狗治病，打针、吃药");
        }
    }
}
public class Penguin extends Pet {
    public void toHospital(){
        if (getHealth()<50){
            setHealth(70);
            System.out.println("给企鹅治病，吃鱼、疗养");
        }
    }
}

抽象类abstract

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

抽象类字符修饰
例如：

public abstract class Pet {
	public abstract void toHospital();
}

向上转型:父类的引用指向子类对象，自动进行类型转换
<父类型> <引用变量名> = new <子类型>();
如：Pet pet=new Dog();

向下转型:将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型
<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
如：Dog dog=(Dog)pet;

instanceof运算符

if(pet instanceof Dog){
	Dog dog = (Dog)pet;
    dog.playDish();

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