JAVA静态方法能被继承重写吗？

最新推荐文章于 2024-03-14 21:21:09 发布

原创最新推荐文章于 2024-03-14 21:21:09 发布 · 656 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #静态 #继承 #重写

JAVASE-常用类专栏收录该内容

3 篇文章

订阅专栏

本文探讨了Java中静态方法的特性，特别是在类继承结构中的行为。通过具体示例，展示了子类如何调用父类的静态方法，但无法重写静态方法，突出了静态方法在继承体系中的特殊地位。

能继承单不能重写
在这里插入图片描述

public class A {
    static void show(){
        System.out.println("静态");
    }
}
class B extends A{
    public static void main(String[] args) {
        B b=new B();
        B.show();
    }
}

在这里插入图片描述

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

LG代码O

关注关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

每日一知识点- Java 方法重载和方法重写

2301_82095378的博客

07-25

1095

😀 准备好了吗？让我们一起步入这座Java神奇的城堡，揭开方法重载（Overloading）和方法重写（Overriding）的神秘面纱。

Java 继承和方法重写

05-13

- **抛出异常**：重写方法抛出的异常类型不能大于被重写方法的异常类型。 - **修饰符**：子类方法不能是 private 或 static，否则不属于重写，而是隐藏。 3. **@Override 注解**：使用 `@Override` 注解可以...

1 条评论您还未登录，请先登录后发表或查看评论

java静态方法能否被重写

08-24

705

JAVA静态方法形式上可以重写，但从本质上来说不是JAVA的重写。因为静态方法只与类相关，不与具体实现相关，声明的是什么类，则引用相应类的静态方法(本来静态无需声明，可以直接引用)，看下例子： class Base{ static void a( ){System.out.println("A"); } void b...

关于java静态方法继承问题

weixin_33894640的博客

03-15

212

结论：java中静态属性和静态方法可以被继承，但是没有被重写(overwrite)而是被隐藏. 原因： 1).静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成对，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静...

Java中的静态方法能否被重写？

12-22

* 非静态方法属于类的实例，是可以被子类重写，从而达到多态的效果；　　静态方法属于类，是不能被重写，故而也不能实现多态。 * 　　下面是具体的验证过程　　首先，定义一个超类A，里边定义一个静态方法和一个非静态方法： publicclassA{ publicvoidunstaticMethod(){ System.out.println("SuperClassunstaticMethod"); } publicstaticvoidstaticMethod(){ System.out.println("SuperClassstaticMethod"); } } 　　接下

Java可以重写静态方法吗？

Habby的专栏

12-16

2423

本文由 ImportNew - 唐小娟翻译自 Geekexplains。如需转载本文，请先参见文章末尾处的转载要求。问：你可以重写静态方法吗？答：如果从重写方法会有什么特点来看，我们是不能重写静态方法的。虽然就算你重写静态方法，编译器也不会报错。也就是说，如果你试图重写静态方法，Java不会阻止你这么做，但你却得不到预期的结果（重写仅对非静态方法有用）。重写指的是根据运行时对象的

Java中的静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？

qq_38366111的博客

03-14

1466

静态方法是与类绑定的，而不是与实例绑定的。子类无法覆盖父类的静态方法，因为无法通过子类的实例来调用父类的静态方法，只能通过父类本身来调用。另外，子类可以通过自己的静态方法来隐藏父类的静态方法。当子类和父类有相同名称的静态方法时，子类的静态方法会隐藏父类的静态方法。隐藏后，通过子类的实例无法调用父类的静态方法，只能通过父类名来调用。当子类继承父类时，子类会继承父类的静态属性和静态方法。子类可以直接使用父类的静态属性和静态方法，无需重新定义。在Java中，静态属性和静态方法是可以被继承的，但不能被重写。

浅谈java中静态方法的重写问题详解

09-05

总之，Java中的静态方法不能被重写，只能被隐藏。静态方法的调用在编译时就已经确定，基于方法调用时的类引用，而不是对象的实际类型。如果想要实现类似重写的效果，应将方法改为非静态，并确保遵循Java的继承和多态...

Java编程子类能否重写父类的静态方法探索

08-29

静态方法可以被子类继承，但是不能被重写。子类可以继承父类的静态方法，但是不能覆盖父类的静态方法。需要注意的是，静态方法是属于类的，而不是对象的。静态方法可以被子类继承，但是不能被重写。这是 Java 编程...

Java静态方法能不能被重写

