Java 重写时应当遵守的 11 条规则

CSDN 的小伙伴们,大家好,我是沉默王二。

重写(Overriding)算是 Java 中一个非常重要的概念,理解重写到底是什么对每个 Java 程序员来说都至关重要,这篇文章就来给大家说说重写过程中应当遵守的 12 条规则。

01、什么是重写?

重写带来了一种非常重要的能力,可以让子类重新实现从超类那继承过来的方法。在下面这幅图中,Animal 是父类,Dog 是子类,Dog 重新实现了 move() 方法用来和父类进行区分,毕竟狗狗跑起来还是比较有特色的。

重写的方法和被重写的方法,不仅方法名相同,参数也相同,只不过,方法体有所不同。

02、哪些方法可以被重写?

规则一:只能重写继承过来的方法

因为重写是在子类重新实现从父类继承过来的方法时发生的,所以只能重写继承过来的方法,这很好理解。这就意味着,只能重写那些被 public、protected 或者 default 修饰的方法,private 修饰的方法无法被重写。

Animal 类有 move()eat()sleep() 三个方法:

public class Animal {
  public void move() { }

  protected void eat() { }

  void sleep(){ }
}

Dog 类来重写这三个方法:

public class Dog extends Animal {
  public void move() { }

  protected void eat() { }

  void sleep(){ }
}

OK,完全没有问题。但如果父类中的方法是 private 的,就行不通了。

public class Animal {
  private void move() { }
}

此时,Dog 类中的 move() 方法就不再是一个重写方法了,因为父类的 move() 方法是 private 的,对子类并不可见。

public class Dog extends Animal {
  public void move() { }
}

03、哪些方法不能被重写?

规则二:final、static 的方法不能被重写。

一个方法是 final 的就意味着它无法被子类继承到,所以就没办法重写。

public class Animal {
  final void move() { }
}

由于父类 Animal 中的 move() 是 final 的,所以子类在尝试重写该方法的时候就出现编译错误了!

同样的,如果一个方法是 static 的,也不允许重写,因为静态方法可用于父类以及子类的所有实例。

public class Animal {
  final void move() { }
}

重写的目的在于根据对象的类型不同而表现出多态,而静态方法不需要创建对象就可以使用。没有了对象,重写所需要的“对象的类型”也就没有存在的意义了。

04、重写方法的要求

规则三:重写的方法必须有相同的参数列表。

public class Animal {
  void eat(String food) { }
}

Dog 类中的 eat() 方法保持了父类方法 eat() 的同一个调调,都有一个参数——String 类型的 food。

public class Dog extends Animal {
  public void eat(String food) { }
}

一旦子类没有按照这个规则来,比如说增加了一个参数:

public class Dog extends Animal {
  public void eat(String food, int amount) { }
}

这就不再是重写的范畴了,当然也不是重载的范畴,因为重载考虑的是同一个类。

规则四:重写的方法必须返回相同的类型

父类没有返回类型:

public class Animal {
  void eat(String food) { }
}

子类尝试返回 String:

public class Dog extends Animal {
  public String eat(String food) {
    return null;
  }
}

于是就编译出错了(返回类型不兼容)。

规则五:重写的方法不能使用限制等级更严格的权限修饰符

可以这样来理解:

  • 如果被重写的方法是 default,那么重写的方法可以是 default、protected 或者 public。
  • 如果被重写的方法是 protected,那么重写的方法只能是 protected 或者 public。
  • 如果被重写的方法是 public, 那么重写的方法就只能是 public。

举个例子,父类中的方法是 protected:

public class Animal {
  protected void eat() { }
}

子类中的方法可以是 public:

public class Dog extends Animal {
  public void eat() { }
}

如果子类中的方法用了更严格的权限修饰符,编译器就报错了。

规则六:重写后的方法不能抛出比父类中更高级别的异常

举例来说,如果父类中的方法抛出的是 IOException,那么子类中重写的方法不能抛出 Exception,可以是 IOException 的子类或者不抛出任何异常。这条规则只适用于可检查的异常。

可检查(checked)异常必须在源代码中显式地进行捕获处理,不检查(unchecked)异常就是所谓的运行时异常,比如说 NullPointerException、ArrayIndexOutOfBoundsException 之类的,不会在编译器强制要求。

父类抛出 IOException:

public class Animal {
  protected void eat() throws IOException { }
}

子类抛出 FileNotFoundException 是可以满足重写的规则的,因为 FileNotFoundException 是 IOException 的子类。

public class Dog extends Animal {
  public void eat() throws FileNotFoundException { }
}

如果子类抛出了一个新的异常,并且是一个 checked 异常:

public class Dog extends Animal {
  public void eat() throws FileNotFoundException, InterruptedException { }
}

那编译器就会提示错误:

Error:(9, 16) java: com.itwanger.overriding.Dog中的eat()无法覆盖com.itwanger.overriding.Animal中的eat()
  被覆盖的方法未抛出java.lang.InterruptedException

