Java基础38 面向对象三大特征之多态

最新推荐文章于 2023-05-15 20:33:36 发布
最新推荐文章于 2023-05-15 20:33:36 发布
阅读量465 收藏
点赞数 1
分类专栏： JavaSE基础 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjiap/article/details/127850951
版权

OOP之多态


)

多态

● 多【多种】态【状态】

方法或对象具有多种形态。 是建立在封装和继承之上的面向对象的第三大特征。

1.多态的具体体现

  1. 方法的多态
    重写和重载体现多态

  2. 对象的多态（核心）
    （1）一个对象的编译类型和运行类型可以不一致。
    （2）编译类型在定义对象时，就确定了，不能改变。
    （3）运行类型是可以变化的。
    （4）编译类型看定义时 “=” 号 的左边，运行看 “=” 号的右边

例如：
Animal animal = new Dog();
【这里animal编译类型是Animal，运行类型是Dog】
animal = new Cat();
【animal的运行类型变成了Cat，编译类型仍然是Animal】

2.向上转型

○ 多态的前提是：两个对象（类）存在继承关系。

○ 多态的向上转型

  1. 本质：父类的引用指向了子类的对象

  2. 语法：父类类型 引用名 = new 子类类型();

  3. 特点：

    • 编译类型看左边，运行类型看右边。
    • 可以调用父类中的所有成员（需遵守访问权限），不能调用子类中特有成员；
    • 最终运行效果看子类的具体实现。

○ 向上转型调用方法的规则
（1）可以调用父类中的所有成员（需遵守访问权限）。
（2）但是不能调用子类的特有成员。
（3）因为在编译阶段，能调用哪些成员，是由编译类型来决定的，最终运行效果看子类（运行类型）的具体实现，即调用方法时，按照从子类（运行类型）开始查找方法，然后调用，规则与方法调用规则一致。

以下面例子为例说明向上转型的规则

Animal类

class Animal{
		String name = "动物";
		int age = 10;
		public void sleep(){
				System.out.println("睡");
		}
		public void run(){
				System.out.println("跑");
		}
		public void eat(){
				System.out.println("吃");
		}
		public void show(){
				System.out.println("表演");
		}	
}

Cat类，继承Animal类

class Cat extends Animal {
		public void eat(){ //重写父类的eat
				System.out.println("猫吃鱼");
		}
		public void catchMouse(){ //cat的特有方法
				System.out.println("猫抓老鼠");
		}
}

Test类

public class Test{
	public static void mian(String[] args){
		//向上转型:父类的引用指向子类的对象
		//语法:父类类型引用名 = new 子类类型();
		Aniaml animal = new Cat();
		// Object obj = new Cat(); 也是可以的,因为Object也是Cat的父类
		
		//调用父类中的所有成员(需遵守访问权限)
		//不能调用子类的特有成员
		//animal.catchMouse(); 是错误的,因为catchMouse是Cat中的特有方法
		animal.eat(); 
		animal.run(); 
		animal.show();
		animal.sleep();
		
		System.out.println("out~");
	}
}

3.向下转型

多态的向下转型

  1. 语法：子类类型 引用名 = （子类类型） 父类引用
  2. 只能强转父类的引用，不能强转父类的对象
  3. 要求父类的引用必须指向的是当前目标类型的对象
  4. 可以调用子类类型中所有的成员

向下转型的使用

以Aniaml类与cat类为例，新增一个dog类

Dog类

public class Dog extends Animal{
}

在Test类中测试

调用Cat的catchMouse方法
//使用多态的向下转型
//(1)语法 : 子类类型 引用名 = (子类类型) 父类引用;
Cat cat = (Cat) animal; //cat的编译类型是Cat,运行类型是Cat
cat.catchMouse();
//(2)父类的引用必须指向的是当前目标类型的对象
//Dog dog = (Dog)animal; //这句会报错,提示类异常

4.属性重写

属性没有重写之说，属性的值看编译类型。

public class Test{
	public static void main(String[] args){
		//属性没有重写之说,属性的值看编译类型
		Base base = new Sub(); //向上转型
		System.out.println(base.count); //编译类型为base,则输出10
		Sub sub = new Sub();
		System.out.println(base.count); //编译类型为sub,则输出20
		
	}
}

class Base { //父类
	int count = 10; //属性
}

class Sub extends Base { //子类
	int count = 20; //属性
}

5.instanceOf

nstanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型。

public class Test{
	public static void main(String[] args){
		BB bb = new BB();
		System.out.println(bb instanceof BB);//true
		System.out.println(bb instanceof AA);//true

		AA aa = new BB();
		System.out.println(aa instanceof AA); //true
		System.out.println(aa instanceof BB); //true

		Object obj = new Object();
		System.out.println(obj instanceof AA);//false
		System.out.println(AA instanceof obj);//true

		String str = "yes";
		System.out.println(str instanceof Object);//true
	}
}

