亲宝软件园·资讯

展开

Java面向对象编程之多态

哈哈怪.... 人气:1

Java面向对象编程之多态

一.对于多态的理解:

通俗点理解,多态其实就是一词多义,就是一种方法的多种状态,即不同的类对象,调用同一个方法名,有不同的实现效果,如下面这段代码块:

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("豆豆");
        Cat cat = new Cat("花花");
        dog.eat();
        cat.eat();
    }
}

对象dog和cat看似都调用了eat方法,都没有传参,按理说输出的结果应该一样,但其实不是这样的,让我们来看一下输出的结果:

在这里插入图片描述

这就是多态的一种表现,所属不同类的不同对象调用同一个方法名,却有着不同的实现效果。

二.多态的实现方法

Java中通过 方法重写(也叫方法覆写)方法重载接口实现多态(主要依赖于继承机制+方法覆写)

1.方法重载

方法重载十分好理解,就是子类和父类的方法名相同,但是参数个数或类型不一样,返回值不作要求,这里不再赘述

2.方法重写

对于方法重写,通常结合向上转型和向下转型两种形式进行应用,其中向上转型更为常见,向下转型相对使用较少

(1)向上转型:就是子类向父类转,向上转型最大的好处就是可以实现参数统一化,向上转型可以表现在三个地方:

其一:产生对象时:

在这里插入图片描述

注意:用这种形式创建的实例化对象dog1,其能调用的方法范围由父类Animal决定,即只能调用Animal类中的方法,而不能调用子类独有的方法,只有当子类有对父类的方法重写时,才调用子类重写后的方法!!!

其二:方法参数的传递:

在这里插入图片描述

其三:方法返回值的传递

在这里插入图片描述

向上转型的最大好处就是——参数统一化,父类引用可以接收子类所有对象

看下面这个例子:

完整代码为:

public class Animal {
    public String name;
    public Animal(String a){
        name = a;
    }
    public void eat(){
        System.out.println("食物");
    }
    public static void fun(Animal animal){
        animal.eat();
    }
}
public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    public void eat(){
        System.out.println("骨头");
    }
}
public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
    public void eat(){
        System.out.println("鱼");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("豆豆");
        Cat cat = new Cat("花花");
        dog.fun(dog);
        cat.fun(cat);
    }
}

结果为:

在这里插入图片描述

拆开来分析:

fun方法的参数为Animal类的实例化对象

在这里插入图片描述

Animal的子类对象,可以直接传入

在这里插入图片描述

也就是说,对于Animal类的所有子类实例化对象,均可以直接向fun方法传参,避免了重复性的写诸如 public static void fun(Dod d){}, public static void fun(Cat a){}等方法

(2)向下转型:向上转型是子类向父类转,向下转型则是将转为的父类还原为子类,这里用 还原 这个词是因为能向下转型的前提是:先发生向上转型且我们需要使用子类独有的方法时,才使用向下转型,也很好理解,父类不一定是子类,只有由子类转成的才可以向下转型还原,向下转型的形式如下:

        Animal animal = new Dog("豆豆");
        Dog dog = (Dog)animal;

基本类似与强制类型转换

注意:向下转型是有风险的,可能无法强制转换成功,这里可以引用instanceof类,用if语句判断,避免报错

        if(dog instanceof Dog){
            
        }

(3)方法重写的几点注意要求:

(4)最后是一道例题,容易掉坑:

public class A {
    public A(){
        this.func();
    }
    public void func(){
        System.out.println("A");
    }
}
class B extends A{
    private int num;
    public B(int num){
        this.num = num;
    }
    public void func(){
        System.out.println("B的num==" + num);
    }

    public static void main(String[] args) {
        B b = new B(100);
        b.func();
    }
}

分析运行后会输出什么呢?

仔细想想,小心掉坑,答案在文章末尾给出

3.抽象类

对于方法的覆写,一般的继承关系下,子类是可以选择覆写也可以选择不覆写的,但在一些场景下,我们想对子类作出强制性覆写要求,这就引出了抽象类的概念

(1)抽象类用abstract修饰,抽象类是普通类的超集,它只是在普通类的基础上多了抽象方法,抽象方法是没有方法体的,形式如下:

在这里插入图片描述

(2)抽象类必须有子类继承

(3)抽象类无法实例化对象,仅能用子类new相应的对象

