重写与隐藏,有些书上或介绍上可能名称不一样,但都大差不差。以前只了解重写,隐藏也听说过,但没有详细了解过,趁现在,整理一下这两方面的内容吧。

  首先,先说一下概念方面的东西。

重写

  重写:子类继承了父类,在子类中声明了与父类具有相同的方法名称与参数列表,并且具有相同的返回类型(或者子类的返回类型是父类的子类型)的实例方法,那么就说子类重写了父类中的同名方法(但父类的方法必须在子类中可见),而重写则是实现多态的前提;子类可以向上转型为父类类型,这样,当通过父类的引用来调用重写的方法时,就可以表现出子类的行为。

1. 如果子类重写了父类的方法,则有如下要求:

(1)子类与父类的方法必须都是实例方法,即都不是静态方法;

(2)子类与父类的方法需要具有相同的方法名称,参数列表,并且子类的返回类型与父类相同,或者是父类的子类型;

public class JavaTest extends Super {
@Override
public Integer print() {
return null;
}
} class Super {
public Object print() {
return null;
}
}

由于Integer是Object的子类,因此满足重写的条件。

(3)子类方法的访问权限不能小于父类的访问权限(可以有相同的访问权限);

public class JavaTest extends Super {
@Override
protected Integer print() {
return null;
}
} class Super {
public Object print() {
return null;
}
}

  访问权限由高到低依次为public,protected,包的访问权限,private。如果子类方法的访问权限低于父类的访问权限,那么编译器将给出错误信息。如上面的代码,编译器就会报错。

(4)子类方法不能比父类方法抛出更多的已检测异常(也称编译时异常),即子类方法抛出的异常必须是父类的子集或和父类是相同的异常;

public class JavaTest extends Super {
@Override
public Integer print() throws IOException {
return null;
}
} class Super {
public Object print() throws FileNotFoundException{
return null;
}
}

如上面代码,由于父类抛出的FileNotFoundException异常是子类抛出的IOException异常的子类,这是不允许的。

注意:如果是未检测异常(运行时异常),则不受此限制,子类也不用显示的使用throws抛出。

(5)父类的方法在子类中必须可见(子类可以使用super来访问父类中被重写的方法);

public class JavaTest extends Super {

    public Integer print() {
return null;
}
} class Super {
private Object print() {
return null;
}
}

如上面代码,父类中的方法是private类型的,在子类是无法访问的,但这不属于重写;

2.重写方法的调用

  当子类向上转型为父类类型A,通过父类的引用来调用某个方法时,Java编译器会先检查当前类有没有实现同名方法,如果有,执行当前类的方法;若没有,则去执行父类的同名方法;若父类没有,则再检查父类的父类有没有实现这个方法,以此类推,直到父类A为止。

public class JavaTest {
public static void main(String[] args) {
SuperClass test = new ThatClass();
test.print1();
test.print2();
test.print3();
}
} class ThatClass extends ThisClass {
public void print1() {
System.out.println("ThatClass print1()");
}
} class ThisClass extends SuperClass {
public void print1() {
System.out.println("ThisClass print1()");
} public void print2() {
System.out.println("ThisClass print2()");
}
} class SuperClass {
public void print1() {
System.out.println("SuperClass print1()");
} public void print2() {
System.out.println("SuperClass print2()");
} public void print3() {
System.out.println("SuperClass print3()");
}
}

执行结果如下:

ThatClass print1()
ThisClass print2()
SuperClass print3()

  还有一种情况,当使用父类的引用调用某个方法(如A方法)时,如果A方法中又调用了另一个父类中的方法(假设为B方法),那么依然按照上述的原则来查找B方法(由子类到父类的查找顺序);

public class JavaTest {
public static void main(String[] args) {
SuperClass test = new ThatClass();
test.print3();
}
} class ThatClass extends ThisClass {
public void print1() {
System.out.println("ThatClass print1()");
}
} class ThisClass extends SuperClass {
public void print1() {
System.out.println("ThisClass print1()");
} public void print2() {
System.out.println("ThisClass print2()");
}
} class SuperClass {
public void print1() {
System.out.println("SuperClass print1()");
} public void print2() {
System.out.println("SuperClass print2()");
} public void print3() {
System.out.println("SuperClass print3()");
print2();
print1();
}
}

打印结果如下:

SuperClass print3()
ThisClass print2()
ThatClass print1()

  简单分析下,父类引用调用print3方法,由于子类都没有重写,所以调用父类的方法,而父类print3方法又调用了父类的其他两个方法,并且这两个方法在子类中均可见,因此按照由子类到父类的查找顺序进行。由于print1方法在子类中被重写,所以调用子类的print1方法,而print2在子类中没有被重写,而是在子类的直接父类中被重写,所以调用子类的直接父类的print2方法。

  注意:JDK5.0之后可以使用@Override注解来标明要重写的方法。如果没有重写,编译器就会报错,如下,编译器就会报错。

