如何界定多态与@Override方法的界限？多态可脱离重写使用吗？

二者能否独立使用？ #

• @Override可独立使用：这个注解仅用于标记当前方法是对父类/接口方法的重写，即便不利用多态特性（比如直接用子类对象调用该方法），依然可以用它做语法校验，避免写错方法签名。示例：

class Parent {
    public void sayHi() {
        System.out.println("Parent says hi");
    }
}

class Child extends Parent {
    @Override // 仅标记重写，直接用Child对象调用也完全合法
    public void sayHi() {
        System.out.println("Child says hi");
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.sayHi(); // 未使用多态，但@Override依然有效
    }
}

• 多态可不依赖@Override：多态核心是“父类引用指向子类对象，调用方法时实际执行子类实现”，哪怕不用@Override注解，只要方法签名与父类一致，依然能实现多态。示例：

class Parent {
    public void sayHi() {
        System.out.println("Parent says hi");
    }
}

class Child extends Parent {
    public void sayHi() { // 无@Override，但确实重写了方法，多态依然生效
        System.out.println("Child says hi");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent p = new Child();
        p.sayHi(); // 多态生效，输出Child的内容
    }
}

不借助方法重写实现多态的场景 #

当然存在，主要分为两类：

1. 基于接口的多态（接口实现类的行为差异） #

接口仅定义方法声明，无具体实现，不同实现类各自实现接口方法，用接口引用指向不同实现类对象时，即可体现多态——这里是“实现接口方法”而非“重写父类方法”。示例：

interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;
    public Circle(double r) { this.radius = r; }
    public double getArea() { // 实现接口方法，不属于重写
        return Math.PI * radius * radius;
    }
}

class Square implements Shape {
    private double side;
    public Square(double s) { this.side = s; }
    public double getArea() { // 实现接口方法，不属于重写
        return side * side;
    }
}

public class Test {
    public static void main(String[] args) {
        Shape s1 = new Circle(5);
        Shape s2 = new Square(4);
        System.out.println(s1.getArea()); // 输出圆的面积，多态生效
        System.out.println(s2.getArea()); // 输出正方形的面积，多态生效
    }
}

2. 方法重载实现编译时多态（静态多态） #

多态分为运行时多态和编译时多态，编译时多态完全通过方法重载实现，不需要方法重写。编译器在编译阶段就会根据参数的类型、数量、顺序确定要调用的方法。示例：

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) { // 重载方法
        return a + b;
    }
    public String add(String a, String b) { // 重载方法
        return a + b;
    }
}

public class Test {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1,2)); // 调用int版本
        System.out.println(calc.add(1.5,2.5)); // 调用double版本
        System.out.println(calc.add("Hello ", "World")); // 调用String版本
    }
}

这里同一个方法名add根据参数不同执行不同逻辑，属于多态的一种，全程未用到方法重写。

内容的提问来源于stack exchange，提问作者Arthur Bittencourt