这几天在做一个关于编译原理的课程设计,在用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关键字解析