Java开发网 - 为什么类中定义的属性直接赋值与在方法中赋值会有不同

Topic: 为什么类中定义的属性直接赋值与在方法中赋值会有不同

1.为什么类中定义的属性直接赋值与在方法中赋值会有不同

Posted by: jimmyofth
Posted on: 2008-09-23 10:11

定义一个父类


public class ParentClass {
public int i=1;
public String s=new String("string---parent");
public char[] ca={'j','a','r'};
void get(){
  System.out.println("i="+i);
  for(int i=0;i<3;i++){
    System.out.print(ca[i]);
  }
  System.out.println("(par-get)/n");
  System.out.println("this is parent class");
}
}

定义一个子类


public class SubClass extends ParentClass {
  int i=2;
  String s=new String("string---sub");
  public char[] ca={'s','u','b'};
  float f=10.0f;
  void get(){
    System.out.println("this is subclass");
    System.out.println("i="+i);
    for(int i=0;i<3;i++){
      System.out.print(ca[i]);
    }
    System.out.print("(sub-get)\n");
  }
  void getF(){
    System.out.println;
  }

}

main方法


    ParentClass p=new SubClass();
    SubClass s=new SubClass();
    System.out.println("---Parent---");
    System.out.println(p.i);
    System.out.println(p.s);
    p.get();
    for(int i=0;i<3;i++){
      System.out.print(p.ca[i]);
    }
    System.out.print("\n");

    System.out.println("---Sub---");
    System.out.println(s.i);
    System.out.println(s.s);
    s.get();

结果


---Parent---
1
string---parent
this is subclass
i=2
sub(sub-get)
jar
---Sub---
2
string---sub
this is subclass
i=2
sub(sub-get)

为什么直接在main方法里取i,s的值，与在get方法里取值是不同的？
一个取自父类，一个取自子类

类的属性是存储在栈里还是堆里？

2.Re:为什么类中定义的属性直接赋值与在方法中赋值会有不同 [Re: jimmyofth]

Copy to clipboard

Posted by: JiafanZhou
Posted on: 2008-09-25 16:37

> 为什么直接在main方法里取i,s的值，与在get方法里取值是不同的？
> 一个取自父类，一个取自子类
Correct, this special rules applies to non-static fields declared in the class.
i.e.
- Fields that have the same as as any super-classes/interfaces will be overridden in the current derived class, and being used in the methods of the derived class.
- Fields does not have the dynamic binding attributes, in other words, they are not polymorphic, any methods are polymorphic.
- As a general rule, fields have the same as as super classes/interfaces should be avoided as not to cause confusion.
- Your example clearly shows this feature.

> 类的属性是存储在栈里还是堆里？
depends if it is a primitive or a Java Object type.
- for a primitive type, it will be stored in the stack.
- for a Java Object type, it will be stored in the heap.
- there are some violation to this general rule, depending on how JRE is implemented by Sun, for example, String has some special Literal Pool that does not strictly follow this rule in order to enhance the performance.

Regards,
Jiafan