qq_58453382的博客

12-17

3680

在Java中非静态方法可以被子类重写，但是静态方法是不能被子类重写的。虽然写完不会报错，但是这样所谓的“重写”是不具备多态的。 public class Person { public static void say() { System.out.println("hi"); } } class Student extends Person{ public static void say() { System.out.println("hello

java静态方法是否被继承？

flybird的博客

03-05

673

java的方法可以被继承，但是并不会体现多态体现继承public class Study { public static void main(String[] args) { B a=new B(); a.demo(); } } class A{ public static void demo(){ System.out.p

Java面试之静态方法能否被重写

Machine4869的博客

08-17

366

演示 package com.mxx.demospring.demo; public class Son extends Father{ @Override public void m02() { System.out.println("son m02"); } public static void m01() { System.out.println("son m01"); } public static void

Java中static静态方法可以继承吗？可以被重写吗？

热门推荐

楼兰剑客

02-28

1万+

结论：可以被继承，但是不能被重写，如果父子类静态方法名相同，则会隐藏父类方法。 1、Java中所有方法都能被继承，包括私有方法(但不可见)和静态方法。 2、Father f = new Son(); f.staticMethod(); Father f = null; f.staticMethod(); 这两个都会调用父类的方法，因为静态方法是类的方法和具体对象没关系，和直接用类名调用一样。 3、...

java静态方法可以被重写吗_父类的静态方法能不能被子类重写

weixin_33037313的博客

02-26

2420

首先答案是不能！这个问题有两个关键字，一个是静态方法，一个是重写。我们来先说说重写，可能很多初学的朋友分不清重写和重载的区别。重写：子类继承父类后，定义了一个和父类中的一模一样方法，这个一模一样是值方法名和参数的定义一模一样。这时候子类要实现这个方法，就称为对父类方法的重写。重载：子类继承父类后，定义了一个和父类中相同名字的方法，但是参数不一样(必须)，实现也不同(可选)，这就是重载。静态方法：j...

java中静态方法可以被继承，不能override

weixin_41866717的博客

06-10

3573

在Java中静态方法可以被继承，但是不能被覆盖，即不能重写。如果子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。父类引用指向子类对象时，只会调用父类的静态方法。所以，它们的行为也并不具有多态性。 ......

java静态方法可以被重写吗,Java中静态方法能否被重写

weixin_42374930的博客

03-16

386

在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写(Override)。方法重写又称方法覆盖。public class Test {public static void main(String[] args) {/*** 结论：* 静态方法可以被继承，但是不能被覆盖，即不能重写。* */Son.st...

静态方法可以重写么？

weixin_34284188的博客

07-03

2897

2019独角兽企业重金招聘Python工程师标准>>> ...

可以重写静态方法吗？

Beckio的博客

01-04

894

如果从重写方法会有什么特点来看，我们是不能重写静态方法的。虽然就算你重写静态方法，编译器也不会报错。也就是说，如果你试图重写静态方法，Java不会阻止你这么做，但你却得不到预期的结果（重写仅对非静态方法有用）。重写指的是根据运行时对象的类型来决定调用哪个方法，而不是根据编译时的类型。让我们猜一猜为什么静态方法是比较特殊的？因为它们是类的方法，所以它们在编译阶段就使用编译出来的类型进行绑定了。使用对

静态方法能被重写么？

硅脂味咖啡的博客

05-02

3301

先建个父类： public class Test { public static void set() { } } 再建个子类： public class Test1 extends Test { } 通过编译器提示，发现没有可以重写的方法，如下图：所以静态方法不能被重写总结其实重写是为了运行时多态，而静态方法初始化时就和类做了绑定，哪来的什么多态特征，所以静...

使用实例方法能被重写对吗？

最新发布

11-12

<think> 我们正在讨论Java中实例方法能否被重写的问题。根据面向对象编程的原则，实例方法是可以被重写的。重写发生在子类中，当子类提供了一个与父类具有相同方法签名（方法名、参数列表）的方法时，就发生了重写。重写允许子类改变继承自父类的方法的行为。引用[2]和引用[3]中的例子都展示了实例方法的重写： - 在引用[2]中，`Animal`类有`cry`方法，`Cat`和`Dog`子类分别重写了`cry`方法，从而实现了多态。 - 在引用[3]中，`Base`类有实例方法`b`，子类`Inherit`重写了该方法，所以当通过父类引用指向子类对象时（`Base c = new Inherit();`），调用`c.b()`会执行子类重写的方法。注意：重写与隐藏的区别： - 实例方法：重写（override）是动态绑定，运行时根据实际对象类型调用方法。 - 静态方法：隐藏（hide）是静态绑定，编译时根据引用类型决定调用的方法。因此，实例方法是可以被重写的，而且这是Java多态性的重要体现。结论：实例方法可以被重写。下面我们用代码示例来验证： ```java class Animal { public void sound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { @Override public void sound() { System.out.println("Dog barks"); } } public class Test { public static void main(String[] args) { Animal myDog = new Dog(); myDog.sound(); // 输出: Dog barks } } ``` 在这个例子中，`Dog`类重写了`sound`方法，所以通过父类引用`myDog`（实际指向子类对象）调用`sound`方法时，执行的是子类重写的方法。另外，重写有一些规则： 1. 子类方法的访问权限不能比父类方法更严格（例如，父类方法是public，子类不能是protected或private）。 2. 返回类型必须相同或是父类方法返回类型的子类型（协变返回类型）。 3. 方法名和参数列表必须相同。 4. 不能重写被final修饰的方法。所以，实例方法的重写是Java多态的核心机制之一。 §§相关问题§§ 1. 重写和重载的区别是什么？ 2. 在重写方法时，如何调用父类的方法？ 3. 重写方法时，子类方法抛出异常有什么限制？ 4. 什么是协变返回类型？能否举例说明？ 5. 为什么静态方法不能被重写？ </think> ### 实例方法能否被重写？在 Java 中，**实例方法可以被重写（override）**，这是面向对象编程中多态性的核心特性之一。以下是详细分析： #### ✅ 实例方法可以被重写的证据 1. **引用[2]的示例代码**： ```java class Animal { public void cry() { System.out.println("我不知道怎么叫"); } } class Cat extends Animal { @Override // 重写父类方法 public void cry() { System.out.println("我是小小猫"); } } ``` 当调用 `new Cat().cry()` 时，输出 `"我是小小猫"`，证明子类成功重写了父类的实例方法。 2. **引用[3]的示例代码**： ```java class Base { void b() { System.out.println("B"); } } class Inherit extends Base { @Override // 重写父类方法 void b() { System.out.println("D"); } } public static void main(String[] args) { Base c = new Inherit(); c.b(); // 输出"D"（动态绑定） } ``` 通过父类引用 `Base c` 调用 `b()` 时，实际执行的是子类重写的方法（输出 `"D"`），这证明了： - 运行时根据**实际对象类型**决定调用哪个方法（动态绑定） - 实现了多态特性 #### ❌ 对比：静态方法不能被重写引用[1]和引用[3]明确展示了静态方法的行为： ```java class StaticSuper { public static String staticGet() { return "Base"; } } class StaticSub extends StaticSuper { public static String staticGet() { return "Derived"; } // 隐藏而非重写 } public static void main(String[] args) { StaticSuper sup = new StaticSub(); System.out.println(sup.staticGet()); // 输出"Base"（静态绑定） } ``` 静态方法的调用由**编译时类型**决定（静态绑定），这被称为**方法隐藏**而非重写。 #### 重写的核心规则 1. **必要条件**： - 相同的方法签名（方法名+参数列表） - 子类访问权限 ≥ 父类（如父类`protected`，子类可为`public`） - 使用 `@Override` 注解（推荐，编译器会验证） 2. **动态绑定机制**： ```mermaid graph LR A[编译时] --> B[检查父类方法存在性] C[运行时] --> D[根据实际对象类型调用方法] ``` 3. **与字段访问的区别**： ```java class Parent { int val = 10; } class Child extends Parent { int val = 20; } // 字段隐藏 Parent obj = new Child(); System.out.println(obj.val); // 输出10（字段静态绑定） ``` ### 总结对比表 | 特性 | 实例方法 | 静态方法 | |--------------|-----------------------------|-----------------------| | **能否重写** | ✅ 是（`@Override`） | ❌ 否（方法隐藏） | | **绑定方式** | 动态绑定（运行时决定） | 静态绑定（编译时决定） | | **多态支持** | ✅ 支持 | ❌ 不支持 | | **调用依据** | 实际对象类型（`new`的类型） | 声明类型（引用类型） | > 📌 **关键结论**：Java 的实例方法支持重写，这是实现多态的基础；而静态方法只能被隐藏，不具备多态性[^1][^2][^3]。