小白的第二篇文章--多态

多态

1.Java中的多态

Java有三大提醒：封装、继承、多态
多态：多种形态。是面向对象的三大特性之一。多态是建立在封装和继承之上

1.1 方法的多态

方法的重写和重载就是方法的多态和体现形式
就比如： 一个宠物狗类以及一个宠物猫类都继承与一个宠物类，两者都进行同样的吃东西行为，但是不同对象吃的东西不同，同一个对象进行同一个行为吃东西，但是吃的东西不同，这就是我理解的方法的多态

package com.wyedu.test1;
class Pet {
    public void eat () {
        System.out.println("宠物吃东西");
    }
}

class Dog extends  Pet {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }

    public void eat(String food){
        System.out.println("狗吃" + food);
    }
}

class Cat extends  Pet {
    @Override
    public void eat() {
        System.out.println("猫吃猫粮");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        dog.eat();
        cat.eat();
        dog.eat("骨头");
        dog.eat("吃粑粑");
    }
}

以上代码可以看到方法的重写，狗类猫类分别重写了宠物父类的吃方法，狗跟猫是不同对象，都进行吃东西操作，那么狗是吃狗粮，猫是吃猫粮，方法的重载，是同一个对象进行一样的操作，但是吃的东西不一样，所以说方法的重写和方法的重载也是多态的一种体现。

1.2对象的多态

真正的多态是将一个对象引用作为一个参数传入或者是作为一个返回值返回来体现。
实现多态我们需要将用到多态的向上转型
多态：父类引用指向子类的对象
例如：Pet dog = new Dog();

package com.wyedu.test2;
class Pet {
    public void eat (){
        System.out.println("动物吃饭");
    }

    public void play(){
        System.out.println("动物玩耍");
    }
}
class Dog extends  Pet {
    @Override
    public void eat() {
        System.out.println("狗狗吃狗粮");
    }

    @Override
    public void play() {
        System.out.println("狗狗玩飞盘");
    }
}

class Cat extends  Pet {
    @Override
    public void eat() {
        System.out.println("喵喵吃猫粮");
    }

    @Override
    public void play() {
        System.out.println("喵喵玩毛线球");
    }
}


public class Test {
    public static void main(String[] args) {
        Pet dog = new Dog();
        dog.eat();
        dog.play();
        Pet cat = new Cat();
        cat.eat();
        cat.play();
    }
}

以上代码是一个普通的多态的向上转型的体现，多态向上转型，对象加点只能调用子类重写父类的方法，以及父类的普通方法，不能调用子类独有的方法，如果想调用子类独有的方法必须进行向下转型
注意事项：
多态：
1、必须有继承
2、必须有重写
3、=左边是父类引用 =右边是子类的对象

1.3 父类的引用指向子类的对象具体如何使用

package com.wyedu.test3;
class Person {
    public void feed (Pet pet) {
        pet.eat();
    }
}

interface Pet {
    void eat();
}

class Dog implements  Pet {

    @Override
    public void eat() {
        System.out.println("狗狗在吃骨头");
    }
}

class Cat implements  Pet {

    @Override
    public void eat() {
        System.out.println("喵喵在吃小鱼");
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Pet dog = new Dog();
        person.feed(dog);

        Pet cat = new Cat();
        person.feed(cat);
    }
}

1.4多态向下转型

语法格式：
先向上再向下
父类类型 父类引用 = new 子类();
子类类型 子类引用 = (子类类型)父类的引用
向下转型可以调用子类独有的方法
向下转型需要强转

package com.wyedu.test4;

class Pet {
    public void eat(){
        System.out.println("宠物吃东西");
    }
}

class Dog extends  Pet {
    @Override
    public void eat() {
        System.out.println("狗狗吃狗粮");
    }
    public void play() {
        System.out.println("狗狗玩飞盘");
    }
}
public class Test {
    public static void main(String[] args) {
        Pet pet = new Dog();
        Dog dog = (Dog)pet;
        dog.eat();

    }

}

1.4instanceof关键字

比较操作符，返回值是布尔类型
语法格式：
对象引用 instanceof 运行类型
永安里判断对象额运行类型（=等号右边），是否是XX类型或者是XX类型的子类
目的是为了在强转的时候不出现问题

package com.wyedu.test5;
class A{}
class B extends A {}
public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        B b1 = new B();
        System.out.println(a instanceof  A);
        System.out.println(a instanceof  B);
        System.out.println(b instanceof  A);
        System.out.println(b1 instanceof  A);
    }
}

最后

这是一个小白写的第二篇博客，如有错误请大家多多见谅及指出，谢谢观看！
2022.7.28 一个Java小白