Java中static关键字详解-优快云博客

　提起static关键字，相信大家绝对不会陌生，但是，想要完全说明白，猛的一想，发现自己好像又说不太明白... ...比方说，昨天被一个同学问起的时候... ... 当然，不是所有人都像我一样学艺不精的，但是像这样的基础不牢的人应该不少，因为常用，所以用大家都会，但是谈到精细之处都够呛。这篇博客是我翻出我原来的学习笔记再加上自己看的一些博客整理出来的，供基础知识不怎么牢靠的同学参考参考。

1. static 关键字要解决的问题

　　这里摘录一下《Java编程思想(第四版)》里关于static关键字的一段原话：(P29)通常来说，当创建类时，就是在描述那个类的对象的外观与行为。除非用new创建那个对象，否则，实际上并未获得任何对象。执行new来创建对象的时候，数据存储空间才被分配，其方法才供外界调用。有两种情形用上述方法是无法解决的。一种情形是，只想为某特定域分配单一存储空间，而不去考虑究竟要创建多少个对象，甚至根本不需要创建任何对象。另一种情形是，希望某个方法不与包含他的类的任何对象关联在一起。也就是说，即使没有创建对象，也能够调用方法。简单来说，static的主要目的就是创建独立于具体对象的域变量与方法。

2. static修饰的变量或方法或类的加载时机

　　在加载类的同时加在static修饰的部分。（注意：这个时候，还不存在具体对象，并且这个过程只进行一次）

3. 通过代码示例来分别看看静态变量、静态方法、静态类的效果

3.1 静态变量（

　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。

　两者的区别是：
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：
　　 在对象之间共享值时
　　 方便访问变量时

）

public class StaticTest{

    public static int count =0;
    
    @SuppressWarnings("static-access")
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StaticTest test1 = new StaticTest();
        System.out.println(test1.count);
        StaticTest test2 = new StaticTest();
        test2.count++;
        System.out.println(test1.count+" "+test2.count+" "+StaticTest.count);
    }

}

输出结果：

0
1    1    1

可见，static变量并不是所在类的某个具体对象所有，而是该类的所有对象所共有的，静态变量既能被对象调用，也能直接拿类来调用。

除此之外，静态变量不能引用非静态方法，原因正如前面描述静态加载时机中说的那样，加载静态的时候，非静态的变量、方法等还不存在，当然就无法引用了。但是，非静态方法或类却能正常引用静态变量或方法。因为非静态总是在静态之后出现的。

3.2 静态方法（

　　静态方法可以直接通过类名调用，任何的实例也都可以调用，
　　因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
　　因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
　　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。　　

　　例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。

　　静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的

）

　　静态方法和静态变量一样，属于类所有，在类加载的同时执行，不属于某个具体的对象，所有对象均能调用。对于静态方法需要注意以下几点：

它们仅能调用其他的static 方法。
它们只能访问static数据。
它们不能以任何方式引用this 或super。

class Simple {
    static void go() {
       System.out.println("Welcome");
    }
}
 
public class Cal {
    public static void main(String[] args) {
       Simple.go();
    }
}

　　静态方法一般用于工具类中，可以直接拿类名调用工具方法进行使用。

3.3 静态类

　　一般来说，一个普通类是不允许被声明为static的，但是，在内部类中可以将其声明为static的，这个时候，外部类可以直接调用内部类，因为static的内部类是在加载外部类的同时加载的，所以也就是说，并不要实例化外部类就能直接调用静态内部类。看例子：

public class BaseStatic {
　　static {
        System.out.println("Load base static");
    }

    public BaseStatic(){
        System.out.println("BaseStatic constructor");
    }
    
    static class BaseInnerClass{
        static{
            System.out.println("Base inner class static");
        }
        
        public BaseInnerClass(){
            System.out.println("BaseInnerClass constructor");
        }
    }

}


public class StaticLoadOrderTest{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BaseStatic.BaseInnerClass();
    }

}