(4)普通子类继承抽象类,必须覆写所有的抽象方法,当子类仍为抽象类时,可以选择不覆写,依旧保留抽象方法

(5)abstract修饰符不能和final同时使用,也不能和private同时使用

4.接口

上面讲的抽象类虽然能实现方法的覆写,但还是有缺陷的,比如抽象类还是遵循单继承原则,一个类也只能继承一个抽象类,同时,在语义上,只要继承,就是A is B 的意思,有时候并不符合逻辑,故而又引出了接口这个概念

(1)接口的定义与使用

我们用关键字interface来定义接口,子类用关键字 implements来实现接口,同时,通常,在命名接口时,我们会用大写的字母“I”开头命名以示区别,如下面一段代码的接口名为 IMessage ,而对于实现接口的子类命名我们通常用Impl作后缀

(2)接口的特点:

接口中只有全局常量和抽象方法(JDK8之前,JDK8又扩展了default方法,了解即可),如:

public interface IMessage {
     public static final int a = 10;
     public abstract void print();
}

接口中只有public权限,且全部为全局常量和抽象方法,故而,在接口内,public、static、final、abstract可以省略不写,默认即为这些关键字,故上一段代码可以直接写成下面这段:

public interface IMessage {
     int a = 10;
     void print();
}

接口是没有单继承限制的,子类可以implements多个父接口,父接口之间用逗号隔开,如:

public class CImpl implements IB,IMessage{    public void print(){            }    public void printf(){            }}

(3)常用的JDK内置的两大接口

a:Comparable接口

当使用Arrays.sort()方法排序时,当排序对象为自定义的类时,sort方法不知道应该按照对象的什么属性进行排序,故而待排序的自定义类需实现该接口,并将抽象方法compareTo覆写,形式如下:

import java.util.Arrays;

public class Person implements Comparable<Person> {
//    两个属性,name和age
    private String name;
    private int age;
//    有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
//    定义输出
    public String toString(){
        return name + "的年龄是" + age;
    }
//    覆写compareTo方法
    public int compareTo(Person o){
        return (this.age - o.age);
    }

    public static void main(String[] args) {
        Person p1 = new Person("言希",18);
        Person p2 = new Person("温衡",16);
        Person p3 = new Person("思莞",17);
        Person []p = new Person[]{p1,p2,p3};
//        用sort方法排序
        Arrays.sort(p);
        System.out.println(Arrays.toString(p));
    }
}

输出结果(按年龄升序):

在这里插入图片描述

b: Cloneable接口

Cloneable接口位于java.lang包中,顾名思义,就是用于克隆,在代码中也就是复制新的对象,新对象的属性方法都是从原对象中拷贝过来的,在实现该接口时,只需要覆写Object类提供的clone方法,如下面示例:

//实现Cloneable接口
public class Animall implements Cloneable{
    private String name;
//    clone方法
    protected Animall clone() throws CloneNotSupportedException {
        return (Animall)super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException{
        Animall a1 = new Animall();
        a1.name = "豆豆";
//        a2由a1克隆而来
        Animall a2 = a1.clone();
//        输出a2,和a1一致
        System.out.println(a2.name);
//        但是a1并不是a2
        System.out.println(a1 == a2);
    }
}

结果如下:

在这里插入图片描述

补充

好了,多态的内容基本就是这么多了,java中的多态主要依赖于继承和方法覆写,而对于那些需要强制性覆写的方法,我们又引出了抽象类,再鉴于抽象类有局限,我们又学习了接口,整体上内容就是这么多了,注意的细节比较多,多敲代码理解理解更棒。

最后,将文中那道例题答案奉上:

在这里插入图片描述

答案解析来啦

在这里插入图片描述

从main方法开始,执行的第一句为 B b = new B(100);,因为B继承自A,故而执行B 的构造方法要先去执行A的构造方法,public A(){ this.func(); },这里注意,虽然是A的构造,但对象是B的,故这里的this,func()实际是B.func(),public void func(){System.out.println(“B的num==” + num);}

因为这里其实还没给num赋值成功,所以num现在还是默认值0,所以输出了答案的第一句 B的num == 0,然后接着执行B的构造方法,将100赋值给了num,最后执行b.func,也就输出了答案的第二句 B的num ==100

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!

加载全部内容

相关教程
猜你喜欢
用户评论