JAVASE基础（static关键字）

一：static的作用

（1）static修饰属性：修饰的变量叫做“静态变量”

（2）static修饰方法：修饰的方法叫做”静态方法“

（3）static定义静态语句块

（4）static与实例语句块

二：细化

（一）static修饰属性（变量）

（1）变量的分类：

1.局部变量

2.成员变量（实例变量，非静态变量）

3.静态变量（储存在方法区）

（2）代码示例：

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);
    }
}
//抽象现实世界中的”陆生“动物
class Animal{
    //Field
    String name;
    int age;
    //静态变量，被存储在方法区
    //所有的java对象共享这一份
    //所以静态变量是类级别的，使用”类名.“方式访问
    static String type = "陆生";
    //Constructor构造函数
    Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
}
/*
输出结果
陆生
陆生
 */

（3）注意：

1.所有的java对象共享这一份属性

2.且不属于对象，访问方式为：类名 . 属性。

（二）static修饰方法

（1）定义：如果在任何方法上应用 static 关键字，此方法称为静态方法。

（2）代码示例：

public class Statictest03 {
    //Field

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

    }
    //静态方法
    //可以使用“类名.”调用，也可以使用“引用.”调用，即使使用“引用.”调用，底层还是“类名.”调用。
    public static void m2(){
        System.out.println("m2....");
    }
    //程序入口
    public static void main(String[] args) {
        Statictest03 st = new Statictest03();
        st.m1();//引用.

        m2();//输出m2....
        st.m2();//引用.  输出m2....

        /*
        Statictest03 s = null;
        s.m1();//空指针异常
         */
        Statictest03 s = null;
        //m2是静态方法，不是成员方法，所以即使引用是空的，也不会空指针异常
        s.m2();//输出m2....
    }
}
/*
输出结果
m2....
m2....
m2....
 */

（3）注意：

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

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

3.静态方法可以访问静态数据成员，并可以更改静态数据成员的值

4.静态方法属于类，而不属于类的对象

（三）static定义静态语句块：

（1）定义：使用static定义的代码块。一般用于初始化静态成员属性。

（2）代码示例：

//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");
    }
}
/*
执行结果：
1
2
3
4
main execute! 1
main execute! 2
 */

（3）注意：

1.静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

2.静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

（四）static与实例语句块

（1）代码示例

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) {
        Statictest02 s = new Statictest02();//不创建对象不会执行
        Statictest02 s1 = new Statictest02();
    }
}
/*
执行结果
A
1
2
3
Statictest02无参构造执行
1
2
3
Statictest02无参构造执行
 */

（2）注意

1.每一次调用构造方法之前会执行一次（不创建对象不会执行）

2.实例语句块执行顺序也是自上而下

三：总结类的构成

类{
     //可以通过”类名.“，”引用.“
     1.静态变量
     2.静态方法

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

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

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

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

     //用在成员方法和构造方法中
     8.this
    }
    空指针异常：空引用访问成员
 */