class ThatClass extends ThisClass {
@Override
public void print1() {
System.out.println("ThatClass print1()");
}
} class ThisClass {
private void print1() {
System.out.println("ThisClass print1()");
}
}

隐藏

1. 什么是隐藏呢?

  隐藏其实和重写差不多,除了隐藏要求所有的方法都是静态方法,而重写是实例方法,其他的要求都是一样的。

  其实隐藏与重写最本质的区别是,重写是多态的前提,利用重写可以实现多态,而隐藏则无法实现多态。

下面通过一个简单的例子来了解一下:

public class JavaTest {
public static void main(String[] args) {
SuperClass superTest = new ThisClass();
superTest.hiding();
superTest.override();
System.out.println("===================");
ThisClass thisTest = (ThisClass)superTest;
thisTest.hiding();
thisTest.override();
}
} class ThisClass extends SuperClass {
public void override() {
System.out.println("ThisClass void override()");
} public static void hiding() {
System.out.println("ThisClass static void hiding()");
}
} class SuperClass {
public void override() {
System.out.println("SuperClass void override()");
} public static void hiding() {
System.out.println("SuperClass static void hiding()");
}
}

结果如下:

SuperClass static void hiding()
ThisClass void override()
===================
ThisClass static void hiding()
ThisClass void override()

通过以上例子,我们发现了重写与隐藏的根本区别:

(1)如果子类重写了父类的方法,则通过父类的引用调用的是子类的方法;

(2)如果子类隐藏了父类的方法,则通过父类的引用调用的仍然是父类的方法;

(3)这表明了实例方法的调用是动态绑定的,是在运行的时候根据对象真正的类型来决定调用哪个方法,而静态方法的调用是静态绑定的,是根据引用的类型来决定调用哪个方法。

2. 成员变量的隐藏

  当子类继承了父类,在子类中声明了与父类具有相同名称的成员变量时,那么就说子类隐藏了父类中的成员变量。子类不能重写父类中的成员变量,只能隐藏。

  所以,不管是静态变量还是实例变量,打印的是父类还是子类的成员变量取决于引用的类型,而不是对象的类型,因为子类隐藏了父类的成员变量。

public class JavaTest {
public static void main(String[] args) {
SuperClass superTest = new ThisClass();
System.out.println(superTest.min);
System.out.println(superTest.max);
System.out.println("===================");
ThisClass thisTest = (ThisClass)superTest;
System.out.println(thisTest.min);
System.out.println(thisTest.max);
}
} class ThisClass extends SuperClass {
public static int max = 8;
public int min = 7;
} class SuperClass {
public static int max = 4;
public int min = 5;
}

结果如下:

5
4
===================
7
8

3. 成员变量的继承

如果子类继承了父类的实例变量,子类将与父类共享该实例变量,在子类中修改将影响到父类,反之亦然。

public class JavaTest {
public static void main(String[] args) {
ThisClass superTest = new ThisClass();
System.out.println("修改之前:");
superTest.printMin();
System.out.println("修改子类之后:");
superTest.setMin(4);
superTest.printMin();
System.out.println("修改父类之后:");
superTest.setSuperMin(7);
superTest.printMin();
}
} class ThisClass extends SuperClass { public void setMin(int value) {
min = value;
} public void setSuperMin(int value) {
super.min = value;
} public void printMin() {
System.out.println("父类的min: " + super.min);
System.out.println("子类的min: " + min);
}
} class SuperClass {
public int min = 5;
}

结果如下:

修改之前:
父类的min: 5
子类的min: 5
修改子类之后:
父类的min: 4
子类的min: 4
修改父类之后:
父类的min: 7
子类的min: 7

至于静态成员变量就不举例了,静态成员变量和实例变量类似,但实例变量是基于对象的,即每一个对象中子类与父类都共享同一份实例对象的拷贝,而不同的对象互不干扰。而静态成员变量是基于类的,这将会导致所有子类与父类都共享同一个静态变量,无论创建多少对象,都是同一份拷贝。

总结:Java的重写与隐藏其实差不多,最根本的区别就是重写可以实现多态,而隐藏则无法实现多态。

参考自:《细说Java》

