深入理解static关键字

深入理解static关键字提到static关键字,相信大家都不陌生,这是相对比较难以理解的一个关键字,相信各位也都能深深感受的到!本篇文章将好好总结一下static这个关键字。文章目录1、static存在的主要意义2、static的独特之处3、静态变量和实例变量的概念4、静态变量和实例变量【重点常用】5、static静态方法6、static代码块7、static应用场景1、static存在的主要意义static的主要…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全家桶1年46,售后保障稳定

提到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) { 
   
         
    }
}

Jetbrains全家桶1年46,售后保障稳定

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

运行结果:
test static 1
test static 2

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

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

别翻了,这篇文章绝对让你深刻理解java类的加载以及ClassLoader源码分析【JVM篇二】

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只为静态变量分配一次内存空间。

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

我相信各位智商都比宜春智商要高,应该都能理解上面的话。下面举了例子完全出于娱乐,理解了大可不必看,下面的例子仅供参考,仅供娱乐一下下气氛,赶时间的熊dei大可略过!

怎么理解呢?打个比喻吧…就比方说程序员小王是一个比较温柔阳光的男孩子,这1024的这一天,老板闲的没事,非要拉着程序员小王来玩耍,怎么个玩法呢?老板和小王一人拿着一把菜刀,规则很简单,互相伤害,一人一刀,你一刀,我一刀…游戏一开始,老板二话不说,跳起来就是一刀,程序员小王二话也没说反手就是一菜刀回去,这个时候老板发飙了,双眼瞪得忒大,跳起来又是一刀,这个时候程序员小王不敢还手了,就没动手。没想到老板越来越生猛,左一刀右一刀全程下来差不多砍个半个时…程序员小王一直没有还过手,因为小王知道他是老板…

这个程序员小王只会在老板第一次挥刀的时候,回老板一刀,之后就不还手了,这个时候我们把程序员小王看做是静态变量,把老板第一次向小王挥刀看做是类加载,把小王回老板一刀看出是分配内存空间,而一人一刀这个回合过程看成是类加载的过程,之后老板的每一刀都看成是创建一次对象。

连贯起来就是static变量值在类第一次加载的时候分配空间,以后创建类对象的时候不会重新分配

之后这个老板挨了一刀之后躺医院了一年,一出院回到公司第一件事就是拉程序员宜春出来玩耍,老板殊不知其然,这个博主程序员宜春性格异常暴躁,老板递给程序员宜春一把菜刀,博主宜春一接过菜刀,猝不及防的被老板跳起来就是一刀,程序员宜春痛的嗷了一声,暴躁的程序员宜春还没嗷完,在嗷的同时跳起来就是给老板一刀,接着老板跳起来又是一刀,程序员宜春嗷的一声又是回一刀,老板跳起来又一刀,程序员宜春嗷的一声又是回一刀,只要老板没停程序员宜春就没停,因为程序员宜春知道,就自己这曝脾气,暴躁起来si都敢摸,肯定有几个老铁知道…

程序员宜春就类似实例变量,每次创建对象,都会为每个对象分配成员变量内存空间,就像老板来一刀,程序员宜春都会回一刀这样子的…

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静态代码块以及各代码块之间的执行顺序

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

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.INSTANCESingletonHolder 才会被加载,此时初始化 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关键字吗?

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

最后,欢迎各位关注我的公众号,一起探讨技术,向往技术,追求技术

在这里插入图片描述

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/234422.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • SPI 协议简介

    SPI 协议简介1.SPI协议SPI协议是由摩托罗拉公司提出的通讯协议(SerialPeripheralInterface),即串行外围设备接口,是一种高速全双工的通信总线。它被广泛地使用在ADC、LCD等设备与MCU间,要求通讯速率较高的场合。1.1SPI物理层SPI通讯设备之间的常用连接方式:SPI通讯使用3条总线及片选线,3条总线分别为SCK、MOSI、MISO,片选线为SS,它们的作用介绍如下:(1)SS(SlaveSelect):从设备选…

  • GIMP教程 4 图层「建议收藏」

    GIMP教程 4 图层「建议收藏」图层可以说是现代制图软件的精髓,也是最根本地区别于纸质制图的地方。GIMP呼出图层窗口的方法也很简单点击【窗口—-可停靠对话框—-图层】或者直接使用快捷键ctrl+L 便可呼出图层窗口剩下的,就跟所有其它制图软件一样了。还有问题可联系作者(QQ616057653)进行交流。…

  • 什么是宽字节注入_百分号两个字节

    什么是宽字节注入_百分号两个字节宽字节注入原理:宽字节(两字节)带来的安全问题主要是吃ASCII字符(一字节)的现象,使用一些特殊字符来”吃掉“经过转义符“\”。在重新详细了解宽字节注入之前,我认为宽字节注入只是出现在网站使用GBK编码的时代,现在已经很少出现了,但是实际上宽字节不只是出现在GBK编码中。在PHP中,通过iconv()进行编码转换时,也可能出现宽字节注入。还有一个误区:这里的编码问题不是出现在HTML页面…

    2022年10月15日
  • SpringBoot框架理解[通俗易懂]

    SpringBoot框架理解[通俗易懂]文章目录SpringBoot框架1SpringBoot入门1.2什么是SpringBoot1官网的解释2我的理解3SpringBoot的优缺点4构建项目1使用Spring官方提供页面构建2使用IDEA构建3pom包介绍1.3SpringBoot核心1约定优于配置2Starter启动器3自动配置工作原理学习SpringBoot后对它的理解,进行一个总结SpringBoot框架1SpringBoot入门1.2什么是SpringBoot1官网的解释​ Sprin

  • currentstyle 织梦_织梦arclist标签支持高亮currentstyle属性方法

    currentstyle 织梦_织梦arclist标签支持高亮currentstyle属性方法找到include/taglib/arclist.lib.php第一步:查找:$channelid=$ctag->GetAtt(‘channelid’);替换:$channelid=$ctag->GetAtt(‘channelid’);$currentstyle=$ctag->GetAtt(‘currentstyle’);第二步:查找:$ct…

  • 怎么创建自己的网站?创建自己网站的步骤「建议收藏」

    怎么创建自己的网站?创建自己网站的步骤「建议收藏」随着互联网的不断发现,越来越多的个人站长在互联网上获得不错的流量。也有很多的企业通过自己搭建网站创建属于自己的企业网站,也获得不错的效果。在互联网风口上,如果你还不做一个网站,那真的损失太大了。为了让广大互联网工作中获利今天牛商网就为大家解答怎么创建自己的网站?创建自己网站的步骤有哪些?1、自己建站第一步:购买域名和服务器。网站的域名和服务器是一个网站的基础配件,域名就相当于你网站的地址,当别人输入你的域名的时候就可以访问你的网站。而服务器就相当于一个房子,用来存放你网站的文件和内容的。同时域名和

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号