6.动态绑定机制（核心）

Java重要特征：动态绑定机制

现在有两个类，A类与B类，其中B类是A类的子类，在main方法中创建对象： A a = new B();调用a.sum()与a.sum1()看看分别得到什么结果？

A类

class A{ //父类
	public int i =10;
	public int sum(){
		return getI() + 10;
	}
	public int sum1(){
		return i + 10;
	}
	public int getI(){
		return i;
	}
}

B类

class B extends A{ //子类
	public int i = 20;
	public int sum(){
		return i + 20;
	}
	public int getI(){
		return i;
	}
	public int sum1(){
		return i + 10;
	}
}

在main方法中 A a = new B(); //向上转型 System.out.println(a.sum()); //输出40
System.out.println(a.sum1()); //输出30

现在注释掉B类中的sum方法，那输出的结果又该如何？

B类

class B extends A{ //子类
	public int i = 20;
	//public int sum(){
	//	return i + 20;
	//}
	public int getI(){
		return i;
	}
	public int sum1(){
		return i + 10;
	}
}

在main中调用
System.out.println(a.sum());

因为B类中的sum被注释了，所以会自动向上找sum方法，而父类A中恰好有sum方法，所以调用了A类的sum方法，而A类的sun方法里返回的是getI()+10；而A与B类中都有getI方法，这里就涉及到了java的动态访问机制。

● Java的动态访问机制

  1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。
  2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。【属性没有动态绑定机制】

现在回过头去看刚才的问题，刚才调用的getI()方法，是属于对象的方法，所以该方法会和该对象的内存地址/运行类型绑定，我们创建的时候使用的运行类型是B类型，所以getI应该调用B类的getI方法：return
i；所以最后a.sum()输出的结果为：20+10 = 30。

那如果再把B类中的sum1()方法再注删掉呢？a.sum1()的结果是什么？

A类

class A{ //父类
	public int i =10;
	public int sum(){
		return getI() + 10;
	}
	public int sum1(){
		return i + 10;
	}
	public int getI(){
		return i;
	}
}

B类

class B extends A{ //子类
	public int i = 20;
	public int getI(){
		return i;
	}
}

由于B中并没有sum1方法，所以依然调用父类A的sum1方法，而sum1()中的 i + 10；i为属性，前面介绍过，java动态绑定机制是：当调用对象的属性时，，没有绑定动态机制，就是哪里声明，哪里使用，所以直接返回B类中的i，结果为：10 + 10 = 20

7.多态数组

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。

应用实例：

现有一个继承结构如下：要求创建1个Person对象、2个Student对象和2个Teacher对象，统一放在数组中，并调用say方法。

代码实现

Person类

public class Person { //父类
    private String name;
    private int age;

    public String say(){ //返回名字和年龄
        return name + "\t" + age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Student类

public class Student extends Person{

    private double score;

    //重写父类say
    public String say(){

        return "学生" + super.say() + "score =" + score;
    }

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }


    public double getScore() {

        return score;
    }

    public void setScore(double score) {

        this.score = score;
    }
}

Teacher类

public class Teacher extends Person{
    private double salary;

    //重写父类的say方法
    public String say(){

        return "老师 :" + super.say()+"salary = " + salary;
    }

    public Teacher(String name, int age, double salary) {
        super(name,age);
        this.salary = salary;
    }

    public double getSalary() {

        return salary;
    }

    public void setSalary(double salary) {

        this.salary = salary;
    }
}

Test类（主方法类）

创建多态数组并遍历调用say方法

public class test {
//    在main中,分别创建Person和Student对象,调用say方法输出自我介绍
    public static void main(String[] args) {

        //创建对象数组
        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("mary",18,100);
        persons[2] = new Student("smith",19,30.1);
        persons[3] = new Teacher("scott",30,20000);
        persons[4] = new Teacher("queen",29,25000);

        //循环遍历多态数组,调用say
        for(int i = 0; i < persons.length; i++){
            //这里person[i] 编译类型是Person,运行类型是根据实际情况由JVM来判断
            System.out.println(persons[i].say());//动态绑定机制
        }
    }
}

运行效果

在这里插入图片描述

现在升级需求：如何调用子类特有的方法，比如Teacher有一个teach，Student有一个study怎么调用？

含特有方法的Teacher

public class Teacher extends Person{
    private double salary;

    //重写父类的say方法
    public String say(){

        return "老师 :" + super.say()+"salary = " + salary;
    }

    //teacher特有方法
    public void teach(){
        System.out.println("老师:" +getName() + "正在授课");
    }

