关于static在java和C++中的用法小谈（一）

这几天在做一个关于编译原理的课程设计，在用java实现的过程中，经常会遇到static关键字，因此决定查询资料，写一篇文章总结一下其用法，并与c++中的static做比较。

java

一. static的用途:

《java编程思想》：““static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

其用法简单描述就是：方便在没有创建对象的情况下来进行调用（方法/变量）

因此，被static关键字修饰的方法或者变量不需要依赖对象进行访问，只要类被加载，就可以通过类名去访问。

可修饰对象：类的成员方法，类的成员变量，代码块。

1. static方法：

一般称作静态方法，没有this，因为不附于任何对象。其不依赖任何对象进行访问的特性，使得静态方法不能访问类中的非静态成员变量和非静态成员方法，因为它们都必须依赖具体的对象才能被调用。反之是可以的，即非静态成员方法可以调用静态成员方法（变量）。

例子如下：

package usestatic;

public class TestStatic {
private static String str1 = "staticstring";
private String str2 = "string";

public TestStatic()
{

}

public static void printstr1() {
System.out.println(str1);
//      System.out.println(str2);        //1.此语句报错：无对象，str2不存在
//      printstr2();                //2.此语句报错：无对象，此方法不存在
}

public  void printstr2() {
System.out.println(str1);
System.out.println(str2);
printstr1();
}

public static void main(String[] args) {
printstr1();
//      printstr2();            //3.此语句报错：无对象，此方法不存在

}
}

有上面的代码的可以看出，static方法在不依赖类的情况下可以被调用，而非静态方法就不行。

对于非静态成员方法，访问静态静态成员方法（变量）都是毫无限制的。

因此，如果在不想创建对象的情况下调用某个方法，就将其设为static。最常用的就是main方法，因为程序在执行main方法的时候没有创建对象，只有通过类型来访问。

类的构造函数实际上也是静态方法。

2. static变量

静态变量：静态变量被所有的对象共享，在内存中只有一个副本，当且仅当类初次加载时被初始化。而非静态变量为对象拥有，创建对象的时候被初始化，存在多个副本，各个对象的副本互不影响。

3. static代码块

对于多次重复用到的变量或者对象，可以形成static代码块，优化程序性能，防止空间浪费。在类初次被加载的时候，会按照static块的顺序执行static块，并且只会执行一次（如果有输出语句便输出）。

因此很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

二. static关键字的误区

java与c/c++中的static的功能不同，java关键字static不会影响到变量或者方法的作用域。在java中只有private，public ，protected（包括访问权限）这几个关键字能够影响到访问权限。

package usestatic;

public class TestStatic {
public static void main(String[] args) {
System.err.println(Number.static_int);
//      System.out.println(Number.pri_static_int);   //报错：static不能改变访问权限
}

}

class Number{
static int static_int = 1111;
private static int pri_static_int = 2222;
}

对this和static的理解：

“`java

package usestatic;

public class TestStatic {

static int static_int = 1111;

public void set_int() {
int static_int = 1;
System.out.println(this.static_int);
System.out.println(static_int);
}

public static void main(String[] args) {
new TestStatic().set_int();      //1111
}

}

“`

this代表当前对象，通过new TestStatic()调用方法的话，当前对象就是new TestStatic()生成的对象，而static变量是被对象所享有的。在set_int()方法内部的值是局部变量，不能与this关联。

所有的静态方法/变量都可以通过对象访问。（只要访问权限足够）

java规定： static是不允许用来修饰局部变量的

三. 常见的面试笔试题

输出代码的执行结果：

package usestatic;

public class Test {
Person person = new Person("Test");
static{
System.out.println("test static");
}

public Test() {
System.out.println("test constructor");
}

public static void main(String[] args) {
new MyClass();
}
}

class Person{
static{
System.out.println("person static");
}
public Person(String str) {
System.out.println("person "+str);
}
}

class MyClass extends Test {
Person person = new Person("MyClass");
static{
System.out.println("myclass static");
}

public MyClass() {
System.out.println("myclass constructor");
}
}

执行结果：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

解释如下：我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

从这可以看出java类的构造函数的执行顺序：

1. 初始化分为为的初始化和实例的初始化

2. 每个类在 JVM 中都对应一个 Class 实例

3. 父类实例是作为子例的部分存在的 (Class 实例之间也存在父子关系)

4. 初始化实例之前要初始化类

基于以上几点就可以理解以下初始化顺序

1. 父类静态属性、静态类 (父类的初始化，对应 JVM 方法 cinit())

2. 子类的静态属性、静态类 (子类的初始化，对应 JVM 方法 cinit())

3. 父类的实例构造，实例变量初始化 (实例变量初始实际会放到 JVM 的 init() 中)

4. 子类的实例构造，实例变量初始化 (也是对应的 init() 方法)

参考文章：Java中的static关键字解析