java基础之关键字static

文章开始先谈谈我对static关键字的看法，首先想到的是不理解，只停留在使用的程度上，平时在工作中使用最多的就是搭配final定义一个常量，其次就是写一些工具类，可以通过类名直接调用，简单、方便。关于static其他的用法，就什么也不了解了。工作中会面试一些刚毕业的或者刚培训出来的新人，我也会问一些static的用法，大部分回答出来的也是这两个方面，其实Static的用法远远不止这两个方面，下面介绍它的用法。

我也是看了好多关于static讲解的文章，自己亲自上手写一些小例子，增加对static的理解，废话不多说，精彩开始。

static修饰变量

在我们平常的使用中，使用最多的就是用static来修饰类的属性和方法，让他们成为类的成员属性和方法。我们通常将用static修饰的成员称为类成员或者静态成员。

代码如下：

public class StaticVariableTest
{
    private String normal = "normal";
    private static String str = "123";
    static StringBuilder sb = new StringBuilder("456");
    /**
     * Description: <br>
     * static修饰成员变量后，此变量称为“静态变量”，能够通过类名直接调用，至于这个变量后期能不能修改，不是static来控制，是根据变量本身的类型来控制的，我们常使用的不可更改的常量，是static
     * 和 final两个关键字配合使用的
     *
     * @param args
     * @see
     */
    public static void main(String[] args)
    {
        System.out.println("========================================");
        StaticVariableTest.str = StaticVariableTest.str + 4;
        System.out.println("此时静态变量str的值为:\t" + StaticVariableTest.str);
        StaticVariableTest svt01 = new StaticVariableTest();
        svt01.normal = "normal01";
        svt01.str = "svt01";
        System.out.println("此时变量normal的值为:\t" + svt01.normal);
        System.out.println("此时svt01中str的值为:\t" + svt01.str);
        System.out.println("此时静态变量str的值为:\t" + StaticVariableTest.str);
        StaticVariableTest svt02 = new StaticVariableTest();
        svt02.normal = "normal02";
        svt02.str = "svt02";
        System.out.println("此时变量normal的值为:\t" + svt02.normal);
        System.out.println("此时svt02中str的值为:\t" + svt02.str);
        System.out.println("此时静态变量str的值为:\t" + StaticVariableTest.str);
        System.out.println("========================================");
        sb.append("789");
        System.out.println("此时静态变量sb的值为:\t" + sb.toString());
        System.out.println("========================================");
    }
}

代码运行结果：

========================================
此时静态变量str的值为:       1234
此时变量normal的值为: normal01
此时svt01中str的值为:svt01
此时静态变量str的值为:       svt01
此时变量normal的值为: normal02
此时svt02中str的值为:svt02
此时静态变量str的值为:       svt02
========================================
此时静态变量sb的值为: 456789
========================================

通过上面的代码和运行结果，不难看出静态变量是可以通过类名直接调用，而普通变量不可以通过类名直接调用，必须存在对象之中，静态变量随着调用的改变一直在改变的，而普通变量的值是随着对象不同而不同。

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

static修饰方法

public class StaticMethodTest
{
    public static void sayHello(String msg)
    {
        System.out.println(msg);
    }
    public void sayByeBye(String msg)
    {
        System.out.println(msg);
    }
    public void testRunStaticMethod()
    {
        sayHello("我是普通方法，调用静态方法，我成功了！");
    }
    public static void sayHello2(String msg)
    {
        // 此地方会提示Cannot make a static reference to the non-static method sayByeBye(String) from the
        // type StaticMethodTest
        // 因此注释掉，否则编译不通过
        // sayByeBye("我是静态方法，调用普通方法，我成功了！");
    }
    /**
     * Description: <br>
     *
     * @param args
     * @see
     */
    public static void main(String[] args)
    {
        StaticMethodTest.sayHello("hello,你好,我是静态方法;\t 我可以直接通过类名调用.");
        StaticMethodTest smt = new StaticMethodTest();
        smt.sayByeBye("byebye,我是普通方法;\t 我只能通过具体对象调用");
        smt.testRunStaticMethod();
    }
}

代码运行结果：

hello,你好,我是静态方法;      我可以直接通过类名调用.
byebye,我是普通方法;  我只能通过具体对象调用
我是普通方法，调用静态方法，我成功了！

通过代码和运行结果，可以看出静态方法可以通过类名直接调用，而不需要去new一个对象调用，减少了资源消耗。而在使用中，静态方法中不可以调用普通方法，而普通方法却可以调用静态方法。静态方法中使用的属性也必须是静态变量。

如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问
另外记住，即使没有显示地声明为static，类的构造器实际上也是静态方法。

