JAVA面试题解惑系列（三）——变量（属性）的覆盖

removed.

请到博文下载PDF文件：http://zangweiren.iteye.com/blog/241218

评论

35 楼 Wuaner 2010-01-19  

其实归根结底就一句话：

类的成员变量不存在多态！

34 楼 junJZ_2008 2009-09-14  

一句话就是：属性是不能被履盖或重写，这不像方法，因对象中的变量都有各存储空间，当创建一个子类对象时，即即使父类的属性为私有的，在创建时也会分配存储它的空间，并且这一空为子类对象所使用。

33 楼 jackdown 2008-10-08  

感觉有点误导人哦。
转型成父类类型，那么访问的本应该都是父类的属性和方法，
但方法调用涉及到多态，故理解多态的特性应该就ok了吧。

32 楼 臧圩人 2008-08-26  

回复Chihom：

完全正确

31 楼 Chihom 2008-08-26  

我觉得通过ParentClass temp = new SubClass();
类似这样的声明，通过temp访问的属性均是父类的；如果父类的方法被子类重写，访问的方法就是子类的
如：

class ParentClass { 
     private String privateField = "父类变量--private"; 
     String getPrivateField()
{
return privateField;
}
    
} 
  
public class SubClass extends ParentClass { 
     public String privateField = "子类变量--private"; 
String getPrivateField()
{
return privateField;
}
  
    
  
     public static void main(String[] args) { 
         ParentClass temp=new SubClass();
System.out.println(temp.getPrivateField());//（1）
//System.out.println(temp.privateField);//不可访问
     } 
}

（1）处之所以能到 “子类变量--private”
是因为父类的方法被重写，从而从子类的方法中获取到子类中的privateField

不知对否，敬请指教

30 楼 thiner 2008-08-23  

你写这么多总结起来就是一句话：属性是不能被覆盖的。

29 楼 kruce 2008-08-13  

引用

当变量类型是父类（ParentClass）时，不管我们创建的对象是父类（ParentClass）的还是子类（SubClass）的，都不存在属性覆盖的问题，因此接下来我们也只考虑变量类型和创建对象都是子类（SubClass）的情况

对属性的引用在编译期就规定好了，扯什么覆盖，别误导别人了
如果声明和引用类型都是子类的话是多么简单啊，还有什么值得考虑的，

28 楼 future_9 2008-07-30  

学习，学习

27 楼 臧圩人 2008-07-28  

回复rururu101：

引用

1、变量、静态变量都是静态绑定的

你在这里想说的是常量吧

引用

2、子类会继承父类所有的成员变量（包括private），子类看不见而已，是隐藏而非覆盖。且private变量不能通过super访问。

是隐藏还是覆盖，这里大家争论的还是个概念问题。就像值传递和引用传递一样。
什么叫隐藏？什么叫覆盖？它们本质上有什么区别呢？

26 楼 rururu101 2008-07-25  

1、变量、静态变量都是静态绑定的
2、子类会继承父类所有的成员变量（包括private），子类看不见而已，是隐藏而非覆盖。且private变量不能通过super访问。

25 楼 臧圩人 2008-07-24  

回复ioryioryzhan：
应该没有什么情况下必须用到，而这种情况确实是需要尽量避免的，因为它会使代码变得艰涩难懂。
面试题中考到的某一些用法都是我们在实际编程中应该避免使用的

24 楼 ioryioryzhan 2008-07-24  

在什么环境下一定要用变量覆盖吗，
我一直是，尽量避免的

23 楼 dickensi 2008-07-23  

不同意楼主的观点。属性不能被覆盖，只能被隐藏

22 楼 臧圩人 2008-07-22  

回复n7kki：
为了避免误解，已经增加注释提示大家注意了，呵呵

21 楼 n7kki 2008-07-22  

hrtc 你够牛B
ParentClass subClass = new SubClass();  
        System.out.println(SubClass.staticField);  
        System.out.println(subClass.finalField);  
        System.out.println(SubClass.staticFinalField);  
        subClass.print();  
这段代码够畏缩 SubClass和subClass

20 楼 臧圩人 2008-07-22  

回复rabbitbug：
你说的对。不过对于方法来说，更准确地描述应该是重写（override）

19 楼 rabbitbug 2008-07-22  

成员属性的覆盖与方法好象相反
比如下面这段代码

class Parent
{
	int i = 10;
	
