Java三大特性之多态

多态

概述

 多态是继封装性,继承性之后,面向对象的第三大特性。

定义

 多态:是指同一行为,具有不同的表现形式。

前提
1.继承或者实现【二选其一】
2.父类的引用指向子类的对象【格式体现】
3.方法的重写【意义:不重写,是无意义的】

多态的表现

 多态表现的格式:

父类类型 变量名 =new 子类对象;
变量名.方法名();

备注:父类类型指的是子类对象继承的父类类型,或则实现的父类接口类型

如果在使用多态方式调用方法时,首先检查父类方法中是否有该方法,如果没有,则编

译报错,如果有,执行的是子类重写后的方法。

多态的好处

  在实际开发中,父类类型作为方法的形式参数,传递子类对象(实参)给方法,进行方法的调用,更能体现出多态的扩展性和便利性。代码如下:

// 定义抽象的父类
public abstract class Animal{
    // 定义一个抽象的方法
    public abstract void eat();
    public void run(){
        System.out.println("用脚跑。。。");
    }
}
// 定义子类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}
public class Bird extends Animal {
    @Override
    public void eat(){
        System.out.println("鸟吃虫");
    }
}

// 定义测试类
public class TestDemo03 {
    
    public static void main(String[] args) {
        // 根据不同的对象,来表现不同的吃的内容
        Cat c = new Cat();
        showCatEat(c);// 猫吃鱼
        
        Dog dog = new Dog();
        showDogEat(dog);// 狗啃骨头
        
        Bird bird = new Bird();
        bird.eat();// 鸟吃虫子。。
        
        Cat c2 = new Cat();
        showAnimalEat(c2);
        
        // 
        Dog dog2 = new Dog();
        showAnimalEat(dog2);
        
    }
	
   /* public static void showCatEat(Cat cat) {
        cat.eat();// 猫吃鱼
    }
    public static void showDogEat(Dog dog) {
        dog.eat();
    }
    public static void showBirdEat(Bird bird) {
        bird.eat();
    }*/
    
    /*
       以上三个方法可以用来多态进行优化,可以被showAnimalEat方法所替代
    */
    public static void showAnimalEat(Animal animal) {
        animal.eat();
        animal.run();
    }  
}

说明:用于多态特性的支持,showAnimalEat方法当中的Animal类型,是Cat和Dog的父类类型,父类类型接收子类对象,当然可以把cat对象和dog对象传递给方法。

当程序执行过程中。执行eat方法实际执行的是各自子类对象重写之后的eat方法

不仅仅可以做到替代,在扩展性方面,无论之后出现多个子类,都不需要编写showXxxEat方法了,直接使用showAnimalEat()方法了。

所以,多态的好处,体现在可以使程序编写更简单,并且具有良好的扩展性。

访问类成员变量的两种方式
  1. 直接通过对象名访问成员变量:看等号左边是谁,优先用谁,没有继续往上找

  2. 间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则继续往上找。

// 定义一个父类
public class Fu {
    int num = 10;
    // 定义成员方法
    public void showNum() {
        System.out.println(num);
    }
}
// 定义子类
public class Zi extends Fu {
    int num = 20;  
    @Override
    public void showNum(){
        System.out.println(super.num);
    }
}
// 定义测试类
public class TestPolyFieldDemo01 {
    public static void main(String[] args) {
        // 多态的表示形式
        // 父类类型 变量名 = new 子类对象;
        // 变量名.成员变量名
        Fu fu = new Zi();
        System.out.println(fu.num);// 10  
        fu.showNum();// 20
        Zi zi = new Zi();
    }   
}

引用数据类型的转型

 多态的转型分为向上转型和向下转型两种:

向上转型
 向上转型:多态本身就是子类类型向父类类型向上转型的过程,这个过程默认的

【当一个父类引用指向了一个子类对象时,便是向上转型】

使用格式

父类类型  变量名 = new 子类类型();
比如: Animal animal = new Cat();

向下转型(可以调用子类特有的方法)

 向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。

一个已经向上转型的子类对象,将父类的引用转为子类引用,可以使用强制类型转换的格式,便是向下转型。

使用格式

子类类型 变量名 =(子类类型) 父类变量名;
比如:  Cat cat = (Cat) animal;

转型的异常

  在进行向下转换的过程中,一不小心就出现java.lang.ClassCastException类型转换异常。

  为了避免这种类型转换异常的发生,Java提供了instanceof关键字,给引用变量做类型的校验。

格式如下:

变量名  instanceof  数据类型
如果变量属于该数据类型,则返回true
如果变量不属于该数据类型,则返回false

所以,我们在转换前,我们最好先进行引用变量的类型判断,代码如下:

public class Test {
    
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Cat();
        // 向下转型
        if (animal instanceof Cat) {
            // 表明你就是一只猫
            Cat cat = (Cat) animal;
            cat.eat();// 吃鱼
            cat.catchMouse();// 逮老鼠
        } else if (animal instanceof Dog) {
            // 表明你就是一只狗
            Dog dog = (Dog) animal;
            dog.lookDoor();
        }
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,关于Java实验三继承和多,我可以为您提供一些基本的知识点和例子。 在Java中,继承是一种重要的面向对象编程概念,它允许一个类(称为子类或派生类)继承另一个类(称为父类或基类)的属性和方法。子类可以使用父类中的属性和方法,也可以添加自己的属性和方法。多是指同一种类型的对象,在不同的情况下会表现出不同的行为。在Java中,多可以通过方法重载和方法重写来实现。 下面是一个简单的例子,演示了如何使用继承和多: ``` // 定义一个动物类 class Animal { public void makeSound() { System.out.println("动物发出声音"); } } // 定义一个狗类,继承自动物类 class Dog extends Animal { @Override public void makeSound() { System.out.println("狗发出汪汪声"); } } // 定义一个猫类,继承自动物类 class Cat extends Animal { @Override public void makeSound() { System.out.println("猫发出喵喵声"); } } // 测试多 public class Test { public static void main(String[] args) { Animal animal1 = new Dog(); Animal animal2 = new Cat(); animal1.makeSound(); // 输出:狗发出汪汪声 animal2.makeSound(); // 输出:猫发出喵喵声 } } ``` 在上面的例子中,我们定义了一个Animal类,它有一个makeSound()方法。然后我们定义了一个Dog类和一个Cat类,它们都继承自Animal类,并重写了makeSound()方法。最后,在测试类中,我们创建了一个Animal类型的变量animal1和animal2,分别指向Dog对象和Cat对象。由于多特性,animal1和animal2都可以调用makeSound()方法,但是它们实际上调用的是Dog类和Cat类中重写的makeSound()方法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值