但如果子类抛出的是一个 unchecked 异常,那就没有冲突:

public class Dog extends Animal {
  public void eat() throws FileNotFoundException, IllegalArgumentException { }
}

如果子类抛出的是一个更高级别的异常:

public class Dog extends Animal {
  public void eat() throws Exception { }
}

编译器同样会提示错误,因为 Exception 是 IOException 的父类。

Error:(9, 16) java: com.itwanger.overriding.Dog中的eat()无法覆盖com.itwanger.overriding.Animal中的eat()
  被覆盖的方法未抛出java.lang.Exception

05、如何调用被重写的方法?

规则七:可以在子类中通过 super 关键字来调用父类中被重写的方法

子类继承父类的方法而不是重新实现是很常见的一种做法,在这种情况下,可以按照下面的形式调用父类的方法:

super.overriddenMethodName();

来看例子。

public class Animal {
  protected void eat() { }
}

子类重写了 eat() 方法,然后在子类的 eat() 方法中,可以在方法体的第一行通过 super.eat() 调用父类的方法,然后再增加属于自己的代码。

public class Dog extends Animal {
  public void eat() {
    super.eat();
    // Dog-eat
  }
}

06、重写和构造方法

规则八:构造方法不能被重写

因为构造方法很特殊,而且子类的构造方法不能和父类的构造方法同名(类名不同),所以构造方法和重写之间没有任何关系。

07、重写和抽象方法

规则九:如果一个类继承了抽象类,抽象类中的抽象方法必须在子类中被重写

先来看这样一个接口类:

public interface Animal {
  void move();
}

接口中的方法默认都是抽象方法,通过反编译是可以看得到的:

public interface Animal
{
  public abstract void move();
}

如果一个抽象类实现了 Animal 接口,move() 方法不是必须被重写的:

public abstract class AbstractDog implements Animal {
  protected abstract void bark();
}

但如果一个类继承了抽象类 AbstractDog,那么 Animal 接口中的 move() 方法和抽象类 AbstractDog 中的抽象方法 bark() 都必须被重写:

public class BullDog extends AbstractDog {

  public void move() {}

  protected void bark() {}
}

08、重写和 synchronized 方法

规则十:synchronized 关键字对重写规则没有任何影响

synchronized 关键字用于在多线程环境中获取和释放监听对象,因此它对重写规则没有任何影响,这就意味着 synchronized 方法可以去重写一个非同步方法。

09、重写和 strictfp 方法

规则十一:strictfp 关键字对重写规则没有任何影响

如果你想让浮点运算更加精确,而且不会因为硬件平台的不同导致执行的结果不一致的话,可以在方法上添加 strictfp 关键字。因此 strictfp 关键和重写规则无关。

到此这篇关于Java 重写时应当遵守的 11 条规则的文章就介绍到这了,更多相关Java 重写规则内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间: 2021-03-28

Java 重写与重载方法与区别详解

