「杂转」JAVA基础——修饰符static深入探索

static：

static是一个修饰符，用于修饰成员（成员变量，成员函数），当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调：类名.静态成员。
修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。Static 块仅在该类被加载时执行一次。

存在：方法区，共享区，数据区（非堆内存、栈内存的另一个存储区）

需要了解jvm classloader

static特点：

1，随着类的加载而加载，也就是说静态会随着类的消失而消失，说明他的生命周期最长
2，优先于对象的存在。（静态先存在，对象后存在。）
3，被所有对象所共享
4，可以直接被类名调用
　　由于静态static不依赖于任何对象就可以进行访问，因此对于静态来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
　　内部类中不能存在static修饰的成员，因为static随着类加载产生，内部类依附于宿主类，系统加载：宿主类–>静态–>内部类，而内部类的静态是随着内部类加载产生，与加载类就加载static矛盾，所以内部类中不能存在static修饰

1、static变量

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

实例变量和类变量的区别：
1，存放位置。
　　 类变量随着类的加载而存在于方法区中。在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　　 实例变量随着对象的建立而存在于堆内存中。没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。
2，生命周期：
　　 类变量生命周期最长，随着类的消失而消失。
　　 实例变量生命周期随着对象的消失而消失。

static成员变量的初始化顺序按照定义的顺序进行初始化。static不可以修饰局部变量；

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

⚠️注意：虽然我们看到static可以让对象共享属性，但是实际中我们很少这么用，也不推荐这么使用。因为这样会让该属性变得难以控制，因为它在任何地方都有可能被改变。如果我们想共享属性，一般我们会采用其他的办法：

public class Person {
    private static int count = 0;
    int id;
    String name;
    int age;

    public Person() {
        id = ++count;
    }

    public String toString() {
        return "Id:" + id + ", Name:" + name + ", Age:" + age;
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "zhangsan";
        p1.age = 10;
        Person p2 = new Person();
        p2.name = "lisi";
        p2.age = 12;
        System.out.println(p1);
        System.out.println(p2);
    }
    /**Output
     * Id:1, Name:zhangsan, Age:10
     * Id:2, Name:lisi, Age:12
     *///~
}

上面的代码起到了给Person的对象创建一个唯一id以及记录总数的作用，其中count由static修饰，是Person类的成员属性，每次创建一个Person对象，就会使该属性自加1然后赋给对象的id属性，这样，count属性记录了创建Person对象的总数，由于count使用了private修饰，所以从类外面无法随意改变。

2、静态方法

静态方法的好处就是不用生成类的实例就能直接调用，可以这样理解使用static修饰的成员不再归对象所以，而是属于类 可以理解为是共有的，也就说只要通过类名就可以访问，不需要耗费资源反复创建对象，因为在程序第一次加载的时候就已经在内存中了，直到程序结束该内存才会释放。如果不是static修饰的成员在使用完之后该内存就会被回收，所以说static要慎用,根据实际情况而定

如果这个方法是作为一个工具来使用，就声明为static，不用new一个对象出来就可以使用了，比如连接到数据库，我声明一个 getConnection()的方法，就定义为静态的，因为连接到数据库不是某一个对象所特有的。它只作为一个连接到数据库的工具。至于提高效率的也未 必，要看具体的方法的用处，去定义这个方法是不是静态的。

static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

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

static方法块和static方法的区别：
静态代码块是自动执行的;
静态方法是被调用的时候才执行的.

静态方法：如果我们在程序编写的时候需要一个不实例化对象就可以调用的方法，我们就可以使用静态方法，具体实现是在方法前面加上static，如下：
public static void method(){}

在使用静态方法的时候需要注意一下几个方面：
在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。（备注：静态变量是属于整个类的变量而不是属于某个对象的）
静态方法不能以任何方式引用this和super关键字，因为静态方法在使用前不用创建任何实例对象，当静态方法调用时，this所引用的对象根本没有产生。

静态程序块：当一个类需要在被载入时就执行一段程序，这样可以使用静态程序块。

public class DemoClass {
    private DemoClass(){}
    public static DemoClass _instance;
    static{
        if(null == _instance ){
            _instance = new DemoClass();
        }
    }
    public static DemoClass getInstance(){
        return _instance;
    }
}

特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

执行顺序：静态变量初始化➡️代码块执行

static总结：

static有利有弊：
利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一格对象中都存储一份。可以直接被类名调用。
弊：生命周期过长，访问出现局限性（静态虽好，只能访问静态）

static使用注意事项：
1，静态方法只能访问静态成员，非静态方法既可以访问静态也可以访问非静态。（Java虚拟机（JVM）加载类时，就会执行该static，静态优先于其他产生对象产生）。
2，静态方法中不可定义this，super等关键字：
　　this:this代表当前对象，static于类加载的时候存在优先于实例对象的产生，static调用非静态时并未产生对象，所以this不代表任何对象为null,未进行初始化操作。）
3，主函数是静态方法。

什么时候使用static
　　因为静态修饰的内容有成员变量和函数。
　　使用静态变量（类变量）：当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
　　使用静态函数：当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。

延伸

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

4.静态导包

相比于上面的三种用途，第四种用途可能了解的人就比较少了，但是实际上它很简单，而且在调用类方法时会更方便。以下面的“PrintHelper”的例子为例，做一下稍微的变化，即可使用静态导包带给我们的方便：

/* PrintHelper.java文件 */
package com.dotgua.study;

public class PrintHelper {

    public static void print(Object o){
        System.out.println(o);
    }
}

/* App.java文件 */

import static com.dotgua.study.PrintHelper.*;

public class App 
{
    public static void main( String[] args )
    {
        print("Hello World!");
    }
    /**Output
     * Hello World!
     *///~
}

上面的代码来自于两个java文件，其中的PrintHelper很简单，包含了一个用于打印的static方法。而在App.java文件中，我们首先将PrintHelper类导入，这里在导入时，我们使用了static关键字，而且在引入类的最后还加上了“.*”，它的作用就是将PrintHelper类中的所有类方法直接导入。不同于非static导入，采用static导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用”方法名”去调用类方法，就好像是该类自己的方法一样使用即可。