深入理解static关键字

灰太狼 2023-10-01 06:21 20阅读 0赞

#### 文章目录 ####

*  1、static存在的主要意义
 *  2、static的独特之处
 *  3、static应用场景
 *  4、静态变量和实例变量的概念
 *  5、静态变量和实例变量区别【重点常用】
 *  6、访问静态变量和实例变量的两种方式
 *  7、static静态方法
 *  8、static静态代码块
 *  9、static变量与普通变量区别
 *  10、静态内部类
 *  11、静态导包
 *  12、static注意事项
 *  13、final与static的藕断丝连

提到static关键字，相信大家都不陌生，这是相对比较难以理解的一个关键字，相信各位也都能深深感受的到！本篇文章将好好总结一下static这个关键字。

在开始讲static之前，我想让各位看一段有意思的代码：

public class Test {
        
         
        static{
        
            System.out.println("test static 1");
        }
      
        static{
        
            System.out.println("test static 2");
        }
        
        public static void main(String[] args) {
        
             
        }
    }

看完程序，小白童鞋发话了：啥玩意？main方法中啥都没有，能运行啥？博主你个星星星…

运行结果：
    test static 1
    test static 2

小白童鞋:那啥…那啥…博主我说啥了，我啥都没说…

其实，上面的代码懂的自然懂，不懂的自然就不懂了，因为上面的代码涉及到JVM的类加载了！当然不在本篇博客文章的范畴内，如果有兴趣理解上面的程序，这篇文章可能会对你有所帮助

[这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析][java_ClassLoader]

## 1、static存在的主要意义 ##

static的主要意义是在于创建独立于具体对象的域变量或者方法。**以致于即使没有创建对象，也能使用属性和调用方法**！

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

为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

## 2、static的独特之处 ##

1、被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法**不属于任何一个实例对象，而是被类的实例对象所共享**。

> 怎么理解 “被类的实例对象所共享” 这句话呢？就是说，一个类的静态成员，它是属于大伙的【大伙指的是这个类的多个对象实例，我们都知道一个类可以创建多个实例！】，所有的类对象共享的，不像成员变量是自个的【自个指的是这个类的单个实例对象】…我觉得我已经讲的很通俗了，你明白了咩？

2、在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行初始化，注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。

3、static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。赋值的话，是可以任意赋值的！

4、被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。

## 3、static应用场景 ##

因为static是被类的实例对象所共享，因此如果**某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量**。

因此比较常见的static应用场景有：

> 1、修饰成员变量  
> 2、修饰成员方法  
> 3、静态代码块  
> 4、修饰类【只能修饰内部类也就是静态内部类】  
> 5、静态导包

以上的应用场景将会在下文陆续讲到…

## 4、静态变量和实例变量的概念 ##

静态变量：  
static修饰的成员变量叫做静态变量【也叫做类变量】，静态变量是属于这个类，而不是属于是对象。

实例变量：  
没有被static修饰的成员变量叫做实例变量，实例变量是属于这个类的实例对象。

还有一点需要注意的是：**static是不允许用来修饰局部变量**，不要问我问什么，因为java规定的！

## 5、静态变量和实例变量区别【重点常用】 ##

静态变量：  
静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。

实例变量：  
每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

## 6、访问静态变量和实例变量的两种方式 ##

我们都知道静态变量是属于这个类，而不是属于是对象，static独立于对象。

但是各位有木有想过：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问【只要访问权限足够允许就行】，不理解没关系，来个代码就理解了

public class StaticDemo {
        
    
            static int value = 666;
    
            public static void main(String[] args) throws Exception{
        
                new StaticDemo().method();
            }
    
            private void method(){
        
                int value = 123;
                System.out.println(this.value);
            }
    
    }

猜想一下结果，我猜你的结果是123，哈哈是咩？其实

运行结果： 666

当然肯定有一些基础非常扎实的大佬会问为什么会有同学认为输出是`123` 。里面定义的`value=123`只是一个很普通的局部变量而已 。和成员变量没有半毛钱关系 。和静态变量也没有关系。是的！确实如这位大佬说的一样！只是博主我说的同学是小白同学，站在小白童鞋的角度上，所以还望大佬理解见谅！我举的这个`StaticDemo`例子主要目的是说明一下`this`也是可以访问`static`的变量的！！！value=123只是一个跑龙套的配角，旨在让小白同学认清其中的关系。

