方法重写和多态

重写

什么是方法重写

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

方法重写的规则

方法名相同
参数列表相同

//父类
public String show(){
        return "我叫"+name+",我的健康值是："+health+",我和主人的亲密度是:"+love;
    }
//子类
public String show(){
        String s=super.show();
        return s+",品种为："+strain;
    }

返回值类型相同或者是其子类–父类返回值类型是Pet 子类重写方法返回值类型Dog,返回值类型是父类返回值类型的子类

public Pet getPet(){
        return new Pet();
    }

public Dog getPet(){
return new Dog();
}

访问权限不能严于父类–如果父类方法访问修饰符是默认，那么子类重写方法访问修饰符是private 会提示编译报错
父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法,静态方法是属于类的

//父类Pet
public static void test(){
    System.out.println("这是父类静态方法")
}
//子类
public static void test(){//可以定义与父类相同的静态方法
	Pet.test();
	super.test();//编译报错
    System.out.println("这是子类静态方法")
}

子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
父类的私有方法不能被子类覆盖
不能抛出比父类方法更多的异常

这里的方法重载位置在同类，有其他情况

//父类
public Pet getPet(){
	return new Pet();
}
//子类
public Pet getPet(String a){//当父类方法被继承时，可以看做是子类的方法所以这种情况也可以认为是重载
	return null;
}

Object

Object类是所有类的直接或间接父类

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

toString//已经被jdk重写过

全类名+@+16进制数
重写toString

public String toString(){
        return this.getName();
    }

hashCode

getClass

equals
Object类的equals()方法
比较两个对象是否是同一个对象，是则返回true
操作符==
简单数据类型，直接比较值。如1==2
引用类型，比较两者是否为同一对象

默认情况下，equals()的作用和==是一样的，都是比较两个对象是否是同一对象

重写equals

告诉计算机一个新的比较规则，品种和姓名相同就是同一个对象

public boolean equals(Dog d){
        if (null==d || null==this.strain ||null==this.getName()) return false;
        //自定义比较规则 品种相同 姓名相同
        return this.strain.equals(d.strain)
                && this.getName().equals(d.getName());
    }

Java.lang.String重写了equals()方法，equals()方法的判断变为了判断其值

        String a="abc";
        String b="abc";
        String c=new String("abc");//分配地址
        String d=new String("abc");
        System.out.println(a == b);//常量池 比值
        System.out.println(b == c);
        System.out.println(c == d);
        System.out.println(a.equals(c));

多态

多态：同一个引用类型，使用不同的实例而执行不同操作 （子类对象引用父类类型）

多态的使用-父类类型作为参数
带宠物去看病

public class Master {
    public void cure(Pet pet){
        pet.toHospital();
    }
}
public void toHospital(){//重写toHospital方法
        if (getHealth()<30){
            setHealth(80);
            System.out.println("狗狗去医院打针吃药");
        }else {
            System.out.println("狗狗不需要去医院");
        }
    }
Pet p=new Dog("阿黄",16,30,"中华田园犬");
        Master m = new Master();
        m.cure(p);

向上转型
Pet p=new Dog(“阿黄”,16,30,“中华田园犬”);//父类的引用指向子类的对象
<父类型> <引用变量名> = new <子类型>();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
此时通过父类引用变量无法调用子类特有的方法

向下转型–父类类型强制转换成子类类型
或将一个指向子类对象的父类引用赋给子类的引用
比如dog有特有的方法-追飞盘
Pet p=new Dog(“阿黄”,16,30,“中华田园犬”);
Dog d=(Dog)p;
d.catchFlyDisc();

多态使用-父类类型作为返回值类型
主人赠送宠物，但是不知道a需要什么宠物，意思是a要告诉主人需要什么宠物，主人返回一个宠物给a

public Pet give(String type){
        if ("狗".equals(type)){
            return new Dog();
        }else if ("企鹅".equals(type)){
            return new Penguin();
        }else {
            return new Cat();
        }
    }

        Master m = new Master();
        Pet p=m.give("狗");//a告诉主人需要一只狗
        p.show();

抽象类
我们看到Pet里面的toHospital()方法不需要有具体的实现
将Pet里面的toHospital()方法声明为抽象方法
Pet类声明为抽象类
实例化Pet毫无意义

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

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

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

Pet p = new Dog();
System.out.println(p instanceof Dog);