【Java初阶（六）下】封装 继承 多态

❣博主主页: 33的博客❣
▶文章专栏分类: Java从入门到精通◀
🚚我的代码仓库: 33的代码仓库🚚

1.前言

在上一篇文章中，我们已经了解了面向对象程序三大特性中其中的两项，封装、继承。这篇文章我们将继续学习多态的相关知识。

本章重点

掌握多态的概念，多态实行的条件，重写，向上转型，向下转型，抽象类。

---

2.多态

2.1多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。总的来说就是同一件事，发生在不同对象身上，就会产生不同的及如果。

---

2.2多态实现条件

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

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

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

//Animal类
public class Animal {
 String name;
 int age;
 public Animal(String name, int age){
 this.name = name;
 this.age = age;
 }
 public void eat(){
 System.out.println(name + "吃饭");
 }
 }
 //Cat类
 public class Cat extends Animal{
 public Cat(String name, int age){
 super(name, age);
 }
 @Override
 public void eat(){
 System.out.println(name+"吃鱼~~~");
 }
 }
  //Dog类
 public class Dog extends Animal {
 public Dog(String name, int age){
 super(name, age);
 }
 @Override
 public void eat(){
 System.out.println(name+"吃骨头~~~");
 }
 }
 //Test类
public class TestAnimal {
	public static void eat(Animal a){
	a.eat();
	}
 	public static void main(String[] args) {
 	Cat cat = new Cat("元宝",2);
 	Dog dog = new Dog("小七", 1);
 	eat(cat);//虽然都调用eat方法，但当传入不同的a值时，会表现出不同的形态
 	eat(dog);
 }
 }

---

2.3重写

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

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
  -父类被static、private修饰的方法、构造方法都不能被重写。重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验。

【重写和重载的区别】

重写：

public class Animal {
 String name;
 int age;
 public Animal(String name, int age){
 this.name = name;
 this.age = age;
 }
 public void eat(){
 System.out.println(name + "吃饭");
 }
 }
 //Cat类
 public class Cat extends Animal{
 public Cat(String name, int age){
 super(name, age);
 }
 @Override
 public void eat(){
 System.out.println(name+"吃鱼~~~");//方法重写
 }
 }

---

2.3.1避免在构造方法中调用重写的方法

2.4向上转型和向下转型

接下来，我们来看一段代码，B是父类，D是子类，D重写func方法

//父类
 class B {
    public B() {
        // do nothing
        func();
    }
 
    public void func() {
        System.out.println("B.func()");
    }
 }
//子类 
 class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
 }
 
public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
 }

输出结果为：
D.func() 0
为什么会是这样的结果呢？

---

2.4.1向上转型

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

Cat cat =new Cat("元宝",1);
Animal animal=cat;
//也可以如下：
Animal animal=new Cat("元宝",1);
animal.eat();

animal是父类类型，但可以引用一个子类对象。
动态绑定：
我们发现当调用animal.eat()方法，编译的时候确实是Animal的eat方法，但是运行的时候是调用的cat的方法，此时我们就称之为动态绑定

---

2.4.2向下转型

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

 public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
     	animal.bark();//编译时编译器将animal当成Animal对象处理而Animal类中没有bark方法，因此编译失败 
     	// 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.mew();
        // animal本来指向的就是狗，因此将animal还原为狗也是安全的   
        dog = (Dog)animal;
        //向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof
           if(animal instanceof Cat){
            cat = (Cat)animal;
            cat.mew();
    		}
        if(animal instanceof Dog){
            dog = (Dog)animal;
            dog.bark();
        }
    }
 }

---

3.抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

当子类继承父类的时候，重写了bark（）狗汪汪叫，猫喵喵叫，在Animai类有bark方法，不具体实现动物的叫法，这时Animal中的bark方法就可以设计为一个“抽象抽象方法”那么Animal就是一个抽象类。

---

3.1抽象类语法

在Java中，一个类如果被abstract 修饰称为抽象类，抽象类中被abstract修饰的方法为抽象方法，抽象方法不要给出具体的实现体。

// 抽象类：被abstract修饰的类
public abstract class Shape {
	// 抽象类也是类，也可以增加普通方法和属性
	public double area;
	public double getArea(){
 	return area;
 	}
   // 抽象方法：被abstract修饰的方法，没有方法体
   abstract public void draw();
   abstract void calcArea();
 } 

说明

• 一个方法可以被修饰为abstract，此时代表这个方法不可以进行实现。此时被称为抽象方法。
• 如果一个类当中包含抽象方法，此时这个类必须是抽象类。
• 抽象类中当中定义的成员和普通类没有区别。
• 抽象类不可以被实例化，存在的意义就是为了被继承。
• 当一个普通类继承了抽象类以后，必须重写抽象方法，如果不想重写，可以把这个类也改为抽象类。

---

4.总结

这篇文章我们已经掌握多态的概念，多态实行的条件，重写，向上转型，向下转型，抽象类。结合前面的知识已经学习了面向对象程序三大特性中其中的两项，封装、继承，感兴趣的同学可以通过其他博主的文章继续深入学习。

---

下期预告：接口