面向对象之多态

最新推荐文章于 2024-08-23 00:00:00 发布

understandbuy

最新推荐文章于 2024-08-23 00:00:00 发布

阅读量27

点赞数

分类专栏：每周小结文章标签： java 开发语言

本文链接：https://blog.csdn.net/understandbuy/article/details/135014676

版权

每周小结专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一.多态

多态：多态是同一种行为具有不同表现形式或形态的能力。

同一方法可以根据发送对象的不同而采用不同的行为方式。

多态的前期是两个类具有着继承的关系，多态是建立在封装和继承之上。

意思：1.有继承关系或者实现关系(继承父类，实现接口)；

2.有父类引用指向子类对象（Fu f = new Zi()）;

3.有方法的重写。

二 .多态的好处

1.使用父类类型作为参数可以接受所有子类对象。

2.体现了多态的扩展性和遍历。

三.多态调用成员的特点。

变量的调用：编译看左边，运行也看左边。

方法的调用：编译看左边，运行看右边。

可以举一个例子：

1.关于多态解决接口的问题。

这里定义一个Amials中的接口，里面有着food，can，age等行为。

根据接口的特性，想要利用这个接口需要有类来实现这个接口。

public interface  Amials {
    void food();
    void can();
    void age();

}

这里再次定义了两个类来实现这个接口，并且重写了里面的方法。

public class cat implements Amials{
    @Override
    public void food() {
        System.out.println("鱼");
    }

    @Override
    public void can() {
        System.out.println("瞄");
    }

    @Override
    public void age() {
        System.out.println("短");
    }
}

public class dog implements Amials{
    @Override
    public void food() {
        System.out.println("肉");
    }

    @Override
    public void can() {
        System.out.println("汪");
    }

    @Override
    public void age() {
        System.out.println("短");
    }
}

如果我们想要便捷的调用这两个类中的属性，需要利用多态。

首先在测试类中创建的一个接口对象,然后进行实现类的赋值。

接着利用接口对象调用接口中的方法就可以，执行实现类中的行为。

这里可以配合switch进行配合使用，从而更能提高代码的操作效率。

如：

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
      Amials szj = null;
      Scanner tll   =new Scanner(System.in);
      int num = tll.nextInt();
        System.out.println("请输入1或者2进行查看信息");
      switch (num){
          case 1 :
              szj =new dog();
              break;
          case 2 :
              szj =new cat();
              break;
      }
      szj.food();
      szj.can();
      szj.food();
    }
}

这种多态的运用可以提高代码的操作效率。

三.多态的转型问题。

1.向上转型

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

特点：编译时需要看左边，运行类型需要看右边。

可以调用父类的所有成员(需遵循访问权限。)

不能调用子类特有的成员。

运行效果要看子类的具体实现。

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

2.2 向下转型。

1.本质：一个向上转型的子类对象，将父类引用转为子类引用。

2.特点：只能能够强制转化父类的引用，不能够强制转化父类的对象。

要求父类的引用必须指向的是当前目标类型的对象。

向下转型后可以调用子类中的所有成员。

向下转型的实例：

equals方法的重写：

public boolean equals(Object obj) {
        Studnet studnet = (Studnet) obj;
      return this.name.equals(((Studnet) obj).name)&&this.getAge()==((Studnet) obj).age;
    }
}

Student student = (Studnet ) obj ;这一句话利用了向下转型，因为Object 是所有类的父类。因此，在传入Object类时，父类不能够调用子类对象的成员，必须进行转型才可以进行成员的调用。

instanceof 比较操作：

1.类型转换异常：使用强转时，会出现类型转化异常。

原因是因为，转化得类型可能并非是父子类关系。因此转化得时候不能进行非继承关系的类之间的转化。

2.instanceof关键字，可以用来判断对象的类型是否为XX类型或XX类型的子类型。

通关该关键字可以进行是否是子类型的判断。

package Poly_;

//演示 instanceof 的使用
public class Test03 {
    public static void main(String[] args) {
        //向上转型
        Person p1 = new Student();
        
        //调用的是 Student 的 mission
        p1.mission();
        
        //向下转型
        //利用 instanceof 进行判断
        if(p1 instanceof Student) {    //判断对象 p1 是否是 Student 类 的实例
            Student s1 = (Student)p1;
            s1.score();  //调用的是 Student 的 score
            //上面这两句也可简写为 ((Student) p1).score();
        }
        else if(p1 instanceof Teacher){ //判断对象 p1 是否是 Teacher 类 的实例
            Teacher t1 = (Teacher)p1;
            t1.salary(); //调用的是 Teacher 的 salary
            //同理，上面这两句也可简写为 ((Teacher) p1).salary();
        }
    }
}

四.多态的优点