【static】

 static成员

首先我们先了解一下

类里面有字段/属性/成员变量

其中分为普通成员变量和静态成员变量

方法/成员方法

方法分为普通成员方法和静态成员方法

其中普通和静态的关键就在于有没有static关键字修饰

class Student{
    public String name;
    public int num;
    public String sex;
    public double score;
    public static String classes;

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

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", num=" + num +
                ", sex='" + sex + '\'' +
                ", score=" + score +
                '}';
    }
}
public class TextDemo {
    public static void main(String[] args) {
        Student student1 = new Student("李华",110,"man",90.0);
        Student student2 = new Student("小红",120,"woman",80.0);

    }

我们打开调试发现：

 并没有发现classes关键字。

其实我们的静态成员变量和静态成员方法其实还有另外一种称呼：

类变量，类方法。他们被存放在方法区。

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

    public static void main(String[] args) {
        Student student1 = new Student("李华",110,"man",90.0);
        Student student2 = new Student("小红",120,"woman",80.0);
        Student.classes = "104java";

        System.out.println(student1);
        System.out.println(student2);
    }

我们将classes的赋值放在实例化对象之后，这样我们运行的结果会是：

 这样我们更加能体现出static修饰成员变量的特性。静态成员变量并没有存储到某个具体的对象中。

【静态成员变量特性】
1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中
4. 类变量存储在方法区当中
5. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

我们静态的成员变量是通过类名来调用

但是我们还是有一种合法但是不合法的访问方式

    public static void main(String[] args) {
        Student student1 = new Student("李华",110,"man",90.0);
        Student student2 = new Student("小红",120,"woman",80.0);
        student1.classes = "104java";

        System.out.println(student1);
        student2.classes = "100java";
        System.out.println(student1);
    }

如果使用成员名来访问也能达到目的，但是不能清晰的表达类成员的特性，降低我们代码的可读性

    public static void main(String[] args) {
        Student student1 = null;
        Student.classes = "104java";
        System.out.println(student1.classes);
    }

这段代码也能帮我们更加好地了解类成员。首先我们的student1（成员名）不指向任何一个对象，但是我们的类成员依然能够赋值。所以我们的就规规矩矩使用类名去访问就可以了。

静态的成员方法 和 静态的成员 都不依赖与对象，因为他们都是类变量。

【静态方法特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
3. 静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量

    public void doHomeWork() {
        System.out.println(this.name+"正在"+classes+"写作业");
    }

    public static void main(String[] args) {
        Student student1 = new Student("李华",110,"man",90.0);
        Student.classes = "104java";
        student1.doHomeWork();
    }

我们这个代码也是能够正常运行的。也就是说，在普通的成员方法当中 是可以使用 静态的成员变量。

    public static void doHomeWork() {
        System.out.println(this.name+"正在"+classes+"写作业");
    }

静态的成员方法当中，不能访问非静态的成员变量和成员方法。（类方法没法找到堆上对象的成员）

非静态的成员方法，是依赖于对象的。