Java第三次上课课堂试验博文

1.Java字段初始化的规律：

运行如下所示的代码

package demo;

public class InitializeBlockDemo

{

/**

* @param args

*/

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字段的初始值

//public int field=100;

{

field=200;

}

public int field=100;

public InitializeBlockClass(int value){

this.field=value;

}

public InitializeBlockClass(){

}

}

注意这是Java字段是放在public int field=100;

之前的。

运行结果截图

如果把Java字段初始化和public int field=100;

调换一下位置的话，其原代码如下:

package demo;

public class InitializeBlockDemo

{

/**

* @param args

*/

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字段的初始值

//public int field=100;

public int field=100;

{

field=200;

}

public InitializeBlockClass(int value){

this.field=value;

}

public InitializeBlockClass(){

}

}

运行结果如图

因此Java字段初始化的规律是按顺序进行，即字段初始化和局部变量初始化哪个靠后就以哪个为准。

2.当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行。静态方法可以继承，而且可以在子类中覆盖！静态块不能继承。以下是源代码：

package demo;

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();

}

}

程序运行截图

通过以上实验我们可以知道，父类的初始化快会随着子类对象的创建而被调用。父类的构造函数也会随着子类对象的创建而被调用。调用的顺序为，先调用静态初始化块，再调用初始化块，最后调用构造函数。在调用这三块的时候，又是按照先调用父类的再调用子类的顺序来完成的。

3.静态方法访问非静态变量：

程序源代码：

//建立一个类验证静态方法如何访问非静态变量

//王宏伟，2015,10,16

package test;

public class TestStaticWay

{

public static void main(String args[])

{

Second s = new Second();

s.show();

}

}

class Second

{

int a;

static void show()

{

Second m = new Second();

System.out.println(m.a);

}

}

程序运行截图

在Java的语法里面，静态的方法是不能直接访问非静态的成员变量的，要想访问非静态的成员变量，只能是在方法体里面创建一个对象实例，即使用new关键字来创建一个对象实例，通过这个对象实例来完成对非静态成员变量的访问。

4.神奇代码：

5种整形的包装类Byte,Short,Integer,Long,Character的对象，在值小于127时可以使用常量池。

源代码及其注释：

package test;

public class StrangeCode

{

public static void main(String[] args)

{

Integer i1=100;

Integer j1=100;

//从常量池当中取数字，是对常量池当中的同一个对象进行操作。所以比较结果为true

System.out.println(i1==j1);

Integer i2=128;

Integer j2=128;

//在堆空间里面创建了两个不同的对象，他们的地址不同，输出的结果为false

System.out.println(i2==j2);

}

}

5.创建一个类，能够随时显示这个类当前的对象的个数

源代码：

//创建一个类，能够随时显示该类的对象的个数

//王宏伟，2015,10,16

package test;

public class TestCreateNum

{

static int num = 0;

public TestCreateNum()

{

num++;

System.out.println("当前该类的对象的个数为" + num + "个");

}

public static void main(String args[])

{

TestCreateNum t = new TestCreateNum();

}

}

程序运行结果截图

程序设计思想：

在类体里面创建一个静态常量num，用来记录对象的个数，初始值为0，然后在写一个构造函数，构造函数的语句为输出对象的个数和num++。构造函数是随着对象的创建而自动调用的，所以每创建一个对象就能显示出当前对象的个数。