JAVA系列 小白入门参考资料 多态

提示：这节多态，与继承有一定的关系。对继承不是很熟悉的同学，可以看我前一篇文章

JAVA系列 小白入门参考资料 继承

目录

1.多态的概念

2.向上转型和向下转型

 2.1 向上转型

 2.2 向下转型

3.方法重写

4.多态实现条件 

---

1.多态的概念

多态的概念：通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状 态。

ps：这张图看起来很熟悉，没错，这张图的思路就是基于继承。 

多态举例子来说的话，就是动物会吃东西 ，但具体到小狗时就是小狗吃狗粮，小猫吃猫粮。因此多态简单来说，就是同一件事情，发生在不同对象身上，就会产生不同的结果。

多态实现涉及的知识点

1.方法重写

2.向上转型 

3.继承（上篇文章已经讲述过）

因此我们先学习 向上转型 和 方法重写 这样到最后，我们才能更好的理解多态和实现多态 

---

2.向上转型和向下转型

 2.1 向上转型

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

语法格式：父类类型 对象名 = new 子类类型 ()

例： Animals animals = new Cat();

下面我们看具体的代码

class Animals{
    String name;
    int age;

    public void eat(){
        System.out.println("在吃东西");
    }

}

class Cat extends Animals{

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

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

public class material {
    public static void main(String[] args) {
        Animals animals = new Dog(); // 向上转型  
        //父类引用              子类对象
    }
}

把一个子类对象赋值给父类引用，这意味着对象的范围变大了，因此向上转型指的是子类对象。

我们可以举一个例子，Animals animals = new Dog(); ，此语句可以用语言理解为我们把小狗归为动物类或者我们说小狗就是一种动物

向上转型的主语就是子类对象

而向上转型还有三种形式

1. 直接赋值

2. 方法传参

3. 方法返回值

public class material {
    
    //方法返回
    public static Animals test(){
        return new Dog();
    }
    
    
    //方法传参
    public static void func(Animals animals){
        
    }

}
    
    public static void main(String[] args) {
        //1.直接赋值
        Animals animals = new Dog(); // 向上转型
        //父类对象引用      子类对象
        
        //2.方法传参
//        public static void func(Animals animals){
//        }
        func(new Dog());
        
        //3.方法返回
//        public static Animals test(){
//            return new Dog();
//        }
        test();
       
}

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

根据向上转型的缺陷，我们就引出了向下转型。 

---

 2.2 向下转型

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

向下转型的主语是父类对象引用

Animals animals = new Animals(); // 正常创建父类对象
Dog dog = (Dog)animals;  // 将父类对象引用  向下转型

Animals animals = new Dog();// 向上转型  大范围 <-- 小范围
Dog dog = (Dog)animals;  // 向下转型   小范围 <-- 大范围

---

3.方法重写

重写 (override) ：也称为覆盖。重写是子类对父类非静态、非 private 修饰，非 final 修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变 。 即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。

简而言之，就是子类能够根据需要实现父类的方法。

方法重写的要求：

1. 方法名和父类相同

2. 方法的参数列表相同(个数，类型，顺序)

3. 返回值相同 

class Animals{
    String name;
    int age;

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

}

class Dog extends Animals{

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

public class test {
    public static void main(String[] args) {
        Animals animals = new Animals();
        animals.eat();

        Animals animals1 = new Dog();
        animals1.eat();
    }
}

像代码 Animals animals1 = new Dog();   animals1.eat();  最后却调用了子类的eat方法。这种行为我们称为动态绑定

动态绑定 ：也称为后期绑定 ( 晚绑定 ) ，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

方法重写注意事项：

1. 静态方法(static) 不能被重写

2. 被private修饰的方法 不能被重写

3. 被final修饰的方法 不能被重写

4. 如果方法被重写，那么子类的访问权限一定要 大于 等于 父类的访问权限

---

4.多态实现条件 

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下

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

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

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。   

class Animals{
    String name;
    int age;

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

}

class Dog extends Animals{

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

public class test {
    public static void main(String[] args) {
        Animals animals = new Animals();
        animals.eat();

        Animals animals1 = new Dog();
        animals1.eat();
    }
}