25- static关键字

 

1. static关键字：修饰成员变量

1）被类的所有对象所共享

2）多了一种调用方式，可以通过类名进行调用（更推荐使用类名进行调用）

3）随着类的加载而加载

 

Student01类，该类的school成员变量是非静态的

public class Student01 {
    String name;
    int age;
    String school;
}

Student02类，该类的school成员变量是静态的

public class Student02 {
    String name;
    int age;
    static String school;
}

StudentDemo1类

public class StaticDemo1 {
    /*
    *  static关键字：修饰符，可以修饰成员变量
    *  1.被类的所有对象所共享
    *  2.多了一种调用方式
    *  3.随着类的加载而加载
    *
    * */
    public static void main(String[] args){
        // Student01类，该类的school成员变量是非静态的
        System.out.println("===============Student01类，该类的school成员变量是非静态的==================");
        Student01 s1 = new Student01();
        s1.name = "张三";
        s1.age = 30;
        s1.school = "北京大学";
        System.out.println(s1.name + "\t" + s1.age + "\t" + s1.school); // 张三    30    北京大学

        Student01 s2 = new Student01();
        s2.name = "李四";
        s2.age = 31;
        // s2.school = "北京大学";
        System.out.println(s2.name + "\t" + s2.age + "\t" + s2.school); // 李四    31    null

        // Student02类，该类的school成员变量是静态的
        System.out.println("===============Student02类，该类的school成员变量是静态的==================");
        Student02 s3 = new Student02();
        s3.name = "王五";
        s3.age = 32;
        s3.school = "清华大学";
        System.out.println(s3.name + "\t" + s3.age + "\t" + s3.school); // 王五    32    清华大学

        Student02 s4 = new Student02();
        s4.name = "赵六";
        s4.age = 33;
        // s4.school = "清华大学";
        System.out.println(s4.name + "\t" + s4.age + "\t" + s4.school); // 赵六    33    清华大学


        // 被static修饰的成员变量，可以通过类名进行调用（更推荐使用类名进行调用）
        // 非静态成员变量，必须通过对象名进行调用
        System.out.println("===============被static修饰的成员变量，可以通过类名进行调用==================");
        System.out.println(s3.school); // 清华大学
        System.out.println(Student02.school); // 清华大学

        // 随着类的加载而加载，优先于对象存在
        // 也就是说，静态成员变量，可以在没有对象的情况下进行调用（可以先赋值静态变量，再创建对象）
        System.out.println("===============随着类的加载而加载，优先于对象存在==================");
        Student02.school = "东华理工大学";
        Student02 s5 = new Student02();
        s5.name = "马铃薯";
        s5.age = 26;
        System.out.println(s5.name + "\t" + s5.age + "\t" + s5.school); // 马铃薯    26    东华理工大学
        
    }
}

 

 

static关键字修饰的成员变量，内存图

 

 

2. static关键字：修饰成员方法

1）常用于制作工具类

2）工具类不是描述事物的，而是帮我们完成一些事情的（打工）

3）如果发现一个类中，所有的方法都是 static 所修饰，则可以私有该类的构造方法（为了不再创建对象，直接通过类名调用静态方法）

 

ArrayTools 工具类（该类的所有成员方法是静态的）

public class ArrayTools {

    // 如果一个类中的方法都是静态的，可以将构造方法私有化，这样就不可以创建对象了
    private ArrayTools() {
    }

    // 获取数组最大值方法
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; ++i) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    // 获取数组最小值方法
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; ++i) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    // 打印数组方法
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length - 1; ++i) {
            System.out.print(arr[i] + ", ");
        }
        System.out.println(arr[arr.length - 1] + "]");
    }

}

Test 类

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

        int[] arr = {1, 2, 3, 4, 5};

        // 这里注意，ArrayTools类中的构造方法是私有的，所以不用创建对象，直接通过类名调用静态方法即可
        // ArrayTools tools = new ArrayTools();

        // 调用ArrayTools类中的方法
        int max = ArrayTools.getMax(arr);
        System.out.println("数组中的最大值是：" + max);

        int min = ArrayTools.getMin(arr);
        System.out.println("数组中的最小值是：" + min);

        ArrayTools.printArray(arr);
    }
}