    public Teacher(String name, int age, double salary) {
        super(name,age);
        this.salary = salary;
    }

    public double getSalary() {

        return salary;
    }

    public void setSalary(double salary) {

        this.salary = salary;
    }
}

含特有方法的Student

public class Student extends Person{

    private double score;

    //重写父类say
    public String say(){

        return "学生" + super.say() + "score =" + score;
    }

    public void study(){
        System.out.println("学生:" + getName() + "正在上课");
    }

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }


    public double getScore() {

        return score;
    }

    public void setScore(double score) {

        this.score = score;
    }
}

Test类

通过向下转型与类型判断完成子类特有方法的调用。

public class test {
//    在main中,分别创建Person和Student对象,调用say方法输出自我介绍
    public static void main(String[] args) {

        //创建对象数组
        Person[] persons = new Person[5];
        persons[0] = new Person("jack",20);
        persons[1] = new Student("mary",18,100);
        persons[2] = new Student("smith",19,30.1);
        persons[3] = new Teacher("scott",30,20000);
        persons[4] = new Teacher("queen",29,25000);

        //循环遍历多态数组,调用say
        for(int i = 0; i < persons.length; i++){
            //这里person[i] 编译类型是Person,运行类型是根据实际情况由JVM来判断
            System.out.println(persons[i].say());//动态绑定机制
            //使用 类型判断 + 向下转型
            if(persons[i] instanceof Student){ //判断person[i] 的运行类型是不是Student
                Student student = (Student) persons[i];
                student.study();
                //熟悉后可以简化为一条语句:
                //((Student)persons[i]).study();
            } else if(persons[i] instanceof Teacher){
                Teacher teacher = (Teacher) persons[i];
                teacher.teach();
                //((Teacher)persons[i]).teach();
            } else if(persons[i] instanceof Person){

            } else{
                System.out.println("类型有误,请检查清楚!");
            }
        }
        }
    }

运行效果

在这里插入图片描述

8.多态参数

多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型。

应用案例

  • 定义员工类Employee，包含姓名和月工资【private】，以及计算年工资getAnnual的方法。普通员工和经理继承了员工。

  • 经理类多了奖金bonus属性和管理manage方法

  • 普通员工类多了work方法，普通员工和经理类要求分别重写getAnnual方法。

  • 测试类中添加一个方法showEmpAnnual(Employee e)，实现获取任何员工对象的年工资，并在main方法中调用该方法【e.getAnnual()】

  • 测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理，则调用manage方法。

代码实现

员工类Employee

public class Employee {
    private String name;
    private double salary;

