JAVA核心技术I---JAVA基础知识（static关键字）

一：static特殊关键字用处

–变量
–方法
–类
–匿名方法

二：静态变量：类共有成员

–static变量只依赖于类存在（通过类即可访问），不依赖于对象实例存在。
–所有的对象实例，对于静态变量都共享存储在一个共同的空间（栈）

class Potato{
    static int number=15;
    
    public void setnumber(int n) {
        this.number=n;
    }
}

public class StaticTest {
    public static void main(String[] args) {
        System.out.println(Potato.number);　　//一：直接类名.静态变量名
        
        Potato p=new Potato();
        p.setnumber(20);
        
        System.out.println(Potato.number);
        System.out.println(p.number);　　//二：对象调用静态变量
        
        Potato p2=new Potato();
        p2.setnumber(30);
        
        System.out.println(Potato.number);
        System.out.println(p.number);
        System.out.println(p2.number);　　//三：不同对象调用的是同一块内存区域，操作一块区域
    }
}

15
20
20
30
30
30

不同于C++，在C++中静态变量要么只能通过类名.静态变量或者静态方法访问。

但是在java中静态变量可以通过对象实例来修改和获取，共享的是同共有内存块，不过生命周期要长于对象实例

其生命周期从类声明开始到程序结束，对象则是从实例化开始，对象消失结束

三：static静态方法

–静态方法也无需通过对象来引用，而通过类名可以直接引用。

–在静态方法中，只能使用静态变量，不能使用非静态变量。

–静态方法禁止引用非静态方法。

class Potato{
    static int number=15;
    
    public void setnumber(int n) {
        this.number=n;
    }
    
    public static int getnumber() {
        //return this.number;    this代表当前对象，static方法只允许访问静态成员，不可以访问对象数据
        return number;
    }
}

public class StaticTest {
    public static void main(String[] args) {
        int val;
        System.out.println(Potato.number);
        
        Potato p=new Potato();
        p.setnumber(20);
        
        val=p.getnumber();    //可以通过对象访问静态方法
        System.out.println(val);
        
        val=Potato.getnumber();    //可以通过类直接访问静态方法
        System.out.println(val);
    }
}

15
20
20

四：static代码块

–只在类第一次被加载时调用。
–换句话说，在程序运行期间，这段代码只运行一次。
–执行顺序：static块 > 匿名块 > 构造

public class Employee {
    //实例域初始化块
    private int age;
    private float salay;
    private boolean sex;
    private String name;    //char name[]可以
    
    static
    {
        //....    静态初始化块,会在对象构造前执行
        System.out.println("static block");
    }
    
    {    //对象初始化块
        System.out.println("object block");
    }
    
    public Employee() {
        System.out.println("construct block");
    }
}

static block　　//先执行类静态块，执行一次
object block　　//每一次对象构造前都会先执行对象初始化块，放在构造方法后面也是先执行与构造方法
construct block　　//之后执行构造方法
object block
construct block

JAVA核心技术I---JAVA基础知识（对象与类）

五：static代码块执行时机

在类加载时刻被执行：（什么是类加载时刻）

类加载时刻：不是指类的声明，而是指第一次使用类来实例化对象的时刻

（一）类声明时候查看静态变量是否执行初始化---（没有初始化）

class A{
    public A(String n) {
        System.out.println("A construct "+n);
    }
}

class B{
    private A a2=new A("a2");
    
    public static A a=new A("a static");
    
    public B() {
        System.out.println("B Construct");
    }
    
    public void Say() {
        System.out.println("B say()");
    }
}

public class Test{

    public static void main(String[] args) {
        System.out.println("main");
        B b;    //声明的时候类B中的静态变量并没有被初始化
        //b=new B();    //在实例化对象之前先执行静态代码块的执行，之后是普通成员变量的初始化，最后执行构造函数
    }
}

（二）类第一次实例化对象时候，静态成员变量被初始化（类被加载）

class A{
    public A(String n) {
        System.out.println("A construct "+n);
    }
}

class B{
    private A a2=new A("a2");
    
    public static A a=new A("a static");
    
    public B() {
        System.out.println("B Construct");
    }
    
    public void Say() {
        System.out.println("B say()");
    }
}

public class Test{

    public static void main(String[] args) {
        System.out.println("main");
        B b;    //声明的时候类B中的静态变量并没有被初始化
        b=new B();    //在实例化对象之前先执行静态代码块的执行，之后是普通成员变量的初始化，最后执行构造函数
    }
}

六：总结

–static变量：不管有多少个对象，内存中只有一份

–static方法：可以用类名直接引用，无需new对象来引用

–static块：static块只执行一次，并且static块 >匿名块>构造