程序设计及总结

请输入并运行以下代码，得到什么结果?？

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()+"个对象");

}

}