回过头再去品味一下上面的那段话，你就能非常客观明了了，这个思想概念要有只是这种用法不推荐！

因此小结一下访问静态变量和实例变量的两种方法：

静态变量：

> 类名.静态变量
> 
> 对象.静态变量(不推荐)

静态方法：

> 类名.静态方法
> 
> 对象.静态方法(不推荐)

## 7、static静态方法 ##

static修饰的方法也叫做静态方法，不知道各位发现咩有，其实我们最熟悉的static静态方法就是main方法了小白童鞋：喔好像真的是哦。由于对于静态方法来说是不属于任何实例对象的，this指的是当前对象，因为static静态方法不属于任何对象，所以就谈不上this了。

还有一点就是：**构造方法不是静态方法**！

## 8、static静态代码块 ##

先看个程序吧，看看自个是否掌握了static代码块，下面程序代码继承关系为 **BaseThree——> BaseTwo——> BaseOne**

BaseOne类

package com.gx.initializationblock;
    
    public class BaseOne {
        
    
        public BaseOne() {
        
            System.out.println("BaseOne构造器");
        }
    
        {
        
            System.out.println("BaseOne初始化块");
            System.out.println();
        }
    
        static {
        
            System.out.println("BaseOne静态初始化块");
    
        }
    
    }

BaseTwo类

package com.gx.initializationblock;
    
    public class BaseTwo extends BaseOne {
        
        public BaseTwo() {
        
            System.out.println("BaseTwo构造器");
        }
    
        {
        
            System.out.println("BaseTwo初始化块");
        }
    
        static {
        
            System.out.println("BaseTwo静态初始化块");
        }
    }

BaseThree 类

package com.gx.initializationblock;
    
    public class BaseThree extends BaseTwo {
        
        public BaseThree() {
        
            System.out.println("BaseThree构造器");
        }
    
        {
        
            System.out.println("BaseThree初始化块");
        }
    
        static {
        
            System.out.println("BaseThree静态初始化块");
        }
    }

测试demo2类

package com.gx.initializationblock;
    
    /*
         注：这里的ABC对应BaseOne、BaseTwo、BaseThree 
     * 多个类的继承中初始化块、静态初始化块、构造器的执行顺序
         在继承中，先后执行父类A的静态块，父类B的静态块，最后子类的静态块，
         然后再执行父类A的非静态块和构造器，然后是B类的非静态块和构造器，最后执行子类的非静态块和构造器
     */
    public class Demo2 {
        
        public static void main(String[] args) {
        
            BaseThree baseThree = new BaseThree();
            System.out.println("-----");
            BaseThree baseThree2 = new BaseThree();
    
        }
    }

运行结果

BaseOne静态初始化块
    BaseTwo静态初始化块
    BaseThree静态初始化块
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器
    -----
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器

至于static代码块运行结果不是很清晰的童鞋，详细讲解请看这篇[Static静态代码块以及各代码块之间的执行顺序][Static]

以上仅仅是让各位明确代码块之间的运行顺序，显然还是不够的，静态代码块通常用来对静态变量进行一些初始化操作，比如定义枚举类，代码如下：

public enum WeekDayEnum {
        
        MONDAY(1,"周一"),
        TUESDAY(2, "周二"),
        WEDNESDAY(3, "周三"),
        THURSDAY(4, "周四"),
        FRIDAY(5, "周五"),
        SATURDAY(6, "周六"),
        SUNDAY(7, "周日");
     
        private int code;
        private String desc;
     
        WeekDayEnum(int code, String desc) {
        
            this.code = code;
            this.desc = desc;
        }
     
        private static final Map<Integer, WeekDayEnum> WEEK_ENUM_MAP = new HashMap<Integer, WeekDayEnum>();
     
        // 对map进行初始化
        static {
        
            for (WeekDayEnum weekDay : WeekDayEnum.values()) {
        
                WEEK_ENUM_MAP.put(weekDay.getCode(), weekDay);
            }
        }
     
        public static WeekDayEnum findByCode(int code) {
        
            return WEEK_ENUM_MAP.get(code);
        }
     
        public int getCode() {
        
            return code;
        }
     
        public void setCode(int code) {
        
            this.code = code;
        }
     
        public String getDesc() {
        
            return desc;
        }
     
        public void setDesc(String desc) {
        
            this.desc = desc;
        }
    }

当然不仅仅是枚举这一方面，还有我们熟悉的单例模式同样也用到了静态代码块，如下：

