变量的多态性初始化 [英] Initialization in polymorphism of variables
问题描述
假设您有以下代码:
class A {
int i = 4;
A(){
print();
}
void print(){
System.out.println(A);
}
}
类B扩展A {
int i = 2; //this line
public static void main(String [] args){
A a = new B();
a.print();
}
void print(){
System.out.println(i);
}
}
这将打印0 2
现在,如果删除标记为this line的行,
代码将打印4 4
- 我理解,如果没有int i = 2; ,
A a = new B();
,初始化i为4,调用构造函数,
它控制 print()方法在
B类
,最后输出4.
a.print()
会调用 print()
方法在类B中,因为方法将在运行时绑定,这也将使用在类A,4定义的值。
(当然如果我的推理有任何错误,让我知道)
- 然而,我不明白是如果有是int i = 2。
为什么是如果你插入代码,第一部分打印0而不是4?为什么它不初始化变量为i = 4,而是分配默认值?
- 方法覆盖
- 实例变量阴影
-
A :: i
B :: i
均为默认值0
- super ,这意味着A的构造函数被调用
-
A :: i
设置为4 -
print()
被调用。由于后期绑定,它绑定到B :: print()
-
B :: print ()
尝试打印B :: i
,它仍然为0
-
-
B :: i
设置为2 - I understand that if there was no int i=2; line,
- However, what i don't understand is if there is int i=2.
- Method overriding
- Instance variable shadowing
- order of constructors
A::i
andB::i
are all in default value0
- super(), which means A's constructor is called
A::i
is set to 4print()
is called. Due to late-binding, it is bound toB::print()
B::print()
is trying to print outB::i
, which which is still 0
B::i
is set to 2
我将简单介绍一下代码中发生的事情,看看你是否明白。
您的代码在概念上看起来像这样(跳过main()):
int i = 0; // default value
A(){
A :: i = 4; //最初在初始化语句
print();
}
void print(){
System.out.println(A);
}
}
类B扩展A {
int i = 0; //记住这个阴影A :: i
public B(){
super();
B :: i = 2;
}
void print(){
System.out.println(i);
}
}
> main(),你调用 A a = new B();
,它构造一个 B
,发生这种情况:
$ b b
然后,当您在 main()
中调用 a.print()
code> B :: print(),它正在输出 B :: i
(此时为2) p>
因此,您看到的结果是
Suppose you have the following code
class A {
int i = 4;
A() {
print();
}
void print () {
System.out.println("A");
}
}
class B extends A {
int i = 2; //"this line"
public static void main(String[] args){
A a = new B();
a.print();
}
void print () {
System.out.println(i);
}
}
this will print 0 2
Now, if you remove line labeled "this line" the code will print 4 4
A a = new B();
will call class A, initializes i as 4, call constructor,
which gives control over to print()
method in class B
, and finally prints 4.
a.print()
will call print()
method in class B because the methods will bind at runtime, which will also use the value defined at class A, 4.
(Of course if there is any mistake in my reasoning, let me know)
why is it that if you insert the code, the first part (creating object) will all of sudden print 0 instead of 4? Why does it not initialize the variable as i=4, but instead assigns default value?
It is a combination of several behaviors in Java.
I will simply go through what happened in your code, and see if you understand.
Your code conceptually looks like this (skipping main()):
class A {
int i = 0; // default value
A() {
A::i = 4; // originally in initialization statement
print();
}
void print () {
System.out.println("A");
}
}
class B extends A {
int i = 0; // Remember this shadows A::i
public B() {
super();
B::i = 2;
}
void print () {
System.out.println(i);
}
}
So, when in your original main()
, you called A a = new B();
, it is constructing a B
, for which this happens:
Then when you call a.print()
in your main()
, it is bounded to B::print()
which is printing out B::i
(which is 2 at this moment).
Hence the result you see
这篇关于变量的多态性初始化的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!