java 类和对象3.0

一.Static成员

1.1拿学生举个例子

public class Student{
// ...
public static void main(String[] args) {
       Student s1 = new Student("Li leilei", "男", 18, 3.8);
       Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
       Student s3 = new Student("Jim", "男", 18, 2.6);
       }
}

使用Student这个类去实例化三个对象，每个对象都有它们自己的特别的名字，年龄，和绩点等成

员信息，这些信息是对不同学生进行描述的。

假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给

类中再加一个成 员变量，来保存同学上课时的教室呢？

答案是不行的。

之前在 Student 类中定义的成员变量，每个对象中都会包含一份 ( 称之为实例变量 ) ，因为需要使用

这些信息来描述 具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生

对象中都存储一份，而是需要让所 有的学生来共享。

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对

象，是所有对象所共享的。

1.2 Static修饰成员变量

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

是所有对象所共 享的 。

静态成员变量属性：

1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2.既可以通过对象访问，也可以通过类名访问，我们一般建议类名访问

3.类变量是存储在方法区当中的

4.生命周期伴随着类的一生(随着类的加载而创建、卸载而销毁)

public class Student{
       public String name;
       public String gender;
       public int age;
       public double score;
       public static String classRoom = "1311";
// ...
public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
       // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
      }
}

在细致一点，我们可以进入idea进行调试，在监视窗口会发现各个成员底下并没有静态成员变量

也就是说静态成员变量不会被存储到某个具体对象当中。

1.3 Static修饰成员方法

一般类中我们的成员变量都会设置为private，方法设置为public，那如果设置之后，Student类的

classRoom如何在类外进行访问呢？

public class Student{
       private String name;
       private String gender;
       private int age;
       private double score;
       private static String classRoom = "1309";
       // ...
}
public class TestStudent {
       public static void main(String[] args) {
       System.out.println(Student.classRoom);
     }
}



编译失败：
Error:(10, 35) java: classRoom 在Student 中是 private 访问控制

那static成员应该如何访问呢？

在java中，static修饰的方法叫做静态方法，是属于类的方法，不是某个对象所特有的，静态成员

变量痛过静态成员方法来访问。

public class Student{
// ...
       private static String classRoom = "1309";
// ...
       public static String getClassRoom(){
       return classRoom;
      }
}
public class TestStudent {
     public static void main(String[] args) {
            System.out.println(Student.getClassRoom());
      }
}


//这样就拿到classroom：1309了

静态方法特性：

1.不属于某个对象，是类方法。

2.可以通过对象调用，也可以通过类名.静态成员方法调用，但是一般是用后者。

3.不能在静态方法中访问任何非静态成员变量。

public static String getClassRoom(){
       System.out.println(this);
       return classRoom;
}
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
       age += 1;
       return classRoom;
}
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

4. 静态方法中不能调用任何非静态方法，因为非静态方法有 this 参数，在静态方法中调用时候无法

传递 this 引用

public static String getClassRoom(){
       doClass();//静态方法
       return classRoom;
}
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

1.4 静态成员变量初始化

注：静态成员方法中一般不会通过构造方法来进行初始化，构造方法是初始化某个对象相关的实例

属性

静态成员变量的初始化有2中方法：就地初始化和静态代码块初始化。

先来看一下就地初始化：

其指的是，在定义的时候给出初始值。

publicclassStudent{
      private String name;
      private String gender;
      private int age;
      private double score;
      private static String classRoom="1309";  
  
  //...
}

那么什么是静态代码块呢？往后看。

二.代码块

2.1 代码块概念以及分类

使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块

静态块

同步代码块（暂且不谈）

2.2 普通代码块：定义在方法中的代码块

这种用法比较少见

public class Main{
       public static void main(String[]args){
{//直接使用{}定义，普通方法块
       int x=10;
       System.out.println("x1="+x);
}
       int x=100;
       System.out.println("x2="+x);
    }
}

//执行结果x1=10，x2=100

2.3 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例

成员变量。

public class Student{
//实例成员变量
      private String name;
      private String gender;
      private int age;
      private double score;
public Student() {
       System.out.println("I am Student init()!");
     }
//实例代码块
  {
      this.name = "bit";
      this.age = 12;
      this.sex = "man";
      System.out.println("I am instance init()!");
   }
public void show(){
       System.out.println("name: "+name+" age: "+age+" sex: "+sex);
     }
}
public class Main {
    public static void main(String[] args) {
           Student stu = new Student();
           stu.show();
     }
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

2.4 静态代码块

使用 static 定义的代码块称为静态代码块。 一般用于初始化静态成员变量。

public class Student{
       private String name;
       private String gender;
       private int age;
       private double score;
       private static String classRoom;
//实例代码块
   {
      this.name = "muda";
      this.age = 12;
      this.gender = "man";
      System.out.println("I am instance init()!");
   }
// 静态代码块
static {
    classRoom = "1306";
    System.out.println("I am static init()!");
}
public Student(){
       System.out.println("I am Student init()!");
}
public static void main(String[] args) {
       Student s1 = new Student();
       Student s2 = new Student();
     }
}

注意事项：

1.静态代码块不管生成多少个对象，其只会执行一次。

2.静态成员变量是类的属性，因此是在JVM加载时开辟空间并初始化的

3.如果一个类中包含多个静态代码块，在编译代码块时，编译器就会按照定义的先后次序依次执行

4.实例代码只有在创建代码时才会执行。