【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);}@Overridepublic void eat(){System.out.println(name+"吃鱼~~~");}}//Dog类public class Dog extends Animal {public Dog(String name, int age){super(name, age);}@Overridepublic 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);}@Overridepublic void eat(){System.out.println(name+"吃鱼~~~");//方法重写}}

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

2.4向上转型和向下转型

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

//父类class B {public B() {// do nothingfunc();}public void func() {System.out.println("B.func()");}}
//子类 class D extends B {private int num = 1;@Overridepublic 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实际指向的是狗// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastExceptioncat = (Cat)animal;cat.mew();// animal本来指向的就是狗，因此将animal还原为狗也是安全的   dog = (Dog)animal;//向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceofif(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，此时代表这个方法不可以进行实现。此时被称为抽象方法。
如果一个类当中包含抽象方法，此时这个类必须是抽象类。
抽象类中当中定义的成员和普通类没有区别。
抽象类不可以被实例化，存在的意义就是为了被继承。
当一个普通类继承了抽象类以后，必须重写抽象方法，如果不想重写，可以把这个类也改为抽象类。