【Java】重写规则

原创 已于 2025-04-01 17:22:49 修改 · 1.3k 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #开发语言
于 2025-04-01 17:21:54 首次发布

目录

一、Override

二、父类与子类

1.实例方法与实例方法

1.1正常情况可以重写

 1.1不能重写的几种特殊情况

2.实例方法与类方法

2.1实例方法不能被类方法重写

2.2类方法不能被实例方法重写

3.类方法与类方法 

三、抽象类

1.abstract+final

2.abstract+static

3.abstract+访问权限降低 

四、接口

一、Override

在我们开始了解Java重写规则之前，先了解一个注解：Override，接下来我会借助这个注解和多态机制来阐述重写机制

在 Java 中，@Override 是一个注解（Annotation），用于指示一个方法是重写（Override）了父类或接口中的方法。它的主要作用是帮助开发者明确代码意图，并在编译时检查方法签名是否正确。如果方法签名不符合父类或接口的定义，编译器会抛出错误。

  • 明确代码意图：告诉编译器和阅读代码的人，这个方法是重写父类或接口中的方法。

  • 编译时检查：如果方法签名与父类或接口中的方法不匹配，编译器会报错，从而避免潜在的错误。

也就是说，如果给方法前面加上override注解，而编译器又不报错的情况下，就是重写成功了

二、父类与子类

1.实例方法与实例方法

1.1正常情况可以重写

代码

public class Person
{
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show()
    {
        System.out.println("姓名："+name+" 年龄："+age);
    }
}

class Student extends Person
{
    private String id;
    private String major;

    public Student(String name, int age, String id, String major) {
        super(name, age);
        this.id = id;
        this.major = major;
    }

    @Override
    public void show()
    {
        System.out.println("姓名："+super.name+" 年龄："+age+" 学号："+id+" 专业："+major);
    }
}

class Test
{
    public static void main(String[] args)
    {
        //重写
        Student s=new Student("小明",19,"23100666","计科");
        s.show();
        //多态
        Person p=new Student("小美",20,"8888","计科");
        p.show();
    }
}

运行结果 

 1.1不能重写的几种特殊情况

（1）子类重写的访问权限不能比父类低（严格），若父类方法是public，则子类也必须是public，不能是protected或private，若违反则报错如下：

（2） 父类方法是private权限时，子类不能重写，只能“隐藏”

若用override尝试重写，报错如下：

这其实已经证明不能重写了，下面我们通过一个例子证明是“隐藏”而非“重写”：

代码 

class Parent {
    private void privateMethod() {
        System.out.println("This is a private method in Parent.");
    }

    // 提供一个公共方法来调用 privateMethod
    public void callPrivateMethod() {
        privateMethod();
    }
}

class Child extends Parent {
    // 尝试重写父类的 private 方法
    private void privateMethod() {
        System.out.println("This is a private method in Child.");
    }

    public static void main(String[] args) {
        Child child = new Child();
        child.callPrivateMethod(); // 调用父类的公共方法
    }
}

运行结果 

可以看到，调用的是父类的方法，我们来对比一下访问权限为public时成功重写的情况

代码

class Parent {
    public void publicMethod() {
        System.out.println("This is a public method in Parent.");
    }

    // 提供一个公共方法来调用 publicMethod
    public void callPrivateMethod() {
        publicMethod();
    }
}

class Child extends Parent {
    // 尝试重写父类的 public 方法
    public void publicMethod() {
        System.out.println("This is a public method in Child.");
    }

    public static void main(String[] args) {
        Child child = new Child();
        child.callPrivateMethod(); // 调用父类的公共方法
    }
}

运行结果 

可以看到，成功重写时，调用的是子类的方法 、

（3）子类重写的方法不能比父类方法抛出更多的异常

这部分具体可见我的另一篇博客【Java】异常处理总结

2.实例方法与类方法

实例方法与类方法不能互相重写

这部分很好理解，重写本质上是为多态服务的，而多态访问方式应该一致，这就要求重写前后的访问方式应该不变，而实例方法和类方法的访问方式是不同的，因此不能互相重写

2.1实例方法不能被类方法重写

代码

class Parent {
    public void display() {
        System.out.println("Parent instance method");
    }
}

class Child extends Parent {
    // 尝试用实例方法重写父类的静态方法
    public static void display() {
        System.out.println("Child static method");
    }
}

class Main {
    public static void main(String[] args) {
        Parent obj1 = new Child();
        obj1.display(); // 调用的是Parent类的实例方法

        Child obj2 = new Child();
        obj2.display(); // 调用的是Child类的静态方法
    }
}

报错 

2.2类方法不能被实例方法重写

代码

class Parent {
    public static void display() {
        System.out.println("Parent static method");
    }
}

class Child extends Parent {
    // 尝试用实例方法重写父类的静态方法
    public void display() {
        System.out.println("Child instance method");
    }
}

