- 浏览: 213391 次
- 性别:
- 来自: 广州
文章分类
- 全部博客 (139)
- java (37)
- web (14)
- database (9)
- compute Net (1)
- design patten (4)
- 生活 (14)
- 求职 (5)
- j2me (1)
- 娱乐 (0)
- 漫画 (0)
- struts (5)
- hibernate (1)
- spring (2)
- ajax (3)
- oracle (3)
- UML&面向对象 (3)
- ffmpeg (2)
- eclipse (8)
- 技巧 (11)
- jsp (2)
- javascript (7)
- flex (2)
- xx (0)
- xxx (0)
- android (0)
- webservice (1)
- 博客 (1)
- jQuery (1)
- split (1)
- iss rewrite (1)
- 踩顶功能ajax (1)
- ext (2)
最新评论
-
longfu2012:
学习了
方法参数前加final的作用 -
irisAndKevin:
你的方法对整除有问题!
java 两数相除 四舍五入 精确 保留2位小数点、任意位小数点 -
wpf523:
...
方法参数前加final的作用 -
wpf523:
不错,解决了我的疑惑
方法参数前加final的作用 -
zhq426:
嗯,挺好用的吧
JAVASCRIPT 取得当前时间,包括农历时间 时间格式:2011年11月8日 16:54 星期二 农历辛卯年(兔) 十月十三 申时
JAVA面试题解惑系列(三)——变量(属性)的覆盖
关键字: java 面试题 继承 变量的覆盖 属性
作者:臧圩人(zangweiren)
网址:http://zangweiren.iteye.com
>>>转载请注明出处!<<<
我们来看看这么一道题:
控制台的输出结果是多少呢?20?40?还是60?
变量,或者叫做类的属性,在继承的情况下,如果父类和子类存在同名的变量会出现什么情况呢?这就是这道题要考查的知识点——变量(属性)的覆盖。
这个问题虽然简单,但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响。
我们先从普通变量说起。依照我们的惯例,先来看一段代码:
这段代码的运行结果如下:
从上面的结果中可以看出,private的变量与其它三种访问权限变量的不同,这是由于方法的重写(override)而引起的。关于重写知识的回顾留给以后的章节,这里我们来看一下其它三种访问权限下变量的覆盖情况。
分析上面的输出结果就会发现,变量的值取决于我们定义的变量的类型,而不是创建的对象的类型。
在上面的例子中,同名的变量访问权限也是相同的,那么对于名称相同但是访问权限不同的变量,情况又会怎样呢?事实胜于雄辩,我们继续来做测试。由于private变量的特殊性,在接下来的实验中我们都把它排除在外,不予考虑。
由于上面的例子已经说明了,当变量类型是父类(ParentClass)时,不管我们创建的对象是父类(ParentClass)的还是子类(SubClass)的,都不存在属性覆盖的问题,因此接下来我们也只考虑变量类型和创建对象都是子类(SubClass)的情况。
运行结果:
运行结果:
上面两段不同的代码,输出结果确是相同的。事实上,我们可以将父类和子类属性前的访问修饰符在friendly、protected和public之间任意切换,得到的结果都是相同的。也就是说访问修饰符并不影响属性的覆盖,关于这一点大家可以自行编写测试代码验证。
对于静态变量和常量又会怎样呢?我们继续来看:
运行结果如下:
虽然上面的结果中包含“子类静态变量”和“子类静态常量”,但这并不表示父类的“静态变量”和“静态常量”可以被子类覆盖,因为它们都是属于类,而不属于对象。
上面的例子中,我们一直用对象来对变量(属性)的覆盖做测试,如果是基本类型的变量,结果是否会相同呢?答案是肯定的,这里我们就不再一一举例说明了。
最后,我们来做个总结。通过以上测试,可以得出一下结论:
我们再回到篇首的那道题,我想大家都已经知道答案了,输出结果应该是40。
网址:http://zangweiren.iteye.com
>>>转载请注明出处!<<<
我们来看看这么一道题:
- class ParentClass {
- public int i = 10;
- }
- public class SubClass extends ParentClass {
- public int i = 30;
- public static void main(String[] args) {
- ParentClass parentClass = new SubClass();
- SubClass subClass = new SubClass();
- System.out.println(parentClass.i + subClass.i);
- }
- }
class ParentClass { public int i = 10; } public class SubClass extends ParentClass { public int i = 30; public static void main(String[] args) { ParentClass parentClass = new SubClass(); SubClass subClass = new SubClass(); System.out.println(parentClass.i + subClass.i); } }
控制台的输出结果是多少呢?20?40?还是60?
变量,或者叫做类的属性,在继承的情况下,如果父类和子类存在同名的变量会出现什么情况呢?这就是这道题要考查的知识点——变量(属性)的覆盖。
这个问题虽然简单,但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响。
我们先从普通变量说起。依照我们的惯例,先来看一段代码:
- class ParentClass {
- private String privateField = "父类变量--private";
- /* friendly */String friendlyField = "父类变量--friendly";
- protected String protectedField = "父类变量--protected";
- public String publicField = "父类变量--public";
- // private的变量无法直接访问,因此我们给他增加了一个访问方法
- public String getPrivateFieldValue() {
- return privateField;
- }
- }
- public class SubClass extends ParentClass {
- private String privateField = "子类变量--private";
- /* friendly */String friendlyField = "子类变量--friendly";
- protected String protectedField = "子类变量--protected";
- public String publicField = "子类变量--public";
- // private的变量无法直接访问,因此我们给他增加了一个访问方法
- public String getPrivateFieldValue() {
- return privateField;
- }
- public static void main(String[] args) {
- // 为了便于查阅,我们统一按照private、friendly、protected、public的顺序
- // 输出下列三种情况中变量的值
- // ParentClass类型,ParentClass对象
- ParentClass parentClass = new ParentClass();
- System.out.println("ParentClass parentClass = new ParentClass();");
- System.out.println(parentClass.getPrivateFieldValue());
- System.out.println(parentClass.friendlyField);
- System.out.println(parentClass.protectedField);
- System.out.println(parentClass.publicField);
- System.out.println();
- // ParentClass类型,SubClass对象
- ParentClass subClass = new SubClass();
- System.out.println("ParentClass subClass = new SubClass();");
- System.out.println(subClass.getPrivateFieldValue());
- System.out.println(subClass.friendlyField);
- System.out.println(subClass.protectedField);
- System.out.println(subClass.publicField);
- System.out.println();
- // SubClass类型,SubClass对象
- SubClass subClazz = new SubClass();
- System.out.println("SubClass subClazz = new SubClass();");
- System.out.println(subClazz.getPrivateFieldValue());
- System.out.println(subClazz.friendlyField);
- System.out.println(subClazz.protectedField);
- System.out.println(subClazz.publicField);
- }
- }
class ParentClass { private String privateField = "父类变量--private"; /* friendly */String friendlyField = "父类变量--friendly"; protected String protectedField = "父类变量--protected"; public String publicField = "父类变量--public"; // private的变量无法直接访问,因此我们给他增加了一个访问方法 public String getPrivateFieldValue() { return privateField; } } public class SubClass extends ParentClass { private String privateField = "子类变量--private"; /* friendly */String friendlyField = "子类变量--friendly"; protected String protectedField = "子类变量--protected"; public String publicField = "子类变量--public"; // private的变量无法直接访问,因此我们给他增加了一个访问方法 public String getPrivateFieldValue() { return privateField; } public static void main(String[] args) { // 为了便于查阅,我们统一按照private、friendly、protected、public的顺序 // 输出下列三种情况中变量的值 // ParentClass类型,ParentClass对象 ParentClass parentClass = new ParentClass(); System.out.println("ParentClass parentClass = new ParentClass();"); System.out.println(parentClass.getPrivateFieldValue()); System.out.println(parentClass.friendlyField); System.out.println(parentClass.protectedField); System.out.println(parentClass.publicField); System.out.println(); // ParentClass类型,SubClass对象 ParentClass subClass = new SubClass(); System.out.println("ParentClass subClass = new SubClass();"); System.out.println(subClass.getPrivateFieldValue()); System.out.println(subClass.friendlyField); System.out.println(subClass.protectedField); System.out.println(subClass.publicField); System.out.println(); // SubClass类型,SubClass对象 SubClass subClazz = new SubClass(); System.out.println("SubClass subClazz = new SubClass();"); System.out.println(subClazz.getPrivateFieldValue()); System.out.println(subClazz.friendlyField); System.out.println(subClazz.protectedField); System.out.println(subClazz.publicField); } }
这段代码的运行结果如下:
- ParentClass parentClass = new ParentClass();
- 父类变量--private
- 父类变量--friendly
- 父类变量--protected
- 父类变量--public
-
- ParentClass subClass = new SubClass();
- 子类变量--private
- 父类变量--friendly
- 父类变量--protected
- 父类变量--public
-
- SubClass subClazz = new SubClass();
- 子类变量--private
- 子类变量--friendly
- 子类变量--protected
- 子类变量--public
从上面的结果中可以看出,private的变量与其它三种访问权限变量的不同,这是由于方法的重写(override)而引起的。关于重写知识的回顾留给以后的章节,这里我们来看一下其它三种访问权限下变量的覆盖情况。
分析上面的输出结果就会发现,变量的值取决于我们定义的变量的类型,而不是创建的对象的类型。
在上面的例子中,同名的变量访问权限也是相同的,那么对于名称相同但是访问权限不同的变量,情况又会怎样呢?事实胜于雄辩,我们继续来做测试。由于private变量的特殊性,在接下来的实验中我们都把它排除在外,不予考虑。
由于上面的例子已经说明了,当变量类型是父类(ParentClass)时,不管我们创建的对象是父类(ParentClass)的还是子类(SubClass)的,都不存在属性覆盖的问题,因此接下来我们也只考虑变量类型和创建对象都是子类(SubClass)的情况。
- class ParentClass {
- /* friendly */String field = "父类变量";
- }
- public class SubClass extends ParentClass {
- protected String field = "子类变量";
- public static void main(String[] args) {
- SubClass subClass = new SubClass();
- System.out.println(subClass.field);
- }
- }
class ParentClass { /* friendly */String field = "父类变量"; } public class SubClass extends ParentClass { protected String field = "子类变量"; public static void main(String[] args) { SubClass subClass = new SubClass(); System.out.println(subClass.field); } }
运行结果:
- 子类变量
- class ParentClass {
- public String field = "父类变量";
- }
- public class SubClass extends ParentClass {
- protected String field = "子类变量";
- public static void main(String[] args) {
- SubClass subClass = new SubClass();
- System.out.println(subClass.field);
- }
- }
class ParentClass { public String field = "父类变量"; } public class SubClass extends ParentClass { protected String field = "子类变量"; public static void main(String[] args) { SubClass subClass = new SubClass(); System.out.println(subClass.field); } }
运行结果:
- 子类变量
上面两段不同的代码,输出结果确是相同的。事实上,我们可以将父类和子类属性前的访问修饰符在friendly、protected和public之间任意切换,得到的结果都是相同的。也就是说访问修饰符并不影响属性的覆盖,关于这一点大家可以自行编写测试代码验证。
对于静态变量和常量又会怎样呢?我们继续来看:
- class ParentClass {
- public static String staticField = "父类静态变量";
- public final String finalField = "父类常量";
- public static final String staticFinalField = "父类静态常量";
- }
- public class SubClass extends ParentClass {
- public static String staticField = "子类静态变量";
- public final String finalField = "子类常量";
- public static final String staticFinalField = "子类静态常量";
- public static void main(String[] args) {
- SubClass subClass = new SubClass();
- System.out.println(SubClass.staticField);
- // 注意,这里的subClass变量,不是SubClass类
- System.out.println(subClass.finalField);
- System.out.println(SubClass.staticFinalField);
- }
- }
class ParentClass { public static String staticField = "父类静态变量"; public final String finalField = "父类常量"; public static final String staticFinalField = "父类静态常量"; } public class SubClass extends ParentClass { public static String staticField = "子类静态变量"; public final String finalField = "子类常量"; public static final String staticFinalField = "子类静态常量"; public static void main(String[] args) { SubClass subClass = new SubClass(); System.out.println(SubClass.staticField); // 注意,这里的subClass变量,不是SubClass类 System.out.println(subClass.finalField); System.out.println(SubClass.staticFinalField); } }
运行结果如下:
- 子类静态变量
- 子类常量
- 子类静态常量
虽然上面的结果中包含“子类静态变量”和“子类静态常量”,但这并不表示父类的“静态变量”和“静态常量”可以被子类覆盖,因为它们都是属于类,而不属于对象。
上面的例子中,我们一直用对象来对变量(属性)的覆盖做测试,如果是基本类型的变量,结果是否会相同呢?答案是肯定的,这里我们就不再一一举例说明了。
最后,我们来做个总结。通过以上测试,可以得出一下结论:
- 由于private变量受访问权限的限制,它不能被覆盖。
- 属性的值取父类还是子类并不取决于我们创建对象的类型,而是取决于我们定义的变量的类型。
- friendly、protected和public修饰符并不影响属性的覆盖。
- 静态变量和静态常量属于类,不属于对象,因此它们不能被覆盖。
- 常量可以被覆盖。
- 对于基本类型和对象,它们适用同样的覆盖规律。
我们再回到篇首的那道题,我想大家都已经知道答案了,输出结果应该是40。
发表评论
-
java 两数相除 四舍五入 精确 保留2位小数点、任意位小数点
2011-11-03 17:53 7214java 四舍五入 精确 保留2位小数点、任意位小数点 ... -
Java中对字符串进行加密和解密
2011-08-18 17:14 17791.引言在实际工作中我们常常会遇到对数据进行加密解密的工作(如 ... -
两个日期之间的天数差
2011-08-11 11:02 1641/** * 两个日期之间的天数差 * @pa ... -
java split 特殊字符 分隔数组
2011-07-28 14:48 2158public class Test { /** ... -
JAVA 取得IP地址
2011-07-21 10:32 1051/** * 取得IP地址 * @param ... -
杯具博客设计
2011-07-08 22:41 883又是遇到了一个悲催的问题。 博客: 博客的设计是这样的: ... -
webservice 同步问题
2011-07-08 22:26 1083今天遇到了一个很郁闷个问题,webservice 同步问题。 ... -
二级栏目树构建
2011-05-30 15:15 822输出栏目树 public class Entr ... -
ttt
2009-10-10 12:50 782<script type="text/ ... -
JXL, POI操作excel文件zz
2009-09-27 11:59 16632008-11-10 JXL, POI操作excel文件z ... -
jxl 写 excel
2009-09-27 11:57 1061package net.blogjava.chenlb;imp ... -
方法参数前加final的作用
2009-07-17 11:01 2581方法参数前加final的作用 2009-06-28 ... -
java 调用ffmpeg执行dos bat命令 带有两个参数
2009-03-12 16:58 3466import java.io.IOException; pu ... -
java 调用ffmpeg执行dos命令
2009-03-12 16:10 1993import java.io.File; import ja ... -
增强Eclipse(MyEclipse)输入代码提示功能
2009-03-02 16:16 1659增强Eclipse(MyEclipse)输入代码提示功能 ... -
myeclipse性能提升技巧
2009-03-02 16:07 947myeclipse性能提升技巧 200 ... -
Java JDK :小心使用 boxing
2008-12-05 18:33 764[size=large]Java JDK :小心使用 boxi ... -
Java JDK:自动装箱和拆箱
2008-12-05 18:06 876[size=large]Java JDK:自动 ... -
JDK5.0新特性介绍
2008-11-16 19:13 803JDK5.0新特性介绍 [转贴 2006-02-23 15: ... -
java面向对象我基本特征
2008-11-04 15:13 801继承:子类继承父类成为特殊的父类。直接获得父类的属性和方法。是 ...
相关推荐
.8 1.3 JAVA面试题解惑系列(三)——变量(属性)的覆盖 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16 1.4 JAVA面试题解惑系列(四)——final、finally和finalize的区别 . . . . ...
**1.3 JAVA面试题解惑系列(三)——变量(属性)的覆盖** - **知识点**:讲解Java中变量覆盖(或称为“隐藏”)的概念,即子类中声明与父类相同名称的变量时,子类变量在子类方法中优先访问。 **1.4 JAVA面试题...
总结来说,对于Java面试中常出现的关于类初始化顺序的问题,开发者应当掌握以下几点: 1. 单个类内成员的初始化顺序:静态变量、静态初始化块、变量、初始化块、构造器。 2. 在继承关系中,子类的静态成员会在父类...
JAVA面试题解惑系列(一)——类的初始化顺序 JAVA 是一门面向对象的编程语言,类的初始化顺序是 JAVA 程序员和 JAVA 工程师面试中一个非常重要的知识点。本文将详细讲解类的初始化顺序,并提供了相关的测试代码,...
《JAVA面试题解惑系列——类的初始化顺序》 在Java编程中,理解类的初始化顺序是面试中常见的考察点,因为它直接关系到程序的执行逻辑。本文将深入探讨类的初始化过程,以及在继承场景下如何理解这个过程。 首先,...
最后,“JAVA面试题解惑系列(十三)——变量(属性)的覆盖”涉及面向对象的特性,子类如何重写父类的方法或属性,以及可见性和访问修饰符的影响。 通过学习这些面试题解惑系列,不仅可以提升Java程序员对语言核心...
JAVA面试题解惑系列(一)——类的初始化顺序 在Java编程语言中,理解类的初始化顺序是非常重要的,尤其是在涉及继承的情况下。本节将详细介绍类初始化的规则,并通过实例来帮助理解。 ##### 类的初始化顺序规则 ...
### Java面试题解惑系列——类的初始化顺序详解 #### 背景介绍 在Java面试过程中,关于类的初始化顺序的问题是常见的考察点之一。此类问题通常涉及到类的加载机制、静态变量与实例变量的区别、初始化块的作用及执行...
JAVA 面试题解惑系列之 String 对象创建机制 本文将深入探讨 JAVA 中 String 对象的创建机制,解答常见的面试题目,并探索 String 对象池的概念和机制。 一、String 对象的创建方式 在 JAVA 中,String 对象可以...
【标题】:“面试题解惑系列(十)——话说多线程” 【描述】:本篇文章主要探讨的是Java中的多线程概念及其在面试中常见的问题解析。 【标签】:“面试题解惑系列(十)——话说多线程” 【部分内容】:在Java中,多...
《JAVA面试题解惑系列——类的初始化顺序》 在Java面试中,关于类的初始化顺序是一个常见的考点。深入理解这一概念,对于成为一名合格的Java开发者至关重要。在Java中,类的初始化顺序遵循一定的规则,这包括静态...
在面试中,能够清晰地解释这个概念不仅显示了你对Java基础知识的掌握,也体现了你在实际编程中解决问题的能力。所以,对于Java程序员和工程师来说,掌握类的初始化顺序是非常基础且重要的知识点。
### JAVA面试题解惑系列——类的初始化顺序 #### 一、基础知识回顾 在Java编程中,类的初始化顺序是一个非常重要的概念,特别是在面试时,它经常被用来考察面试者对于Java类加载机制的理解程度。类的初始化顺序...
### JAVA面试题解惑系列知识点总结 #### 一、类的初始化顺序 **知识点概述:** 在Java中,类的初始化顺序是一个常见的面试问题。它主要涉及到类成员(包括静态和非静态)的加载和初始化过程。理解这些基础知识有助...
Java中的字符串(String)是编程面试中的热门话题,其特性与操作是面试官常常用来考察候选人基础知识的手段。本文将深入探讨String对象的一些关键知识点。 首先,我们要了解`String`类的`length()`方法。这个方法返回...