【细说Java】Java的重写与隐藏的更多相关文章

  1. 类与接口(五)java多态、方法重写、隐藏

    一.Java多态性 面向对象的三大特性:封装.继承.多态. 多态的类型,分为以下两种: 编译时多态: 指的是 方法重载.编译时多态是在编译时确定调用处选择那个重载方法,所以也叫 静态多态,算不上真正的 ...

  2. Java学习笔记二十二:Java的方法重写

    Java的方法重写 一:什么是方法的重写: 如果子类对继承父类的方法不满意,是可以重写父类继承的方法的,当调用方法时会优先调用子类的方法. 语法规则 返回值类型.方法名.参数类型及个数都要与父类继承的 ...

  3. java构造方法和重写equals

    Cell的构造函数 package Test; import java.util.Objects; public class Cell { int a; int b; public int getA( ...

  4. Java 15 新特性:隐藏类

    什么是隐藏类 隐藏类,是一种不能被其他类直接使用的类.引入隐藏类的主要目的是给框架来使用,使得框架可以在运行时生成类,并通过反射间接使用它们.可能有点抽象,不要紧,下面我们通过一个例子来直观的认识它! ...

  5. Java/Java Web中乱码解决汇总

    在开发Java/Java Web Application过程中,往往会出现乱码问题,而且有的时候真会弄得人很烦,浪费太多的时间. 记得之前看过一篇帖子,详细解释了Encoding/Decoding过程 ...

  6. 关于C#重写,隐藏的一些事

    第一次开始写技术博客,不知该从何处下手,本人算是菜鸟一枚,每每看到博客园里面的大牛们分享的技术文章,只能望其项背,高不可攀.但细细想来,若不尝试着从小处从低处慢慢去积累分享,想要成为技术大牛也只能沦为 ...

  7. 重载(overload),覆盖/重写(override),隐藏(hide)

    写正题之前,先给出几个关键字的中英文对照,重载(overload),覆盖/重写(override),隐藏(hide).在早期的C++书籍中,常常把重载(overload)和覆盖(override)搞错 ...

  8. C#之重写与隐藏

    一 重写与隐藏区别 (1)方法重写:就是在基类中的方法用virtual关键字来标识,然后在继承类中对该类进行重写(override),这样基类中的方法已经被重写了,已经失去了功能了.当让基类的对象的引 ...

  9. 新手如何学习Java——Java学习路线图

    推荐初学者阅读:新手如何学习Java——Java学习路线图

随机推荐

  1. ionic上拉加载更多解决方法

    第一步: $scope.hasmore = true;//是否允许上拉加载 $scope.num = 8;//显示条数 第二步://查询显示内容,查出所有的 $scope.Group = functi ...

  2. MVCC的一种实现方案

    源信息来源:http://my.oschina.net/juliashine/blog/111624 -- 简单描述: 一个data-server,通过mvcc来实现事务的一致性,已支持更高的吞吐和更 ...

  3. JS日期格式化函数性能优化篇

    最近开发的软件中需要用到日志功能,其中有一个重要功能是显示日期和时间.于是网上搜了一把,搜到大量的日期格式化函数,不过比较了下,感觉代码都不够优雅,而且性能都不给力.对线上一些代码进行了评测,以下是一 ...

  4. JAVA 多线程同步与互斥

    1. 为什么需要互斥: ​互斥操作  保证了  多线程操作的  原子性 , java的 互斥 语义 有 synchronized 关键字 提供. 主要方式 有  同步代码块 和  同步方法 两种 2. ...

  5. css中的垂直居中方法

    单行文字 (外行高度固定) line-height 行高, 将line-height值与外部标签盒子的高度值设置成一致就可以了. height:3em; line-height:3em; 多行文字 图 ...

  6. 一些YY

    都说苦痛难熬,哪里想过苦痛也是良药. 现在想起什么就说什么吧,反正自己还很弱,没有身高,没有长相,家里不富,学习也是渣,,, 大一的时候自己也很努力的去学习,去实践,但是成绩不理想,我就在想也许时间还 ...

  7. javascript基础之自执行函数

    1.匿名函数的定义方式 如下 var temp = function(){} 2.自执行函数 (function(){             内容    })        () 不带参数 (fun ...

  8. java反射新的应用

    利用java反射动态修改运行中对象的私有final变量,不管有没有get方法获取这个私有final变量. spring aop 本质是cglib,动态代理 可以做很多事情 query.addCrite ...

  9. mysql source命令导入sql文件效率分析和索引整理

    Query OK, 24918 rows affected (0.90 sec)Records: 24918  Duplicates: 0  Warnings: 0 Query OK, 24923 r ...

  10. php获取某个目录下面文件的内容

    if(!defined('PATH'))define('PATH', dirname(dirname(__FILE__)).'/');ini_set ( 'include_path', '.:' . ...