用static关键字修饰成员变量

有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。

1、 static的作用

• 与类绑定：static成员属于类本身，而不是类的实例。
• 共享数据：static变量在类的所有实例之间共享。
• 直接访问：static成员可以通过类名直接访问，无需创建对象。

2、代码示例

我们可以通过：public static String teachername; 这个语句来定义一个静态变量。

当然我们也可以对他直接赋值：public static String teachername="老师名字";

也可以像下一个代码块中一样，在测试类中再赋值：Student.teachername="老师名字";

public class Student {
    //姓名，年龄，性别，假设一个班的学生共享一个老师
    private String name;
    private int age;
    private String gender;
    public static String teachername;

    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;
    }

    public void study() {
        System.out.println(name + "正在学习");
    }

    public void show() {
        System.out.println(name + "," + age + "," + gender+","+teachername);
    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student.teachername="老师名字";
        Student s1 =new Student();
        s1.setName("张三");
        s1.setAge(23);
        s1.setGender("男");

        s1.study();
        s1.show();


        Student s2 =new Student();
        s2.setName("李四");
        s2.setAge(20);
        s2.setGender("女");

        s2.study();
        s2.show();
    }
}

 用static修饰成员方法

有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态方法。 直接用 类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。

静态方法多用在测试类和工具类中。javabean类，测试类，工具类都是什么？-CSDN博客

与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

代码示例 

 下面通过工具类展现了如何去定义静态方法及其调用。

public class ArrayUtil {
    //私有化构造
    //目的：为了不让外界创建它的对象
    private ArrayUtil(){}
 
    //需要定义为静态的，方便调用
    public static String printArr(int[] arr){
        StringBuilder sb =new StringBuilder();
        sb.append("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
 
    public static double getAverage(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) {
        int[] arr1={1,23,42,12,33};
        double[] arr2={1,23,42,12,33};
 
        String str =ArrayUtil.printArr(arr1);//调用静态方法
        System.out.println(str);
 
        System.out.println(ArrayUtil.getAverage(arr2));
    }
}

静态方法的注意事项

• 静态方法中没有this关键字
• 静态方法中，只能访问静态。
• 非静态方法可以访问所有。
   

public class StaticNonStaticExample {
    // 静态变量
    static int staticVariable = 10;
    // 非静态变量
    int nonStaticVariable = 20;

    // 静态方法
    public static void staticMethod() {
        // 可以访问静态变量
        System.out.println("静态方法访问静态变量: " + staticVariable);

        // 下面这行代码会报错，因为静态方法不能访问非静态变量
        // System.out.println("静态方法访问非静态变量: " + nonStaticVariable);
    }

    // 非静态方法
    public void nonStaticMethod() {
        // 可以访问静态变量
        System.out.println("非静态方法访问静态变量: " + staticVariable);
        // 可以访问非静态变量
        System.out.println("非静态方法访问非静态变量: " + nonStaticVariable);
    }

    public static void main(String[] args) {
        // 调用静态方法
        staticMethod();

        // 创建对象
        StaticNonStaticExample example = new StaticNonStaticExample();
        // 调用非静态方法
        example.nonStaticMethod();
    }
}    

在上述代码里，staticMethod 属于静态方法，只能访问静态变量 staticVariable，若尝试访问非静态变量 nonStaticVariable 则会引发编译错误。而 nonStaticMethod 作为非静态方法，既能访问静态变量，也能访问非静态变量。在 main 方法中，直接调用了静态方法，调用非静态方法则需要先创建类的对象