1. 静态变量/方法：
成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例，必须在类实例化后才真正存在，不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有（相当于全局变量），不需要实例化就已经存在。
方法也可分为实例方法和静态方法。其中，实例方法必须在类实例化之后通过对象来调用，而静态方法可以在类实例化之前就使用。与成员变量不同的是：无论哪种方法，在内存中只有一份——无论该类有多少个实例，都共用同一个方法。(静态方法中不能直接使用实例变量和实例方法)
实例方法的调用：
ClassA a = new ClassA(); //必须经过实例化
a.instanceMethod();
静态方法的调用：
ClassA.staticMethod(); //无需经过实例化
2. 静态方法的声明和定义
定义一个静态方法和定义一个实例方法，在形式上并没有什么区别，只是在声明的头部，需要加上一个关键字static。它的一般语法形式如下：
[访问权限修饰符] static [返回值类型] 方法名([参数列表]){
语句序列
}
例如下面是一个静态的方法：
public static void stFun(){
System.out.println("这是一个静态方法");
}
3.静态方法和实例方法的区别
静态方法和实例方法的区别主要体现在两个方面：
● 在外部调用静态方法时，可以使用“类名.方法名”的方式，也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
● 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
实例代码： 静态方法访问成员变量示例
class accessMember{
private static int sa; //定义一个静态成员变量
private int ia; //定义一个实例成员变量
//下面定义一个静态方法
static void statMethod(){
int i = 0; //正确，可以有自己的局部变量
sa = 10; //正确，静态方法可以使用静态变量
otherStat(); //正确，可以调用静态方法
ia = 20; //错误，不能使用实例变量
insMethod(); //错误，不能调用实例方法
}
static void otherStat(){
}
//下面定义一个实例方法
void insMethod(){
int i = 0; //正确，可以有自己的局部变量
sa = 15; //正确，可以使用静态变量
ia = 30; //正确，可以使用实例变量
statMethod(); //正确，可以调用静态方法
}
}//end of class accessMember
4.静态代码块
在类中，可以将某一块代码声明为静态的，这样的程序块叫静态初始化段。静态代码块和静态变量一样，都只“属于”类，而不是类的实例。静态代码块的一般形式如下：
static {
语句序列
}
● 静态代码块只能定义在类里面，它独立于任何方法，不能定义在方法里面。
● 静态代码块里面的变量都是局部变量，只在本块内有效。
● 静态代码块会在类被加载时自动执行（比main早），而无论加载者是JVM还是其他的类。
● 一个类中允许定义多个静态代码块，执行的顺序根据定义的顺序进行。
● 静态代码块只能访问类的静态成员，而不允许访问实例成员。
public class staticBlock{
//定义一个普通的main()方法
public static void main(String args[]){
System.out.println("This is main method.");
}
//定义一个静态代码块
static{
System.out.println("This is static block.");
int stVar = 0; //这是一个局部变量，只在本块内有效
}
}
编译通过后，用java命令加载本程序，会得到如下输出：
This is static block.
This is main method.
从以上输出结果中可以看出，静态代码块甚至在main方法之前就被执行。在main()方法中可以完成的任务在静态代码块中都可以完成。但是二者在执行上仍然有一些区别，main方法是整个程序启动的入口，而静态代码块是存在于某个类中的一个过程。
5.静态的类变量
Java允许以类作为静态成员变量的类型，那么静态成员变量就是一个对象。如果是基本数据类型的静态成员变量，在类的外部可以不必创建对象就直接使用。但如果静态成员是对象，问题就要复杂得多。因为对象所属的类，既可能有静态成员，也可能有实例成员。而其中的实例成员必须要在对象实例化后才能使用，问题的核心在于：系统是否会为静态的类变量创建实例。（静态的类变量也是静态变量，所以使用前，静态类变量需要初始化创建实例）
//-----------文件名supplyTest.java-----------------
public class supplyTest{
//定义一个静态方法供测试用
public static void statShow(){
System.out.println("这是静态方法");
}
//定义一个实例方法供测试用
public void instShow(){
System.out.println("这是实例方法");
}
}//end of supplyTest.java
//-----------文件名supplyTest.java-----------------
下面这个程序中，定义了一个supplyTest类型的变量，作为静态成员，没有显示地实例化它。
//-----------文件名hasStatMember.java-----------------
public class hasStatMember{
static supplyTest stVar; //定义一个静态成员
public static void main(String args[]){
stVar.statShow(); //调用静态方法
stVar.instShow(); //调用实例方法
}
}
//-----------文件名hasStatMember.java-----------------
这个程序可以编译通过，但它运行的结果如下：
这是静态方法
Exception in thread "main" java.lang.NullPointerException
at hasStatMember.main(hasStatMember.java:5)
从运行结果中可以看出，静态方法被正常执行，但实例方法不能执行，原因是未创建对象实例。这说明尽管stVar被声明成static类型，系统仍然不会自动为它创建对象，所以程序必须改成如下内容才能正常运行：
//-----------文件名hasStatMember.java-----------------
public class hasStatMember{
static supplyTest stVar = new supplyTest(); //定义一个静态成员并实例化它
public static void main(String args[]){
stVar.statShow(); //调用静态方法
stVar.instShow(); //调用实例方法
}
}
//-----------文件名hasStatMember.java-----------------
程序的输出结果是：
这是静态方法
这是实例方法
从输出结果中可以看出，stVar的实例化是在定义时完成的，这意味着在hasStatMember类的外部可以像在内部一样使用它。下面这个程序演示了对stVar的使用形式。
//-----------文件名useStVar.java-----------------
public class useStVar{
public static void main(String args[]){
hasStatMember.stVar.statShow(); //调用静态方法
hasStatMember.stVar.instShow(); //调用实例方法
}
}
//-----------文件名useStVar.java-----------------
程序的输出结果如下：
这是静态方法
这是实例方法
无论是静态方法还是实例方法，都是通过“类名.静态变量名.方法名”的形式来使用的。读者可能会觉得这种形式有点眼熟。确实如此，前面大量使用的“System.out.println”就是这种形式。其中，System是系统预定义好的一个类，out是它的一个静态成员，println是out的一个实例方法。
6.Java中的初始化顺序
JAVA类首次装入时，会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的，静态成员变量和静态初始化块级别相同（静态成员），非静态成员变量和非静态初始化块级别相同。
初始化顺序：（示例1、示例2）
1.类装载时，初始化父类的静态成员-->初始化子类的静态成员
2.(创建实例时,如果不创建实例,则不执行2、3)初始化父类的非静态代码（变量定义等）--->初始化父类构造函数
3.初始化子类非静态代码（变量定义等）--->初始化子类构造函数
类只有在使用New调用创建的时候才会被 JAVA类装载器装入（装入时静态成员初始化）创建类实例，按照父子继承关系进行初始化类实例创建：首先初始化块部分先执行，然后是构造方法；然后从子类的初始化块执行，最后是子类的构造方法。类消除时候，首先消除子类部分，再消除父类部分
class Test1 {
public static int k=0;
public static Test1 t1=new Test1("t1");
public static Test1 t2=new Test1("t2");
public static int i=print("1");
public static int n=99;
public int j=print("j");
{
print("构造块");
}
static{
print("静态块");
}
public Test1(String str)
{
System.out.println((++k)+":"+str+" i="+i+" n="+n);
++i;++n;
}
public static int print(String str){
System.out.println((++k)+":"+str+" i="+i+" n="+n);
++n;
return ++i;
}
}
public class Try {
static{
System.out.println("Try:静态代码块");
}
{
System.out.println("Try:非静态代码块");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Try:main()");
Test1 t=new Test1("init");
}
}结果：
Try:静态代码块
Try:main()
1:j i=0 n=0
2:构造块 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
7:1 i=6 n=6
8:静态块 i=7 n=99
9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102
分析： jvm首先装入Try类，所以先进行Try类的静态成员初始化；之后运行main();
main中创建Test1实例前先要装入Test1类：静态成员初始化；
public static Test1 t1=new Test1("t1");时是又创建一个实例，此时Test1类可看做已装入，所以进t1的实例化：非静态成员（变量/代码块）+构造函数。
之后的步骤就容易理解了
扫一扫
1162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