public class Singleton {
        
        private static Singleton instance;
     
        static {
        
            instance = new Singleton();
        }
     
        private Singleton() {
        }
     
        public static Singleton getInstance() {
        
            return instance;
        }
    }

## 9、static变量与普通变量区别 ##

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

还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

## 10、静态内部类 ##

静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

1、它的创建是不需要依赖外围类的创建。  
2、它不能使用任何外围类的非static成员变量和方法。

代码举例（静态内部类实现单例模式）

public class Singleton {
        
        
       // 声明为 private 避免调用默认构造方法创建对象
        private Singleton() {
        
        }
        
       // 声明为 private 表明静态内部该类只能在该 Singleton 类中被访问
        private static class SingletonHolder {
        
            private static final Singleton INSTANCE = new Singleton();
        }
    
        public static Singleton getUniqueInstance() {
        
            return SingletonHolder.INSTANCE;
        }
    }

当 `Singleton` 类加载时，静态内部类 `SingletonHolder` 没有被加载进内存。只有当调用 `getUniqueInstance()`方法从而触发 `SingletonHolder.INSTANCE` 时 `SingletonHolder` 才会被加载，此时初始化 `INSTANCE` 实例，并且 JVM 能确保 `INSTANCE` 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

## 11、静态导包 ##

静态导包格式：`import static`

这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法

//  Math. --- 将Math中的所有静态资源导入，这时候可以直接使用里面的静态方法，而不用通过类名进行调用
    //  如果只想导入单一某个静态方法，只需要将换成对应的方法名即可
     
    import static java.lang.Math.;
    //  换成import static java.lang.Math.max;具有一样的效果
     
    public class Demo {
        
    	public static void main(String[] args) {
        
     
    		int max = max(1,2);
    		System.out.println(max);
    	}
    }

静态导包在书写代码的时候确实能省一点代码，可以直接调用里面的静态成员，但是会影响代码可读性，所以开发中一般情况下不建议这么使用。

## 12、static注意事项 ##

1、静态只能访问静态。  
2、非静态既可以访问非静态的，也可以访问静态的。

## 13、final与static的藕断丝连 ##

到这里文章本该结束了的，但是static的使用始终离不开final字眼，二者可谓藕断丝连，常常繁见，我觉得还是很有必要讲讲，那么一起来看看下面这个程序吧。

package Demo;
    
    class FinalDemo {
        
        public final double i = Math.random();
        public static double t = Math.random();
    }
    
    public class DemoDemo {
        
        public static void main(String[] args) {
        
    
            FinalDemo demo1 = new FinalDemo();
            FinalDemo demo2 = new FinalDemo();
            System.out.println("final修饰的  i=" + demo1.i);
            System.out.println("static修饰的 t=" + demo1.t);
            System.out.println("final修饰的  i=" + demo2.i);
            System.out.println("static修饰的 t=" + demo2.t);
    
            System.out.println("t+1= "+ ++demo2.t );
    //      System.out.println( ++demo2.i );//编译失败
          }
    }
    运行结果：
    	final修饰的  i=0.7282093281367935
    	static修饰的 t=0.30720545678577604
    	final修饰的  i=0.8106990945706758
    	static修饰的 t=0.30720545678577604
    	t+1= 1.307205456785776

static修饰的变量没有发生变化是因为static作用于成员变量只是用来表示保存一份副本，其不会发生变化。怎么理解这个副本呢？其实static修饰的在类加载的时候就加载完成了（初始化），而且只会加载一次也就是说初始化一次，所以不会发生变化！

至于final修饰的反而发生变化了？是不是巅覆你对final的看法？关于final详细讲解博主也准备好了一篇文章[程序员你真的理解final关键字吗？][final]

ok,文章就先到这里了，希望这篇文章能够帮助到你对static的认识，若有不足或者不正之处，希望谅解并欢迎批评指正！

参考：  
《java编程思想》  
http://baijiahao.baidu.com/s?id=1601254463089390982&wfr=spider&for=pc  
https://blog.csdn.net/qq\_34337272/article/details/82766943  
https://www.cnblogs.com/dolphin0520/p/3799052.html

[java_ClassLoader]: https://blog.csdn.net/qq_43842093/article/details/122267598
[Static]: https://blog.csdn.net/qq_43842093/article/details/122267541
[final]: https://blog.csdn.net/qq_43842093/article/details/122266033