十一、Java基础之static关键字

/*
一、static关键字：
　　1.static修饰的变量叫做“静态变量”
　　2.static修改的方法叫做“静态方法”
　　3.static还可以定义静态语句块
 */

二、以下语句演示：static定义静态语句块:
　　　　static定义的静态语句块在类加载阶段执行，并且只执行一次，并且自上而下顺序执行

public class StaticTest11 {
    //静态语句块
    static{
        System.out.println("1");
    }
    static{
        System.out.println("2");
    }
    static{
        System.out.println("3");
    }
    static{
        System.out.println("4");
    }
    //入口
    public static void main(String[] args){

        System.out.println("main execute!  1");
        System.out.println("main execute!  2");
    }
}

结果

1
2
3
4
main execute!  1
main execute!  2

/*
三、关于实例语句块
　　1.每一次调用构造方法之前，会执行一次（每一次对象创建之前执行一次）
　　2.实例语句块执行顺序是自上而下
 */

public class StaticTest12 {
    //静态语句块
    static{
        System.out.println("A");
    }
    //实例语句块
    {
        System.out.println("1");
    }{
        System.out.println("2");
    }{
        System.out.println("3");
    }
    StaticTest12(){
        System.out.println("构造方法执行");
    }

    public static void main(String[] args){
        new StaticTest12();

        new StaticTest12();
    }
}

结果：

A
1
2
3
构造方法执行
1
2
3
构造方法执行

/*
四、static修饰的方法叫做静态方法
    1.一般工具类中的方法大部分都是静态方法
    2.静态方法不用创建对象也能直接访问该方法

 */

public class StaticTest13 {
    //成员方法
    public void m1(){
        System.out.println("m1");

    }
    //静态方法
    //可以使用"类型."方式调用
    //静态方法中不能直接访问非静态数据
    //静态方法中不能使用this
    public static void m2(){
        System.out.println("m2");

    }
    //入口
    public static void main(String[] args){
        //访问成员方法，必须有对象，引用
        StaticTest13 st=new StaticTest13();
        st.m1();
        //静态方法中不能直接访问非静态方法
       // m1();//Error:(27, 9) java: 无法从静态上下文中引用非静态 方法 m1()

        //访问静态方法可通过类名.静态方法名，或直接静态方法名
        //静态方法也能用“引用.”
        StaticTest13.m2();
        //该方法执行不需要对象
        //编译阶段检查出st是StaticTest13类型，编译沟通过，运行时，仍然使用“StaticTest13.m2”的方式访问
        st.m2();


        //空的引用去访问成员的时候，会出现空指针异常
        //m2方法不是“成员”，而是静态的
        //所以即使引用是空的，也不会报空指针异常
        StaticTest13 s=null;
        s.m2();

    }
}

结果：

m1
m2
m2
m2

/*
五、static 修饰的变量叫做“静态变量”
类{
    成员变量
    成员方法

    静态变量
    静态方法

    静态语句块

    实例语句块

    构造方法

    this
}

1.变量分类：
        1.局部变量
        2.成员变量，（实例变量，非静态变量）
        3.静态变量（方法区）

2.什么时候声明成静态变量？
　　如果这个属性所有的对象都有，并且这个属性的值是相同的，则该属性声明成静态属性

3.什么时候初始化
　　成员变量：创建java对象的时候初始化
　　静态变量：在类加载阶段赋值，并且只赋值一次

 */

public class StaticTest14 {

    public static void main(String[] args){
        Animal01 a1=new Animal01("AAA",10);

        Animal01 a2=new Animal01("BBB",20);

        //如何访问：(类.)
        System.out.println(Animal01.type);

        //也可以使用  引用
        System.out.println(a1.type);

        Animal01 a3=null;
        System.out.println(a3.type);//静态变量底层访问的时候一定使用，类名，和对象无关，不会出现空指针异常


    }
}

//抽象现实世界中的“陆生”动物
class Animal01{
    //Field
    // 成员变量：(一对象一份)
    //成员变量在创建对象的时候初始化，并且存储在堆中的每一个对象中
    String name;
    int age;
    //String type="水生";
    //静态变量，被存储在方法区
    //所有的java对象共享一份
    //所以静态变量是类级别的，使用“类.”的方式访问
    static String type="水生";

    //Constructor
    //构造方法
    Animal01(String name,int age){
        this.name=name;
        this.age=age;
    }


}

六、总结

类{
    //可以通过“类名.”，也可以通过“引用.”即使是使用“引用.”,底层也是“类名.”
    成员变量
    成员方法

    //必须对象存在才可以访问，采用“引用.”
    静态变量
    静态方法

    //类加载的时候只执行一次
    静态语句块

    //构造方法没调用之前执行一次
    实例语句块

    //创建对象，给成员变量赋值
    构造方法

    //用在成员方法和构造方法中
    this
}