Java之static关键字

动力节点学习笔记

/*
    static修饰的方法叫做静态方法

        一般情况下工具类中的方法大部分都是静态方法。

        静态方法不用创建对象也能直接访问该方法。

*/
public class StaticTest03{

    //成员方法
    //成员方法必须使用“引用.”调用
    public void m1(){

    }

    //静态方法
    //可以使用“类名.”方式调用.也可以用“引用.”，即使用的是“引用.”，底层还是用的“类名.”
    //静态方法中不能直接访问非静态数据.
    //静态方法中不能使用this
    public static void m2(){
        System.out.println("m2....");
    }

    //入口
    public static void main(String[] args){

        StaticTest03 st = new StaticTest03();
        st.m1();

        m2();

        //静态的方法按照正规的方式访问：“类名.”
        //静态的方法也能用“引用.”访问
        st.m2(); //编译阶段检查出st是StaticTest03类型，编译通过，运行的时候，仍然使用 "StaticTest03."的方式访问。
                    //该方法执行不需要对象。


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

    }

}

 

 

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

    以下例子演示：static定义静态语句块

    static定义的静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行。
*/
public class StaticTest01{

    //静态语句块
    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");
    }

}

 

/*
    关于实例语句块
        每一次调用构造方法之前会执行一次。
        实例语句块执行顺序也是自上而下。
*/

public class StaticTest02{

    //静态语句块
    static{
        System.out.println("A");
    }

    //实例语句块
    {
        System.out.println("1");
    }


    {
        System.out.println("2");
    }


    {
        System.out.println("3");
    }

    //构造方法
    StaticTest02(){
        System.out.println("StaticTest02无参数的构造执行！");
    }

    //入口
    public static void main(String[] args){

        //调用构造方法
        new StaticTest02();

        new StaticTest02();

        new StaticTest02();
    }
}

 

/*
    static修饰的变量叫做“静态变量”

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

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


        成员变量：创建java对象的时候初始化。
        静态变量：在类加载阶段赋值，并且只赋值一次。
*/
public class StaticTest04{

    public static void main(String[] args){

        Animal a1 = new Animal("AAA",10);
        Animal a2 = new Animal("BBB",11);

        //如何访问(类名.)
        System.out.println(Animal.type);

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


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

    }
}


//抽象现实世界中的“陆生”动物
class Animal{

    //Field
    //成员变量(一个对象一份.)
    //成员变量在创建对象的时候初始化，并且存储在堆中的每一个对象中。
    String name;
    int age;

    //静态变量，被存储在方法区.
    //所有的java对象共享这一份。
    //所以静态变量是类级别的，使用“类名.”的方式访问.
    static String type = "陆生";

    //Constructor
    Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
}

 

/*
    关于代码的顺序
*/
public class StaticTest05{

    //编译通过
    static int i = 100;

    static{
        System.out.println(i);
    }



    //非法向前引用
    /*
    static{
        System.out.println(i);
    }

    static int i = 100;
    */

}

 

/*

    类{

        //可以通过“类名.”，也可以通过“引用.”，即使使用“引用.”底层也是“类名.”
        //1.静态变量
        //2.静态方法

        //必须对象存在才可以访问，采用“引用.”
        //3.成员变量
        //4.成员方法

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

        //类加载时只执行一次。
        //6.静态语句块

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

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

    空指针异常：空引用访问成员

*/