Java学习Static关键字用法源代码
1.如果不用static修饰，一个类中的对象相同的属性只能重复赋值public class Hello {
public static void main(String[] args) {
Student s1=new Student();//创建了一个实例化的对象p1,它是Person类对象的具体化
Student s2=new Student();
Student s3=new Student();
s1.schoolname="XXX大学";
s2.schoolname="XXX大学";
s3.schoolname="XXX大学";
}
}
class Student{
String schoolname;//学校名
int Num;//学号
String name;//姓名
}
2.static 关键字的用法一：修饰静态成员
一个类中相同的属性可以被定义成静态成员变量
public class Hello {
public static void main(String[] args) {
Student s1=new Student();//创建了一个实例化的对象p1,
它是Person类对象的具体化
Student s2=new Student();
Student s3=new Student();
Student.schoolname="XXX大学";
System.out.println("学生s1的学校名
"+s1
System.out.println("学生s2的学校名
"+s2
System.out.println("学生s3的学校名
"+s3
}
}
class Student{
static String schoolname;//定义的静态成员变量学校名int Num;//学号
String name;//姓名
}
3.static 关键字的用法二：修饰方法，静态方法
静态方法不用创建具体的对象就可以被调用：格式类名.静态方法名
public class Hello {
public static void main(String[] args) {
Student.schoolname="XXX大学";
Student.say();
Student.play();
System.out.println("学生的学校名
"+Student.schoolname);
}
}
class Student{
static String schoolname;//定义的静态成员变量学校名int Num;//学号
String name;//姓名
static void play() {
System.out.println("我在玩");
}
static void say() {
int name;
int Num;//局部变量
System.out.println("我的名字");
}
}
3.static 关键字的用法三：修饰代码块，静态代码块
静态代码块只执行一次，随着类第一次实例化对象的创建执行。
public class Hello {
public static void main(String[] args) {
Student.schoolname="XXX大学";
Student s1=new Student();
Student s2=new Student();
Student.say();
Student.play();
System.out.println("学生的学校名
"+Student.schoolname);
}
}
class Student{
static String schoolname;//1.定义的静态成员变量学校名int Num;//学号
String name;//姓名
//2.被static修饰的方法是静态方法
static void play() {
System.out.println("我在玩");
}
static void say() {
int name;
int Num;//局部变量
System.out.println("我的名字");
}
static {
System.out.println("静态代码块执行了");
}
}。
静态关键字：static
静态关键字：static1.静态关键字:static(1).static的作⽤.修饰成员变量的⽤法1. static关键字的作⽤static是静态的意思,可以修饰成员变量和成员⽅法.static修饰成员变量表⽰该成员变量只在内存中只存储⼀份,可以被共享访问.修改.举个例⼦:package top.xiaoytongxue.day02;public class User {//这个onlineNumber就是成员变量public static int onlineNumber = 162;private String name;private int age;}2.成员变量可以分为2类静态成员变量(有static修饰,属于类,内存中加载⼀次):常表⽰如在线⼈数信息.等需要被共享的信息,可以被共享访问public class User{//静态成员变量public static String onlineNumber = 161;}类名.静态成员变量.(推荐)对象.静态成员变量.(不推荐)public class User{public static String onlineNumber = 161;//实例成员变量对象.实例成员变量 (这种可以调⽤实例成员变量)private String name;private int age;}总结:1.成员变量的分类和访问分别是什么样的?静态成员变量(有static修饰,属于类,加载⼀次,可以被共享访问),访问格式:类名.静态成员变量(推荐)对象.实例成员变量(不推荐)2.两种成员变量各⾃在什么情况下定义?静态成员变量:表⽰在线⼈数等需要被共享的信息实例成员变量:属于每个对象,且每个对象信息不同时(name,age,...)(2).static修饰成员患变量的内存原理⾸先⽅法区加载User.class类,然后在栈内存中加载main⽅法,在栈内存中User u1 和User u2中地址指向堆内存中,⼩y和⼩h都只指向⼀个static 类静态变量区.package top.xiaoytongxue.day02;public class User {//静态成员变量:有static修饰,属于类,加载⼀次,可以被共享访问public static int onlineNumber = 162;// 实例成员变量:⽆static修饰,属于每个对象private String name;private int age;public static void main(String[] args) {// 1.类名.静态成员变量System.out.println(User.onlineNumber);System.out.println(onlineNumber);User.onlineNumber++;User u1 = new User(); = "⼩y";u1.age = 18;System.out.println();System.out.println(u1.age);// 对象名称.静态成员变量(不推荐)u1.onlineNumber++;User u2 = new User(); = "⼩h";u2.age = 29;System.out.println();System.out.println(u2.age);//对象名称.静态成员变量(不推荐)u2.onlineNumber++;System.out.println(User.onlineNumber);}}(3).static修饰成员⽅法的基本⽤法1.成员⽅法的分类:静态成员⽅法(有static修饰,属于类),建议⽤类名访问,也可以⽤对象访问.实例成员⽅法(⽆static修饰,属于对象),只能⽤对象触发访问.使⽤场景表⽰对象⾃⼰的⾏为的,且⽅法中奖需要访问实例成员的,则该⽅法必须申明成实例⽅法.如果该⽅法是以执⾏⼀个共⽤功能为⽬的,则可以申明成静态⽅法.总结1.成员⽅法的分类和访问分别是什么样的?静态成员⽅法(有static修饰,属于类和对象共享)访问格式:类名.静态成员⽅法.对象.静态成员⽅法.(不推荐)实例成员⽅法(⽆static修饰,属于对象)的访问格式:对象.实例成员⽅法2.每种成员⽅法的使⽤场景是怎么样的?表⽰对象⾃⼰的⾏为的,且⽅法中需要访问实例成员的,则该⽅法必须申明成实例⽅法.如果该⽅法是以执⾏⼀个通⽤功能为⽬的,或者需要⽅便访问,则可以申明成静态⽅法.案例:做⼀个随机验证码⽤静态成员⽅法package top.xiaoytongxue.day01;import java.util.Random;public class demo1 {public static void main(String[] args) {createCode(5);}/**** 这⾥是将这个随机⽣成验证码做成了⼀个静态⽅法⽅便调⽤* @param n* @return*/public static String createCode(int n){//1.使⽤String开发⼀个验证码String chars = "abcdefgfijklmnopqrstuvwsyzABCDEFGHIJKLMNOPJRSTUVWSYZ0123456789";//2.定义⼀个变量⽤于存储⼀个五位随机随机的字符作为验证码String code = "";//3.循环Random r = new Random();for (int i = 0; i < n; i++) {int index = r.nextInt(chars.length());//4.根据随机出来的索引提取相应的字符code += chars.charAt(index);}System.out.println("随机的验证码为:" + code);}(4).static修饰成员⽅法的内存原理(5).static实际应⽤案例:设计⼯具类1.什么是⼯具类?⼯具类中定义的都是⼀些静态⽅法,每个⽅法都是以完成⼀个共⽤的功能为⽬的.举个例⼦,在企业的管理系统中,通常需要在⼀个系统的很多业务处使⽤验证码进⾏防刷新等安全控制.验证码就很好的解决了这个问题.但是如果登录和注册等多处地⽅都存在验证码逻辑,就会导致同⼀个功能多处开发,会出现代码重复度过⾼.⼯具类的好处⼀是调⽤⽅便,⼆是提⾼了代码复⽤(⼀次编写,处处可⽤)为什么⼯具类中的⽅法不⽤实例⽅法做?实例⽅法需要创建对象调⽤,此时⽤对象只是为了调⽤⽅法,这样只会浪费内存.⼯具类的定义注意建议将⼯具类的构造器进⾏私有,⼯具类⽆需创建对象.⾥⾯都是静态⽅法,直接⽤类名访问即可.总结1.⼯具类是什么,有什么好处?内部都是⼀些静态⽅法,每个⽅法完成⼀个功能⼀次编写,处处可⽤,提⾼代码的重⽤性2.⼯具类有什么要求?建议⼯具类的构造器私有化处理⼯具类不需要创建对象案例/*静态⽅法,⼯具⽅法*/public static double getAverage(int[] arr){// 求值最⼤值最⼩值int max = arr[0];int min = arr[0];int sum = 0;for (int i = 0; i < arr.length; i++) {if (arr[i] > max){max = arr[i];}if (arr[i] < min){min = arr[i];}sum += arr[i];}return sum;}/*静态⽅法,⼯具⽅法*/public static String toString(int[] arr){if (arr != null){String result = "[";for (int i = 0; i < arr.length; i++) {result += (i == arr.length - 1 ? arr[i] : arr[i] + ",");}result += "]";return result;}else {}}(6).static的注意事项总结[⾯试热点]static访问注意实现:静态⽅法只能访问静态的成员,不可以直接访问实例成员实例⽅法可以访问静态的成员,也可以访问实例成员静态⽅法中是不可以出现this关键字的.package top.xiaoytongxue.day02;public class demo2 {//静态成员变量public static int onlineNumber;//实例成员变量private String name;public static void getMax(){// 1.静态⽅法可以直接访问静态成员System.out.println(demo2.onlineNumber);System.out.println(onlineNumber);inAddr();//3.静态⽅法中不能出现this关键字System.out.println(this);}private static void inAddr() {}public void run(){//2.实例⽅法可以直接访问静态成员,也可以访问实例成员System.out.println(demo2.onlineNumber);System.out.println(onlineNumber);demo2.getMax();getMax();System.out.println(name);sing();}private void sing() {}}。
static关键字的用法
static关键字的用法摘要：一、static 关键字的简介二、static 关键字在Java 中的用法1.静态变量2.静态方法3.静态代码块三、static 关键字在C++中的用法1.静态变量2.静态方法4.静态代码块四、static 关键字在Python 中的用法1.静态变量2.静态方法3.静态代码块五、static 关键字在不同编程语言中的差异和注意事项正文：static 关键字是一个在不同编程语言中都广泛使用的关键字，它的作用主要是用于声明静态的变量、方法和代码块。
在本文中，我们将详细介绍static 关键字在Java、C++和Python 这三种编程语言中的用法，并比较它们之间的差异和注意事项。
首先，我们来看static 关键字在Java 中的用法。
在Java 中，static 关键字可以用于声明静态变量、静态方法和静态代码块。
静态变量是在类级别定义的变量，它被所有类的实例共享。
静态方法是不依赖于对象实例的方法，可以直接通过类名来调用。
静态代码块是在类被加载时自动执行的代码块。
接下来，我们来看static 关键字在C++中的用法。
在C++中，static 关键字同样可以用于声明静态变量和静态方法。
静态变量在程序整个运行期间只会被初始化一次，且所有对象共享同一个静态变量。
静态方法可以直接通过类名来调用，不需要创建类的实例。
需要注意的是，C++中的静态变量和静态方法默认是public 权限，可以通过类名直接访问。
最后，我们来看static 关键字在Python 中的用法。
在Python 中，static 关键字用于声明静态变量和静态方法。
静态变量在模块级别定义，所有导入该模块的对象共享同一个静态变量。
静态方法可以直接通过模块名来调用。
需要注意的是，Python 中的静态变量和静态方法默认是public 权限，可以通过模块名直接访问。
总之，static 关键字在不同编程语言中的用法虽然相似，但仍存在一些差异。
static关键字的使用及说明
static关键字的使⽤及说明static 关键字主要有以下⼏种使⽤场景：修饰类的成员变量。
修饰类的成员⽅法。
修饰类的代码块。
修饰内部类。
1. static 修饰类的成员变量时，被称为静态成员变量。
引⽤ static 修饰的成员变量时，⽆需创建类的实例对象，可直接使⽤类.变量名进⾏调⽤。
代码⽰例：public class Student {int age; //普通变量static String name; //静态变量}public static void main(String[] args) {Student student = new Student();System.out.println(student.age); //普通成员变量，需要实例化对象进⾏调⽤System.out.println(); //静态成员变量，⽆需实例化对象即可调⽤}2. static 修饰类的成员⽅法时，被称为静态成员⽅法。
引⽤ static 修饰的成员⽅法时，⽆需创建类的实例对象，可直接使⽤类.⽅法名进⾏调⽤。
代码⽰例：public class Student {/*** 普通⽅法*/public void haha(){}/*** 静态⽅法*/public static void say(){}}public static void main(String[] args) {Student student = new Student();student.haha(); //普通成员⽅法，需要实例化对象进⾏调⽤Student.say(); //静态成员⽅法，⽆需实例化对象即可调⽤}3. static 修饰类的代码块时，被称为静态代码块。
在类加载时，静态代码块先执⾏，其次是普通代码块，最后是类的构造⽅法。
⽽且不管类创建多少对象，静态代码块只执⾏⼀次，⽽普通代码块和构造⽅法会执⾏多次。
代码⽰例：public class Student {Student(){System.out.println("我是默认的构造⽅法");}{System.out.println("我是代码块");}static {System.out.println("我是被static修饰的静态代码块"); }}public static void main(String[] args) {Student s1=new Student();Student s2=new Student();}输出结果：我是被static修饰的静态代码块我是代码块我是默认的构造⽅法我是代码块我是默认的构造⽅法4. static 只能修饰内部类，不能修饰普通类。
Java关键字final、static使用总结
Java关键字final、static使⽤总结假如⼀个变量存在于⼀个函数中,函数调⽤结束后,普通变量会被释放内存。
⽽静态变量的内存则不会释放。
假如后⾯的程序段要调⽤该函数，该函数中该静态变量的值可以继续使⽤。
⼀、final根据程序上下⽂环境，Java关键字final有“这是⽆法改变的”或者“终态的”含义，它可以修饰⾮抽象类、⾮抽象类成员⽅法和变量。
你可能出于两种理解⽽需要阻⽌改变：设计或效率。
final类不能被继承，没有⼦类，final类中的⽅法默认是final的。
final⽅法不能被⼦类的⽅法覆盖，但可以被继承。
final成员变量表⽰常量，只能被赋值⼀次，赋值后值不再改变。
final不能⽤于修饰构造⽅法。
注意：⽗类的private成员⽅法是不能被⼦类⽅法覆盖的，因此private类型的⽅法默认是final类型的。
1、final类final类不能被继承，因此final类的成员⽅法没有机会被覆盖，默认都是final的。
在设计类时候，如果这个类不需要有⼦类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final⽅法如果⼀个类不允许其⼦类覆盖某个⽅法，则可以把这个⽅法声明为final⽅法。
使⽤final⽅法的原因有⼆：第⼀、把⽅法锁定，防⽌任何继承类修改它的意义和实现。
第⼆、⾼效。
编译器在遇到调⽤final⽅法时候会转⼊内嵌机制，⼤⼤提⾼执⾏效率。
例如：View Code1public class Test1 {23public static void main(String[] args) {4// TODO ⾃动⽣成⽅法存根5 }67public void f1() {8 System.out.println("f1");9 }10//⽆法被⼦类覆盖的⽅法11public final void f2() {12 System.out.println("f2");13 }1415public void f3() {16 System.out.println("f3");17 }1819private void f4() {20 System.out.println("f4");21 }22 }2324public class Test2 extends Test1 {2526public void f1(){27 System.out.println("Test1⽗类⽅法f1被覆盖!");28 }2930public static void main(String[] args) {31 Test2 t=new Test2();32 t.f1();33 t.f2(); //调⽤从⽗类继承过来的final⽅法34 t.f3(); //调⽤从⽗类继承过来的⽅法35//t.f4(); //调⽤失败，⽆法从⽗类继承获得3637 }38 }3、final变量（常量）⽤final修饰的成员变量表⽰常量，值⼀旦给定就⽆法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表⽰三种类型的常量。
java类中的static方法
java类中的static方法宝子们！今天咱们来唠唠Java类中的static方法呀。
你可以把static方法想象成是住在集体宿舍里的那种公共资源。
它是属于类的，而不是属于类的某个实例对象的哦。
就好比宿舍里的公共洗衣机，不管是哪个舍友要用，它就在那儿，大家都能使。
比如说，咱们有个类叫MathUtils，里面有个static方法add，用来做加法。
class MathUtils {public static int add(int a, int b) {return a + b;}}你看，当我们想要调用这个add方法的时候，不需要先创建一个MathUtils的对象，就像这样直接调用就行啦：int result = MathUtils.add(3, 5);System.out.println(result);这多方便呀，就像你不用先把公共洗衣机买回家再洗衣服一样。
而且呢，static方法不能直接访问非static的成员变量和方法哦。
为啥呢？这就好比公共洗衣机不能直接去洗你藏在自己被窝里的小袜子一样，它只能处理公共的、和整个类相关的事情。
再来说说它的好处呀。
它在内存中只有一份拷贝呢。
不管你创建了多少个这个类的对象，这个static方法就那么一个，不会因为对象多了就变得臃肿。
这就像是宿舍里的公共设施，不会因为住的人多了就多出来好几个洗衣机。
不过呢，也得小心使用。
如果你的static方法太多，而且逻辑很复杂，可能就会让这个类变得很混乱，就像宿舍里堆了太多公共杂物一样，找个东西都费劲。
总的来说，Java类中的static方法是个很有趣又很实用的东西啦。
它就像是类的小助手，随时待命，只要你按照规则来调用它，就能轻松帮你搞定很多事情呢。
宝子们，是不是感觉对它的理解更深刻一点啦 。
static的五种用法
static的五种用法
"static" 这个关键字在编程中有多种用法，具体用法取决于编程语言。
以下是"static" 关键字在许多编程语言中常见的五种用法：
1. 静态变量（Static Variables）：
在函数内部声明的静态变量在程序执行期间保持其值不变。
它们在函数调用之间保持其值，而不像普通的局部变量那样在每次函数调用时重新初始化。
2. 静态方法（Static Methods）：
在类中声明的静态方法是不需要实例化类就可以调用的方法。
它们通常用于执行与类相关的操作，而不是与实例相关的操作。
3. 静态类（Static Classes）：
在一些编程语言中，可以声明静态类，这些类不能被实例化，且只能包含静态成员。
4. 静态成员变量（Static Member Variables）：
在类中声明的静态成员变量是类的所有实例共享的变量。
它们的值对于所有实例都是相同的。
5. 静态导入（Static Imports）：
在Java 中，可以使用静态导入来直接访问静态成员，而不需要使用类名来限定。
这样可以简化代码，使得静态成员的使用更加方便。
需要注意的是，不同的编程语言可能会对"static" 关键字有不同的用法和语义。
上述用法主要是针对一些常见的编程语言，比如C/C++、Java、C# 等。
在特定的编程语言中，"static" 关键字可能还有其他用法。
Java：Java中static关键字作用
Java：Java中static关键字作⽤static关键字最基本的⽤法是：1、被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类来2、被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类来3、被static修饰的变量、被static修饰的⽅法统⼀属于类的静态资源，是类实例之间共享的。
@ JDK把不同的静态资源放在了不同的类中为什么不把所有静态资源放在⼀个类⾥⾯呢？主要有以下⼏个原因：1、不同的类有⾃⼰的静态资源，这可以实现静态资源分类。
⽐如和数学相关的静态资源放在ng.Math中，和⽇历相关的静态资源放在java.util.Calendar中，这样就很清晰了2、避免重名。
不同的类之间有重名的静态变量名、静态⽅法名也是很正常的，如果所有的都放在⼀起不可避免的⼀个问题就是名字重复，这时候怎么办？分类放置就好了。
3、避免静态资源类⽆限膨胀，这很好理解。
静态⽅法不可以引⽤⾮静态资源例如下⾯代码：public class A{private int i = 1;public static void main(String[] args){//报错，静态⽅法内不能引⽤⾮静态属性i = 1;}}⾮静态⽅法⾥⾯可以引⽤静态资源⽰例：public class A{//静态属性private static int i = 1;//⾮静态⽅法public void main(String[] args){i = 1;}}静态资源属于类，但是独⽴于类存在的。
从JVM的类加载机制的⾓度讲，静态资源是类初始化的时候加载的，⽽⾮静态资源是类new的时候加载的。
静态块静态块也是static的重要应⽤之⼀。
也是⽤于初始化⼀个类的时候做操作⽤的，和静态变量、静态⽅法⼀样，静态块⾥⾯的代码只执⾏⼀次，且只在初始化类的时候执⾏。
需要注意的三点：1、Static修饰的⽅法执⾏顺序是怎么样的？public class A{private static int a = B();static{System.out.println("Enter A.static block");}public static void main(String[] args){new A();}public static int B(){System.out.println("Enter A.B()");return 1;}} 输出结果：Enter A.B()Enter A.static block结论：静态资源的加载顺序是严格按照静态资源的定义顺序来加载的。
Java面向对象学习（四）static关键字与抽象类
Java⾯向对象学习（四）static关键字与抽象类1.static：静态的2.static⽤法1）static修饰属性static可以修饰变量，被static修饰的变量都是存放在堆中的静态⽅法区，与类⼀起加载。
所以调⽤static修饰的变量可以使⽤类名.变量名的⽅式调⽤，且⼀般都是使⽤这种⽅式1public class Student {2private static String name; //静态的变量，⼀般⽤于多线程中3private int age; //⾮静态的变量45public static void main(String[] args) {6//要使⽤这个类，先要初始化这个类7 Student student = new Student();89//static修饰的对象我们⼀般都直接⽤类.变量的⽅式调⽤，⽽⾮静态变量不可以10 System.out.println(name); //在当前类可以直接调⽤name，但不能直接调⽤age11 System.out.println(); //在其他类中可以直接调⽤类名.name12//System.out.println(Student.age); //这句话报错Non-static field 'age' cannot be referenced from a static context13//也可以通过对象调⽤14 System.out.println();15 System.out.println(student.age);16 }17 }2）static修饰⽅法调⽤⽅法与属性同理1public class Student {2//static修饰⽅法3//静态⽅法4public static void run1(){56 }7//⾮静态⽅法，在⾮静态⽅法中可以直接调⽤静态⽅法，因为静态⽅法是和类⼀起加载的8public void run2(){9 run1();10 }1112public static void main(String[] args) {13//可以直接调动静态⽅法run114 run1(); //当前类中调⽤的写法15 Student.run1(); //其它类中调⽤的写法16//run2();在调⽤时必须先初始化这个类,否则不能调⽤17new Student().run2();18 }19 }3）static修饰代码块static修饰代码块，与类⼀起加载，只会加载⼀次。
Java static关键字详解
Java static关键字详解1. 关键字：static详解如果想让一个成员变量被类的所有实例所共享，就用static修饰即可，称为类变量（或类属性）！1.1 类属性、类方法的设计思想当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。
我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。
例如，所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。
此外，在类中声明的实例方法，在类的外面必须要先创建对象，才能调用。
但是有些方法的调用者和当前类的对象无关，这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。
这里的类变量、类方法，只需要使用static修饰即可。
所以也称为静态变量、静态方法。
1.2 static关键字•使用范围：–在Java类中，可用static修饰属性、方法、代码块、内部类•被修饰后的成员具备以下特点：–随着类的加载而加载–优先于对象存在–修饰的成员，被所有对象所共享–访问权限允许时，可不创建对象，直接被类调用1.3 静态变量1.3.1 语法格式使用static修饰的成员变量就是静态变量（或类变量、类属性）[修饰符]class类{[其他修饰符]static数据类型变量名;}1.3.2 静态变量的特点•静态变量的默认值规则和实例变量一样。
•静态变量值是所有对象共享。
•静态变量在本类中，可以在任意方法、代码块、构造器中直接使用。
•如果权限修饰符允许，在其他类中可以通过“类名.静态变量”直接访问，也可以通过“对象.静态变量”的方式访问（但是更推荐使用类名.静态变量的方式）。
•静态变量的get/set方法也静态的，当局部变量与静态变量重名时，使用“类名.静态变量”进行区分。
从零开始学Java（十四）详解Java中的static关键字（上）
从零开始学Java（十四）详解Java中的static关键字（上）✔上一篇Java零基础系列文章我们说到了Java种this关键字的使用，今天继续来说说Java中的static关键字，篇幅较多，分为上下两篇更新，这篇文章主要内容：•Java中static关键字•Java中static静态变量Java中的static关键字static是java语言中的关键字，表示“静态的”，它可以用来修饰变量、方法、代码块等。
•修饰的变量叫做静态变量•修饰的方法叫做静态方法•修饰的代码块叫做静态代码块在java语言中凡是用static修饰的都是类相关的，不需要创建对象，直接通过“类名”即可访问，即使使用“引用”去访问，在运行的时候也和堆内存当中的对象无关。
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。
通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。
在成员的声明前面加上关键字static（静态的）就能创建这样的成员。
如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。
你可以将方法和变量都声明为static。
static 成员的最常见的例子是main（）。
因为在程序开始执行时必须调用main() ，所以它被声明为static。
\•声明为static的变量称为静态变量或类变量。
可以直接通过类名引用静态变量，也可以通过实例名来引用静态变量，但最好采用前者，因为后者容易混淆静态变量和一般变量。
静态变量是跟类相关联的，类的所有实例共同拥有一个静态变量。
\•声明为static的方法称为静态方法或类方法。
静态方法可以直接调用静态方法，访问静态变量，但是不能直接访问实例变量和实例方法。
静态方法中不能使用this关键字，因为静态方法不属于任何一个实例。
Java中static静态变量java中的变量包括：局部变量和成员变量，在方法体中声明的变量为局部变量，有效范围很小，只能在方法体中访问，方法结束之后局部变量内存就释放了，在内存方面局部变量存储在栈当中。