详解Java面向对象编程之多态

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）方法重写的几点注意要求：

• 只能覆写成员方法，不能重写static静态方法，但是方法重载是可以重载static方法的
• 子类进行方法重写，子类方法的权限修饰符>=父类方法的权限修饰符，同时，子类并不能覆写父类的private方法，对于父类的包访问权限修饰方法，在不同包下的子类也不能覆写
• 用final修饰的方法也不能覆写哦（JDK中的String类就是一个final类）
• 返回值必须相同，或是向上转型的，即覆写的方法的返回值可以是父类方法返回类型的子类
• 注意方法覆写与方法重载的区别，方法覆写：子类与父类的方法名一样，参数、返回值类型均一样，如果只返回值类型不一样编译会报错
• 可使用@override 检验方法覆写是否一样

（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(){            }}

• 同时，接口之间也可以多继承，一个接口可以extends多个父接口
• 接口同抽象类一样，是不能直接实例化对象的，必须通过实现它的子类进行实例化
• 如果一个子类既有继承的父类，也有实现的接口，则先继承父类再实现父接口

（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);
    }
}

结果如下：

补充：

• Cloneable接口是标记接口，即它本身并没有任何抽象方法，当一个类实现了该接口，就表示该类具备了克隆能力
• clone方法的源代码为protected native object clone() throws CloneNotSupportedException；,其中native也是一个关键字，表明是本地方法，即调用了C++的同名方法故而，我们还可以发现，native修饰的方法也是没有方法体的
• 没有方法体的一定是抽象方法 ⅹ错误，因为native方法也是没有方法体的

好了，多态的内容基本就是这么多了，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

总结

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

最新评论