class Main {
    public static void main(String[] args) {
        Parent obj1 = new Child();
        obj1.display(); // 调用的是Parent类的静态方法

        Child obj2 = new Child();
        obj2.display(); // 调用的是Child类的实例方法
    }
}

运行结果 

3.类方法与类方法 

类方法不能被类方法重写，只是“隐藏”

尝试用override注解

代码

class Parent {
    public static void display() {
        System.out.println("Parent static method");
    }
}

class Child extends Parent {
    // 尝试重写父类的静态方法
    @Override
    public static void display() {
        System.out.println("Child static method");
    }
}

class Main {
    public static void main(String[] args) {
        Parent obj1 = new Child();
        obj1.display(); 

        Child obj2 = new Child();
        obj2.display();
    }
}

报错 

不使用override注解时，是“隐藏”

代码 

class Parent {
    public static void display() {
        System.out.println("Parent static method");
    }
    public void show()
    {
        display();
    }
}

class Child extends Parent {
    // 尝试重写父类的静态方法
    public static void display() {
        System.out.println("Child static method");
    }
}

class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();
    }
}

运行结果

三、抽象类

首先需要明确，抽象类是可以含有抽象方法的特殊的类，因此服从<二、父类与子类>中的所有规则，除此以外，还需要考虑abstract，final修饰符等

总体来讲，这部分可以从这个角度来考虑：抽象方法存在的意义就是为了继承重写的，因此但凡是某个代表需要重写的修饰符和某个代表不能重写的修饰符混用，这就矛盾了，是错误的

（1）代表需要重写的修饰符：abstract

（2）代表不能重写的修饰符：final，static，private（还包含二.1中几个不能重写的特殊情况）

为了证明这一点，我们来看几个例子

1.abstract+final

代码

abstract class Parent {
    final abstract public void display();

}

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

class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.display();
    }
}

报错 

2.abstract+static

代码

abstract class Parent {
    abstract public static void display();

}

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

class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.display();
    }
}

报错

3.abstract+访问权限降低 

代码

abstract class Parent {
    abstract public void display();

}

class Child extends Parent {
    protected void display() {
        System.out.println("Child static method");
    }
    
    public static void main(String[] args) {
        Child obj = new Child();
        obj.display();
    }
}

报错 

四、接口

接口的重写规则仍然服从上面说的基本规则，但还需考虑特殊情况

接口与类不同，接口的实现类可以实现多个接口，这种情况下，如果多个接口中定义了同名的默认方法，实现类必须显式地重写该方法，不然编译器就无法确定使用哪个接口的默认方法

示例

interface A {
    default void greet() {
        System.out.println("Hello from A");
    }
}

interface B {
    default void greet() {
        System.out.println("Hello from B");
    }
}

class C implements A, B {
    @Override
    public void greet() {
        System.out.println("Hello from C"); // 显式实现
    }
}

若没有显式重写，报错如下：

