❣博主主页: 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.总结
这篇文章我们已经掌握多态的概念,多态实行的条件,重写,向上转型,向下转型,抽象类。结合前面的知识已经学习了面向对象程序三大特性中其中的两项,封装、继承,感兴趣的同学可以通过其他博主的文章继续深入学习。
下期预告:接口