Java笔记之面向对象中（九）

王博1999

已于 2022-04-23 16:55:57 修改

阅读量446

点赞数 1

分类专栏：自学Java 文章标签： java

于 2022-04-23 12:25:29 首次发布

本文链接：https://blog.csdn.net/weixin_44604159/article/details/124257229

版权

自学Java 专栏收录该内容

30 篇文章 2 订阅

订阅专栏

学习内容

一、多态
二、java的动态绑定机制
三、instanceof比较操作符
四、多态的应用
- 1.多态数组
- 2.多态参数

一、多态

1.基本介绍

多态是指方法或对象的多种形态，建立在封装和继承的基础之上，主要解决代码的复用性和维护性，多态的使用基础是，两个类有继承关系

2.对象的多态

（1）一个对象的编译类型和运行类型可以一致，也可以不一致；在创建对象时，编译类型在等号左边，运行类型在等号的右边

public class Test {
    public static void main(String[] args) {
        //b的编译类型就是A，运行类型就是B
        A b = new B();
        //b1的编译类型就是B，运行类型也就是B
        B b1 = new B();
    }
}

class A{
}
class B extends A{
}

（2）编译类型在确定对象时，就已经确定了，不能改变

（3）运行类型是可以变化的

public class Test {
    public static void main(String[] args) {
        //b的编译类型就是A，运行类型就是B
        A b = new B();
        //b的运行类型是可以改变的，为C
        b = new C();
    }
}

class A{
}
class B extends A{
}
class C extends A{
}

3.快速入门

public class Test {
    public static void main(String[] args) {
        Master zhangsan = new Master("张三");
        Cat cat = new Cat("小花");
        fish fish = new fish("鱼");
        zhangsan.feed(cat,fish);

        Master lisi = new Master("李四");
        Dog dog = new Dog("小黄");
        bone bone = new bone("骨头");
        lisi.feed(dog,bone);
    }
}

//动物类
class Animal{
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }
}

class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }
}

//食物类
class Food{
    String name;

    public Food(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class fish extends Food{
    public fish(String name) {
        super(name);
    }
}

class bone extends Food{
    public bone(String name) {
        super(name);
    }
}

//主人类
class Master{
    private String name;

    public Master(String name) {
        this.name = name;
    }

    //animal的编译类型是Animal，可以指向的接收Animal的子类
    //food的编译类型是Food，可以指向的接收Food的子类
    //这样的话就不用定义多个feed方法，体现了多态性
    public void feed(Animal animal,Food food){
        System.out.println("主人"+name+"给"+animal.getName()+"喂"+food.getName());
    }
}

4.多态的转型

1.向上转型

语法格式

父类类型引用名 = new 子类类型();

使用细节

编译类型看左边，运行类型看右边
可以调用父类中的所有成员（需注意访问修饰符）
不能调用子类中特有的成员如：子类特有方法或者属性

public class test1 {
    public static void main(String[] args) {
        Animal1 animal = new dog();
        animal.name = "动物";
        animal.sleep(); //睡觉（子类）

        //下面是错误的，因为向上转型不能调用子类中特有的方法或属性
        animal.age = 20;
        animal.run();
    }
}

class Animal1{
    String name;

    public void sleep(){
        System.out.println("睡觉（父类）");
    }

    public void eat(){
        System.out.println("吃东西");
    }
}

class dog extends Animal1{
    int age;
    public void sleep(){
        System.out.println("睡觉（子类）");
    }

    public void run(){
        System.out.println("跑...");
    }
}

2.向下转型

语法格式

子类类型引用名 = （子类类型）父类引用 ; 　　　//把父类强转为子类类型

使用细节

只能强转父类的引用，不能强转父类的对象
要求父类的引用，必须是指向当前目标类型的对象（就是说父类的引用，必须是指定当前要向下转型的类）
向下转型后，可以调用子类中所有的属性和方法

public class test1 {
    public static void main(String[] args) {
        Animal1 animal = new dog();
        animal.name = "动物";
        animal.sleep(); //睡觉（子类）

        //下面是错误的，因为向上转型不能调用子类中特有的方法或属性
        //animal.age = 20;
        //animal.run();

        //如果想访问子类中特有的方法和属性，则可以向下转型
        dog dog1 = (dog) animal;
        dog1.run();
        dog1.age = 20;
    }
}

class Animal1{
    String name;

    public void sleep(){
        System.out.println("睡觉（父类）");
    }

    public void eat(){
        System.out.println("吃东西");
    }
}

class dog extends Animal1{
    int age;
    public void sleep(){
        System.out.println("睡觉（子类）");
    }

    public void run(){
        System.out.println("跑...");
    }
}

public class test1 {
    public static void main(String[] args) {
        //要求父类的引用，必须是指向当前目标类型的对象（就是说父类的引用，必须是指定当前要向下转型的类）
        Animal1 animal = new dog(); //向上转型，
        dog dog1 = (dog) animal;    //向下转型
        dog1.run();
        dog1.age = 20;

        //实际上animal这个对象是指向dog类的，所以不能对cat进行向下转型
        cat cat1 = (cat) animal;    //编译时会报错：ClassCastException

        Animal1 animal1 = new cat(); //向上转型
        cat cat2 = (cat) animal1;     //向下转型,正确的
    }
}

class Animal1{
    String name;

    public void sleep(){
        System.out.println("睡觉（父类）");
    }

    public void eat(){
        System.out.println("吃东西");
    }
}

class dog extends Animal1{
    int age;
    public void sleep(){
        System.out.println("睡觉（子类）");
    }

    public void run(){
        System.out.println("跑...");
    }
}

class cat extends Animal1{
}

注意事项

属性没有重写之说，属性调用的值直接看编译类型

public class test1 {
    public static void main(String[] args) {
        //向上转型,属性的调用看编译类型，等号的左边为编译类型
        Animal1 Animal = new cat();
        System.out.println(Animal.age);	//输出10
    }
}

class Animal1{
    int age = 10;
}
class cat extends Animal1{
    int age = 5;
}

二、java的动态绑定机制

☆ 当调用对象方法时，该方法会和该对象的内存地址也就是运行类型绑定

☆ 当调用对象属性时，没有动态绑定机制，在哪里声明，就在哪里使用

public class test1 {
    public static void main(String[] args) {
        //情况一
        A a = new B();  //向上转型
        System.out.println(a.sum());    //40
        System.out.println(a.sum1());   //30

        //情况二
        //如果把B类中的方法sum去掉，用a调用sum方法，则会去父类找，父类中sum方法返回getX()+10;
        //那么getX()是调用A类的还是B类的呢？答案是B类
        //因为当调用方法时，该方法和该对象的运行类型绑定
        System.out.println(a.sum());    //30

        //情况三
        //如果把B类中的方法sum1去掉，用a调用sum1方法，则会去父类找，父类中sum1方法返回x+10;
        //那么x是调用A类的还是B类的呢？答案是A类
        //因为属性没有动态绑定机制，在哪里声明，就在哪里使用
        System.out.println(a.sum1());    //20
    }
}

class A{
    int x = 10;

    public int sum(){
        return getX()+10;
    }

    public int sum1(){
        return x+10;
    }

    public int getX() {
        return x;
    }
}
class B extends A{
    int x = 20;

    public int getX() {
        return x;
    }

    public int sum(){
        return x+20;
    }

    public int sum1(){
        return x+10;
    }
}

三、instanceof比较操作符

instanceof用于判断对象的运行类型是否为XXX类型或者为XXX的子类型

public class test1 {
    public static void main(String[] args) {
        A a = new B();  //a的编译类型为A，运行类型为B
        B b = new B();  //b的编译类型为B，运行类型为B
        Object obj = new Object();  //obj的编译类型为B，运行类型为B

        System.out.println(a instanceof A); //true
        System.out.println(b instanceof A); //true
        System.out.println(obj instanceof A);   //false
    }
}

class A{}
class B extends A{}

四、多态的应用

1.多态数组

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

案例：要求创建 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组中，并调用每个对象 say 方法

package com.test;

public class test1 {
    public static void main(String[] args) {
        Person[] person = new Person[5];
        person[0] = new Person("小明",20);
        person[1] = new Student("张三", 18, 100);
        person[2] = new Student("李四", 20, 99);
        person[3] = new Teacher("王五",40,7000);
        person[4] = new Teacher("赵六",30,6000);

        //输出每个对象中的say方法
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i].say());
            //输出子类中特有的方法
            //因为study()和teach()是子类特有的方法，penson调用不了，
            //如果想调用，则需要用向下转型调用子类中特有的方法
            if(person[i] instanceof Student){       //判断person[i]的运行类型是不是Student
                /*
                Student student = (Student)person[i];   //向下转型
                student.study();
                上面两句等价于
                ((Student)person[i]).study()
                 */
                ((Student)person[i]).study();      //向下转型
            }else if (person[i] instanceof Teacher){
                ((Teacher)person[i]).teach();
            }
        }
    }
}

