方法的重写与多态

1、方法的重写和方法重载的区别

方法重写：

两个类有继承关系；

父类和子类方法名相同，参数列表相同，参数定义入口，返回值定义出口

返回值类型要保持一致（子类的返回值类型和父类的一致）

访问修饰符不能严于父类

方法重载

必须在同一个类中

方法名相同；

参数列表不同（参数个数，类型，顺序不同）

与访问修饰符和返回值无关

2、多态

多态 是指同一种方法具有不同的表现形式

子类引用父类类型，

父类有子类的多种形态，建立于方法重写的基础上

3、类型转换

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

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

向下转型： <子类型><引用变量名>=(<子类型>)<弗雷西的引用变量>;

将一个指向子类对象的父类引用赋给一个子类的引用

即：父类类型转换为子类类型，需要强制类型转换

4、比如有宠物、猫、狗和企鹅等，宠物就可以看成另外三种动物的父类

public class Pets {
    private String name;    //私有的(不能为马化腾)
    private int health;
    private int love; //范围0-100.默认值是20

    public void setName(String name) {
        if (name == "马化腾") {
            System.out.println("输入的值错误");
        }
        this.name = name;
    }

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

    // 公共的访问接口
    public void setHealth(int health) { //setter 入口
        if (health < 0 || health > 100) {
            System.out.println("健康值的范围为0-100，默认值60");
            health = 60;
        }
        this.health = health;
    }

    public int getHealth() {  //getter 标记出口
        return this.health;
    }

    public void setLove(int love) {
        if (love < 0 || love > 100) {
            System.out.println("亲密值是0-100，默认值是20");
            love = 20;
        }
        this.love = love;
    }

    public int getLove() {
        return this.love;
    }

    void print() {
        System.out.println("宠物的自白：");
        System.out.print("我叫" + name + "，我的健康值：" +
                health + "，亲密度" + love);
    }
    void show(){}

//    public Pets() {
//        System.out.println("父类无参");
//    }

}

public class Dog extends Pets{

    private String strain;  //没有封装逻辑

    public void setStrain(String strain){
       this.strain=strain;
    }
    public String getStrain(){
        return this.strain;
    }

    public Dog(){}  //快捷方式 alt+Fn+insert-->
               // constructor（右键 Generate ）

    public Dog(String name, int health, int love, String strain) {
//        this.name = name;
//        this.health = health;
//        this.love = love;
//        this.strain = strain;
        setName(name);     //用set上锁，
        setHealth(health);
        setLove(love);
        setStrain(strain);
    }
//    private void say(){
//        System.out.println("汪汪汪");
//    }
//    public void getSay(){
//        say();
//    }
    void  print(){
     //  print();  //递归调用，必须有条件的退出，否则会栈溢出
        super.print();  //super代表父类对象
        System.out.println(",品种是："+strain);
    }
//    Pets aaa(){
//        return new Pets();
//    }
    void show(){
        super.show();
        System.out.println("狗正在接飞盘");
    }
}

public class Penguins extends Pets{
    private String gender;
    public void setGender(String gender) {
        if(gender=="Q仔") {
            System.out.println("Q仔");
        }
        else if(gender=="Q妹"){
            System.out.println("Q妹");}
        else {
            System.out.println("性别错误，默认是Q妹");
            gender="Q妹";
        }
        this.gender = gender;
    }
    public String getGender() {

        return gender;
    }


    void  print() {
         super.print();
        System.out.println("我的性别是"+gender);
    }
    void show(){
        super.show();
        System.out.println("企鹅可以在南极游泳");
    }
}

public class Cat extends Pets {
    public Cat() {
        System.out.println("子类无参");
    }
    public Cat(int a) {
        System.out.println("子类有参");
    }

    public static void main(String[] args) {
        Cat c=new Cat();
    }
}

public class TestDag {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.setName("欧欧");
        d.setHealth(100);
        d.setLove(0);
        d.setStrain("雪娜猎犬");
        d.print();
//      System.out.println(d.getHealth());
//      Cat c=new Cat();
//        c.setName("楠楠");
//        c.setHealth(100);
//        c.setLove(0);
//      c.print();
      Penguins p=new Penguins();
      p.setName("喃喃");
      p.setHealth(100);
      p.setLove(0);
      p.setGender("Q");
      p.print();
      p.show();
    }
}

狗狗和企鹅，在引用父类的属性和方法的同时，还有自己特有的方法属性，这就是方法重现

5、 多态就是可以在重写的基础上实现的。

比如狗狗，企鹅，他们都有一样的方法，去医院，可以在父类再写一个方法，类型是宠物。效果是什么宠物进来了，就让它实现这个方法

public class Marster {
    void  cure(Pet p){
        p.toHospital();
    }

    public static void main(String[] args) {
        Marster m = new Marster();
        Dog d = new Dog();
        m.cure(d);
        Cat c = new Cat();
        m.cure(c);
        Pet p = new Dog();  //子类对象引用父亲类型
        if (p instanceof Dog) {  //判断对象是否是某类型
            Dog dog = (Dog) p;  //强制类型转换
            dog.stain="小土狗";
            System.out.println(dog.stain);
        }
        if(p instanceof Cat){
        Cat cat=(Cat) p;
    }
          Object o=p;
        if(o instanceof  Pet) {
            System.out.println("是");
        }
        Penguins p1=new Penguins();
        m.cure(p1);
        if(p1 instanceof Penguins){
            System.out.println("是的");
        }
    }
}