Java中的static基础知识篇

1、static的基本概念

---

Java中的static关键字是一个非常重要的概念，它用于声明属于类本身而不是类实例的变量和方法。当你使用static修饰一个成员（变量或方法）时，这个成员就被所有类的实例共享。

---

特点：

         1，可以被所有实例化的对象所共享

public class Student{
//用static修饰teacher变量

private String name;
private int age;
static String teacher = "小明";

public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public static String getTeacher() {
        return teacher;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void setTeacher(String teacher) {
        lianxi1.teacher = teacher;
    }

}

public class StudentText{
public static void main(String[] args){

Student b1 = new Student("小王",18);
Student b2 = new Student("小荣",19);

System.out.println(b1.teacher);

System.out.println(b2.teacher);

//返回结果均为"小明"

 }
}

         2，与类的加载同时加载，存在先于对象

public class Student{
//用static修饰teacher变量

private String name;
private int age;
static String teacher = "小明";

public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public static String getTeacher() {
        return teacher;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void setTeacher(String teacher) {
        lianxi1.teacher = teacher;
    }



}

public class StudentText{
public static void main(String[] args){

System.out.println(Student.teacher);
//结果为"小明"

 }
}

---

2、static的用法

（1）静态变量

public class MyClass {  
    static int count = 0; // 静态变量  
  
    public void increment() {  
        count++;  
    }  
  
    
}

public class MyClassText{
public static void main(String[] args) {  
        MyClass obj1 = new MyClass();  
        MyClass obj2 = new MyClass();  
  
        obj1.increment(); // count 变为 1  
        obj2.increment(); // count 变为 2  
  
        System.out.println(MyClass.count); // 输出 2  
    }  

}

由上述代码可以看出被static修饰的成员变量属于类本身，而不是类的任何特定实例。这意味着无论创建了多少个类的对象，静态变量都只有一份拷贝，被所有实例共享。

---

（2）静态方法

public class MyClass {  
     
    // 静态方法 
    static void increment() {  
        System.out.println("这是一个静态方法");   
    }  
  
    
}

public class MyClassText{
public static void main(String[] args) {  
        
       MyClass.increment();// 使用类名调用静态方法
       MyClass obj = new MyClass();  
        obj.increment(); // 使用类的实例调用静态方法也是允许的，但通常不推荐
    }  

}

静态方法也是属于类本身，而不是类的实例。因此，你不能在静态方法中直接访问类的非静态成员（变量和方法），因为非静态成员是依赖于类的具体实例的。但是，你可以通过类的实例或类名本身来调用静态方法。

---

（3）静态块

 在类加载时执行，只执行一次，静态块通常用于初始化静态变量，在有多个静态块时，它们会按照在类中的顺序执行。

public class MyClass {  
     
static {  
        System.out.println("静态块执行了");  
       }
  
    
}

public class MyClassText{
public static void main(String[] args) {  
        
      // 当类被加载时，静态块会被执行  

}

---

（4）静态导入

静态导入允许你直接使用静态成员（如静态方法和静态变量），而不需要通过类名来引用它们。这可以通过import static语句实现。

import static java.lang.Math.PI;  
import static java.lang.Math.pow;  
  
//Math为自己创建的类
public class Test {  
    public static void main(String[] args) {  
        System.out.println(PI); // 直接使用PI，而不需要Math.PI  
        System.out.println(pow()); // 直接使用pow，而不需要Math.pow  
    }  
}