引言
在Java编程中，static关键字是一个非常重要的概念。它可以用于变量、方法、代码块。提供了在内存管理和代码结构上的独特优势，理解并正确使用static关键字是掌握Java编程的重要一步。
static关键字是什么？
static关键字是Java中的一个修饰符，用于声明类的成员变量、方法、代码块和嵌套类。使用static修饰的成员属于类本身，而不是类的实例。也就是说，static成员在内存中只有一份，共享给所有实例。
为什么设置static关键字？
1、如果方法和变量属于非静态的，他们只有在对象当中才会被分配内存空间，也就是只有对象才能调用。如果没有static关键字，那么类是不可以调用自己的属性和方法的，只能用对象去调用。2、方便类去使用自己的方法和变量。
static的使用
1、static修饰变量:
修饰的变量属于类变量，存储在方法区的静态常量池当中，被所有对象共享。
2、static修饰方法：
静态方法是属于类而不是类的实例的方法。它可以在不创建类的实例的情况下被调用。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗。
静态方法只能访问静态变量和调用其他静态方法，不能访问实例变量或调用实例方法。但是在非静态成员方法中是可以访问静态成员方法和静态成员变量。
如何使用main方法调用当前类中的方法：第一种为，在非静态方法前加static关键字；第二种为创建对象，让对象调用。
3、static修饰代码块：
在main方法之前运行，目的是优化程序。
static实例讲解
1、修饰变量和方法简单实例
public class A{
public String name = "张三";
public static String address = "保定";
public static void run(String num){
System.out.println("跑"+num+"米");
}
public String toString(){
return "name="+name+'\'+
"address="+address + '\'
}
} 下面创建test类
public class Test {
public static void main(String[] args){
A p1 = new A();
A p2 = new A();
p1.name = "li4";
p1.address = "北京";
p1.run("100");
p2.name = "wang5";
p2.address = "上海";
p2.run("200");
System.out.println(p1.toString);
System.out.println(p1.toString);
}
} //最后输出结果为name="li4" address="上海" 跑100米
// name="wang5" address="上海" 跑200米内存图详解
static修饰的address，p1和p2共用一个address，所以address一开始由保定变成北京再变成上海；而static修饰的方法run相当于共用一个工具，每个人的值还是各自的。
2、static修饰代码块分析
public class Test extends Base{
public Test(){
System.out.println("test constructor");
}
public static void main(String[] args){
new Test();
}
static{
System.out.println("test static");
}
//static修饰的代码块在main方法执行之前执行，其目的是修饰main方法。
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}运行步骤：
//程序执行先找main方法启动程序 //1、首先扫描main方法所在的Test类，发现其有父类Base类，则先扫描父类，发现Base类没有父类 //2、Base.class加载进方法区，此时Base类的static代码块执行 //3、Test.class加载进方法区，此时Test类的static代码块执行 //4、main方法入栈，执行new Test(); 创建Test类的对象 //5、创建子对象前要先创建父类对象，先执行Base（）构造器，再执行Test（）构造器 运行结果：
3、static修饰代码块分析（2题将main方法改到base类）
public class Test extends Base{
public Test(){
System.out.println("test constructor");
}
static{
System.out.println("test static");
}
//static修饰的代码块在main方法执行之前执行，其目的是修饰main方法。
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
public static void main(String[] args){
new Test();
}
}运行步骤：
//将main方法改到base类后 //1、首先扫描main方法所在的base类，发现其没有父类 //2、Base.class加载进方法区，此时Base类的static代码块执行 //3、main方法入栈，执行new Test(); //4、扫描test类，发现其有父类且已经扫描过了 //5、Test.class加载进方法区，此时Test类的static代码块执行 //6、执行new Test(); 创建Test类的对象 //7、创建子对象前要先创建父类对象，先执行Base（）构造器，再执行Test（）构造器
运行结果：
4、局部变量
public class A {
private static int a;
public static void main(String[] args) {
modify(a);
System.out.println(modify(a));
System.out.println(a);
}
public static int modify(int a){
return ++a;
}
} //运行结果为 1 0注意：modify中的int a是一个在modify方法中局部变量，不影响在静态常量池中的a；
int类型a的默认值为0；
Java只进行值的传递；
变形：
public class B {
private int a;
public static void main(String[] args) {
B a1 = new B();
modify(a1.a);
System.out.println(modify(a1.a));
System.out.println(a1.a);
}
public static int modify(int a){
return ++a;
}
} //输出结果为 1 0 return只是返回了modify的值，并没有对对象a1中的a进行更改。
5、运用
public class Demo {
public Demo(String aa){
System.out.println("我是构造器:"+aa);
}
static {
System.out.println("我是静态代码块1");
}
public static Demo demo = new Demo("构造demo中对象");
static {
System.out.println("我是静态代码块2");
}
}
class Test{
public static void main(String[] args) {
Demo demo = new Demo("test中对象");
}
}运行过程：扫码--->加载(编译)--->运行
1.main方法在哪里我们就先去扫描那个类---->首先去扫描Test类，发现没有父类，也没有static修饰的代码，那么编译Test类，并且将main方法入栈。
2.执行new Demo("test中对象"）；在执行之前扫描Demo类，发现没有父类，所以编译Demo类，在编译的过程中static代码块按顺序优先执行。
3.首先输出的是 “我是静态代码块1”
4.执行 public static Demo demo = new Demo("构造demo中对象"）；此时会涉及到调用Demo构造方法，所以输出 “我是构造器:构造demo中对象”
5.输出 “我是静态代码块1”
6.编译完毕，回到main方法当中继续执行new Demo("test中对象"）；现在可以创建对象了！！也就是进行到了运行阶段
7.通过调用构造器创建对象：
运行结果：