static代码块

public class StaticBlockTest
{
    private static int i;
    static
    {
        System.out.println("我是静态块，我在加载class时候执行！并且只执行一次！！！");
        // 此处i必须是静态变量
        i = 888;
    }
    /**
     * Description: <br>
     *
     * @param args
     * @see
     */
    public static void main(String[] args)
    {
        System.out.println("=========start=========");
        StaticBlockTest.i = 999;
        System.out.println(StaticBlockTest.i);
        System.out.println("========middle=========");
        StaticBlockTest sbt = new StaticBlockTest();
        System.out.println("========end=========");
    }
}

代码运行结果：

我是静态块，我在加载class时候执行！并且只执行一次！！！
=========start=========
999
========middle=========
========end=========

从结果中可以看出，静态代码块是在类加载的时候执行的，并且只执行一次。

static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

参考
为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:

class Person{
    private Date birthDate;
    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }
    boolean isBornBoomer() {
        Date startDate = Date.valueOf("1946");
        Date endDate = Date.valueOf("1964");
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：

class Person{
    private Date birthDate;
    private static Date startDate,endDate;
    static{
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }
     
    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }
     
    boolean isBornBoomer() {
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}

static修饰类

public class StaticClassTest
{
    private String normalStr = "normal string";
    private static String staticStr = "static string";
    static class StaticInner
    {
        static
        {
            System.out.println("静态内部类中可以有静态块！！！普通内部类中不可以有静态块！！！");
        }
        public void referenceOutVariable()
        {
            // 此处提示 Cannot make a static reference to the non-static field normalStr，编译不通过
            // System.out.println("我是内部类中的普通方法, 我要打印外部类中的normalStr:" + normalStr);
            System.out.println("我是静态内部类中的普通方法, 我要打印外部类中的staticStr:" + staticStr);
        }
        public static void referenceOutVariableStatic()
        {
            // 此处提示 Cannot make a static reference to the non-static field normalStr
            // System.out.println("我是静态内部类中的静态方法, 我要打印外部类中的normalStr:" + normalStr);
            System.out.println("我是静态内部类中的静态方法, 我要打印外部类中的staticStr:" + staticStr);
        }
    }
    class Inner
    {
        // Cannot define static initializer in inner type StaticClassTest.Inner
        // static {
        // }
        public void referenceOutVariable()
        {
            System.out.println("我是普通内部类中的普通方法, 我要打印外部类中的普通变量normalStr:" + normalStr);
            System.out.println("我是普通内部类中的普通方法, 我要打印外部类中的静态变量staticStr:" + staticStr);
        }
        // 此处提示 The method referenceOutVariableStatic cannot be declared static; static methods can
        // only be declared in a static or top level type
        // 编译错误
        /**
         * public static void referenceOutVariableStatic() { }
         **/
    }
    /**
     * Description: <br>
     *
     * @param args
     * @see
     */
    public static void main(String[] args)
    {
        System.out.println("=====可以直接调用静态内部类中的静态方法,但不可以直接通过类名调用静态内部类中的普通方法=====");
        StaticClassTest.StaticInner.referenceOutVariableStatic();
        StaticClassTest.StaticInner si = new StaticClassTest.StaticInner();
        si.referenceOutVariable();
    }
}

代码运行结果：

=====可以直接调用静态内部类中的静态方法,但不可以直接通过类名调用静态内部类中的普通方法=====
静态内部类中可以有静态块！！！普通内部类中不可以有静态块！！！
我是静态内部类中的静态方法, 我要打印外部类中的staticStr:static string
我是静态内部类中的普通方法, 我要打印外部类中的staticStr:static string

此处静态内部类中的所有调用，只能调用外部类中的所有静态方法/变量

静态导包

/* 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导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样使用即可。

总结：

static是java中非常重要的一个关键字，而且它的用法也很丰富，主要有五种用法：

用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
静态块用法，将多个类成员放在一起初始化，使得程序更加规整，以优化程序性能；
静态内部类用法，具体左右在后面降到内部类中做介绍，目前只是熟悉有此用法；
静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便；

参考文章：
https://www.cnblogs.com/dotgua/p/6354151.html?utm_source=itdadao&utm_medium=referral

https://www.cnblogs.com/dolphin0520/p/3799052.html

java基础之关键字static

static修饰变量

static修饰方法

static代码块

static修饰类

静态导包

总结：

用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；

用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；

静态块用法，将多个类成员放在一起初始化，使得程序更加规整，以优化程序性能；

静态内部类用法，具体左右在后面降到内部类中做介绍，目前只是熟悉有此用法；

静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便；