目录
一、为什么需要static关键字:
给大家举一个简单的例子吧。雷电将军自从发布了眼狩令以后,由于夺取的神之眼越来越多,将军幕府做账的没一会儿就算不清了。幸好,新来的管账儿会用Java,就自告奋勇地想用Java帮雷电将军编个小程序。以下是他写的代码 :
packageknowledge.polymorphism.about_static.eyecut; publicclassCaptive { //Captive,俘虏的意思;代表被缴获神之眼的对象。privateStringname; publicCaptive() {}; publicCaptive(Stringname) {this.name=name;} publicvoidsetName() {this.name=name;} publicStringgetName() {returnname;} publicvoidrecycle_eyes() { System.out.println(getName() +"的神之眼被收回🌶!"); } } classRecycle { publicstaticvoidmain(String[] args) { intcount=0; //count变量用于统计累计收回的神之眼的数量。Captivewanye=newCaptive("万叶"); wanye.recycle_eyes(); ++count; Captiveshenli=newCaptive("神里凌华"); shenli.recycle_eyes(); ++count; Captiveheart_sea=newCaptive("珊瑚宫心海"); heart_sea.recycle_eyes(); ++count; //...............................System.out.println("--------------------------------------------"); System.out.println("当前已回收了"+count+"枚神之眼."); } }
运行结果 :
可以看到,管账儿的思路还是很清晰的。他通过创建Captive类对象来代表被回收了神之眼的对象。又在main方法中定义了count变量存储已缴获神之眼的数量,并且每缴获一枚神之眼就让count变量自增加一。
但是,大家看完这段代码后,有没有感觉有丶不对劲?
就up自己来说,我看完这段代码后想提出两个疑问——
①.从count变量的用途来看,它与Captive类有着较为密切的关系,但count变量却定义在了Captive类之外。这是否违背了OOP编程的基本理念?
②.count变量定义在了Recycle类的main方法中,如果以后我们想单独调用count变量,该怎么整?
诶,这显然是不可回避的两个问题。那么,怎么避免这种情况呢?这不,我们的static关键字来了,今天咱们就给管账儿的好好上一课。
二、static关键字概述 :
1.作用 :
static,静止的,静态的。static关键字可用于修饰类的成员。
修饰成员变量时,将被修饰的成员变量称为“类变量”,或者“静态变量”,“静态属性”。
修饰成员方法时,将被修饰的成员方法称为“类方法”,或者“静态方法”。
2.使用 :
使用static非常简单,我们只需要在定义成员变量或者成员方法时,在它们之前加上一个“static”即可。但要注意,平时我们在定义这些类的成员时,往往也会用访问权限修饰符修饰,那static关键字要写到访问权限修饰符之前呢还是之后呢?
答案是都可以,但是up建议大家写在访问权限修饰符之后,既符合绝大多数程序🐒的编程习惯,也符合IDEA默认的一个顺序,如下所示 :
//修饰成员变量privatestaticStringname; //修饰成员方法publicstaticStringgetName() { returnname; }
那如何调用我们定义好的这些“类变量” 和 “类方法” 呢?
调用类变量——类名.成员变量名;
调用类方法——类名.成员方法名(形参);
//其实也可以通过对象来调用。
三、static修饰成员变量详解 :
1.特点 :
①被static修饰修饰的成员变量,也就是类变量,被本类所有对象共享——即该类所有对象都可以对它进行二次更改。
②从JDK8.0开始,static修饰的成员变量位于堆空间中。
说明 : 当类加载器将含有static修饰的成员变量的类加载到方法区时,会根据反射机制生成一个字节码文件对象,即Class对象。Class对象在堆空间中,而static变量保存在Class实例的尾部。如下图所示 : (即所有对象访问的某个类变量,其实就是那一份)
2.细节 :
①什么时候考虑使用static关键字?
当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)。比如 : 某个Java培训机构要统计所有学员的累计交费总额,就可以在学员类中将学费属性设置为静态属性。再比如我们开篇举的雷电将军眼狩令的例子,我们可在俘虏类中定义count静态属性,每个俘虏类对象共享count变量。
②静态变量和非静态变量的区别?
静态变量被该类所有对象共享;而非静态变量是被每个对象独享。
内存角度 :
静态变量在堆空间的Class实例中,该类所有对象都是通过地址值继而找到Class实例中真正的类变量,它们共享的某个静态变量,是唯一的;而非静态变量是每创建一个新对象,都会在堆空间开辟空间,并且这块空间的一部分会用来存储非静态变量的内容,所以每个对象都各自有各自的非静态变量,不唯一。
访问方式 :
在上文static的使用中,我们提了一嘴——类变量既可以通过“类名.”的形式来调用,也可以通过“对象.”的形式来调用,但是建议大家优先使用“类名.”的形式来访问类变量。这里还要补充一点:在访问类变量时,也要遵循访问权限修饰符的规则。比如,如果某个类的一个静态属性为私有的,那么你就不能在其他类中直接访问这个静态属性。
而对于非静态属变量,非静态变量不能通过“类名.”的形式来访问,只能通过“对象.”的形式来访问。并且非静态属性的访问也要遵循访问权限修饰符的规则。
③关于静态变量的初始化问题 :
静态变量的初始化在类加载时就已经执行完毕了。因此,静态变量的使用与是否创建了该类对象无关,只与该类是否加载有关;只要静态变量所在的类加载完毕,就可以使用该类的静态变量了。
④关于静态变量的生命周期 :
如上一条所述。类变量的生命周期是随着类的加载开始,并随着类的回收而消亡的,与对象无关。
⑤关于公有静态常量 :
随意修改静态变量的值在某些情况下是有危险的,因此,为了降低风险,可以同时用final关键字修饰静态变量(一般写在static之后),使其称为静态常量;若想要让这个静态常量为大家所共同使用,可以使用public访问权限修饰符进行修饰,即公有静态常量。如下 :
//静态常量finalstaticStringname="Cyan"; //公有静态常量publicstaticfinalStringsex="male";
对于静态常量来说,只能通过在定义时为其赋初值;或者先定义,在静态代码块中为其赋值的方法来进行初始化。不可以在构造器中进行静态常量的初始化。原因其实也很简单,静态属性的初始化是随着类的加载就执行完毕的,而构造器是在初始化对象时才会被调用,你加载类时发现这个静态属性没有初始化,就是不行。(PS : 关于静态代码块,文章后面up附上了链接,这里大家先了解一下即可)
而且在单独调用静态常量时,如果该静态常量在定义时就进行了初始化,则不会引起类的加载,这是因为jvm在编译阶段对类做了编译优化。但如果在定义静态常量时没有直接进行初始化,而是在静态代码块中进行了初始化,那么调用该静态常量时,其所在的类还是会被加载。(其特征就是类中的静态代码块被执行)
3.演示 :
①对于静态变量和非静态变量访问方式的演示 :
up以Sample_1类作为第一个演示类,以Test_1类作为测试类。老规矩,为了简洁,up将Test_1类写在了Sample_1类的源文件中,Sample_1类,Test_1类代码如下 :
packageknowledge.polymorphism.about_static.fields; publicclassSample_1 { //静态成员变量staticStringname_1; //非静态成员变量Stringname_0; } classTest_1 { publicstaticvoidmain(String[] args) { //访问静态变量//通过类名访问Sample_1.name_1="Cyan"; System.out.println("类名.name_1 = "+Sample_1.name_1); System.out.println("-----------------------------------------"); //通过对象访问Sample_1s1=newSample_1(); //s1对象System.out.println("s1's name_1 = "+s1.name_1); Sample_1sp1=newSample_1(); //ss1对象System.out.println("sp1's name_1 = "+sp1.name_1); System.out.println("-----------------------------------------"); //某个对象修改了静态变量的值,其他所有对象再次访问时,即是修改后的值。sp1.name_1="Rain"; System.out.println("s1's name_1 = "+s1.name_1); System.out.println("sp1's name_1 = "+sp1.name_1); System.out.println("-----------------------------------------"); //访问非静态变量//只能通过对象访问s1.name_0="Five"; System.out.println("s1's name_0 = "+s1.name_0); //Sample_1.name_0; //这么访问会报错,因为非静态变量不能通过类名来访问。System.out.println("sp1's name_0 = "+sp1.name_0); } }
运行结果 :
通过代码和运行结果我们可以看出,当我们更改了静态变量的值时,所有对象访问该静态变量都是修改后的值。而对于非静态变量,一个对象更改了其非静态变量的值后,丝毫不会影响另一个对象访问自己的非静态变量时的值。
②对访问静态变量时需遵循访问权限的演示 :
up以Sample_2类作为第二个演示类,以Test_2类作为测试类。
Sample_2类,Test_2类代码如下 :
packageknowledge.polymorphism.about_static.fields; publicclassSample_2 { //私有的静态变量privatestaticStringcolor="Cyan"; //默认的静态变量staticdoublescore=411; } classTest_2 { publicstaticvoidmain(String[] args) { //System.out.println("color = " + Sample_2.color);System.out.println("score = "+Sample_2.score); } }
运行结果 :
如代码所示,我们在Sample_2类中定义了两个静态变量。score变量无访问修饰符,默认本包下可以使用。我们当然可以在Test_2类中直接访问score变量;而对于color变量,color变量为Sample_2类私有的成员变量,因此不能直接跨类使用。如果你想在Test_2类中直接调用color变量,就会报错,如下图所示 :
③对“眼狩令”问题中管账儿写的代码做出改进 :
改进后的代码如下 : (注意count变量的变化)
packageknowledge.polymorphism.about_static.eyecut; /** Captive,俘虏的意思;代表被缴获神之眼的对象。*/publicclassCaptive { privateStringname; staticintcount=0; //count变量用于统计累计收回的神之眼的数量。publicCaptive() {}; publicCaptive(Stringname) {this.name=name;} publicvoidsetName() {this.name=name;} publicStringgetName() {returnname;} publicvoidrecycle_eyes() { System.out.println(getName() +"的神之眼被收回🌶!"); } } classRecycle { publicstaticvoidmain(String[] args) { Captivewanye=newCaptive("万叶"); wanye.recycle_eyes(); ++Captive.count; Captiveshenli=newCaptive("神里凌华"); shenli.recycle_eyes(); ++Captive.count; Captiveheart_sea=newCaptive("珊瑚宫心海"); heart_sea.recycle_eyes(); ++Captive.count; //...............................System.out.println("--------------------------------------------"); System.out.println("当前已回收了"+Captive.count+"枚神之眼."); } }
运行结果 :
如代码所示,我们将原先在Recycle类main方法中的count变量定义到了Captive类中,并且将count变量设置为了静态变量。那么首先,负责统计Captive对象累计被回收神之眼的数量的count变量与Captive类之间有了关系。其次,将来便可以直接通过Captive类的类名来访问count变量,也有利于程序将来的扩展。
④对“培训机构收钱统计”的模拟演示 :
up以Student类作为第四个演示类,以Charge类作为测试类。我们在Student类中定义tuition静态变量用于存储总的学费。
Student类,Charge类代码如下 :
packageknowledge.polymorphism.about_static.fields; publicclassStudent { staticdoubletuition=0; //静态变量tuition,用于存储总的学费privateStringname; //学生的姓名privateStringID; //学生的IDprivateStringproject; //学生的交费项目publicStudent(Stringname, StringID, Stringproject) { this.name=name; this.ID=ID; this.project=project; } publicvoidshowTuition() { System.out.println("当前累计收学费 "+tuition+" RMB."); } } classCharge { publicstaticvoidmain(String[] args) { //创建学生对象,并修改学生类中静态变量tuition的值。Studentcyan=newStudent("Cyan", "20210001", "Spring Boot"); System.out.println("0001号学员Cyan,学习Spring Boot,花费10000."); Student.tuition+=10000; cyan.showTuition(); System.out.println("---------------------------------------"); Studentfive=newStudent("Five", "20210002", "mysql"); System.out.println("0002号学员Cyan,学习mysql,花费5500."); Student.tuition+=5500; five.showTuition(); System.out.println("---------------------------------------"); Studentrain=newStudent("Rain", "20210003", "k8s"); System.out.println("0003号学员Rain,学习k8s,花费3700."); Student.tuition+=3700; rain.showTuition(); } }
运行结果 :
⑤公有静态常量演示 :
up以Demo类为第五个演示类。以Test_5为测试类。演示内容分为两部分,第一部分我们演示一下静态常量的初始化,第二部分演示一下调用静态常量时引起的类的加载的问题。
第一部分 :
Demo类,Test_5类代码如下 :
packageknowledge.polymorphism.about_static.fields; publicclassDemo { //静态常量staticfinalStringname="Cyan"; //公有静态常量publicstaticfinalintage=20; //关于静态常量的初始化://1.在定义时就初始化,就像我们上面写得一样.//2.在静态代码块中初始化,如下 :publicstaticfinalStringsex; static { sex="male"; } //3.PS : 静态常量不能在构造器中初始化,如下是错误的写法 :/* public static final String hobby;public Demo() {hobby = "basketball";}*/} classTest_5 { publicstaticvoidmain(String[] args) { System.out.println("name = "+Demo.name); System.out.println("age = "+Demo.age); System.out.println("sex = "+Demo.sex); } }
运行结果 :
第二部分 :
Demo类,Test_5类代码如下 :
我们先在Demo类中定义一个静态常量hobby,并且在定义时就给它赋初值。接着在测试类中调用这个静态常量,看看静态代码块中的内容会不会被执行。
packageknowledge.polymorphism.about_static.fields; publicclassDemo { //测试————关于调用类的静态常量时,类的加载问题//静态常量在定义时已经初始化staticfinalStringhobby="music"; static { System.out.println("这句话输出,说明第一个静态代码块被执行"); System.out.println("hobby = "+hobby); } } classTest_5 { publicstaticvoidmain(String[] args) { //直接调用hobby静态常量System.out.println("hobby = "+Demo.hobby); } }
运行结果 :
可以看到,在输出语句中调用了静态常量hobby,但是类中的静态代码块并没有被执行,说明调用hobby静态常量并没有导致类的加载。
接着,我们再来定义一个静态常量color,并在另一个静态代码块中为其赋初值。在测试类中调用该静态常量,测试静态代码块中的内容会不会执行。
Demo类,Test_5类代码如下 :
packageknowledge.polymorphism.about_static.fields; publicclassDemo { //测试————关于调用类的静态常量时,类的加载问题//静态常量在定义时已经初始化staticfinalStringhobby="music"; static { System.out.println("这句话输出,说明第一个静态代码块被执行"); System.out.println("hobby = "+hobby); System.out.println("-----------------------------------"); } //静态常量在定义时未初始化,而是在静态代码块中完成了初始化staticfinalStringcolor; static { color="cyan"; System.out.println("这句话输出,说明第二个静态代码块被执行"); System.out.println("color = "+color); System.out.println("-----------------------------------"); } } classTest_5 { publicstaticvoidmain(String[] args) { System.out.println("hobby = "+Demo.hobby); System.out.println("color = "+Demo.color); } }
运行结果 :
我们来分析一下输出结果 :
首先,main函数第一条输出语句中调用了Demo.hobby,hobby是静态常量,并且是个在定义时就已经赋了初值的静态常量,因此调用Demo.hobby时不会加载类,静态代码块中的语句也就不会执行。但是,main函数第二条输出语句中调用了Demo.color,color也是静态常量,但它是个在定义时没有赋初值,而在静态代码块中才进行了初始化的静态常量,因此调用Demo.color时会加载类,静态代码块随着类的加载而被执行。因此,控制台上按照定义的顺序先后打印出了两个代码块中的内容。类加载后,才打印出了输出语句中的color变量。
四、static修饰成员方法详解 :
1.静态方法 :
static关键字修饰的成员方法,称为静态方法 或 类方法(只需在非静态方法的访问权限修饰符后面增加一个static关键字即可)。调用静态方法同调用静态变量类似,既可以通过对象来调用,也可以通过类名来调用,当然,一般情况下均使用类名调用。
需要注意的是——静态方法中没有引用this,也没有super。因此,在静态方法中不能访问非静态成员。而在非静态方法,是可以访问静态成员和非静态成员的。当然,以上两点都必须在满足访问权限修饰符的前提下。(一定要牢记红色加粗字体)
2.静态方法的使用场景 :
只需要访问静态成员,且不涉及到任何和对象相关的成员,所需参数均可由形参列表显式提供,这时候我们就可以定义静态方法。
up光这么说多少有些抽象,大家可以想想静态方法的特点——静态方法可以通过类名来调用,无需创建对象,要不为啥叫类方法。其实就是这么回事儿。比如我们有名的工具类Arrays类,打开Arrays类的源码,查看它的Structure你会发现,Arrays类中定义非常多的方法,而且它们无一例外都是静态方法,如下GIF所示 :
其实,判断这些方法是不是静态方法不需要一个一个地点开查看,有个小技巧——注意看上面演示图中——每个方法的图标左下角都有一个类似于镂空菱形的小玩意儿,其实这就表示该方法用了static修饰。你也可以自己试着写一个方法验证一下。
话说回来,当我们使用Arrays类的这些方法时,比如我们最常见的toString(),或者sort() 等方法,我们不需要创建Arrays类对象,而是直接通过类名来调用——“Arrays.toString()”,“Arrays.sort()”,等等。这就是静态方法的使用场景,要不为什么管Arrays类叫工具类呢。
3.静态方法的生命周期 :
静态方法和非静态方法都是随着类的加载开始,将结构信息存储在方法区,并随着类的回收而消亡。
4.静态方法的案例演示 :
说实话,也没啥演示的😂。给大家演示一下工具类静态方法的调用和自定义静态方法的调用吧。up以TestStaticMethod类和Demo类为栗,我们在TestStaticMethod类中定义一个数组,并用Arrays类的sort方法对其进行排序,再遍历排序后的数组。在Demo类中定义一个静态方法,然后在TestStaticMehtod类中的main方法中利用类名来调用该静态方法。
TestStaticMethod类和Demo类代码如下 :
packageknowledge.polymorphism.about_static.method; importjava.util.Arrays; publicclassTestStaticMethod { publicstaticvoidmain(String[] args) { int[] array=newint[]{11, 5, 2, 985, 211, 5}; //调用Arrays类的静态方法sort() 对当前数组进行正向排序。Arrays.sort(array); for (inti=0; i<array.length; i++) { System.out.println("数组第"+ (i+1) +"个元素是:"+array[i]); } System.out.println("---------------------------------------"); //调用自己瞎jb写的静态方法Demo.roll_up(); } } classDemo { //在Demo类中定义一个静态方法,该方法仅作为演示,无实际意义publicstaticvoidroll_up() { System.out.println("卷死👴了!"); } }
5.静态成员的特点总结 :
静态成员不依赖于类的特定实例,被类的所有实例共享,就是说static关键字修饰的成员变量或者成员方法不需要依赖于对象来进行访问,只取决于类是否被加载,只要这个类被加载,jvm就可以根据类名找到它们,直接“类名.___”的形式就可以调用。
五、深入理解main函数(main形式说明) :
1.main形式回顾 :
public static void main(String[] args) { //方法体(代码) }
Δmain函数是所有程序的唯一入口,由jvm来调用。
publicclassDemo_main { publicstaticvoidmain(String[] args) { //Codes } }
2.main形式解析 :
①为什么访问权限修饰符是public?
因为main函数是一切程序的入口,jvm需要调用类的main() 方法来开启一个程序的执行。而jvm要想调用main() 方法,就必须要求main() 方法是公共的,否则不满足jvm的访问条件。如果我们去掉main函数前面的public修饰符,main函数将无法被jvm执行,如下GIF图演示 :
②为什么要用static修饰?
在static关键字的万字详解篇中,我们提到了静态方法的使用场景——当我们只需要访问静态成员,不需要访问该类对象的状态,和该类的对象并无什么瓜葛时,可以在该类中根据需要定义若干静态方法。我们也举了Arrays类等工具类的例子。
回到main函数上,对于main函数所在的类,jvm并不需要创建该类的对象或者访问该类对象的状态,jvm的目的就是直接访问main函数,所以main函数必须设置为static类型——静态方法。其实前提都是因为main函数的作用——充当程序的唯一入口。
一样的,如果我们去掉main函数前面的static关键字,main函数将无法被jvm执行,如下GIF图演示 :
③关于返回值类型 :
jvm仅将main函数当作程序的入口来使用,不需要你返回任何值,自然main函数的返回值类型定义为void类型。举一个不是特别恰当的例子:你把马桶当作程序,马桶盖子当作main函数。那么,你平时大号是不是都需要先找到马桶盖子,然后打开,后面up就不做详细阐述了,反正打开马桶盖必须是首要条件,而且再经过你的一系列操作,最后结束,再盖上马桶盖子。我想,你不会希望在你大号完毕后,马桶再给你吐出一些东西来吧😅?其实就是一个道理。
④关于形参列表 :
main函数的形参是“String[] args”,显然args表示一个String类型的数组。但是要知道,main函数是jvm来调用的,因此想直接传入实参还没那么容易。有两种途径可以解决 :
①DOS命令,不知道大家还记不记得😂。就是cmd那黑窗口。在DOS中给main函数传入实参的使用格式如下 :
java 运行的类型 第一个参数 第二个参数 第三个参数 第四个参数 第五个参数......
传入的参数之间要在分割处打空格。给大家举个例子演示一下 :
up在桌面新建了一个txt文件,文件重命名给它改成.java后缀,如下图所示 :
在Demo.java文件中写入“输出args数组内容”的代码,如下图所示 : (因为up使用DOS存在乱码问题,因此这里只能使用英文了,望理解😂。
然后按下win + R进入运行界面,在运行界面中输入CMD进入DOS界面;接着,在DOS界面输入 "cd Desktop" 命令敲回车进入桌面,然后通过javac命令进行编译,编译后就可以使用java命令运行了,如下GIF图演示(===分多张图演示===) :
在演示的GIF图中大家可以看到,Demo.java文件编译后,up在运行时手动传入了三个实参Cyan,Rain和TY,并且都随着打印args数组的语句的执行而成功输出了。
②IDEA设置。要想在IDEA中也达到类似的——手动给main函数传入实参的效果,需要你单独更改类的Program arguments。大家可以在IDEA的Run(运行)一栏,依次点击Run ---> Edit Configurations ---> 找到Program arguments,然后在Program arguments一栏中手动给出当前类main函数的实参,多个实参中间仍然以空格分割。
up以Demo_main为例,如下GIF演示图所示(分多张演示图) :
可以看到,在未设置参数时直接运行Demo_main类,无输出结果;而通过更改Program arguments参数,成功打印出了args数组中传入的实参。
⑤关于main函数中调用本类成员的问题 :
①我们可以在main函数中直接调用本类的静态成员(类变量和类方法)。
up还是以Demo_main类举个栗子吧,Demo_main类代码如下 :
packageknowledge.polymorphism.mainEX; publicclassDemo_main { privatestaticStringname="Cyan"; publicstaticvoidHaha() { System.out.println("哈哈哈哈哈哈哈哈哈"); } publicstaticvoidmain(String[] args) { Haha(); System.out.println("name = "+name); } }
运行结果 :
如图所示,main方法调用本类的静态成员不需要通过类名的形式,而是直接用就可以。
②main函数并不能直接访问本类的非静态成员。
如果你非想访问,必须在main函数中创建一个该类的对象,然后再通过对象的形式去访问类中的非静态成员。仍以Demo_main类为栗,Demo_main类代码如下 :
packageknowledge.polymorphism.mainEX; publicclassDemo_main { privateStringname="Cyan"; publicvoidHaha() { System.out.println("哈哈哈哈哈哈哈哈哈"); } publicstaticvoidmain(String[] args) { Demo_maindemo_main=newDemo_main(); demo_main.Haha(); System.out.println("name = "+demo_main.name); } }
运行结果 :
🆗, 以上就是对main函数形式上的一些解释。
六、关于静态代码块的说明 :
"静态代码块"相关部分讲解非常详细,因此篇幅较长。为了避免影响大家的阅读体验,up把关于java 代码块的一些说明单独拎了出来,链接如下 :
https://blog.csdn.net/TYRA9/article/details/128997395?spm=1001.2014.3001.5501
七、总结 :
🆗,以上就是关于static关键字的一些知识点分享。我们从雷电将军的“眼狩令”开始引入为什么需要static关键字。接着又详细分享了关于static修饰属性和行为的一些注意点,又举了诸如main函数形式解读和静态代码块这些static的具体应用。 感谢阅读!
System.out.println("END------------------------------------------------------------");