    public double getAnnual(){
        return 12 * salary;
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

manage类

public class manger extends Employee{
    private double bonus;

    //获取年薪
    public double getAnnual(){
        return super.getAnnual() + bonus;
    }

    public void manage(){
        System.out.println("经理: "+ getName()+"is working");
    }

    public manger(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}

普通员工类（Ordinary_employees）

public class Ordinary_employees extends Employee{

    public void work(){
        System.out.println("普通员工 " +getName() +"is working");
    }

    public double getAnnual(){ //因为普通员工没有其他收入,则直接调用父类方法就可以
        return super.getAnnual();
    }

    public Ordinary_employees(String name,double salary){
        super(name,salary);
    }
}

test类

创建普通员工与经理的对象，添加两个新方法并输出需求。

public class test {
    //    在main中,分别创建Person和Student对象,调用say方法输出自我介绍
    public static void main(String[] args) {

        Ordinary_employees tom = new Ordinary_employees("tom",2500);
        manger milan = new manger("milan",5000,250000);
        test t = new test();
        t.showEmpAnnual(tom);
        t.showEmpAnnual(milan);
        t.testWork(tom);
        t.testWork(milan);
    }
    //添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资,并在main方法中调用该方法【e.getAnnual()】
    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());//动态绑定机制
    }
    //添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法。
    public void testWork(Employee e){
            if(e instanceof Ordinary_employees){
                ((Ordinary_employees)e).work();//向下转型
            }else if(e instanceof  manger){
                ((manger)e).manage(); //向下转型
            } else {

            }
    }

效果实现

在这里插入图片描述

chen.c.
关注
专栏目录
selenium-java-3.8.0
01-15
WebDriver jar包3.8.0版本，亲测可用，亲测可用，亲测可用
面向对象三大特征——多态
weixin_53616401的博客
03-27 291
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上。一讲到多态，肯定会有运行类型和编译类型，那么什么是编译类型什么是运行呢，有这么一句话=
Java简单的选择排序（38）
qq_63448189的博客
05-15 164
Java简单的选择排序
Java_38 递归
songteng2012的博客
04-23 225
Java_38 递归 //参考资料:https://blog.csdn.net/u011541946/article/details/73477616 //递归:就是自己调用了自己. /*构成递归需具备的条件： 1. 子问题须与原始问题为同样的事，且更为简单； 2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。 为了描述递归，我们这里演示计算阶乘的值。当阶乘中N=1或者N=0...
java 38_Java38. 外观数列
weixin_34970098的博客
02-24 153
外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下：1. 12. 113. 214. 12115. 1112211被读作"one 1"("一个一") , 即11。11 被读作"two 1s"("两个一"), 即21。21 被读作"one 2", "one 1"("一个二","一个一"), 即12...
javascript面向对象三大特征之多态实例详解
12-13
本文实例讲述了javascript面向对象三大特征之多态。分享给大家供大家参考，具体如下： 多态 从某种意义上来说，多态是面向对象中重要的一部分，也是实施继承的主要目的。 一个实例可以拥有多个类型，它既可以是这种...
Java面向对象的3大特征之多态
最新发布
07-27
多态是Java面向对象编程的三大特征之一，另外两个是封装和继承。封装保证了对象的内部实现对外是隐藏的，继承则允许子类扩展和定制父类的行为，而多态则提供了将不同子类对象进行相同处理的机制。 在实际应用中，...
【Java】基础18：面向对象三大特性之多态
01-21
面向对象三大特性：封装、继承和多态。 今天学最后一个特性：多态。 什么叫多态呢？按照字面意思理解就是多种形态的意思。 还是举昨天的那个例子： 动物园里动物都得吃食物，兔子吃胡萝卜，猫吃鱼，狗吃肉。 同一...
Java 面向对象三大特性之多态
05-20
总之，多态是Java面向对象编程中的重要概念，它极大地提升了代码的灵活性和可扩展性。理解和熟练运用多态，可以帮助我们编写出更高效、更易于维护的代码。在实际开发中，应充分利用多态的特性，以适应不断变化的需求...
java包装类转换_Java从入门到入土（38）包装类转换
weixin_42517503的博客
02-16 199
Java是一种面向对象的编程语言，他提供了8种基本数据类型。但是，这8种基本数据类型并不符合面向对象的编程机制，因为基本数据类型并不具有对象所具有的属性，方法，构造方法等特征。Java之所以提供8中基本数据类型主要是为了保持和c等其他语言的延续性。Java提供了对8种基本数据类型的“包装”，称之为包装类。包装类符合对象的特征，对基本数据类型进行了封装，提供了一些必要的属性和方法，满足了面向对象编程...
在线测试——面向对象课堂测试
肉丸不肉
03-28 2678
1、 public class A { int i=10; public A() { i=20; } public static void main(String[] args) { A a=new A(); System.out.println(a.i); } } 执行代码后，系统输出的结果是（ 20 ）。 ...
java错题集
weixin_43343423的博客
04-02 4221
下面程序执行的结果是？(B) class Test { public static void main(String[] args) { System.out.println(“”+‘a’+1); } } A. 98 B. a1 C. 971 D. 197 下面数组定义错误的是（C） A. int [] arr ={23,45,65,78,89}; B. int [...
面向对象学习第四节
xiao_chainiao的博客
07-17 2859
1.编写一个学生类，提供name、age、gender、phone、address、email成员变量，且为每个成员变量提供setter、getter方法。为学生提供默认的构造器和带所有成员变量的构造器。为学生提供方法，用于描绘吃、喝、玩、睡等行为。 2.利用第1题定义的Student类，定义一个Student[]数组保存多个Student对象作为通讯录数据。程序可通过name、email、ad...
java 继承
取名为猫的狗的博客
09-04 185
子类能够继承父类所有的一切，但不能访问父类中private修饰的。 class A{ public int m = 10; } class B extends A{ } public class Demo { public static void main(String[] args) { B b = new B(); System.out.println(b.m); //10 } } 当要执行方法时： if (该方法被子类重写
Java基础37 方法重写与覆盖
chenjiap的博客
11-14 1478
重写的介绍及其使用、练习
Java基础11（if 条件语句）
chenjiap的博客
04-02 1074
Java基础11
JavaSE 面向对象（高级）
chenjiap的博客
01-26 904
static类变量、main方法与代码块、单例模式、final关键字、抽象类、接口与内部类的介绍及其使用
Java基础28（方法重载）
chenjiap的博客
09-01 721
方法重载的概念及使用方法
Java基础43 异常（Exception）
chenjiap的博客
02-21 720
异常（Exception）的概念，用法，体系图以及习题
Java程序设计：面向对象基础与类的多态
"本资源是关于Java程序设计的第二章内容，主要讲解了Java程序的基础和...本章内容深入浅出地介绍了Java面向对象编程的基础，为后续的程序设计打下了坚实的基础。学习者应熟练掌握这些概念，并通过实践应用来深化理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值