【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.总结

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


下期预告:接口

评论 21
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值