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字段初始化的规律是按顺序进行，即字段初始化和局部变量初始化哪个靠后就以哪个为准。
1.当多个类之间有继承关系时，创建子类对象会导致父类初始化的执行。 静态 方法可以继承，而且可以在子类中覆盖！ 静态 不能继承。
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();
}
}
程序运行截图
父类的初始化快会随着子类对象的创建而被调用。父类的构造函数也会随着子类对象的创建而被调用。调用的顺序为，先调用 静态 初始化块，再调用初始化块，最后调用构造函数。在调用这三块的时候，又是按照先调用父类的再调用子类的顺序来完成的。
- 静态 方法访问非 静态 变量：
程序源代码：
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关键字来创建一个对象实例，通过这个对象实例来完成对非 静态 成员变量的访问。
种整形的包装类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);
}
}
4.创建一个类，能够随时显示这个类当前的对象的个数
源代码：
package test;
public class TestCreatea
{
static int a = 0;
public TestCreatea()
{
a++;
System.out.println("当前该类的对象的个数为" + a + "个");
}
public static void main(String args[])
{
TestCreatea t = new TestCreatea();
}
}
程序运行结果截图
程序设计思想：
在类体里面创建一个 静态 常量 a，用来记录对象的个数，初始值为0，然后在写一个构造函数，构造函数的语句为输出对象的个数和a++。构造函数是随着对象的创建而自动调用的，所以每创建一个对象就能显示出当前对象的个数。