Redian新闻
>
local变量被赋值了几次?
avatar
local变量被赋值了几次?# Java - 爪哇娇娃
q*u
1
class X{ public int i=5; }
class Y extends X{ public int i=10; }
public class Test2{
public static void main(String[] args){
X x = new Y();
System.out.println("x.i = " + x.i );
}
}
答案是5,我在考虑, i的话在这里是不是赋值了2次,第一次在new Y(), 第二次在X x
=...的upcast这里出现。或者是i其实在这个X x = new Y()中,内存中有两个i? 我觉
得应该不是后者,因为X x的话,本身应该是reference, 个人猜应该是在upcast里面被
重新赋值成5.
还做了cpp的测试,
#ifndef STOCK_HPP_
#define STOCK_HPP_
class Stock{
public:
double price;
Stock();
};
class StockB : public Stock{
public:
avatar
q*u
2
自己敲了一下,
class P{
public int i;
public P(){
i = 5;
System.out.println("P.i = "+i);
}
}
class K extends P{
public int i;
public K(){
i = 10;
System.out.println("K.i = "+i);
}
}
public class Test4{
public static void main(String[] args){
P x = new K();
K k = (K)x;
System.out.println("x.i = " + x.i );
System.out.println("k.i = "+k.i);
}
}
输出是
P.i = 5
K.i = 10
x.i = 5

【在 q*********u 的大作中提到】
: class X{ public int i=5; }
: class Y extends X{ public int i=10; }
: public class Test2{
: public static void main(String[] args){
: X x = new Y();
: System.out.println("x.i = " + x.i );
: }
: }
: 答案是5,我在考虑, i的话在这里是不是赋值了2次,第一次在new Y(), 第二次在X x
: =...的upcast这里出现。或者是i其实在这个X x = new Y()中,内存中有两个i? 我觉

avatar
u*s
3
变量没有overwrite
-------------------
| P |
| int i=5; |
| --------------- |
| | K | |
| | int i=10; | |
| | | |
| --------------- |
------------------

【在 q*********u 的大作中提到】
: 自己敲了一下,
: class P{
: public int i;
: public P(){
: i = 5;
: System.out.println("P.i = "+i);
: }
: }
: class K extends P{
: public int i;

avatar
q*u
4
你这样写,当然逻辑理解上没有问题,
但是我不知道能不能说物理内存里面,出现这种连续(包含)的现象?

变量没有overwrite
-------------------
| P |
| int i=5; |
| --------------- |
| | K | |
| | int i=10; | |
| | | |
| --------------- |
------------------

【在 u****s 的大作中提到】
: 变量没有overwrite
: -------------------
: | P |
: | int i=5; |
: | --------------- |
: | | K | |
: | | int i=10; | |
: | | | |
: | --------------- |
: ------------------

avatar
q*u
5
把这个完整的用java和cpp都写了一下,由于太长,先得两个小结论:java默认
function都有virtual的功能(final class 除外了),按照java术语就是override了
。另外,在继承中,both cpp和java,父类和子类的本地变量,都是内存上相互独立的。
Java版本:
class P{
public int i;
public P(){
i = 5;
System.out.println("P.i = "+i);
}
public int getI(){
return i;
}
}
class K extends P{
public int i;
public K(){
i = 10;
System.out.println("K.i = "+i);
}


【在 q*********u 的大作中提到】
: 自己敲了一下,
: class P{
: public int i;
: public P(){
: i = 5;
: System.out.println("P.i = "+i);
: }
: }
: class K extends P{
: public int i;

avatar
h*0
6
这个是必然的,面向对象性要求的。
另外,内存上是否连续,是过程式语言的思维方式。面向对象的思维方式就是,这个不
关你的事,取决于编译器(以及jvm)具体实现方式。
当然,c++里肯定是连续的,而java里应该是连续的。毕竟连续状态下效率是最好的。

的。

【在 q*********u 的大作中提到】
: 把这个完整的用java和cpp都写了一下,由于太长,先得两个小结论:java默认
: function都有virtual的功能(final class 除外了),按照java术语就是override了
: 。另外,在继承中,both cpp和java,父类和子类的本地变量,都是内存上相互独立的。
: Java版本:
: class P{
: public int i;
: public P(){
: i = 5;
: System.out.println("P.i = "+i);
: }

avatar
q*u
7
cpp中一定是连续吗?当然不反对连续提高效率的说法。
另外连续不一定说明有包含的现象,就是说,jvm里面是否存在内存中的:
__________________
| Kid Class int i|
| _____________ |
| | | |
| |Parent class |
| | int i | |
| |___________| |
|________________| 还是分开来的两块?
各类文章都是喜欢这么画,其实这个误导性还是很大的。
由于有gc, 这个的确在java里面钻牛角尖了,不过很想把这个东西有一个afirmative的
答案,或者是没有?
如果是根据不同的os, jvm表现出不同的分配,那倒是很值得了解一下。

这个是必然的,面向对象性要求的。
另外,内存上是否连续,是过程式语言的思维方式。面向对象的思维方式就是,这个不
关你的事,取决于编译器(以及jvm)具体实现方式。
当然,c++里肯定是连续的,而java里应该是连续的。毕竟连续状态下效率是最好的。
的。

【在 h*****0 的大作中提到】
: 这个是必然的,面向对象性要求的。
: 另外,内存上是否连续,是过程式语言的思维方式。面向对象的思维方式就是,这个不
: 关你的事,取决于编译器(以及jvm)具体实现方式。
: 当然,c++里肯定是连续的,而java里应该是连续的。毕竟连续状态下效率是最好的。
:
: 的。

avatar
h*0
8
cpp目前的实现就是一块整的啊。没听说过可以分块的。
java里怎么分的有区别吗?你又没有野指针。

【在 q*********u 的大作中提到】
: cpp中一定是连续吗?当然不反对连续提高效率的说法。
: 另外连续不一定说明有包含的现象,就是说,jvm里面是否存在内存中的:
: __________________
: | Kid Class int i|
: | _____________ |
: | | | |
: | |Parent class |
: | | int i | |
: | |___________| |
: |________________| 还是分开来的两块?

avatar
q*u
9
的确是整的, 如果一个基类100k, 子类120k, 那么根据子类new出来的对象地址的前
100k是基类内容,还有20k跟在后面

cpp目前的实现就是一块整的啊。没听说过可以分块的。
java里怎么分的有区别吗?你又没有野指针。

【在 h*****0 的大作中提到】
: cpp目前的实现就是一块整的啊。没听说过可以分块的。
: java里怎么分的有区别吗?你又没有野指针。

avatar
k*d
10
local variable can not be overwritten
just method can be overwritten
the i in X and the i in Y are two variebles, in fact you can call i in Y as
j or other names, then it is very clear!
相关阅读
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章,不代表同意其说法或描述,仅为提供更多信息,也不构成任何建议。文章信息的合法性及真实性由其作者负责,与Redian.news及其运营公司无关。欢迎投稿,如发现稿件侵权,或作者不愿在本网发表文章,请版权拥有者通知本网处理。