重写(Override) 重写是子类对父类的允许访问的方法的实现过程进行重新编写!返回值和形参都不能改变.即外壳不变,核心重写! 重写的好处在于子类可以根据需要,定义特定于自己的行为. 也就是说子类能够根据需要实现父类的方法. 在面向对象原则里,重写意味着可以重写任何现有方法.实例如下: class Animal{ public void move(){ System.out.println("动物可以移动"); } } class Dog extends Animal{ public

java子类调用父类的方法中包含子类重写的实例方法

# 看题目是不是很绕,这个我也不知道怎么才能更简单的表达了 # 先看代码: public class Common { public static void main(String[] args) { Sub sub = new Sub(); sub.testSub(); } } class Parent { protected boolean test() { throw new RuntimeException(); } protected void testParent() { if (t

Java重写与重载之间的区别

重写(Override) 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变.即外壳不变,核心重写! 重写的好处在于子类可以根据需要,定义特定于自己的行为. 也就是说子类能够根据需要实现父类的方法. 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常.例如: 父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,因为 Exception 是 IOException 的父类,只能抛出 IOEx

java编程枚举类型那些事!枚举类型定义和重写枚举的方法

什么是枚举类型 枚举类型(Enumerated Type) 很早就出现在编程语言中,它被用来将一组类似的值包含到一种类型当中. 而这种枚举类型的名称则会被定义成独一无二的类型描述符,在这一点上和常量的定义相似.不过相比较常量类型,枚举类型可以为申明的变量提供更大的取值范围. 简单的枚举类型定义 假如你希望创建一个颜色库,你可以这样定义枚举类型 enum Color {red, green, yellow, black}; 然后你就可以使用它 Color T = Color.red; if (T

Java 重载、重写、构造函数的实例详解

Java 重载.重写.构造函数的实例详解 方法重写 1.重写只能出现在继承关系之中.当一个类继承它的父类方法时,都有机会重写该父类的方法.一个特例是父类的方法被标识为final.重写的主要优点是能够定义某个子类型特有的行为. class Animal { public void eat(){ System.out.println ("Animal is eating."); } } class Horse extends Animal{ public void eat(){ Syste

java中为何重写equals时必须重写hashCode方法详解

前言 大家都知道,equals和hashcode是java.lang.Object类的两个重要的方法,在实际应用中常常需要重写这两个方法,但至于为什么重写这两个方法很多人都搞不明白. 在上一篇博文Java中equals和==的区别中介绍了Object类的equals方法,并且也介绍了我们可在重写equals方法,本章我们来说一下为什么重写equals方法的时候也要重写hashCode方法. 先让我们来看看Object类源码 /** * Returns a hash code value for

关于java中可变长参数的定义及使用方法详解

JAVA中可以为方法定义可变长参数( Varargs)来匹配不确定数量的多个参数,其定义用"..."表示.其实,这类似于为方法传了一个数组,且在使用方法上也和数组相同,如下: public void test(String... str){ for(String s : str){ } } 调用方法就像普通的调用方式相同,只不过可以匹配的参数为0到多个.如下: test(); test("lilei"); test("lilei","h

Java中通过Class类获取Class对象的方法详解

前言 本文主要给大家介绍的是关于Java通过Class类获取Class对象的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍: 阅读API的Class类得知,Class 没有公共构造方法.Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的 获取Class对象的三种方式(实例采用Person类) 方式1:通过Object类的getObject()方法 Person p = new Person(); Class c

java中重写equals()方法的同时要重写hashcode()方法(详解)

object对象中的 public boolean equals(Object obj),对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true: 注意:当此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码.如下: (1) 当obj1.equals(obj2)为true时,obj1.hashCode() == obj2.hashCode()必须为true (2) 当obj

java中synchronized(同步代码块和同步方法)详解及区别

 java中synchronized(同步代码块和同步方法)详解及区别 问题的由来: 看到这样一个面试题: //下列两个方法有什么区别 public synchronized void method1(){} public void method2(){ synchronized (obj){} } synchronized用于解决同步问题,当有多条线程同时访问共享数据时,如果进行同步,就会发生错误,Java提供的解决方案是:只要将操作共享数据的语句在某一时段让一个线程执行完,在执行过程中,其他

Java 中桥接模式——对象结构型模式的实例详解

Java  中桥接模式--对象结构型模式的实例详解 一.意图 将抽象部分与它的实现部分分离,使他们都可以独立的变化. 二.适用性 以下一些情况使用Bridge模式 你不希望在抽象和它的实现部分之间有一个固定的绑定关系.例如这种情况可能因为,在程序运行时刻实现部分应可以被选择或者切换. 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充.这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合,并分别对他们进行扩充. 对一个抽象的实现部分的修改应对客户不产生影响,即客户代码不必重新编译

Java中SSM框架实现增删改查功能代码详解

记录一下自己第一次整合smm框架的步骤. 参考博客和网站有:我没有三颗心脏 How2J学习网站 1.数据库使用的是mySql,首先创建数据库ssm1,并创建表student create database ssm1; use ssm1; CREATE TABLE student( id int(11) NOT NULL AUTO_INCREMENT, student_id int(11) NOT NULL UNIQUE, name varchar(255) NOT NULL, age int(1

java中的前++和后++的区别示例代码详解

java中的前加加++和后加加++,有很多人搞的很晕,不太明白!今天我举几个例子说明下前++和后++的区别! 其实大家只要记住一句话就可以了,前++是先自加再使用而后++是先使用再自加! 前++和后++总结:其实大家只要记住一句话就可以了,前++是先自加再使用而后++是先使用再自加! 请大家看下面的例子就明白了! public class Test { public static void main(String[] args) { //测试,前加加和后加加 //前++和后++总结:其实大家只要

使用Java构造和解析Json数据的两种方法(详解二)

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,采用完全独立于语言的文本格式,是理想的数据交换格式.同时,JSON是 JavaScript 原生格式,这意味着在 JavaScript 中处理 JSON数据不须要任何特殊的 API 或工具包. 在www.json.org上公布了很多JAVA下的json构造和解析工具,其中org.json和json-lib比较简单,两者使用上差不多但还是有些区别.下面接着介绍用org.json构造和解析Json数据的方法

使用Java构造和解析Json数据的两种方法(详解一)

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,采用完全独立于语言的文本格式,是理想的数据交换格式.同时,JSON是 JavaScript 原生格式,这意味着在 JavaScript 中处理 JSON数据不须要任何特殊的 API 或工具包. 在www.json.org上公布了很多JAVA下的json构造和解析工具,其中org.json和json-lib比较简单,两者使用上差不多但还是有些区别.下面首先介绍用json-lib构造和解析Json数据的方法

JS中call/apply、arguments、undefined/null方法详解

a.call和apply方法详解 -------------------------------------------------------------------------------- call方法: 语法:call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 定义:调用一个对象的一个方法,以另一个对象替换当前对象. 说明: call 方法可以用来代替另一个对象调用一个方法.call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指