JAVA基础（8）面向对象编程3

public class Student {
    private static int totalStudents; // 私有静态变量，统计学生总数
    static String schoolName; // 缺省权限修饰符，方便类外访问
    private int studentId;
    private String studentName;

    public Student() {
        totalStudents++;
        studentId = totalStudents; // 使用totalStudents静态变量的值为studentId赋值
    }

    public Student(String studentName) {
        this();
        this.studentName = studentName;
    }

    public void setStudentId(int studentId) {
        this.studentId = studentId;
    }

    public int getStudentId() {
        return studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public static int getTotalStudents() {
        return totalStudents;
    }

    public static void setTotalStudents(int totalStudents) {
        Student.totalStudents = totalStudents;
    }

    @Override
    public String toString() {
        return "Student{schoolName = " + schoolName + ", studentId = " + studentId + ", studentName = " + studentName + "}";
    }
}

public class TestStaticVariable {
    public static void main(String[] args) {
        // 静态变量totalStudents的默认值是0
        System.out.println("Student.totalStudents = " + Student.getTotalStudents());

        Student s1 = new Student("张三");
        Student s2 = new Student("李四");
        System.out.println(s1); // 静态变量schoolName的默认值是null
        System.out.println(s2); // 静态变量schoolName的默认值是null
        System.out.println("Student.totalStudents = " + Student.getTotalStudents()); // 静态变量totalStudents值是2

        Student.schoolName = "学校";
        System.out.println(s1); // 静态变量schoolName的值是学校
        System.out.println(s2); // 静态变量schoolName的值是学校

        // 通过“对象.静态变量”的形式来访问静态变量
        s1.schoolName = "新的学校";

        System.out.println(s1); // 静态变量schoolName的值是新的学校
        System.out.println(s2); // 静态变量schoolName的值是新的学校
    }
}

在这个例子中，我们定义了一个 Student 类来表示学生信息。静态变量 totalStudents 用于统计学生总数，静态变量 schoolName 表示学校名称。每创建一个新的 Student 对象时，totalStudents 变量都会自增，并将其值赋给该学生的 studentId 属性。通过静态方法 getTotalStudents 和 setTotalStudents 可以访问和修改 totalStudents 的值。

TestStaticVariable 类中展示了如何创建学生对象、访问和修改静态变量，以及输出学生信息。

4.静态方法

（1）语法格式

用static修饰的成员方法就是静态方法。

[修饰符] class 类{
[其他修饰符] static 返回值类型方法名(形参列表){
方法体
}
}

（2）静态方法的特点

静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。
只要权限修饰符允许，静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。
在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
静态方法可以被子类继承，但不能被子类重写。
静态方法的调用都只看编译时类型。
因为不需要实例就可以访问static方法，因此static方法内部不能有this，也不能有super。如果有重名问题，使用“类名.”进行区别。

（3）举例

public class student {
    public static void study(){
        System.out.println("我要用Theodore的博客学习JAVA");
    }
}
public class CSDNer {
    public static void speak(){
        System.out.println("欢迎大家来到我的博客学习");
    }
}
public class Test1 {
    public static void main(String[] args) {
        student.study();
        CSDNer.speak();

    }
}

二、类的成员——代码块

1.代码块的定义

如果成员变量想要初始化的值不是一个硬编码的常量值，而是需要通过复杂的计算或读取文件、或读取运行环境信息等方式才能获取的一些值，该怎么办呢？此时，可以考虑代码块（或初始化块）。

代码块(或初始化块)的作用：对Java类或对象进行初始化

代码块(或初始化块)的分类：

一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)
没有使用static修饰的，为非静态代码块。

2.静态代码块

如果想要为静态变量初始化，可以直接在静态变量的声明后面直接赋值，也可以使用静态代码块。

（1）语法格式

在代码块的前面加static，就是静态代码块。

【修饰符】 class 类{
static{
静态代码块
}
}

（2）特点

可以有输出语句。
可以对类的属性、类的声明进行初始化操作。
不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
若有多个静态的代码块，那么按照从上到下的顺序依次执行。
静态代码块的执行要先于非静态代码块。
静态代码块随着类的加载而加载，且只执行一次。

（3）举例

public class Chinese {
//    private static String country = "中国";

    private static String country;
    private String name;

    {
        System.out.println("非静态代码块，country = " + country);
    }

    static {
        country = "中国";
        System.out.println("静态代码块");
    }

    public Chinese(String name) {
        this.name = name;
    }
}

public class TestStaticBlock {
    public static void main(String[] args) {
        Chinese c1 = new Chinese("张三");
        Chinese c2 = new Chinese("李四");
    }
}

//运行结果
//静态代码块
//非静态代码块，country = 中国
//非静态代码块，country = 中国

3.非静态代码块

（1）语法格式

【修饰符】 class 类{
{
非静态代码块
}
【修饰符】构造器名(){
// 实例初始化代码
}
【修饰符】构造器名(参数列表){
// 实例初始化代码
}
}

（2）说明

特点:

可以有输出语句。
可以对类的属性、类的声明进行初始化操作。
除了调用非静态的结构外，还可以调用静态的变量或方法。
若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
每次创建对象的时候，都会执行一次。且先于构造器执行。

作用：

和构造器一样，也是用于实例变量的初始化等操作。

意义：

如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码。

（3）举例

import java.util.ArrayList;
import java.util.List;

public class Person {
    private String name;
    private int age;
    private List<String> hobbies;
    private String identifier;

    // 非静态代码块，用于初始化复杂对象和共享初始化代码
    {
        hobbies = new ArrayList<>();
        identifier = generateIdentifier();
        System.out.println("非静态代码块执行: 初始化hobbies和identifier");
    }

    // 构造方法1
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法1执行: name = " + name + ", age = " + age);
    }

    // 构造方法2
    public Person(String name) {
        this.name = name;
        this.age = 0; // 默认年龄
        System.out.println("构造方法2执行: name = " + name);
    }

    // 生成标识符的方法
    private String generateIdentifier() {
        return "ID-" + (int)(Math.random() * 10000);
    }

    public void addHobby(String hobby) {
        hobbies.add(hobby);
    }

    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age + ", Identifier: " + identifier + ", Hobbies: " + hobbies);
    }

    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        p1.addHobby("Reading");
        p1.addHobby("Swimming");
        p1.displayInfo();

        Person p2 = new Person("Bob");
        p2.addHobby("Running");
        p2.displayInfo();
    }
}

/*
输出结果：

非静态代码块执行: 初始化hobbies和identifier
构造方法1执行: name = Alice, age = 30
Name: Alice, Age: 30, Identifier: ID-XXXX, Hobbies: [Reading, Swimming]
非静态代码块执行: 初始化hobbies和identifier
构造方法2执行: name = Bob
Name: Bob, Age: 0, Identifier: ID-XXXX, Hobbies: [Running]

*/