java的static关键字

其中，需要注意的是：
1.普通和静态的区别就是有无被static关键字修饰。
2.普通成员变量和普通成员方法是属于对象的。
而静态的成员变量和成员方法是属于类的，不属于任何一个对象，是所有对象共有的。

static修饰成员变量

class Student{
    private String name;
    private String sex;
    private int age;
    private double score;
    private static String classes;

    public static String getClasses() {
        return classes;
    }

    public static void setClasses(String classes) {
        Student.classes = classes;
    }

    Student(String name, String sex, int age, double score){
        this.name=name;
        this.sex=sex;
        this.age=age;
        this.score=score;
    }

    //这里classes的输出是我自己添加的
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", classes=" + classes +
                '}';
    }
    //还有一些getter和setter方法，以及toString方法
}
public class test {

    public static void main(String[] args) {
        Student stu1 = new Student("张三","男",18,88.5);
        Student stu2 = new Student("李笑笑","女",17,98.5);
        System.out.println();
    }
}

成员变量classes加了static修饰

成员变量classes不加static修饰

调试可以看见，经过static修饰的classes成员变量，在stu1和stu2对象中并不包含。
当给静态成员变量classes赋值之后，可以看见

public class test {

    public static void main(String[] args) {
        Student.setClasses("大四1801班");
        
        Student stu1 = new Student("张三","男",18,88.5);
        Student stu2 = new Student("李笑笑","女",17,98.5);
        System.out.println(stu1);
        System.out.println(stu2);
    }
}

**可以看见，静态成员变量classes的赋值是没有创建对象之前，stu1和stu2对象中依旧没有classes这个静态成员变量，但可以输出，且是两个对象共用的。
**
一个小例子

public static void main(String[] args) {
        Student stu = null;
        Student.setClasses("大四1801班");
        System.out.println(stu.getClasses());
    }

**这里没有出现空指针异常!!!
①Student stu = null;stu表示其不指向任何对象。
②classes不属于任何一个对象，所以与stu无关。
③对于静态成员变量的访问，正确方式是通过类名来访问，但是通过对象也可以访问，只不过是合法但不合理，不建议。
**
总结：
1.静态成员变量不依赖于对象，能直接通过类名访问，又叫做类变量。
2.静态的成员变量存在于JVM的方法区，全局只有一份，为所以对象共享。而对象在堆上开辟。
2.非静态成员变量都是依赖于对象的，通过对象的引用访问。
3.在链接阶段第二步准备中会给静态成员变量开辟空间，并设置为默认值。

当然，静态的成员方法也一样，通过类名调用

class Student{
//省略了之前重复的
public static void staticFunc(){
        System.out.println("这是一个静态的成员方法");
    }
    public void func(){
        System.out.println("这是一个普通的成员方法");
    }
}
public class test {

    public static void main(String[] args) {
        Student.staticFunc();
    }
}

互相访问

1.普通方法访问静态成员变量

class Student{
 public void func(){
        System.out.println("这是一个普通的成员方法    "+"我访问静态成员方法："+classes);
    }
}
 public class test {

    public static void main(String[] args) {
        Student stu1 = new Student("张三","男",18,88.5);
        stu1.func();
        Student.setClasses("大四1801班");
        Student stu2 = new Student("李笑笑","女",17,98.5);
        stu2.func();
    }
}

普通的成员方法内部是可以使用静态的成员变量的
2.静态方法访问普通成员变量


可以看到是否加this都会报错，无法通过编译。
所以我们可以得知，静态方法不能访问普通成员变量。普通成员变量是依赖于当前对象的，访问普通成员变量的前提是实例化一个对象。而静态方法的使用是不依赖于对象的，在不创建对象前就存在，可以调用，所以无法访问依赖对象的普通成员变量。
3.其他互相访问
与成员变量一样，静态成员方法不能调用普通成员方法，而普通成员方法可以调用静态成员方法。
如果非要调用普通的成员方法，我们就先要实例化一个对象

public class Test {

    public static void main(String[] args) {
        Test t = new Test();
        t.func();
    }
    public void func(){
        System.out.println("hello world");
    }
 }

总结
静态成员变量特性：
1.不属于某个具体的对象，是类的属性，所有对象共享，不存储于某个对象的空间中。
2.既可以通过对象访问，也可以通过类名访问，但推荐类名访问。
3.类变量存储于方法区。
4.生命周期伴随类的一生（随着类的加载而加载，随着类的销毁而销毁）。
静态成员方法特性：
1.被static修饰的方法叫做静态成员方法，是类的方法，不为某个对象所有。静态成员一般通过静态方法访问。
2.可以通过对象调用，也可以通过类名调用。更推荐使用类名，即类名.静态方法（…）方式。
3.静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量。
4.静态方法中不能调用非静态方法，因为非静态方法有this参数，在静态方法中调用时无法传递this引用参数。
5.静态方法无法重写，不能实现多态。