Java基础--static关键字

引言

        在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.通过调用构造器创建对象：

运行结果：