面向对象：类、封装、构造方法

一、类

1.定义

     一个类通常包括以下内容：

1. 属性（成员变量）：描述对象的特征或状态，如名称、年龄、颜色等。
2. 方法：描述对象的行为或操作，如运行、停止、计算等。
3. 构造方法：用于初始化对象的特定属性值。
4. 访问修饰符：控制类、属性和方法的可见性，如 public、private、protected等。
5. 类方法（静态方法）：属于类本身而不是对象实例的方法。
6. 实例方法：每个对象实例都有自己的一份拷贝。
7. 继承：允许一个类继承另一个类的特性。
8. 接口：定义类遵循的协议，描述了类应该具有的方法。
9. 抽象类：不能被实例化，用作其他类的基类。

类：

• 定义：类是对一类事物的抽象描述，用来描述具有相同属性和行为的对象集合的模板。
• 特点：类是抽象的，它描述了对象应该有什么样的属性和行为，但并不直接与具体的对象实例相关。

对象：

• 定义：对象是类的实例化结果，是类的具体实体，具有独特的属性和行为。
• 特点：对象是具体的，它具体地展现了类的属性和行为，并可以被程序调用和操作。

区别：

1. 抽象与具体：类是对一类事物的抽象描述，而对象是类的具体实例。
2. 模板与实体：类是描述对象的模板，而对象是类的具体实体，包含了具体的数据和状态。
3. 一个类可以创建多个对象：同一个类的不同对象，结构相同，数据不同。

2、数据类型的默认值：

        int类型默认值是：0

        double类型默认值是：0.0

        boolean类型默认值是：false

        String类型默认值是：null

        int[]类型默认值是：null

        Student[]类型默认值是：null

        boolean[]类型默认值是：null

        int[] array = new int[3]; 里面的存放默认值是0

        boolean[] array = new boolean[3]; 里面的存放默认值是false

        Student[] array = new Student[3];里面的存放默认值是null

public class Student {
    //描述一个学生的信息：描述所有学生的共同特征
    int id;
    String name;
    int age;
    String gender;
}
@Test
public void test() {
    Student student = new Student();
    System.out.println(student.id);//0
    System.out.println(student.name);//null
    System.out.println(student.gender);//null
}
@Test
public void test1() {
    //类是对象的模版，对象是类的具体实例
    //一个类可以创建多个对象：同一个类的不同对象，结构相同,数据不同
    //student1;变量、实例、对象
    Student student1 = new Student();
    //对象，属性
    student1.id = 1;
    student1.name = "张三";
    student1.age = 23;
    student1.gender = "男";
    System.out.println(student1.name);
    }
@Test
public void test2() {
    int[] arry1 = new int[3];
    boolean[] arry2 = new boolean[3];
    Student[] students = new Student[3];
    for (int i = 0; i < students.length; i++) {
        System.out.println(students[i]);//输出的结果都为null
    }
    
    //增强的for循环
    //students.for 数组的名字+.+for 快捷输入
    for (Student student : students) {
        System.out.println(student);
    }
    int[] arry = {23, 45, 678};
    for (int i : arry) {
        System.out.println(i);
    }
}

3.空指针异常

        NullPointerException空指针异常（引用数据类型）

@Test
public void test4(){
    //在方法里面定义的叫局部变量
    //Student student;在全局里面可以用局部需要初始化
    Student student = null;
    //Variable 'student' might not have been initialized
    //没有初始化
    System.out.println(student);//方法为空正常
    //java.lang.NullPointerException: Cannot read field "id" because "student" is null
    System.out.println(student.id);//属性为空异常

        修改后：

@Test
public void test5(){
    //初始化student
    Student student = new Student();
    System.out.println(student.id);
    System.out.println(student.name);
    System.out.println(student.gender);
}

4、toString()

        toString() 是一个Object类中的方法，被用来返回对象的字符串表示。当我们打印一个对象时，实际上是调用了对象的 toString() 方法来获取其字符串表示。

        如果在自定义类中没有重写 toString() 方法，默认情况下会继承自Object类的 toString() 方法

public class Student {
    //属性
    int id;
    String name;
    int age;
    String gender;
//方法
@Override
public String toString() {
    return "Student{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            ", gender='" + gender + '\'' +
            '}';
}
@Test
public void test6() {
    Student student1 = new Student();
    //对象，属性
    student1.id = 1;
    student1.name = "张三";
    student1.age = 23;
    student1.gender = "男";
    System.out.println(student1.toString());
}

        在这个示例中，通过重写 toString() 方法，我们自定义了Student 类的字符串表示形式,使其输出对象的姓名和年龄信息。

        当调用System.out.println(student) 时，实际上会调用 person.toString() 方法来输出对象信息。

二、封装private/get/set

        封装（Encapsulation）指的是将数据（属性）和操作数据的方法（行为）捆绑在一起，通过访问控制（访问修饰符）来限制对数据的访问，从而保证数据的安全性和完整性。

        封装的主要目的是隐藏对象的内部细节，只暴露必要的接口供外部访问，同时可以通过公共方法来控制对数据的访问，确保数据被安全地访问和修改。通过封装，有以下优点：

1. 数据隐藏：将对象的实现细节隐藏起来，只暴露必要的接口，避免外部直接访问对象的内部数据。
2. 数据访问控制：通过使用访问修饰符（如private、protected、public）来控制对属性的访问，保证数据的安全性。
3. 代码复用：可以通过提供公共方法来访问和修改对象的数据，避免代码重复。

public class Teacher {
    private int age;
    private int id;
    private String name;
    private String gender;
    
    // 属性私有，通过get、set方法访问：
    public int getAge() {
        return age;
}
    public void setAge(int age) {
        if (age >= 1 && age <= 110) {
        this.age = age;
    }
}
    

三、构造方法

        在Java中，构造方法（Constructor）是一种特殊类型的方法，用于初始化对象时执行必要的操作。构造方法的名称与类名相同，并且没有返回类型（甚至没有void）。在创建对象时，会自动调用适当的构造方法来初始化对象。

      构造方法有以下几种类型：

1. 无参构造方法：不带任何参数的构造方法。
2. 有参构造方法：带有参数的构造方法，用于接收初始化对象时所需的参数。

     特点：

        1、方法名和类名一样

        2、没有返回值

//无参构造方法
//如果不写，Java默认提供这样一个无参构造方法.
//如果你写了，Java就不会再提供这个无参构造方法
public Student() {
}
@Test
public void test1() {

    //无参构造方法
    Student student = new Student();
    student.setId(1);
    student.setAge(12);
    student.setGender("男");
    student.setName("张三");
    System.out.println(student);
}

//有参构造方法
public Student(int id, String name, int age, String gender) {
    //this代表当前对象，把通过构造方法传递过来的值赋值给当前对象的id
    this.id = id;
    this.name = name;
    this.age = age;
    this.gender = gender;
}
@Test
public void test2() {
    //有参构造方法
    Student student = new Student(2, "李四", 12, "男");
    System.out.println(student);
}

         如果不写任何构造方法，系统默认提供一个无参数构造方法，只是我们看不到而已。

         如果自己写了任何一个构造方法，系统就不会提供这个默认无参构造方法。

         如果自己写了一个带参数的构造方法，就要把无参数构造方法也要写上。

构造方法和一般方法的不同：

1、构造方法是在new对象的时候运行，而一般的方法是在对象调用的时候才执行。

2、一个对象的建立，构造方法只执行一次，而一般方法可以被改对象调用多次。