Java面向对象之多态

Java是一门面向对象的编程语言，其中最重要的特性之一就是多态。多态是指同一个方法或者同一个类，在不同的时间、不同的对象上具有不同的表现形式。下面我们来仔细分析Java中的多态。

引言

Java的多态性分为静态多态和动态多态。

静态多态性是指在编译期就可以确定方法的调用对象，也就是说，在程序编译时已经确定了将要调用的方法。在Java中静态多态性可以通过方法的重载来实现。

动态多态性是指在运行期根据对象的实际类型决定要调用的方法。在Java中动态多态性可以通过方法的重写和接口来实现。

方法的重载

方法的重载是指在同一个类中定义两个或者多个具有相同名称但是参数不同的方法。编译器会根据传入的参数类型来选择正确的方法执行。

举个例子，假设我们有一个Calculator类，它有两个“add”方法，一个是int类型的，另一个是double类型的：

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

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

当我们使用Calculator类的时候，编译器会根据我们传入的参数类型来选择正确的方法。例如：

Calculator calculator = new Calculator();
int sum1 = calculator.add(1, 2);
double sum2 = calculator.add(1.0, 2.0);

在这个例子中，第一次调用“add”方法是传入了两个int类型的参数，因此编译器会自动选择第一个重载方法。第二次调用是传入了两个double类型的参数，因此编译器会自动选择第二个重载方法。

方法的重写

方法的重写是指在子类中覆盖父类中的同名方法。当子类的对象调用该方法时，会优先调用子类的方法。

举个例子，我们有一个Animal类和一个Dog类，Dog类是Animal类的子类。在Animal类中有一个“makeSound”方法，在Dog类中也有同名方法：

public class Animal {
    public void makeSound() {
        System.out.println("这是一个动物！");
    }
}

public class Dog extends Animal {
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

当我们创建一个Dog对象并且调用“makeSound”方法时，实际上会优先调用Dog类中的方法而不是Animal类中的方法：

Dog dog = new Dog();
dog.makeSound(); // 输出："汪汪汪"

接口

接口是一种特殊的类，它只包含方法声明而没有方法实现。在Java中，一个类可以实现一个或多个接口，从而获得接口中声明的方法。

举个例子，我们有一个Animal接口和一个Dog类，Dog类实现了Animal接口，因此必须实现Animal接口中声明的所有方法：

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("汪汪汪");
   }
}

当我们创建一个Dog对象并且调用“makeSound”方法时，实际上会调用Dog类中实现的makeSound方法：

Dog dog = new Dog();
dog.makeSound(); // 输出："汪汪汪"

示例

下面通过两个例子来更好地理解Java中的多态性。

例子1

首先我们先创建一个Animal接口：

public interface Animal {
    public void makeSound();
}

然后我们创建一个Dog类实现Animal接口：

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

接着我们创建一个Cat类实现Animal接口：

public class Cat implements Animal {
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

最后我们创建一个AnimalSound类来调用“makeSound”方法：

public class AnimalSound {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();
        animal = new Cat();
        animal.makeSound();
    }
}

在这个例子中，我们先创建了一个Dog对象并且将其转化为Animal类型。当我们调用“makeSound”方法时，实际上会调用Dog类中实现的makeSound方法。

接着我们创建一个Cat对象并且将其转化为Animal类型，同样调用“makeSound”方法时，实际上会调用Cat类中实现的makeSound方法。

例子2

再来看一个例子，我们先创建一个Shape类：

public abstract class Shape {
    public abstract void draw();
}

然后我们创建两个子类Circle和Rectangle：

public class Circle extends Shape {
    public void draw() {
        System.out.println("画一个圆形");
    }
}

public class Rectangle extends Shape {
    public void draw() {
        System.out.println("画一个矩形");
   }
}

最后我们创建一个ShapeDrawing类来调用“draw”方法：

public class ShapeDrawing {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
        shape = new Rectangle();
        shape.draw();
    }
}

在这个例子中，我们先创建了一个Circle对象并且将其转化为Shape类型。当我们调用“draw”方法时，实际上会调用Circle类中实现的draw方法。

接着我们创建一个Rectangle对象并且将其转化为Shape类型，同样调用“draw”方法时，实际上会调用Rectangle类中实现的draw方法。