我的个人博客主页：如果’'真能转义1️⃣说1️⃣的博客主页
关于Java基本语法学习---->可以参考我的这篇博客：《我在VScode学Java》
关于Java数组学习、JVM中的堆和栈—>可以参考我的这篇文章我在VScode学Java(Java一维数组、二维数组、JVM中的堆和栈）重制版

【1】类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
【2】对象或实体所拥有的特征在类中表示时称为类的属性。对象执行的操作称为类的方法。

Main myObj = new Main();其中两个Main分别代表着什么：
在这行代码中，Main出现了两次。第一个Main是类的名称，代表着类名。而第二个Main是构造函数的调用，表示要创建一个对象的实例。

类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

数据区域表示为:
dataFieldName: dataFieldType 数据域名:数据域类型
构造方法可以表示为:
ClassName(parameterName: parameterType) 类名(参数名:参数类型)
方法可以表示为:
methodName(parameterName: parameterType): returnType 方法名(参数名:参数类型):返回类型

叁._.构造方法 【 在一个类中，与类名相同的方法就是构造方法。】（构造器、构造函数）—>在创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的

使用new关键字创建对象时，会调用对应的构造方法

、
（1）构造方法（Constructor）是Java中一种特殊的方法，用于创建新对象并初始化其数据成员。它的名称与类名相同，没有返回值类型（包括void），可以有参数，也可以没有参数。当使用关键字“new”创建一个新对象时，就会自动调用该类的构造方法。
（2）构造方法可以执行各种初始化操作，例如设置默认值、分配空间等。在Java中，每个类都必须至少有一个构造方法。如果没有显式地定义，Java编译器会默认生成一个无参构造方法。

在Java中，构造器和构造函数是同一个概念，没有区别。
构造器（Constructor）是一种特殊的方法，用于创建并初始化对象。
它具有与类相同的名称，并且没有返回类型（包括void），可以带有参数。

注意事项：一个常见的错误就是将关键字void放在构造方法的前面

1. 构造器与类同名。
2. 每个类可以有一个以上的构造器
3. 构造器可以有0个、1个或多个参数
4. 构造器没有返回值。
5. 构造器总是结合 new 操作符一起调用

意义----> 其好处包括方便，初始化对象状态，类型安全，灵活性

方便在创建对象时直接传递参数。接收参数并在对象初始化的过程中使用这些参数来设置对象的状态。这样，我们可以在创建对象的同时就初始化对象的属性，使得对象在创建后就处于合适的状态。

new运算符是Java中用于创建对象的关键操作符。它在内存中分配空间，初始化对象，并返回对该对象的引用。

当使用new运算符创建对象时，发生以下步骤：

1. 内存分配：new运算符根据对象的类型确定所需的内存空间，并在堆内存中分配足够的空间来存储对象的成员变量和方法。
2. 初始化：分配内存后，Java会调用适当的构造函数来初始化对象。通过调用构造函数，可以设置对象的初始状态、分配资源等。
3. 返回引用：初始化完成后，new表达式返回对新创建对象的引用。通过这个引用，我们可以访问并操作该对象的成员变量和方法。

下面是使用new运算符创建对象的示例代码：

ClassName object = new ClassName();

其中，ClassName是要实例化的类名。object是对新创建对象的引用，可以使用它来访问对象的成员变量和方法。

需要注意的是，除了使用默认的无参构造函数外，我们还可以使用带有参数的构造函数来创建对象。例如：

ClassName object = new ClassName(arg1, arg2);

这将调用带有参数的构造函数来初始化对象，并传递相应的参数。

总结：

• new运算符用于在堆内存中分配空间并初始化对象。
• new运算符执行三个步骤：内存分配、初始化和返回引用。
• 通过new运算符创建的对象可以使用对该对象的引用来访问和操作。

构造方法和set对比：总结起来，构造方法用于在创建对象时进行初始化，而set 方法用于在对象创建后修改对象的属性值。

总结起来，构造方法用于在创建对象时进行初始化，
而set 方法用于在对象创建后修改对象的属性值。

构造方法（Constructor）是一种特殊的方法，用于在创建对象时进行初始化操作。它通常在实例化一个类时被调用，用于给新创建的对象分配内存并初始化其成员变量。构造方法的主要目的是确保对象在创建后具有一致的状态。当你创建一个新对象时，构造方法会被自动调用，将提供的参数用于初始化对象的状态。构造方法的作用是在对象创建时设置初始值，而不是给对象命名。

set 方法（setter）是一种用于设置对象属性值的方法。它通常用于修改对象的状态或赋予新的值。set 方法通常被定义为公共方法，接受参数并将其值分配给对象的成员变量。通过调用set 方法，你可以更改对象的属性值，而不是创建一个新的对象。

类代码为什么报错：

main主方法

package asdasdasdasdasdasdasdasdasd;

public class asdasdasdasdadasdad {
    public static void main(String[] args) {
        // 使用构造方法创建一个新的 Person 对象
        Person111 person1 = new Person111("John", 25);
        System.out.println(person1.getName()); // 输出：John
        System.out.println(person1.getAge()); // 输出：25

        // 使用 set 方法修改对象的属性值
        person1.setName("Mike");
        person1.setAge(30);
        System.out.println(person1.getName()); // 输出：Mike
        System.out.println(person1.getAge()); // 输出：30
    }
}

上述的类代码哪里错了+改进：

（1） setName 和 setAge 方法应该是实例方法，而不是静态方法。因为它们是用于设置实例属性的，而不是类属性。因此，需要将方法声明中的 static 关键字删除。
（2）getName 方法返回类型应该是 String，而不是 char[]。因为 name 属性是一个字符串，而不是字符数组。因此，需要将方法声明中的返回类型从 char[] 改为 String。
（3）getAge 方法返回类型应该是 int，而不是 char[]。因为 age 属性是一个整数，而不是字符数组。因此，需要将方法声明中的返回类型从 char[] 改为 int。

package asdasdasdasdasdasdasdasdasd;

public class Person111 {
    private String name;
    private int age;

    // 构造方法
    public Person111(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // set 方法用于设置 name 属性值
    public void setName(String name) {
        this.name = name;
    }

    // set 方法用于设置 age 属性值
    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 其他方法...

}

改后结果

在创建对象的时候给成员变量进行赋值：使用new关键字创建对象时，会调用对应的构造方法

构造方法是一个特殊的方法，它在创建对象时被自动调用，主要用于初始化该对象的成员变量。通过构造方法可以将对象创建和初始化的过程合并在一起，使代码更加简洁、易读。

因此，我们可以把构造方法看作是一种特殊的初始化方法，用于给对象的成员变量赋初始值。这样，在创建对象时，就可以直接调用构造方法，将对象的属性进行初始化，而无需手动为每一个属性赋值，提高了代码的效率和可维护性。

为什么构造器中直接赋值就需要有参构造，而无参的可以连无参的也不需要：

如果在类中没有定义任何一个构造方法，则 Java 会自动为该类生成一个默认的构造方法。默认的构造方法不包含任何参数，并且方法体为空。
无参数的构造方法也被称为Nullary构造方法，因为它不带任何参数。而只有编译器自动生成的无参构造方法才被称为默认构造函数。如果你自己编写了一个无参数且没有具体内容的构造函数，那就只是一个空的构造函数，而不算作默认构造函数。

[ 0 ] 构造函数指的是在以下情况下由编译器自动添加的无参构造方法：

1. 当类中没有显式声明任何构造函数时，编译器会自动生成一个默认构造函数。

2. 当类中含有其他构造函数（有参构造函数），但没有提供无参构造函数时，在某些情况下（如创建对象实例时不传递参数），编译器会自动添加一个默认构造函数。

默认构造函数具有无参且没有特定实现的特点，它仅完成对象的初始化工作。如果用户显式声明了其他构造函数，则需要同时显式声明默认构造函数，否则无法通过无参方式创建对象实例。

【 1 】有参的：

（1）类中显式地定义了一个或多个构造方法，则 Java 不再提供默认构造方法。：

当在一个类中显式地定义了一个或多个构造方法时，Java编译器将不再提供默认的无参构造方法。这意味着如果你在类中定义了至少一个构造方法，并且没有显式地定义无参构造方法，那么在创建该类的对象实例时，只能使用已定义的构造方法来传递必要的参数。

这样做的好处是可以确保对象在被实例化时都必须经过有效的初始化过程。通过构造方法，你可以在对象创建时对成员变量进行赋值，进行一些必要的准备工作，以确保对象在创建后处于一种可用的状态。使用构造方法的方式可以灵活地根据需求来初始化对象，并允许在对象创建的过程中传递必要的参数。

然而，有时候我们可能需要支持无参方式创建对象实例，比如在某些情况下不需要传递任何参数来创建对象。在这种情况下，你需要显式地定义一个无参构造方法，以便支持无参方式的对象实例化。通过定义无参构造方法，你可以在创建对象时省略必要的参数，从而提供更方便的对象创建方式。

总而言之，当存在显式定义的构造方法时，编译器会自动提供一个默认的无参构造方法；当不存在显式定义的构造方法时，编译器会自动提供一个无参构造方法。根据实际需求，你可以选择合适的构造方法来创建对象，并通过显式定义构造方法来满足特定的需求。

有参构造函数与无参构造函数相比，它接受一个或多个参数，并用这些参数来初始化类的对象。有参构造函数允许我们在创建对象时提供必要的信息，从而实现更灵活的对象创建和初始化。

（2）有参构造函数的定义如下：

public class ClassName {
    // 有参构造函数
    public ClassName(参数类型 参数1, 参数类型 参数2, ...) {
        // 初始化代码
    }
}

其中，参数类型和参数名是根据需要定义的，可以根据具体的需求传入不同类型和数量的参数。

使用有参构造函数时，我们可以根据对象创建时所需的不同参数进行不同的初始化操作。这使得我们能够定制对象的创建过程，并确保对象被正确地初始化。

当定义了有参构造函数时，如果我们还希望使用无参构造函数创建对象，那么我们需要同时在类中显式地定义一个无参构造函数。否则，只能使用带有参数的构造函数创建对象。

请注意以下事项：

• 类可以同时定义多个构造函数，包括无参构造函数和有参构造函数。
• 在构造函数内部，可以使用传入的参数对对象的属性进行初始化。
• 构造函数没有返回类型，包括void类型也不需要写。
• 使用特定的构造函数创建对象时，应根据构造函数的参数类型和数量提供相应的参数。
  

【 2 】无参的：

Java中的无参构造函数是一个特殊的构造函数，它没有任何参数。它被用来创建一个类的对象，并执行一些初始化操作。当我们在一个类中没有明确定义任何构造函数时，Java会自动提供一个默认的无参构造函数。

无参构造函数的定义如下：

public class ClassName {
    // 无参构造函数
    public ClassName() {
        // 初始化代码
    }
}

注意事项：

• 无参构造函数的名称与类名相同。
• 无参构造函数没有返回类型，包括void类型也不需要写。
• 如果在类中显式地定义了带参数的构造函数（有参构造函数），而没有定义无参构造函数，那么编译器将不会自动提供无参构造函数。
• 每个类都可以有多个构造函数，包括无参构造函数和带参数的构造函数。

（1）解释：

构造方法是用来初始化对象的特殊方法。在你的代码中，你创建了一个Student类的对象，并使用默认的构造方法来初始化对象。然后你又创建了一个新的Student对象，并使用有参构造方法来初始化对象。这两种方式都是可以的，具体使用哪种方式取决于你的需求。

在默认的构造方法中，对象的属性会被初始化为默认值。而在有参构造方法中，你可以通过传入参数来指定对象的属性值。在你的代码中，你使用了无参构造方法来创建对象，然后通过调用对象的setName和setAge方法来设置对象的属性值。

如果你希望在创建对象的同时就指定对象的属性值，那么你可以使用有参构造方法。有参构造方法可以接受参数，并将参数的值赋给对象的属性。这样你就可以在创建对象的同时，将属性值初始化为你想要的值。

总结起来，无参构造方法适用于对象的属性值可以在创建对象后再进行设置的情况，而有参构造方法适用于在创建对象时就需要指定属性值的情况。

（2）Java的无参构造方法不是用来修改默认值的，而是在创建对象时执行一些特定的操作或初始化实例变量。：

Java的无参构造方法不是用来修改默认值的，而是在创建对象时执行一些特定的操作或初始化实例变量。

无参构造方法是指没有参数的构造方法，它不接受任何输入参数，因此无法通过参数传递值来修改默认值。

它主要用于以下情况：

1. 创建一个对象时需要执行特定的操作：无参构造方法可以在对象创建时执行一些必要的操作，例如打开文件、建立数据库连接等。

2. 初始化实例变量：无参构造方法可以设置实例变量的初始值，但这并不是修改默认值，而是为实例变量赋予一个初始值。

   以下是一个简单的示例，演示了无参构造方法的使用：

package work629;

public class BOOK {
    private  String author;
    private String title;
    private double price;
    private String publisher;
    private int publishedYear;

    public BOOK() {
        this("12", "123", 12,  "12", 1);
    }

    public BOOK(String author1, String title, double price, String publisher, int i) {
        author = author1;
        this.title = title;
        this.price = price;
        this.publisher = publisher;
        this.publishedYear = i;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author1) {
        author = author1;
    }

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return this.price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPublisher() {
        return this.publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public int getPublishedYear() {
        return this.publishedYear;
    }

    public void setPublishedYear(int publishedYear) {
        this.publishedYear = publishedYear;
    }

    public void showDisplayBook() {
        System.out.println("Author: " + author);
        System.out.println("Title: " + this.title);
        System.out.println("Price: " + this.price);
        System.out.println("Publisher: " + this.publisher);
        System.out.println("Published Year: " + this.publishedYear);
    }
}

[ 1 ]this 关键字在 Java 中用于引用当前对象。在这个代码中，this 关键字被用于两个不同的地方。-------->通过使用 this关键字来调用有参构造函数，并传递默认的参数值，无参构造函数可以使用这些参数值来初始化对象的属性。

【 1 】无参构造函数 public BOOK() 在内部调用了有参构造函数 public BOOK(String author1, String title, double price, String publisher, int i)。通过使用 this 关键字来调用有参构造函数，并传递默认的参数值，无参构造函数可以使用这些参数值来初始化对象的属性。

【 2 】在有参构造函数 public BOOK(String author1, String title, double price, String publisher, int i) 中，this 被用于引用当前对象的属性。这是为了区分构造函数的参数和对象的属性。通过使用 this 关键字，可以将传递给构造函数的参数值赋给对象的属性。

所以，当你创建一个 BOOK 对象时，如果没有提供参数，无参构造函数将会被调用，并且它会使用默认的参数值来初始化对象的属性。

[ 2 ]修改，默认值后的：

[ 1 ]基本格式：在一个类中，与类名相同的方法就是构造方法。

public class Student {
修饰符 类名(参数) {
方法体;}
}

特点：构造方法不能被 static、final、synchronized、abstract 和 native（类似于 abstract）修饰。不要在构造方法里使用 return 来返回当前类的对象，因为构造方法的返回值是隐式的。

构造方法是一种特殊类型的方法，其与类名相同且大小写一致，没有返回值类型，连void都没有，并且没有具体的返回值（不能由return语句返回结果数据）。构造方法的作用是在创建对象时自动执行，用于初始化对象的属性和成员变量，为对象设置默认值，以确保对象在创建时具有正确的状态和属性。

构造方法有以下特点：

1. 方法名必须与类名相同，且没有返回值类型。
2. 构造方法在对象创建时自动调用，不能手动调用。
3. 可以有多个重载版本，根据传递的参数不同选择不同的构造方法。
4. 构造方法可以用于初始化对象的成员变量和其他属性，也可以设置默认值，保证对象创建时属性的初始状态是正确的。
5. 构造方法可以访问类的私有属性和方法，但不能访问非静态的类变量和非静态的方法。
6. 构造方法在对象创建完成后，返回给调用者一个指向该对象的引用。

综上所述，构造方法是一种特殊类型的方法，用于创建和初始化对象。它的主要作用是在对象创建时自动执行，完成对象的初始化工作，保证对象具有正确的状态和属性。

怎么运作的：（1）由虚拟机调用，不能手动调用构造方法。（2）每创建一次对象，就会调用一次构造方法

构造方法是一种特殊类型的方法，用于初始化对象的状态并执行必要的设置。在Java中，当我们使用关键字 “new” 创建一个对象时，虚拟机会自动调用适当的构造方法来创建该对象¹。这是由编译器和运行时环境自动处理的过程。

加深理解

构造方法是在对象被实例化时被调用的。也就是说，当我们使用关键字“new”创建一个对象时，Java将会自动调用该对象的构造方法。在构造方法中，我们可以执行一些初始化的操作，例如设置对象的初始状态、分配内存空间等。因此，构造方法执行的时机可以看作是在对象被创建时。

[ 2 ]有参构造和无参构造

其中，类名与构造方法名相同，无返回值类型，构造方法体可以为空。形参列表可以包含多个参数，多个参数之间用逗号隔开。

（1）显式和隐式的区别主要在于构造方法的定义和调用方式。

当涉及到构造方法时，显式和隐式的区别主要在于构造方法的定义和调用方式。

1. 显式构造方法：

显式构造方法是由开发人员在类中显式地定义的构造方法。您可以根据需要定义不同参数的构造方法，并在其中编写特定的初始化逻辑。下面是一个示例代码：

public class Person {
    private String name;
    private int age;

    // 显式定义的有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 显式定义的无参构造方法
    public Person() {
        // 可以在这里进行默认初始化操作
        this.name = "Unknown";
        this.age = 0;
    }

    // 其他方法和属性的定义...
}

在上面的示例中，我们显式地定义了两个构造方法：一个有参构造方法和一个无参构造方法。有参构造方法用于传入姓名和年龄进行初始化，而无参构造方法可以用于默认初始化。

2. 隐式构造方法：

隐式构造方法是系统自动生成的默认构造方法，当您没有显式地定义构造方法时，系统会提供一个默认的无参构造方法。它通常执行简单的默认初始化操作。以下是一个示例代码：

public class Person {
    private String name;
    private int age;

    // 默认的隐式构造方法

    // 其他方法和属性的定义...
}

由于我们没有显式定义构造方法，系统会提供一个默认的无参构造方法。这个默认的构造方法会对name和age进行默认初始化，例如将name初始化为null，将age初始化为0。

因此，以下是使用默认的无参构造方法创建对象的示例代码

Person person = new Person(); // 调用默认的无参构造方法

3.在使用这些构造方法创建对象时，区别如下：

显式和隐式的区别在于是否手动编写了构造方法的定义，而不是构造方法的调用方式。

Person person1 = new Person("Alice", 25); // 调用显式的有参构造方法
Person person2 = new Person(); // 调用显式的无参构造方法
Person person3 = new Person(); // 调用隐式的无参构造方法

通过显式构造方法，您可以按照自己的需求进行初始化，而通过隐式构造方法，系统会提供默认的初始化方式。

（2）无参构造是一个类中的方法，它没有参数。不带任何参数的构造方法，在创建对象时调用。

这种构造方法可以被用来初始化对象的实例变量，当对象被创建时自动调用。

public student() {
空参构造}

为什么如果我们自己没有写任何的构造方法，那么虚拟机给我们加一个空参构造方法

在Java中，如果我们没有显式地为类编写构造方法，Java虚拟机会为我们提供一个默认的空参构造方法。这是因为每个类都需要一个构造方法，用于创建该类的对象。

构造方法是用于初始化对象的特殊方法，它具有与类相同的名称，并且没有返回类型。当我们创建一个类的实例时，构造方法会被自动调用，用于初始化对象的状态。

如果我们没有定义任何构造方法，Java编译器会自动为我们生成一个默认的空参构造方法。这个默认构造方法没有任何参数，并且不执行任何操作，只是简单地创建一个对象实例。

提供默认的空参构造方法的目的是确保在创建对象时不会发生错误。如果没有默认构造方法，当我们使用无参的构造方法创建对象时，编译器将无法找到合适的构造方法，从而导致编译错误。

总结来说，Java虚拟机为我们提供默认的空参构造方法是为了保证类的实例化过程的正常进行，即使我们没有显式地定义构造方法。

== 待解决：如何知道空参里面的属性，其是如何调用的==

(3)有参构造是一个类中的方法，它包含至少一个参数。可以在创建对象时传递参数，并根据不同的参数创建不同的对象。

这种构造方法可以被用来初始化对象的实例变量，并且可以接受外部传递的参数。有参构造的参数通常用来设置对象的状态。

public student(string name,int age) 
带参构造..}

[ 3 ]注意事项

1. 构造方法的名字必须与类名相同，且没有返回类型。
2. 构造方法可以有访问修饰符，但没有返回类型。
3. 如果没有定义构造方法，Java编译器会自动生成一个默认的无参构造方法，但如果自己定义了有参构造方法，就需要自己编写无参构造方法。
4. 如果自己定义了有参构造方法，就需要显式定义无参构造方法，否则不能使用该类的无参构造方法。
5. 构造方法可以重载，即同一个类中可以拥有多个构造方法名相同但参数不同的构造方法。
6. 在构造方法中可以调用其他构造方法，使用关键字this（必须是第一行语句）。
7. 不能在构造方法中定义静态变量或静态方法，因为它们属于类，而构造方法是属于对象的。
8. 构造方法可以用来初始化实例变量或执行其他操作，比如打开文件等。
9. 构造方法不能被继承，但子类可以使用父类的构造方法。
10. 构造方法必须在创建对象时被调用，不能手动调用。

其他方面：

（1）构造方法的定义
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了
（2）构造方法的重载
带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载
（3）使用方式：任何时候都手动写上空参和带全部参数的构造方法
无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法。
任何类定义出来，默认就自带了无参数构造器，写不写都有

[ 4 ]方法重载：链接到那篇文章

方法重载是指在同一个类中，可以定义多个方法名称相同但参数列表不同的方法。这些方法根据不同的参数类型、参数个数或者参数顺序进行区分。当调用该方法时，编译器会根据传入的参数类型来确定具体要执行的方法。

通过方法重载，我们可以利用相同的方法名来表示实现相似功能但参数不同的情况。这样可以提高代码的复用性和可读性。

方法重载需要满足以下条件：

• 方法名必须相同。
• 参数列表必须不同，可以是参数类型的不同组合、参数个数的不同或参数顺序的不同。
• 返回类型可以相同也可以不同。

下面是一个示例，展示了方法重载的概念：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

在上面的示例中，Calculator 类定义了三个名为 add 的方法，它们的参数列表不同。第一个方法接收两个整型参数，返回它们的和；第二个方法接收两个双精度浮点数参数，返回它们的和；第三个方法接收三个整型参数，返回它们的和。这样，在使用 Calculator 类时，可以根据不同的需求选择适合的 add 方法。

总而言之，方法重载允许我们使用相同的方法名来处理不同类型和数量的参数，提供了更灵活的代码设计和调用方式。

总结

在Java中，每个类都有一个默认的无参构造方法，如果没有显示地定义任何构造方法的话。当然，你也可以创建一个或多个有参构造方法来初始化对象。当你创建一个新的对象时，你可以使用定义好的构造方法来初始化它。如果你没有提供任何构造方法，Java会自动提供一个无参构造方法来初始化对象的实例变量。

肆._. JavaBean类

>什么是封装对象代表什么，就得封装对应的数据，并提供数据对应的行为[如何正确设计对象的属性和方法]

JavaBean类是Java语言中的一种特殊类，通常用于表示某种实体对象。JavaBean类通常由一组属性（属性）和对这些属性的访问方法（getter和setter）组成，还可以包含构造函数、方法、事件处理程序等。JavaBean类通常被用于封装、传输和存储数据。这种类必须遵循一个特定的约定，包括使用公共构造函数、提供公共setter和getter方法等。JavaBean类是Java程序中一种常见的组件，可以用于构建复杂的GUI应用程序、Web应用程序和其他类型的Java应用程序。

[ 1 ]规范

好的，这是一份符合JavaBean规范的类示例：
1、类名：驼峰命名法
2、成员变量使用private修饰
3、提供至少两个构造方法：无参构造方法+带全部参数的构造方法
4、成员方法:提供每一个成员变量对应的setXxx()/getXxx()

public class Student {
    // 成员变量使用private修饰
    private String name;
    private int age;
    private String school;

    // 无参构造方法
    public Student() {
    }

    // 带全部参数的构造方法
    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    // set和get方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    // 其他行为
    public void study() {
        System.out.println("I'm " + name + ", I'm studying.");
    }

    public void sleep() {
        System.out.println("I'm " + name + ", I'm sleeping.");
    }
}

其中，成员变量使用private修饰，提供了一个无参构造方法和一个带全部参数的构造方法；每一个成员变量都提供了对应的setXxx()/getXxx()方法。除此之外，还提供了两个行为：study()和sleep()。

快捷键、快捷方式

（1）常见的java编辑器：alt + insert
（2）Vscode：右击-到如图所示的地方2

[ 2 ]JavaBean类通常包含以下方法：

1. 构造函数（Constructor）：

JavaBean类应该提供一个无参数的构造函数，以便可以使用new关键字创建类的实例。除了无参数构造函数，还可以提供其他重载的构造函数来支持不同的初始化方式。

//构造函数用于创建对象时进行初始化操作。
public class Person {
    private String name;
    private int age;

    public Person() {
        // 无参数构造函数
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 其他方法和属性...
}

Person类提供了一个无参数的构造函数和一个带有参数的构造函数。无参数构造函数可以用于创建默认的Person对象，而带有参数的构造函数可以在创建对象时同时设置姓名和年龄。

2. 属性的访问方法（Getter和Setter）：

JavaBean类通常会为每个私有属性提供对应的公共访问方法，即getter和setter方法。getter方法用于获取属性的值，而setter方法用于设置属性的值。

Getter方法用于获取私有属性的值，而Setter方法用于设置私有属性的值。以下是一个示例代码：

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    // 其他方法和属性...
}

在上述示例中，Person类提供了getName()和setName()方法来获取和设置姓名，以及getAge()和setAge()方法来获取和设置年龄。

3. equals()和hashCode()方法：

JavaBean类通常会重写equals()和hashCode()方法，以便在比较对象时进行适当的操作。这样可以根据对象的内容而不是引用地址来进行比较和哈希计算。

equals()方法用于比较对象是否相等，hashCode()方法用于计算对象的哈希值。以下是一个示例代码：

public class Person {
    private String name;
    private int age;
    
    // 构造函数、Getter和Setter方法...

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    // 其他方法...
}

在上述示例中，equals()方法通过比较姓名和年龄来判断对象是否相等，并使用Objects.equals()方法来处理可能为null的属性。hashCode()方法使用Objects.hash()方法计算对象的哈希值，包括姓名和年龄。

4. toString()方法：

JavaBean类通常会重写toString()方法，以便以字符串形式返回对象的内容表示。这在调试和日志记录时非常有用。

toString()方法用于返回对象的字符串表示。

public class Person {
    private String name;
    private int age;
    
    // 构造函数、Getter和Setter方法...
    
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    // 其他方法...
}

在上述示例中，toString()方法返回了一个包含姓名和年龄的字符串表示，方便在调试和日志记录时使用。

5. clone()方法：

JavaBean类可以实现Cloneable接口并重写clone()方法，以支持对象的克隆操作。这使得可以通过复制现有对象来创建新的对象。

clone()方法用于创建对象的副本

public class Person implements Cloneable {
    private String name;
    private int age;
    
    // 构造函数、Getter和Setter方法...

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    // 其他方法...
}

在上述示例中，Person类实现了Cloneable接口，并重写了clone()方法。通过调用super.clone()来创建对象的浅拷贝副本。

【3】Java对象的销毁

Java中的对象销毁是通过垃圾回收器（Garbage Collector）自动处理的。垃圾回收器负责检测和清理不再被引用的对象，并释放它们所占用的内存。

当一个对象不再被引用时，也就是没有任何变量引用指向该对象时，该对象会被标记为可回收的。当垃圾回收器运行时，它会扫描堆内存中的对象，并将未被引用的对象进行回收。

垃圾回收器的工作过程如下：

1. 标记阶段：垃圾回收器从根对象（如静态变量、活动线程等）开始，递归地遍历所有引用链，将所有仍然被引用的对象标记为活动对象。
2. 清除阶段：垃圾回收器清理并回收那些未被标记为活动对象的对象。被回收的对象所占用的内存将被释放。
3. 整理阶段：在清除阶段后，垃圾回收器可能会对堆内存进行整理，以消除内存碎片，使得分配连续内存空间更加高效。

对象的销毁是由垃圾回收器自动管理的，我们无法手动销毁一个对象。但可以通过调用System.gc()方法建议垃圾回收器执行垃圾回收操作，但不能确保立即执行。

需要注意的是，对象的销毁仅涉及内存空间的释放，而不涉及其他清理操作（例如关闭文件或网络连接等）。对于这些资源的释放，我们应该使用适当的代码来手动处理，例如在finally块中进行关闭操作。

总结：

• Java中的对象销毁由垃圾回收器自动处理。
• 对象销毁发生在对象不再被引用时，并由垃圾回收器标记为可回收对象。
• 垃圾回收器通过标记、清除和整理阶段来进行垃圾回收操作。
• 我们无法手动销毁一个对象，但可以通过建议垃圾回收器执行垃圾回收来间接影响对象的销毁时机。

在Java中，一个对象被当作垃圾回收的情况可以分为以下几种：

1. 对象不再被引用：当一个对象没有任何变量引用指向它时，即没有根节点引用到该对象，它就成为了垃圾。这包括对象的所有引用都被置为null，或者超出了其作用域，无法再被访问到。

2. 引用链断裂：如果一个对象存在循环引用，并且这个循环引用与其他对象没有相连的引用链，那么这些循环引用形成的对象组合将成为垃圾。因为它们无法通过任何现有引用访问到。

3. 显式置为null：通过将对象的引用设置为null，可以显式地表示该对象已不再需要。当发生这种情况时，垃圾回收器会在适当的时候回收该对象。

4. 强制执行System.gc()：调用System.gc()方法可以建议垃圾回收器执行垃圾回收操作。但是，它不能确保立即回收所有垃圾对象，并且强制执行垃圾回收并不是一种良好的实践。

需要注意的是，垃圾回收是由垃圾回收器自动处理的，我们无法手动销毁一个对象。垃圾回收器会周期性地检查和处理不再被引用的垃圾对象。

在实际编程中，我们应该避免创建无用的对象，并及时释放资源，以帮助垃圾回收器更有效地回收垃圾对象。

其他

@Override是个什么的，为什么会生成这个

@Override 是一个注解（Annotation），用于表示方法是覆盖（重写）父类或实现接口中的方法。它是Java语言提供的一种元数据（metadata）机制，用于提供编译器和开发工具的额外信息。

生成 @Override 注解的原因是为了增强代码的可读性和可维护性。当我们在子类中编写一个方法，意图是覆盖父类或实现接口的方法时，通过添加 @Override 注解，可以明确地告诉编译器和其他开发者，我们是有意重写父类或接口中的方法，而不是意外地创建了一个新的方法。

如果我们错误地使用 @Override 注解，而实际上并没有覆盖父类或接口中的方法，编译器会报错，提醒我们检查代码逻辑。

总结来说，@Override 注解是一种用于标识方法覆盖（重写）的元数据，它帮助我们在编译时捕获错误并提供了更好的代码可读性。

学习

accessor method(getter)(读取器方法 (访问器))
action (动作)
attribute (属性)
behavior (行为)
constructor (构造方法)
date field (数据域)
data-field encapsulation (数据域封装)
default constructor (默认构造方法)
dot operator (.)(圆点运算符)
instance (实例)
instance variable(实例变量)

instantiation(实例化)
mutator method (setter) (设置器方法(修改器))
no-arg constructor (无参构造方法)
object-oriented programming(OOP)(面向对象程序设计)
Unified Modeling Language(UML)(统一建模语言)
package-private(package-access)(包私有 (或包访问))
private (私有的)
property (特征)
reference variable(引用变量)
reference type(引用类型)
state (状态)
static method (静态方法)
static variable (静态变量)

总结

·类是对象的模板。它定义对象的属性，并提供创建对象的构造方法以及对对象进行操作的方法。
·类也是一种数据类型。可以用它声明对象引用变量。对象引用变量中似乎存放了一个对象，但事实上，它包含的只是对该对象的引用。严格地讲，对象引用变量和对象是不同的，但是大多数情况下，它们的区别是可以忽略的。
·对象是类的实例。可以使用new操作符创建对象，使用点运算符 (.) 通过对象的引用变量来访问该对象的成员。
·实例变量或方法属于类的一个实例。它的使用与各自的实例相关联。静态变量是被同一个类的所有实例所共享的。可以在不使用实例的情况下调用静态方法。
`类的每个实例都能访问这个类的静态变量和静态方法。然而，为清晰起见，最好使用“类名.变量和“类名.方法”来调用静态变量和静态方法。

·修饰符指定类、方法和数据是如何被访问的。公共的 (public) 类、方法或数据可以被任何客户访问，私有的 (private) 方法或数据只可能在类内被访问。可以提供get方法或者set方法，使客户能够看到或修改数据。通俗点讲，get方法称为读取器(或访问器)，set方法称为设置器 (或修改器)。
·get方法具有签名public returnType getPropertyName()。如果返回类型(returnType)是boolean型，则get方法应该定义为public boolean isPropertyName()。set方法具有签名public void setPropertyName(dataType propertyValue)。
·所有传递给方法的参数都是值传递的。对于基本类型的参数，传递的是实际值，而若参数是引用数据类型，则传递的是对象的引用。
·Java数组是一个包含基本类型值或对象类型值的对象。当创建一个对象数组时，它的元素被赋予默认值null。

构造函数的名字为什么会和类名是一样的

构造函数的名字与类名相同是Java语言的约定和规定之一。这种设计选择使得构造函数能够在对象创建时被自动调用。

当使用new关键字创建一个类的实例时，编译器会查找与类名匹配的构造函数，并自动调用它来初始化对象。因此，构造函数的名字与类名相同可以方便地标识和关联构造函数与所属的类。

此外，与类名相同的构造函数名字还有助于提高代码的可读性和可理解性。通过使用相同的名字，程序员可以直观地知道哪个方法是用于创建对象的构造函数。

需要注意的是，尽管构造函数的名字与类名相同，但是它们的签名（参数类型和顺序）必须是唯一的。因此，如果在同一个类中定义了多个构造函数，它们应该具有不同的参数列表，以便可以根据传递的参数来区分它们。这就是Java中的方法重载的概念，通过参数列表的不同来区分同名的方法或构造函数。

public class MyClass {
    private int value;

    // 构造函数
    public MyClass(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public static void main(String[] args) {
        // 创建 MyClass 对象的实例
        MyClass myObject = new MyClass(10);

        // 访问对象的方法
        int result = myObject.getValue();
        System.out.println("Value: " + result);
    }
}

构造方法在对象创建时自动调用，只会被调用一次，并且没有返回类型

package work629;

public class BOOK {
    private String author;
    private String title;
    private double price;
    private String publisher;
    private int publishedYear;

    public BOOK() {
    }

    public BOOK(String author, String title, double price, String publisher, int publishedYear) {
        this.author = author;
        this.title = title;
        this.price = price;
        this.publisher = publisher;
        this.publishedYear = publishedYear;
    }

    public String getAuthor() {
        return this.author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return this.price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPublisher() {
        return this.publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public int getPublishedYear() {
        return this.publishedYear;
    }

    public void setPublishedYear(int publishedYear) {
        this.publishedYear = publishedYear;
    }

    public void showDisplayBook() {
        System.out.println("Author: " + this.author);
        System.out.println("Title: " + this.title);
        System.out.println("Price: " + this.price);
        System.out.println("Publisher: " + this.publisher);
        System.out.println("Published Year: " + this.publishedYear);
    }

}

这是一个名为BOOK的Java类，它具有以下成员变量和方法：

成员变量：

• author：表示书籍的作者。
• title：表示书籍的标题。
• price：表示书籍的价格。
• publisher：表示书籍的出版商。
• publishedYear：表示书籍的出版年份。

构造函数：

• BOOK()：无参构造函数，用于创建一个空的BOOK对象。
• BOOK(String author, String title, double price, String publisher, int publishedYear)：带有参数的构造函数，用于在创建BOOK对象时初始化成员变量。

方法：

• Getter 和 Setter 方法：用于获取和设置成员变量的值。
• showDisplayBook()：用于打印书籍的详细信息，包括作者、标题、价格、出版商和出版年份。

这个类提供了一种方便的方式来表示和操作书籍对象。你可以创建一个BOOK对象，并使用构造函数设置属性值，然后使用提供的方法获取和修改属性，以及展示书籍的详细信息。

请注意，根据Java的命名约定，类名应该使用大写字母开头（例如Book而不是BOOK），这样更符合通用的编码规范。

showDisplayBook() 不是构造方法，它是一个普通的实例方法。构造方法用于初始化对象的状态，而 showDisplayBook() 方法用于展示书籍的详细信息。

构造方法在对象创建时自动调用，只会被调用一次，并且没有返回类型。在你提供的代码中，有两个构造方法：一个是无参构造方法 BOOK()，用于创建一个空的 BOOK 对象，另一个是带有参数的构造方法 BOOK(String author, String title, double price, String publisher, int publishedYear)，用于在创建 BOOK 对象时初始化成员变量。

而 showDisplayBook() 方法是一个公共的实例方法，用于打印书籍的详细信息。它没有参数，也没有返回值。你可以在创建 BOOK 对象后调用该方法，以便展示该书籍的信息。

自动调用的过程是什么样的：

当使用关键字 new 创建一个对象时，Java会执行以下步骤来自动调用构造方法：

1. 在内存中为对象分配空间，用于存储对象的成员变量和方法。
2. 确定要使用的构造方法（无参构造方法或带参构造方法）。
3. 调用所选的构造方法，将对象初始化为初始状态。
4. 返回对新创建的对象的引用。

具体过程如下：

1. 使用关键字 new 创建对象，如 Book book = new Book();。
2. Java将在内存中为对象分配空间。
3. 根据构造方法的选择，选择对应的构造方法进行调用。
   • 如果使用的是无参构造方法，会直接调用 BOOK() 构造方法进行对象初始化。
   • 如果使用的是带参构造方法，会根据提供的参数类型和数量，匹配合适的构造方法进行调用，如 new Book("Author", "Title", 10.99, "Publisher", 2021);。
4. 在构造方法内部，可以执行所需的操作，例如初始化成员变量，执行一些特定的逻辑等。
5. 构造方法执行完毕后，将返回对新创建的对象的引用。
6. 将对象的引用赋值给变量 book，这样就可以通过该变量来访问和操作该对象的成员变量和方法。

总结起来，自动调用构造方法的过程就是在对象创建时，根据选择的构造方法进行初始化，并返回对新创建对象的引用。这样就可以通过该对象来访问和操作其成员变量和方法。

Getter 方法来获取属性的值

方法会操作对象并访问他们的实例字段。

一个好的类需要:

数据私有；初始化数据；见名知意；不要让一个类承担过多的责任，可能容易忘

java在构造器中初始化数据是什么意思

在Java中，构造器是一种特殊的方法，当创建一个对象时，构造器会被自动调用。在构造器中初始化数据意味着在创建对象时，通过构造器来给对象的属性或变量赋初值。这样可以确保对象在创建时具有正确的初始状态，使得对象在后续使用中不会出现任何不可预见的错误。初始化数据的方式包括直接赋值、调用其他方法来初始化、从外部文件或数据库中读取数据等等。

举例：

假设有一个名为Person的类，包含属性name和age，现在需要在构造器中初始化这两个属性。

1. 直接赋值：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;   // 直接赋值
        this.age = age;
    }
}

在创建Person对象时，调用构造器并传入name和age，即可在构造器中为name和age属性赋初值。

2. 调用其他方法来初始化：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        setName(name);   // 调用其他方法来初始化
        setAge(age);
    }

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

    public void setAge(int age) {
        this.age = age;
    }
}

在构造器中调用setName和setAge方法来初始化属性。

3. 从外部文件或数据库中读取数据：

public class Person {
    private String name;
    private int age;

    public Person() {
        try {
            Properties prop = new Properties();
            prop.load(new FileInputStream("person.properties"));
            this.name = prop.getProperty("name");   // 从外部文件中读取数据
            this.age = Integer.parseInt(prop.getProperty("age"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在构造器中从person.properties文件中读取name和age属性的值。

方法和类的区别和关系

方法和类是面向对象编程中的两个重要概念。

类是一种抽象的概念，它代表了一类具有相似属性和行为的对象。类定义了对象的结构和行为，并且可以用来创建多个具有相同属性和行为的对象。在代码中，类通常用关键字class来定义。

方法是类中的一个成员，它定义了类的行为。方法是一段可重用的代码，用于执行特定的任务。方法可以访问类的属性，并且可以返回一个值。在代码中，方法通常定义在类的内部，并且可以通过类的实例来调用。

类和方法之间有以下关系：

一个类可以包含多个方法，这些方法定义了类的行为。
方法可以访问类的属性，以便执行特定的任务。
类的实例可以通过调用方法来执行特定的操作。
下面是一个示例代码，展示了类和方法的关系：

public class MyClass {
    private int myProperty;

    public void setMyProperty(int value) {
        myProperty = value;
    }

    public int getMyProperty() {
        return myProperty;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        myObject.setMyProperty(10);
        int value = myObject.getMyProperty();
        System.out.println(value); // 输出 10
    }
}

在上面的代码中，MyClass是一个类，它包含了两个方法setMyProperty和getMyProperty，用于设置和获取myProperty属性的值。在Main类的main方法中，我们创建了一个MyClass的实例myObject，并通过调用方法来设置和获取属性的值。

注意一点，将类和测试类写在一个文件中需要注意的：

1.> 不要类和测试类都是public的情况，要不然报错The public type Dog must be defined in its own file【根据你提供的代码和问题，问题出在你的代码中定义了两个public类，而Java规定每个源文件只能有一个public类，并且该类的名称必须与文件名相同。】

package worrk705;

public class DogTest {
    public static void main(String[] args) {
        // 创建Dog对象
        Dog d = new Dog();
        // 调用Dog对象的runs()方法
        d.runs();
    }
}

class Dog {
    // 定义一个jump()方法
    public void jump() {
        System.out.println("正在执行jump方法");
    }

    // 定义一个runs()方法，runs()方法需要借助jump()方法
    public void runs() {
        Dog d = new Dog();
        d.jump();
        System.out.println("正在执行 runs 方法");
    }
/**public void runs() {
    // 使用this引用调用runs()方法的对象
    this.jump();
    System.out.println("正在执行runs方法");
}
*/

// public void run1() { jump(); System.out.println("正在执行run方法"); }
}

实际上下面的两者，只要和文件名一样的就好

1. 如果是测试类包裹类的情况：
   就需要自己测试类{MAIN调用 ;CLASS 类}

2. 如果是类包裹测试类的情况：
   就是类{属性方法； main中调用}

这两个 Dog d = new Dog();为什么没有互相影响:

1. 这两行代码创建了两个不同的Dog对象，分别赋值给了两个不同的变量d。尽管它们具有相同的类型和名称，但它们是两个独立的实例。
2. 在DogTest类的main方法中，首先创建了一个Dog对象d，然后调用了d的run方法。在run方法内部，又创建了一个新的Dog对象d，并调用了它的jump方法。
3. 由于这两个Dog对象是独立的实例，它们之间没有直接的影响。每个对象都有自己的内存空间和状态。因此，第一个Dog对象的创建和调用run方法不会影响第二个Dog对象。
4. 

this和开创对象的对比：

代码定义了一个名为Dog的类，其中包含了三个方法：jump()、runs()和run1()。在runs()方法中，创建了一个Dog对象d，然后调用了jump()方法，并打印了一条消息。在run()方法中，使用this关键字调用了jump()方法，并打印了一条消息。在run1()方法中，直接调用了jump()方法，并打印了一条消息。

这三个方法的功能相似，都是调用jump()方法并打印一条消息。不同之处在于runs()方法中创建了一个新的Dog对象，而run()方法和run1()方法则是在当前对象上调用jump()方法。

【在runs()方法中，通过创建一个新的Dog对象来调用jump()方法。这意味着每次调用runs()方法时，都会创建一个新的Dog对象，并调用其jump()方法。这种方式可能会导致内存的浪费，因为每次都需要创建一个新的对象。

而在run()方法中，通过this关键字引用调用该方法的对象来调用jump()方法。这意味着在调用run()方法时，会使用当前对象来调用jump()方法。这种方式更加高效，因为不需要创建新的对象，而是直接使用当前对象。

因此，从性能的角度来看，run()方法更加高效，因为它避免了创建新的对象的开销。】

如果你想要比较这三个方法的不同之处，可以注意到runs()方法中创建了一个新的Dog对象，而run()方法和run1()方法则是在当前对象上调用jump()方法。此外，runs()方法和run()方法都使用了this关键字来引用当前对象。

run1()、run2()和run3()是Dog类中的三个不同方法。以下是它们在使用上的区别和相似之处的解释：我要中文的回答·

run1()、run2()和run3()是Dog类中的三个不同方法。它们在使用上有一些区别和相似之处。

首先，让我们来看一下这三个方法的定义和实现：

public void run1() {
    Dog d = new Dog();
    d.jump();
    System.out.println("正在执行run1方法" + '\n');
}

public void run2() {
    this.jump();
    System.out.println("正在执行run2方法" + '\n');
}

public void run3() {
    jump();
    System.out.println("正在执行run3方法");
}

run1()方法中，我们创建了一个新的Dog对象，并调用了jump()方法。然后，我们打印了一条消息。这个方法没有使用this关键字。

run2()方法中，我们使用this关键字来调用当前对象的jump()方法。然后，我们打印了一条消息。

run3()方法中，我们直接调用了jump()方法，而没有使用this关键字。然后，我们打印了一条消息。

现在让我们来看一下这三个方法的区别和相似之处：

相同之处：

所有三个方法都调用了jump()方法。
所有三个方法都打印了一条消息。

区别之处：

run1()方法创建了一个新的Dog对象，并调用了jump()方法。这意味着每次调用run1()方法时，都会创建一个新的对象。
run2()方法使用this关键字来调用当前对象的jump()方法。这意味着它只能在当前对象上调用jump()方法。
run3()方法直接调用了jump()方法，而没有使用this关键字。这意味着它可以在当前对象上调用jump()方法，也可以在其他对象上调用。

vscode怎么在预览模式中点击另外一个文件,不会被替换掉

首选快捷键ctrl+shift+p，在搜索框里输入settings进行搜索，看到User Setting选项，点击打开输入enablePreview搜索

---

1. 【para1】：在许多面向对象的编程语言中，包括Java，对象的创建通常涉及使用构造方法。构造方法是一种特殊类型的方法，用于初始化对象的状态并执行必要的设置。在Java中，当我们使用关键字 “new” 创建一个对象时，虚拟机会自动调用适当的构造方法来创建该对象。这是由编译器和运行时环境自动处理的过程。
   【para2】：不能手动调用构造方法的原因在于构造方法的目的是在对象创建时执行必要的初始化操作。如果我们手动调用构造方法，就相当于对一个已经存在的对象执行初始化操作，这可能导致对象状态的混乱和不一致。此外，构造方法可能包含特定于对象创建过程的逻辑，例如分配内存、设置默认值等。这些步骤由虚拟机负责处理，以确保对象的正确创建。
   【para3】：当我们在类中定义了构造方法时，虚拟机会在对象创建时自动选择合适的构造方法进行调用。根据参数的不同，可以有多个构造方法的重载形式。虚拟机根据我们提供的参数类型和数量来选择调用哪个构造方法。
   【para4】：总结起来，对象的创建由虚拟机自动处理，其中包括调用适当的构造方法来执行初始化操作。我们无需手动调用构造方法，因为这是由编译器和运行时环境自动完成的。 ↩︎