class Person{
    private String name;
    private int 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;
    }

    public String say(){
        return name+" "+age;
    }
}

class Student extends Person{
    private int cj;

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

    public int getCj() {
        return cj;
    }

    public void setCj(int cj) {
        this.cj = cj;
    }

    @Override
    public String say() {
        return "学生："+super.say()+"成绩="+cj;
    }

    public void study(){
        System.out.println("学生"+getName()+"在学习");
    }
}

class Teacher extends Person{
    private int salary;

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

    public int getSalary() {
        return salary;
    }

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

    @Override
    public String say() {
        return "老师："+super.say()+"工资="+salary;
    }

    public void teach(){
        System.out.println("老师"+getName()+"在教学");
    }
}

2.多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

案例演示
要求：定义员工类Employee,包含姓名和月工资private，以及计算年工资的方法getAnnual。普通员工和经理继承了员工，经理类多了奖金bonus属性和管理manage方法，普通员工类多了work方法，普通员工和经理类要求分别重写getAnnual方法

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

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

public class test1 {
    public static void main(String[] args) {
        Worker worker = new Worker("张三", 3000);
        Manager manager = new Manager("李四", 5000, 5000);
        test1 test1 = new test1();
        test1.showEmpAnnual(worker);
        test1.showEmpAnnual(manager);
        test1.testWork(worker);
        test1.testWork(manager);
    }

    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
    }

    public void testWork(Employee e){
        if (e instanceof Worker){
            ((Worker)e).work();
        }else if (e instanceof Manager){
            ((Manager)e).manage();
        }
    }
}

//员工类
class Employee{
    private String name;
    private int salary;

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

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

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

    public int getAnnual(){
        return 12*getSalary();
    }
}

//普通员工类
class Worker extends Employee{
    public Worker(String name, int salary) {
        super(name, salary);
    }

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

    //特有的方法
    public void work(){
        System.out.println("普通员工"+getName()+"在工作");
    }
}

//经理类
class Manager extends Employee{
    private int bonus;

    public Manager(String name, int salary, int bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public int getBonus() {
        return bonus;
    }

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

    @Override
    public int getAnnual() {
        return super.getAnnual()+getBonus();
    }

    //特有的方法
    public void manage(){
        System.out.println("项目经理"+getName()+"在规划");
    }
}