java如何在一个类中重写

在Java中，重写（Override）指的是在子类中重新定义父类中已经定义的方法。重写允许子类根据需要对父类的方法进行修改和扩展。要在一个类中重写一个方法，需要遵循以下核心原则：方法签名相同、访问权限不低于父类方法、返回类型兼容。其中，最关键的一点是方法签名相同，这意味着方法名称和参数列表必须一致。

接下来，详细描述方法签名相同。在Java中，如果要重写一个方法，子类中的方法必须与父类中的方法具有完全相同的方法名称和参数列表。这是确保子类方法正确重写父类方法的基础。如果方法签名不同，那么该方法将被视为子类中的一个新方法，而不是父类方法的重写。

一、方法签名相同

在Java中，方法签名包括方法名称和参数列表。当我们说方法签名相同时，意味着子类方法的名称和参数类型、顺序必须与父类方法完全一致。举个例子：

class Parent {
    void display() {
        System.out.println("Parent display()");
    }
}
class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display()");
    }
}

在这个例子中，Child类中的display方法与Parent类中的方法具有相同的签名，因此它成功地重写了父类的方法。方法签名相同是重写的基础，如果参数类型或顺序发生改变，重写将不会发生。

二、访问权限不低于父类方法

在重写方法时，子类的方法访问权限不能低于父类的方法访问权限。也就是说，如果父类的方法是public的，那么子类的方法也必须是public的，不能是protected或private的。举个例子：

class Parent {
    public void display() {
        System.out.println("Parent display()");
    }
}
class Child extends Parent {
    @Override
    public void display() {
        System.out.println("Child display()");
    }
}

上述代码是合法的，但如果我们将子类的display方法访问权限改为protected或private，编译器将报错。

三、返回类型兼容

从Java 5开始，允许子类方法返回一个父类方法返回类型的子类类型，这被称为协变返回类型。例如：

class Parent {
    Parent getObject() {
        return new Parent();
    }
}
class Child extends Parent {
    @Override
    Child getObject() {
        return new Child();
    }
}

在这个例子中，Child类重写了Parent类的getObject方法，并且返回类型是Child，这是允许的，因为Child是Parent的子类。

四、使用`@Override`注解

尽管不是必须的，但强烈推荐使用@Override注解来标识重写的方法。这不仅提高了代码的可读性，还能帮助编译器检查是否真的发生了重写。例如：

class Parent {
    void display() {
        System.out.println("Parent display()");
    }
}
class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display()");
    }
}

如果子类的方法没有正确地重写父类的方法，编译器会给出错误提示，有助于早期发现问题。

五、重写与重载的区别

在讨论重写时，必须明确区分重写（Override）和重载（Overload）。重载指的是在同一个类中定义多个方法，这些方法具有相同的方法名称但参数列表不同。重载是编译时多态性的一种形式，而重写是运行时多态性的一种形式。

class Example {
    void display() {
        System.out.println("No parameters");
    }
    void display(int a) {
        System.out.println("One parameter: " + a);
    }
}

在这个例子中，display方法被重载了两次，但没有重写任何方法。

六、重写中的异常处理

在重写方法时，子类方法声明的异常不能超过父类方法声明的异常。这意味着如果父类方法没有声明任何检查异常，子类方法也不能声明任何检查异常。如果父类方法声明了一个异常，子类方法可以声明相同的异常或该异常的子类。例如：

class Parent {
    void display() throws IOException {
        System.out.println("Parent display()");
    }
}
class Child extends Parent {
    @Override
    void display() throws FileNotFoundException {
        System.out.println("Child display()");
    }
}

在这个例子中，Child类的display方法声明了FileNotFoundException，这是合法的，因为FileNotFoundException是IOException的子类。

七、静态方法和私有方法不能被重写

静态方法和私有方法不能被重写，因为静态方法属于类，而不是对象。私有方法则是类的内部实现，子类无法访问。例如：

class Parent {
    static void display() {
        System.out.println("Parent display()");
    }
    private void show() {
        System.out.println("Parent show()");
    }
}
class Child extends Parent {
    static void display() {
        System.out.println("Child display()");
    }
    private void show() {
        System.out.println("Child show()");
    }
}

在这个例子中，display方法在Child类中重新定义，但它并没有重写父类的静态方法。相同地，show方法在Child类中重新定义，但它也没有重写父类的私有方法。

八、抽象方法的重写

在Java中，抽象类可以包含抽象方法，这些方法没有实现，需要在子类中重写。抽象方法必须在子类中实现，否则子类也必须声明为抽象类。例如：

abstract class Parent {
    abstract void display();
}
class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display()");
    }
}

在这个例子中，Child类必须实现Parent类的抽象方法display，否则Child类也必须声明为抽象类。

九、接口方法的重写

在Java中，接口可以定义方法，这些方法需要在实现类中重写。接口中的方法默认是public和abstract的，因此在实现类中重写时，方法必须是public的。例如：

interface Displayable {
    void display();
}
class Child implements Displayable {
    @Override
    public void display() {
        System.out.println("Child display()");
    }
}

在这个例子中，Child类必须实现Displayable接口的display方法，并且方法必须声明为public。

十、重写与多态性

重写是实现运行时多态性的关键。在Java中，通过父类引用调用重写的方法时，实际执行的是子类的方法。例如：

class Parent {
    void display() {
        System.out.println("Parent display()");
    }
}
class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display()");
    }
}
public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.display();  // 输出: Child display()
    }
}

在这个例子中，尽管obj的引用类型是Parent，但实际对象是Child，因此调用display方法时执行的是Child类的实现。

十一、重写的实际应用

重写在实际开发中有广泛的应用，特别是在设计模式和框架中。一个常见的例子是Java的集合框架，其中许多类重写了Object类的方法，如toString、equals和hashCode。重写这些方法有助于提供更有意义的字符串表示和更有效的集合操作。例如：

class Person {
    private String name;
    private int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

在这个例子中，Person类重写了toString、equals和hashCode方法，以提供更有意义的字符串表示和更有效的集合操作。

十二、总结

重写是Java中一个非常重要的概念，它允许子类根据需要修改和扩展父类的方法。要正确地进行重写，必须确保方法签名相同、访问权限不低于父类方法、返回类型兼容，并推荐使用@Override注解来标识重写的方法。了解重写的细节和实际应用对于编写高效、可维护的代码至关重要。希望这篇文章能帮助你更好地理解Java中的重写概念。