【java杂谈】Java中的多态

HIT-lx

已于 2023-03-22 20:18:59 修改

阅读量447

点赞数 1

分类专栏： Java杂谈文章标签： java 个人开发软件工程软件构建 Powered by 金山文档

于 2023-03-22 20:13:40 首次发布

本文链接：https://blog.csdn.net/qq_64219369/article/details/129716759

版权

Java杂谈专栏收录该内容

6 篇文章 0 订阅

订阅专栏

🥖多态是什么？

w3school上对多态是这样描述的：

Polymorphism means "many forms", and it occurs when we have many classes that are related to each other by inheritance.

实际上，多态就是“多种形式”，它具有以下两层意义：

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

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

多态具有三种类型：

Ad hoc polymorphism (特殊多态)

Parametric polymorphism (参数化多态)

Subtyping (also called subtype polymorphism or inclusion polymorphism 子类型多态、包含多态)

接下来，我将对三种多态逐一分析：

🫓多态的三种类型：

🚝Ad hoc polymorphism (特殊多态)

这种多态发生在方法具有不同的实现时，在常见的编程语言中常常通过方法重载（overloading）实现。

public class OverloadExample {

            public static String add(String c, String d) {
                return c.concat(d);
            }

            public static String add(String c, String d, String e) {
                return c.concat(d).concat(e);
            }

            public static int add(int a, int b) {
                return a + b;
            }
        }

在上述代码中，add()方法具有多种实现，他们的参数列表不同（包括参数的数量不同以及参数的数据类型不同，但不包括参数名称不同），编译器会将其视作不同的方法。

在具体使用add()方法时，根据参数的不同，会调用相应的方法：

public static void main(String args[]) {
    System.out.println(add("C", "D"));
    System.out.println(add("C", "D", "E"));
    System.out.println(add(2, 3));
}

值得注意的是，方法的重载也可以发生在子类和父类中，观察下面的例子：

class Animal {
        public void eat() {
        }
    }

    class Horse extends Animal {
        public void eat(String food) {
        }
    }

在这个例子中，子类Horse重载了父类的eat()方法，相当于:

class Animal {
        public void eat() {
        }
    }

    class Horse extends Animal {
        public void eat() {
        }

        public void eat(String food) {
        }
    }

将其实例化，调用eat()方法，会有以下结果：

        Animal a = new Animal();
        a.eat();
        a.eat("food");//编译报错，因为Animal类没有eat(String food)方法

        Animal b = new Horse();
        b.eat();
        b.eat("food");//编译报错，因为在编译阶段对象b会被视作一个Animal类，报错原因同上

        Horse c = new Horse();
        c.eat();
        c.eat("food");

对象b会被视作一个Animal类。

最后，给出方法重载(Overloading)与方法重写(Overriding)的区别：

🚞Parametric polymorphism (参数化多态)

参数化多态就是函数工作过程中的数据结构支持多种类型，在Java中通常使用“泛型”来实现。

在Java中有以下几种泛型：

泛型变量

泛型类

泛型接口

泛型方法

我们逐一分析：

🐳泛型变量：

见如下例子：

public class GenericClass<T>{
    //t是一个泛型成员变量
    private T t;
  
    public  void function(T t){

    }

在这个例子中T是一个泛型变量，这意味着T可以是任意的引用数据类型（详情可见笔者博文：数据类型与类型检验）。

🐋泛型类：

//GenericClass是一个泛型类
public class GenericClass<T>{
    //t是一个泛型成员变量
    private T t;
  
    public  void function(T t){

    }

仍然是刚刚的例子，GenericClass类在声明时添加了<T>这就是说，这个类是一个泛型类，具有一个泛型T。类的泛型也可以有多个，语法为：

[访问修饰符] class 类名<泛型1,泛型2,...> {
    泛型1 泛型成员1 ;
    泛型2 泛型成员2;
    ...
}

🐬泛型接口：

类似于泛型类，就是在接口上定义泛型，作用于方法：

public interface GenericInterface<T> {
    
    public T get();
    
    public void set(T t);

    public T delete(T t);
    
    default T defaultFunction(T t){
        return t;
    }
}

🐟泛型函数：

写法是函数返回类型旁加上泛型，用于实现一个通用数据类型的函数：

public class GenericFunction {

    public <T> void function(T t) {
    }

    public <T> T functionTwo(T t) {
        return t;
    }

    public <T> String functionThree(T t) {
        return "";
    }
}