静态变量Static

DuanDuan413

已于 2024-06-16 19:05:57 修改

阅读量742

点赞数 14

文章标签：学习

于 2024-05-15 17:56:39 首次发布

本文链接：https://blog.csdn.net/Eliaukgo/article/details/138907218

版权

1、静态变量Static——涉及共享时使用，随类加载而加载，优先于对象

1.1 如何使用？第四行，加修饰符：static，使得teachername共享

定义格式：

修饰符 static 数据类型变量名 = 初始值；

静态成员变量的访问:

格式1：类名.静态变量

格式2：利用对象调用

1.2 static内存图

静态区变量，是共享的，在静态区（堆内存中）只有一份（jdk8以后，jdk8以前建立在方法区中）；

jdk8以前串池，静态区都在方法区里。从jdk8开始，方法区被拆分为元空间，原方法区的部分空间（如串池静态区）被分配到了堆空间中

非静态区变量，不是共享的，每个对象单独存放

1.3 静态方法及其访问

调用方法：工具类名.方法名

私有化：private 类名(){ }

工具类命名规则：

工具类代码示例1：

工具类：

public class ArrayUtil {
    //私有化方法,目的不让外界创建他的对象
    private ArrayUtil(){
    }
    //设置静态,方便调用
    public static String printArr(int []arr){
        StringBuilder sc = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            int element = arr[i];
            if (i==arr.length-1){
                sc=sc.append(element+"]");
            }else {
                sc = sc.append(element+", ");
            }
        }
        return sc.toString();
    }

    public static double getAerage(double []arr){
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum+arr[i];
        }
        return sum/arr.length;
    }
}

测试类：

public class TestDemo {
    public static void main(String[] args) {
        //调用printArr
        int []arr1 = {1,2,3,4,5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);
        //调用
        double []arr2 = {1,2,4,6,7};
        double aerage = ArrayUtil.getAerage(arr2);
        System.out.println(aerage);
    }
}

工具类代码示例2：

创建三部分：学生类、工具类、测试类

学生类：

public class student {
    private String name;
    private int age;
    private String gender;

    public student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

工具类：

import java.util.ArrayList;

public class studentTool {
    private studentTool(){
    }
    //返回最大学生年龄
    public static int getMaxAge(ArrayList<student> list){
        int maxAge = list.get(0).getAge() ;
        for (int i = 1; i < list.size(); i++) {
            student element = list.get(i);
            if (element.getAge()>maxAge){
                maxAge = element.getAge();
            }
        }
        return maxAge;
    }
}

测试类：

import java.util.ArrayList;
import java.util.Scanner;

public class studentTest {
    public static void main(String[] args) {
        ArrayList<student> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            student stu = new student();
            Scanner sc = new Scanner(System.in);
            System.out.println("输入学生姓名：");
            String name = sc.next();
            System.out.println("输入学生年龄：");
            int age = sc.nextInt();
            System.out.println("输入学生性别：");
            String gender = sc.next();
            stu.setName(name);
            stu.setAge(age);
            stu.setGender(gender);
            list.add(stu);
        }
        int maxAge = studentTool.getMaxAge(list);
        System.out.println("最大年龄为："+maxAge);

    }

}

1.4 小结

1.当 static修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为**静态方法**。该类的每个对象都**共享**同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。