static 关键字

static 静态的

static 可以修饰内部类（这里不讨论）

static 可以修饰属性 ====>> 静态变量

static 可以修饰方法 ====>> 静态方法

static 可以修饰代码块 ====>>静态代码块

• static 修饰属性 ====>> 静态变量

　static可以修饰成员变量，不能修饰局部变量

public class Student {
    String stuID;
    String name;
    static String clsName;    //static 修饰成员变量
}

public class TestStudent {

　　public static void main(String[] args) {
    　　Student s1 = new Student();
    　　s1.stuID="sg1524163";
    　　s1.name="刘备";
    　　s1.clsName="蜀国一班";//一处设置处处设置，一处修改处处修改！

    　　Student s2 = new Student();
    　　s2.stuID="sg16556163";
    　　s2.name="关羽";
    　　//s2.clsName="蜀国一班";

    　　Student s3 = new Student();
    　　s3.stuID="sg16657463";
    　　s3.name="张飞";
    　　//s3.clsName="蜀国一班";
　　　　//当遇到很多对象都有同一个属性的值时，可用static修饰这个属性来减少赋值
    　　System.out.println(s1.name+"\t"+s1.clsName);
    　　System.out.println(s2.name+"\t"+s2.clsName);
    　　System.out.println(s3.name+"\t"+s3.clsName);
　　}
}
输出结果：
刘备　　蜀国一班
关羽　　蜀国一班
张飞　　蜀国一班

 需注意的问题

上面的例子中，是用对象(s1、s2、s3) 去调用静态属性(clsName) 的。--> clsName

但是，建议用类去调用。--> Student.clsName 

当成员变量声明时使用了 static 关键字，那么这种变量称为静态变量，没有使用 static 关键字称为实例变量。 

实例变量必须先创建对象，通过“引用”去访问，而静态变量访问时不需要创建对象，直接通过“类名”访问。

public class Phone {
    int memory;
    static String name;
}


//测试类
package test;
public class TestPhone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.memory = 128;　　//通过”引用“访问
        //p1.name = "红米";
        Phone.name = "红米";　　//通过”类名“访问
        System.out.println("内存："+p1.memory);
        System.out.println("品牌："+Phone.name);
    }
}
输出结果：
　　内存：128
　　品牌：红米

 静态变量总结：

所有实例相关的，包括实例变量和实例方法，必须先创建对象，然后通过“引用”的方式去访问，如果空引用访问实例相关的成员，必然会出现空指针异常。所有静态相关的，包括静态变量和静态方法，直接使用“类名”去访问。虽然静态相关的成员也能使用“引用”去访问，但这种方式并不被主张。

• static修饰方法 ====>> 静态方法

被static关键字所修饰的方法就是静态方法。

比如我们import的util包，全是工具类！工具类所有的方法都是静态方法！

使用方法：类名 . 静态方法

下面，我们自定义一个工具类（所有方法用 static 修饰）

package cn.bjpowernode.javase01.day11.static02;

public class PrintUtil {
    //打印长方形
    public static void rect(int a,int b){
        for(int i=1;i<=a;i++){
            for(int j=1;j<=b;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
    //打印等腰三角形
    public static void triangle(int a){
        for(int i=1;i<=a;i++){
            for(int j=1;j<=(a-i);j++){
                System.out.print(" ");
            }
            for(int z=1;z<=(2*i-1);z++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

 创建测试类去调用上面的工具类（类名 . 静态方法）

package cn.bjpowernode.javase01.day11.static02;

public class Test {
    public static void main(String[] args) {
        PrintUtil.rect(5,10);
        PrintUtil.triangle(5);
    }
}
//结果如下：

• static 可以修饰代码块 ====>>静态代码块

先看格式：

在 { } 内，除了明显的死循环，其他内容都可以写，跟方法体没什么区别
但是，静态代码块儿只能调用静态的成员，非静态代码块什么都能调用！

package test;
public class Student {
    String name;
    static  String clsName;    //静态变量

    public static void fun1(){   //静态方法
        System.out.println("fun1...");
    }

    public void fun2(){　　 System.out.println("fun2...");　　}

    public Student() {　　System.out.println("Student的构造函数...");　　}

    static{　　System.out.println("Student的静态代码块。。。");　　}

    {　　System.out.println("Student的非静态代码块...");　　}
}

 

创建测试类

package test;
public class TestStudent {
    public static void main(String[] args) {
        System.out.println("main....");
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println("姓名："+s1.name);
        System.out.println("班级："+Student.clsName);    //类.静态变量
        Student.fun1();    //类.静态方法
        s1.fun2();
    }

    static{　　System.out.println("TestStudent的静态代码块。。。");　　}

    {　　System.out.println("TestStudent的非静态代码块...");　　}
}

执行结果：
    TestStudent的静态代码块。。。
    main....
    Student的静态代码块。。。
    Student的非静态代码块...
    Student的构造函数....
    Student的非静态代码块...
    Student的构造函数....
    姓名：null
    班级：null
    fun1...
    fun2...

输出结果的解释如下：

一个类中有静态代码块、非静态代码块、构造函数时，如果创建对象，执行顺序：静态代码块 ==> 非静态代码块 ==> 构造函数

如下图：方法区中有个静态区，用来存放静态代码块、静态的变量、方法；而堆区就存放非静态的。

　　　　当运行TestStudent 类时，

　　　　　　第一步：编译把 *.java 文件变成 *.class 文件
　　　　　　第二步：类加载( ClassLoader )，把代码片段加载到 jvm 虚拟机的方法区！
　　　　　　类加载如果遇到静态代码块，直接执行！所以输出行2（仅一次）

　　　　　　当创建了对象s1，就会加载Student类，在堆中开辟0x112位置，所以输出行4（仅一次）、5、6

　　　　　　当创建了对象s2，在堆中开辟0x234位置，所以输出行7(同5)、8(同6)

　　　　　　即，如果多次创建对象，非静态代码块和构造函数执行多次，静态代码块只执行一次！

　　　　　　静态代码块只在类加载时执行，而类加载只会加载一次！
　　　　　　第三步：执行程序

 

jvm打开，执行程序，jvm关闭！