Java 重写(Override)与重载(Overload)
weixin_30847271的博客
08-16 1197
重写(Override) 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个...
Java 三大特性之多态
2301_82302966的博客
05-06 1282
介绍多态以及其中涉及的重写、向上转型、向下转型、instanceof、动态绑定、静态绑定等
Java知识点（九）：方法的重写、重写和重载的区别、package、import、public、private、protected、默认访问控制符、static、final
qq_45138120的博客
04-26 4645
包括方法的重写（Override）、重写和重载的区别、访问控制（package、import、public、private、protected、默认访问控制符、访问控制修饰符对比）、静态变量、静态方法、静态块、成员变量和静态变量的区别、修饰成员变量、修饰方法、修饰类。
java重写方法
热门推荐
m0_62476684的博客
04-07 2万+
文章目录一.重写二.重写和重载的区别1.重载2.重写3.代码举例 一.重写 重写（override）：也称覆盖。重写是子类对父类非静态，非private，非final方法的实现过程进行重新编写，返回值（JDK7以后，被重写的方法返回值类型可以不同，但是必须是具有父子关系的）和形参都不能改变。即外壳不变，核心重写。 【方法重写的规则】： 1.子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名(参数列表) 要完全一致 2.JDK7以后，被重写的方法返回值类型可以不同，但是必须是具有父
替换手机号中间4位（php，js）
mobeinight的专栏
12-24 2010
JS方法function hideMobile(num){ var mphone =num.substr(3,4); var lphone = num.replace(mphone,"****"); return lphone; } php方法 $phone=substr_replace($phone,'****',3,4);
Java方法重写的规则
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！✨
06-19 6128
在Java中，方法重写（Overriding）是面向对象编程中的一个核心概念，它允许子类提供一个与父类相同名称、相同参数列表的方法，以实现或修改父类方法的行为。
java方法重写规则_Java中重写的规则
weixin_34410564的博客
02-13 1134
子类不能重写父类的静态方法，私有方法。即使你看到子类中存在貌似是重写的父类的静态方法或者私有方法，编译是没有问题的，但那其实是你重新又定义的方法，不是重写。具体有关重写父类方法的规则如下：重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。有个人曾经这样说：父类为protected的，子类重写时一定要用pub...
java重写规则
单色冰灵的博客
08-06 4238
摘自:百度问答(xiangjuan314) java的重写规则: 对于异常重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。重写规则之一：重写方法不能比被重写方法限制有更严格的访问级别。 （但是可以更广泛，比如父类方法是包访问权限，子类的重写方法是public访问权限。） 比如：Object类有个toString()方法，开始重写这个方...
脸打肿都不要忘了呀，Java 重写时应当遵守的 11 条规则！！
沉默王二
03-26 1万+
CSDN 的小伙伴们，大家好，我是沉默王二。 重写（Overriding）算是 Java 中一个非常重要的概念，理解重写到底是什么对每个 Java 程序员来说都至关重要，这篇文章就来给大家说说重写过程中应当遵守的 12 条规则。 01、什么是重写？ 重写带来了一种非常重要的能力，可以让子类重新实现从超类那继承过来的方法。在下面这幅图中，Animal 是父类，Dog 是子类，Dog 重新实现了 move() 方法用来和父类进行区分，毕竟狗狗跑起来还是比较有特色的。 重写的方法和被重写的方法，不仅方法名相同，
Java方法重写
2301_76161469的博客
08-07 6063
重写override，也称为覆盖）：在子类中对父类中允许访问的方法的实现过程进行重新编写，子类中方法的名称、返回值类型、参数列表与父类相同，只有方法体中的实现不同。
Java方法重写与重载的区别
weixin_46015018的博客
01-20 8915
Java方法重写（Override）与重载（Overload）的区别(超详细) 首页在我们要学习这个知识点之前，应该要先了解什么是多态？ 在最初学习java的时候，人们都知道，java这种面向对象的语言，一共有三大特征，分别是：封装、继承、多态。 多态是同一个行为具有多个不同表现形式或形态的能力。 举个例子，比如大多数动物（抽象类）会叫，但是狗（实现类）就是汪汪汪，猫（实现类）就是喵喵喵。 多态实现的必要条件 子类必须继承父类 必须有重写 父类引用指向子类对象 多态的实现途径 多态的实现
Java-方法的重写
qq_53125287的博客
05-19 701
纸类对父类继承过来的方法进行的覆盖，覆写的操作，就称为方法的重写。
Java中的重写(Override)
weixin_68105699的博客
08-21 2182
Java中的重写(Override)
Java详解重写
Happy_syy的博客
07-30 493
1.什么是重写： 重写就是重新改写，对父类方法进行改写或改造的现象称为方法重写或方法覆盖，例如 public void eat() { System.out.println("用筷子吃饭"); } @Override public void eat() { System.out.println("用刀叉吃饭"); } public static void mai...
java基础-重写
m0_61285646的博客
05-02 633
/ 发短信System.out.println("发短信。。。。。。");// 玩游戏System.out.println("玩游戏。。。。。。");// 来电显示System.out.println("来电显示你的电话号码");// System.out.println("来电显示你的电话号码");System.out.println("显示头像");System.out.println("显示号码归属地");
Java--方法重写
m0_67721787的博客
01-02 2194
方法重写
Java——重写（Override）与重载（Overload）（概念理解+应用举例）
贝尔摩德苦艾酒
06-22 1万+
Java——重写（Override）与重载（Overload）（概念理解+应用举例）
java的重写
qq_39222456的博客
10-24 742
重写 与 重载 之间的区别: 都是方法的重写和重载 重载: 在同一个类中 多个方法组成,方法名相同 参数列表不同|方法签名不同 重写: 1.在不同的类中 2.继承|实现 3.方法签名相同 2.重写的作用: 子类存在从父类中继承的功能,但是子类对功能的实现,与父类不一样,可以对这个功能进行方法的重写 3.如何使用重写方法: 子类对象...
Java中重载和重写的区别
qq_45041581的博客
01-18 8000
文章目录 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 JavaSE自学新手，学完三大特征总结。 一、重载是什么？ 1.重载是在一个类中实现的，可以使用在构造器、方法中。 2.重载是方法名相同，形参列表不同的构造器、方法间彼此构成重载，与权限修饰符、返回值类型无关。 3.在运行时，我们可以选择调用不同形参的方法。 4.代码举例： private void show(){ System.
java方法重写的规则
m0_61672451的博客
03-21 3391
java方法重写（override/overwrite）规则： 1.方法名参数列表相同 2.子类访问权限大于或者等于父类的： 权限修饰符表示权限访问范围：private < 缺省 < protected < public 3.子类方法的返回值类型小于或等于父类的： （1）父类的为void时，子类相同。 （2）父类的为基本类型时，子类为相同的基本数据类型。 （3）父类的引用类型时，子类的小于或等于父类的。（eg：父类的为A，那么子类的需要为A或者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值