[Java知识库]JAVA中多态以及向上转型向下转型、重写的讲解

重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 注意！！！返回值和形参都不能改变。

重写的好处在于子类可以根据需要，定义特定 于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写的用法：

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println("动物正在吃饭");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println(name+"正在吃猫粮");
    }
}

public class chongxie {
    public static void main(String[] args) {
        Animal cat = new Cat("猫",2);
        cat.eat();
    }
}

最终输出：

?如上：cat可以使用专属于其类型的方法，从而打印出其相对应的“吃猫粮”。

多态

多态定义

多态实现条件：

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3.通过父类的引用调用重写的方法

多态的使用场景（个人理解）：在有多个类型之后，若有一个方法在很多个子类中被重写，而我们在创建一个子类变量的时候，若一时间不记得此变量具体为什么类型的时候，就可以利用多态，直接输出该变量的重写方法。

多态的使用

package practice3.chongxie;
class Animal1{
    String name;
    int age;

    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
}

class Dog extends Animal1{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃狗粮");
    }
}

class Cat1 extends Animal1{
    public Cat1(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃猫粮");
    }
}
public class duotai {
    public static void eat(Animal1 animal){//记得写static！！！！！！！！！！
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("修勾",2);
        Cat1 cat = new Cat1("修猫",1);
        eat(dog);
        eat(cat);
    }
}

最终输出结果：

向上转型

向上转型：创建一个子类对象，将其当成父类对象来使用。?

向上转型的格式：：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("猫",2);//向上转型

向上转型的使用场景：

1.函数传参

如之前多态里的代码一样，在我们未确定我们创建的类型是什么的时候，要使用一个方法，可以先写一个函数，其形参可以设为一个父类类型，然后我们将子类传参进去，此时是不会报错的，这样子可以让我们写的代码思路更加清晰且可读性更强。

（之前多态的例子）：

package practice3.chongxie;
class Animal1{
    String name;
    int age;

    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
}

class Dog extends Animal1{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃狗粮");
    }
}

class Cat1 extends Animal1{
    public Cat1(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃猫粮");
    }
}
public class duotai {
    public static void eat(Animal1 animal){//记得写static！！！！！！！！！！
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("修勾",2);
        Cat1 cat = new Cat1("修猫",1);
        eat(dog);
        eat(cat);
    }
}

2.方法返回

场景模拟：有两个选择，买修猫或者买修勾，我们能通过输入 “狗”/“猫” 来选择我们想买的动物，那么就要创建一个变量，来装下修勾类或者修猫类，那么在我们定义变量的时候，是使用Dog类函数Cat类来定义嘞？这时候我们就可以定义一个函数，先判定要买的是猫还是狗狗，然后用Animal这个父类创建变量来接收。

package practice3.chongxie;
class Animal1{
    String name;
    int age;

    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
}

class Dog extends Animal1{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃狗粮");
    }
}

class Cat1 extends Animal1{
    public Cat1(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name+"正在吃猫粮");
    }
}
public class duotai {
    public static void eat(Animal1 animal){
        animal.eat();
    }

    public static Animal1 buyAnimal(String animal){//此时函数的返回值为父类，就所有其子类都可以返回
        if(animal=="猫"){
            return new Cat1("修猫咪",2);
        }else if(animal=="狗"){
            return new Dog("修勾勾",2);
        }else {
            return null;
        }
    }
    public static void main(String[] args) {
        Animal1 ani1 = buyAnimal("狗");
        ani1.eat();
        Animal1 ani2 = buyAnimal("猫");
        ani2.eat();
    }
}

最终输出：

向上转型缺点：

我们在将子类装到父类变量中时，由于其类型还是父类，使用子类若没有重写的方法，那么子类的方法我们是无法使用的，若要使用，我们则需要向下转型。

向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换。

向下转型使用方法：强制类型转换。

但向下转型有风险：当我们强制转为其子类的时候，若转错子类类型，那么此时就会报错，这时我们就需要先了解一个关键字：instanceof?

instanceof

instanceof的使用：（变量名） instanceof? （子类类名），若前面的变量为其子类类型，那么会返回true，反之则返回false。若我们用这个关键字先来判定为哪种类型，那么就能保证其安全性，不会报错。

向下转型的使用

package practice4.XiangXiaZhuanXing;
class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("test正在吃饭");
    }
}

class Bird extends Animal{
    public Bird(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+"吃鸟粮");
    }
    public void said(){
        System.out.println("我是鸟");
    }
}

public class practice4 {
    public static void main(String[] args) {
        Animal animal = new Bird("鸟",2);
        animal.eat();
        //这上面能都用到鸟的方法，针对鸟而不是针对动物这个大类，是因为重写了方法，所以输入向上转型，不能使用鸟中的方法，但是
        //此时eat算是animal的方法，因为animal中爷又这个方法，但是由于被重写，使用此时针对鸟，但如果我们将没有重写的方法调
        //出来，即把只在鸟这个类中的方法使用，此时还是会报错，如下：

        //animal.said();//此时报错，因为animal中没有这个方法

        //以及向上转型了，那么要怎么样向下转型呢？
        if(animal instanceof Bird){
            Bird bird = (Bird)animal;
            bird.said();
        }
    }
}

又是收获满满的一天~?