在看答案之前，自己想想这个输出结果是什么？

先不急着看答案，我们先来看看这个执行过程：首先，在进入StaticLoadOrderTest的main方法之前，加载StaticLoadOrderTest类，然后执行new BaseStatic.BaseInnerClass();这里需要注意：因为BaseInnerClass是静态的，所以这里并不需要加载外部类和实例化外部类，可以直接加载BaseInnerClass并实例化。所以输出：

 Load base static
 Base inner class static
 BaseInnerClass constructor

这里留个坑：当直接使用外部类类名.静态内部类进行实例化的时候，如果外部类没有加载的话（实际上也是没有加载），那么这个statement: BaseStatic.BaseInnerClass中的BaseStatic是个什么存在？？？？难道只是与静态内部类发生了简单的名称关联吗？若是这样还设计静态内部类干嘛呢？我觉得java设计者们不至于犯这种错误吧？也可能因为自己对于JVM并不熟悉，对于底层不太了解，若是路过的大神能帮忙解决一下，感激不尽！！！！

3.4 关于静态加载顺序的示例

下面这段代码的输出是什么？

public class BaseStatic {
    static {
        System.out.println("Load base static");
    }
    
    public BaseStatic(){
        System.out.println("BaseStatic constructor");
    }
    
    static class BaseInnerClass{
        static{
            System.out.println("Base inner class static");
        }
        
        public BaseInnerClass(){
            System.out.println("BaseInnerClass constructor");
        }
    }

}

public class StaticLoadOrderTest {
    
    static {
        System.out.println("Load test");
    }
    
    public StaticLoadOrderTest(){
        System.out.println("Test constructor");
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BaseStatic();
        new StaticLoadOrderTest();
        new BaseStatic.BaseInnerClass();
    }

}

　　和上面一样，分析一下过程：在进入main方法之前，需要加载StaticLoadOrderTest类，这时候发现有static代码块，先加载静态代码块，然后进入main方法内部，new BaseStatic()，这时候需要加载BaseStatic类，同时也要先加载静态代码块，然后调用构造器。注意：这里并没有加载BaseInnerClass，因为它是内部类只有在真正用到的时候才会进行加载，相信聪明的读者看到这个是不是想到了又一种单例设计模式的实现方式？自己研究吧。回到main方法中，接下来该执行new StaticLoadOrderTest()了，因为StaticLoadOrderTest类之前已经被加载过一次了，并且类只加载一次，所以这里就直接构造了；然后是最后一句new BaseStatic.BaseInnerClass()了，和上面例子一样，这里就不再细讲。所以输出结果为：

Load test
Load base static
BaseStatic constructor
Test constructor
Base inner class static
BaseInnerClass constructor

　　再考虑一下，如果我把上面的例子改成下面这样，输出结果又会是什么呢？

public class BaseStatic {
    static {
        System.out.println("Load base static");
    }
    
    public BaseStatic(){
        System.out.println("BaseStatic constructor");
    }
    
    static class BaseInnerClass{
        static{
            System.out.println("Base inner class static");
        }
        
        public BaseInnerClass(){
            System.out.println("BaseInnerClass constructor");
        }
    }

}



public class StaticLoadOrderTest extends BaseStatic{
    
    static {
        System.out.println("Load test");
    }
    
    public StaticLoadOrderTest(){
        System.out.println("Test constructor");
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BaseStatic.BaseInnerClass();new StaticLoadOrderTest(); 
        new BaseStatic();
    }

}

4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
•
它们仅能调用其他的static 方法。
•
它们只能访问static数据。
•
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.

class UseStatic {
static int a = 3;
static int b;

static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}

static {
System.out.println("Static block initialized.");
b = a * 4;
}

public static void main(String args[]) {
meth(42);
}
}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

注意：在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {

System.out.println("a = " + a);
}
}

class StaticByName {

public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}

下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的

5.static代码块

　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

public class Test5 {
private static int a;
private int b;

static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}