标签：
请输入并运行以下代码，得到什么结果?？
package com;
public class Test {
// public static int value=1;//类变量，跟main是同级关系
public static void main(String[] args) {
Foo obj1=new Foo();
Foo obj2=new Foo();
System.out.println(obj1==obj2);
}
}
class Foo
{
int value=100;
}
以下代码为何无法通过编译？哪儿出错了？
上面Foo obj1=new Foo();的括号中少了下面定义的类中的参数initValue,在加 int initValue = 0
package com;
public class Test {
// public static int value=1;//类变量，跟main是同级关系
public static void main(String[] args) {
int initValue = 0;
Foo obj1=new Foo(initValue);
}
}
class Foo
{
int value;
public Foo(int initValue){
value=initValue;
}
}
使用上页幻灯片中定义的类，以下代码输出结果是什么？
package com;
public class Test {
// public static int value=1;//类变量，跟main是同级关系
public static void main(String[] args) {
InitializeBlockClass obj=new InitializeBlockClass();
System.out.println(obj.field);
obj=new InitializeBlockClass(300);
System.out.println(obj.field);
}
}
class InitializeBlockClass {
{
field=200;
}
public int field=100;
public InitializeBlockClass (int value){
this.field=value;
}
public InitializeBlockClass (){
}
}
输出的结果是100，300，初始化以定义式的结果为准，在花括号中的结构为辅，在实际开发中不要这样写代码，应该尽量保证一个字段只初始化一次！
当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行。请自行编写示例代码验证以上结论。
package com;
public class Test {
// public static int value=1;//类变量，跟main是同级关系
public static void main(String[] args) {
InitializeBlockClass obj=new InitializeBlockClass();
{
obj.field=200;
}
System.out.println(obj.field);
obj=new InitializeBlockClass(300);
System.out.println(obj.field);
InitializeBlockNext obj1=new InitializeBlockNext();
System.out.println(obj1.field1);
obj1=new InitializeBlockNext(500);
System.out.println(obj1.field1);
InitializeBlockBack obj2=new InitializeBlockBack();
System.out.println(obj2.field2);
obj2=new InitializeBlockBack(600);
System.out.println(obj2.field2);
}
}
class InitializeBlockClass {
public int field=100;
public InitializeBlockClass (int value){
this.field=value;
}
public InitializeBlockClass (){
}
}
class InitializeBlockNext{
public int field1=100;
public InitializeBlockNext (int value){
this.field1=value;
}
public InitializeBlockNext (){
}
}
class InitializeBlockBack{
{
field2=200;
}
public int field2=100;
public InitializeBlockBack (int value){
this.field2=value;
}
public InitializeBlockBack (){
}
}
请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。
class Root
{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root()
{
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root
{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid()
{
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg)
{
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
//通过super调用父类中有一个字符串参数的构造器
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
public class TestStaticInitializeBlock
{
public static void main(String[] args)
{
new Leaf();
}
}
首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕后再去看父类有没有非静态代码块。如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕后接着看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕执行构造方法。总之静态代码块内容优先，然后是父类的非静态代码块和构造方法，做后是子类的非静态代码块和构造方法。
静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
请编写代码验证你的想法。
package demo;
class StaticDemo{
static int x;//静态 变量 x
int y;//实例 变量 y
static public int getX(){
return x;
}
static public void setX(int newX){
x=newX;
}
public int getY(){
return y;
}
public void setY(int newY){
y=newY;
}
}
public class ShowDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println("静态变量x="+StaticDemo.getX());
//System.out.println("实例变量y="+StaticDemo.getY());
StaticDemo a=new StaticDemo();
StaticDemo b=new StaticDemo();
a.setX(1);
a.setY(2);
b.setX(3);
b.setY(4);
System.out.println("静态变量a.x="+a.getX());
System.out.println("实例变量a.x="+a.getY());
System.out.println("静态变量b.x="+b.getX());
System.out.println("实例变量b.x="+b.getY());
}
}
静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接使用实例成员变量，所以他不能调用实例方法。
动手练习
不使用Eclipse，直接使用命令行运行Test1.java，Test2.Java，Test3.Java
跟踪对象
分析：定义一个函数getNumber();用来计算创建对象的个数。定义一个整数型i.用来数对象个数。
package dome;
public class Num {
private static double i;
public Num(){
i++;
}
public static double getNumber(){
return i;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Num d1=new Num();
Num d2=new Num();
Num d3=new Num();
Num d4=new Num();
System.out.println("一共创建了"+Num.getNumber()+"个对象");
}
}
标签：
原文地址：http://www.cnblogs.com/wanggong2014/p/4887931.html