	void printme()
	{
		System.out.println("parent:" + i);
		
	}
}

public class Inhert3 extends Parent
{
	int i =20;
	
	void printme()
	{
		System.out.println("sub:" + i);
		
	}

	public static void main(String[] args)
	{

		Inhert3 i3 = new Inhert3();
		i3.printme();
		System.out.println(i3.i);
		
		Parent a4 = new Inhert3();
		a4.printme();
		System.out.println(a4.i);
		
		((Parent)new Inhert3()).printme();
		System.out.println(((Parent)new Inhert3()).i);
	}

}

运行的结果是
sub:20
20
sub:20
10
sub:20
10


a4.printme() 运行的是子类的方法
但a4.i却是父类的属性

18 楼 臧圩人 2008-07-18  

CSDN网友 dracularking 写道：

若没看错 楼主说的这种情况应该是隐藏(hidden) 翻译区别于覆盖，因为容易与override混淆

子类对父类的继承可能导致各种陷阱，比如隐藏（hidden），遮蔽（shadow），遮掩（obscure），覆写（override），重载（overload）等行为。

来看看2个隐藏的例子：

1.

class Base {
    public String className = "Base";
}

class Derived extends Base {
    private String className = "Derived";
}

public class PrivateMatter {
    public static void main(String[] args) {
        System.out.println(new Derived().className);
    }
}

我们可能指望它打印Base，可很抱歉，此程序是无法编译通过，刚一看错误信息你可能愣住：

无权访问private的className。。。

对于实例方法，子类可以对父类的实例方法进行覆写，可对于实例变量（而且包括类变量，静态方法,final静态变量），子类只能隐藏父类中的相同名称的变量，而不是覆写。根据new Derived()的编译期类型为子类Derived，调用子类的className属性，可此属性是声明为private的，所以无法编译通过。如果我们想调用父类中被隐藏的className,可以通过向上转型来实现：

System.out.println(((Base)new Derived()).className);

此例告诉我们，JAVA语言中子类定义与父类相同类型和名称的变量、嵌套类型和静态方法，都将隐藏掉父类中相应的方法，而不是覆写，所以，请避免隐藏！此过程中当然也不存在所谓多态。另外，我们不应该违反这样一条规则：对基类所做的任何行为，都应当可以同样作用于子类。此例中子类className为private，违反了基类中className是public的定义，这样的写法应该避免。

2.也许哪一天你突然想自己写一个String来代替java.lang中的String，让我们来看看会发生什么？

public class StrungOut {
    public static void main(String[] args) {
        String s = new String("Hello world");
        System.out.println(s);
    }
}

class String {
    private final java.lang.String s;

    public String(java.lang.String s) {
        this.s = s;
    }

    public java.lang.String toString() {
        return s;
    }
}

试运行此程序，JVM会给你一个非常奇怪的消息：

StrungOut does not have a main method！

怪了，明明有个main方法啊？？请注意，main方法中的参数String []args，其中的String类型要求是java.lang.String，可JVM会自动地把把这些参数认为是我们自定义的下面那个String类型，这就是错误的原因所在。教训：避免重用类名，特别是java平台的类型，特别是java.lang包下的类名！在此例中，当前类所在包中的所有类的main方法都将因此失效。

17 楼 臧圩人 2008-07-18  

CSDN网友 sagezk 写道：

子类从超类继承下来了一个 s 自己又添加了一个实例域 s，这样当创建了一个子类实例时它内部就保存有两个都叫 s 的实例域的值，当我们从这个子类对象外部去访问 s 只能看到和访问到子类自己定义的 s 的值，而打父类继承下来的 s 被子类的 s 给遮盖住了（这个就是你说的所谓覆盖，当你站在别人前面时我只能看到你，但不等于被你挡住的人就不存在了），所有访问不到被遮住的父类继承下来的那个 s。而当我们从子类对象内部去访问 s 时，基于同样道理我们只能看到子类自己的 s，当想访问超类定义的 s 时要用 super 来限定，即 super.s（前提是有访问权限，即如果子类和超类在同一个包内那超类的 s 的访问级别应该是“默认的”、protected 或 public，分处不同包时超类的 s 的访问级别应该是 protected 或 public）。

16 楼 臧圩人 2008-07-17  

回复zfyyfz：

zfyyfz 写道

我来说一句，方法是按 类型（句柄）去访问的，方法是按对象访问的 ；

是不是写错了？怎么两处都是方法？