断断续续得，类和对象的学习笔记也将要迎来尾声，希望大家多多支持哦

1.再谈学生类

使用我们在之前的博客中写的学生类 来实例化三个对象s1、s2、s3，每个对象都有他们特有的名字，性别，年龄，学分绩点等成员信息，这些信息就是对不同学生来进行描述的

  1. class Student {
  2.     private String name;
  3.     private int age;
  4.     private double score;
  5.     private static int classes;
  7.     //    这时我们可以看到访问限定都是private修饰的
  8. //    我们就需要用到get和set等方法去让外界去接触到这些成员变量
  9. //    IDEA给我们提供了generate的方法，达到“一劳永逸”
  10.    public Student() {
  11.         this("\u0000","\u0000",0,0);
  12.     }
  14.     public Student(String name, String sex,int age, double score) {
  15.         this.name = name;
  16.         this.age = age;
  17.         this.sex = sex;
  18.         this.score = score;
  19.     }
  20.     public void doClass() {
  21.         System.out.println(this.name + "正在上课");
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public int getAge() {
  33.         return age;
  34.     }
  36.     public void setAge(int age) {
  37.         this.age = age;
  38.     }
  40.     public double getScore() {
  41.         return score;
  42.     }
  44.     public void setScore(double score) {
  45.         this.score = score;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Student{" +
  51.                 "name='" + name + '\'' +
  52.                 ", age=" + age +
  53.                 ", score=" + score +
  54.                 '}';
  55.     }
  56.         public static void main(String[] args) {
  57.         Student s1 = new Student("Li Lei","男",18,3.8);
  58.         Student s2 = new Student("Han Mei","女",19,4.0);
  59.         Student s3 = new Student("Gremmie","男",19,5.0);
  60.     }
  62. }

image.png
假设三个同学是同一个班上的，那么他们上课肯定是在同一个教室，那既然是在同一个教室中，那能否给类中再加上一个成员变量，来保存同学上课时的教室呢？
The answer is No.
之前再Student类中定义的成员变量，每个对象中都会包含一份（称之为实例变量），因为需要使用这些信息来描述具体的学生。
而现在要表示学生上课的教室，这个教室并不是需要每个学生都去输入一次，而是让这些拥有共同教室的学生来共享我们只定义了一次的变量。
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，它并不属于某个具体的对象，是所有对象所共享的。
或者可以说，静态成员和对象没有关系。通过类直接调用
下面我们就来介绍static成员变量

2.static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性就是：

不属于某个具体的对象，为所有对象共享 与对象没有直接联系

🍰[静态成员变量特性]：

  • 不属于某个具体的对象，是类的属性，不储存与某个对象的空间中
  • 既可以通过对象访问，也可以通过类访问，但是前者属于“合法但不合理”，编译可以通过，但逻辑上说不通，所以一般更推荐用类名来访问静态成员变量
  • 类变量存储在方法区当中
  • 类变量的生命周期伴随着类而生，伴随着类而灭（即：随着类的加载而创建，随着类的卸载而销毁）

我们在类中的成员变量添上一个班名，并且直接本地初始化

  1.  private String name;
  2.     private int age;
  3.     private String sex;
  4.     private double score;
  5.     private static String classes = "三年二班";

我们用两个访问类变量的方法来测试一下

  1.    public static void main(String[] args) {
  2.         //静态成员变量可以直接通过类名访问
  3.         System.out.println(Student.classes);//更推荐这种！
  5.         Student s1 = new Student("Li Lei","男",18,3.8);
  6.         Student s2 = new Student("Han Mei","女",19,4.0);
  7.         Student s3 = new Student("Gremmie","男",19,5.0);
  9.         //也可以通过对象访问：但是classRoom是三个对象共享的
  10.         System.out.println(s1.classes);
  11.         System.out.println(s2.classes);
  12.     }

输出👇：
image.png
然后我们再用调试方法来运行代码可以看到，静态成员变量其实并没有存储到某个具体的对象中
1.png
Java类和对象のstatic成员详解 - 图4
再强调一遍，静态的长远变量和静态的成员方法，都不依赖于对象，（因为他们是类变量）

  1. 普通的成员方法当中，是可以使用静态的成员变量的
  2. 静态的成员方法当中，不能访问非静态的成员（因为静态的成员变量是依赖于对象的）

我在之前的一篇博客中也对静态做出了相关的分析，大家可以去看一看👉静态类成员
另外，我们会不难发现，我们在写main方法的时候，都是public static void main…那么这里的static可不可以省略呢？理论上是没问题的，但是现在大多规定一定要有static，作为运行程序的入口
image.png
我们可以看到，没了static，都不能run和debug了

3.static修饰成员的方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？
image.png
我们可以看到在另外一个类中不可以直接调用 private修饰的静态成员变量classes
那么，static属性应该如何访问呢？
我们在这里就要用到之前博客提到过的get方法了👉getter and setter
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。
静态成员一般是通过静态方法来进行访问的

  1. public class Student{
  2. //...
  3.     private static String classes = "三年二班";
  4. //...
  5.     public static String getClasses(){
  6.     return classes;
  7.     }
  8. }
  9. public class TestStudent{
  10.     public static void main(String[] args){
  11.         System.out.println(Student.classes);
  12.     }
  13. }
  15. //输出为三年二班

🍨[静态方法特性]

  1. 不属于某个具体的对象，是类方法
  2. 可以通过对象来调用，也可以通过 类名.静态方法名(); 来调用，但前者合法不合理，推荐用后者

  3. 静态方法没有隐藏的this引用参数，因此我们并不能在静态方法中访问任何非静态成员变量

    1. public static String getClasses(){
    2.  System.out.println(this);
    3.  return classes;
    4. }

    👆这里会编译失败：Error:(35,28)java:无法从静态上下文中引用非静态变量 this 

    1. public static String getClasses(){
    2.  age += 1;
    3.  return classes;
    4. }

    👆这里也会编译失败：Error:(35,9)java:无法从静态上下文中引用非静态变量age (这里的age是成员变量，可以看出静态方法中不能直接引用非静态成员变量)

  4. 静态方法中不能调用任何非静态方法，因为非静态方法中，系统编译器会自动导入形参this，在静态方法中调用的时候无法传递this引用，我在前面的博客中也有详细介绍👉this的引用

总结一下成员变量和成员方法
1.png
Java类和对象のstatic成员详解 - 图8
再强调一遍，静态的成员变量和静态的成员方法，都不依赖于对象，（因为他们是类变量）

  1. 普通的成员方法当中，是可以使用静态的成员变量的
  2. 静态的成员方法当中，不能访问非静态的成员（因为静态的成员变量是依赖于对象的）

我在之前的一篇博客中也对静态做出了相关的分析，大家可以去看一看👉静态类成员
另外，我们会不难发现，我们在写main方法的时候，都是public static void main…那么这里的static可不可以省略呢？理论上是没问题的，但是现在大多规定一定要有static，作为运行程序的入口
image.png
我们可以看到，没了static，都不能run和debug了

static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化和静态代码块初始化

  1. 就地初始化

就地初始化指的是：在定义时直接给出初始化

  1. public class Student{
  2.     private String name;
  3.     private String gender;
  4.     private int age;
  5.     private double score;
  6.     private static String classRoom = "三年二班"；
  8.     //...
  9. }
  1. 静态代码块初始化

那么什么是代码块呢，下一篇博客给大家讲解~
感谢阅读