Estoy aprendiendo clases y objetos de Java (método de construcción de Java, JavaBean) en VScode, la segunda serie + cómo hacer clic en otro archivo en el modo de vista previa de VScode y no será reemplazado

News 2023-08-26 01:47:30 views: null

Página de inicio de mi blog personal: si '' realmente puede escapar 1️⃣ diga 1️⃣ página de inicio del blog
sobre el aprendizaje de gramática básica de Java ----> puede consultar mi blog: "Aprendo Java en VScode"

[1] Una clase es una colección de objetos que describen un grupo de objetos con las mismas características (atributos) y el mismo comportamiento (métodos).
[2] Las características que posee un objeto o entidad se denominan atributos de una clase cuando se expresan en una clase. Las operaciones realizadas por un objeto se denominan métodos de la clase.

Main myObj = new Main();其中两个Main¿Qué representan?

在这行代码中，`Main`出现了两次。第一个`Main`是类的名称，代表着类名。
		  而第二个`Main`是构造函数的调用，表示要创建一个对象的实例。

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

Continuación de "Aprendo Java en VScode (clases y objetos Java)"

El área de datos se expresa como:
dataFieldName: dataFieldType _ Nombre del campo de datos: tipo de campo de datos
El método de construcción se puede expresar como:
ClassName(parameterName: parameterType) _ Nombre de la clase (nombre del parámetro: tipo de parámetro)
El método se puede expresar como:
methodName(parameterName: parameterType): returnType _ Nombre del método (nombre del parámetro: tipo de parámetro): tipo de retorno

3._Método de construcción [En una clase, el método con el mismo nombre que la clase es el método de construcción. ] (constructor, constructor) -> Al crear un objeto, la máquina virtual lo llama automáticamente para inicializar las variables miembro

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

(1) Un constructor (Constructor) es un método especial en Java que se utiliza para crear un nuevo objeto e inicializar sus miembros de datos . Su nombre es el mismo que el nombre de la clase, no tiene ningún tipo de valor de retorno (incluido void) y puede tener parámetros o no.

当使用关键字“new”创建一个新对象时，就会自动调用该类的构造方法。

(2) El constructor puede realizar varias operaciones de inicialización , como establecer valores predeterminados, asignar espacio, etc. En Java, cada clase debe tener al menos un constructor. Si no se define explícitamente, el compilador de Java generará un constructor sin argumentos de forma predeterminada.

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

Nota: Un error común es colocar la palabra clave void delante del constructor.

  1. El constructor tiene el mismo nombre que la clase.
  2. Cada clase puede tener más de un constructor.
  3. Los constructores pueden tener 0, 1 o más parámetros.
  4. Los constructores no devuelven un valor.
  5. Los constructores siempre se llaman con el nuevo operador.

significado ----> esBeneficios incluidosComodidad, inicialización del estado del objeto, seguridad de tipos, flexibilidad

Es conveniente pasar parámetros directamente al crear un objeto. Recibe parámetros y los utiliza durante la inicialización del objeto para establecer el estado del objeto. De esta manera, podemos inicializar las propiedades del objeto mientras lo creamos, de modo que el objeto esté en el estado apropiado después de su creación.

El operador <1> newes un operador clave en Java para crear objetos. Asigna espacio en la memoria, inicializa un objeto y devuelve una referencia a ese objeto.

Cuando se crea un objeto utilizando newun operador, se producen los siguientes pasos:

  1. asignación de memoria: newEl operador determina el espacio de memoria requerido según el tipo de objeto y asigna suficiente espacio en la memoria del montón para almacenar las variables miembro y los métodos del objeto.

  2. .inicialización: Después de asignar memoria, Java llama al constructor apropiado para inicializar el objeto. Al llamar al constructor, puede establecer el estado inicial del objeto, asignar recursos, etc.

  3. referencia posterior: Cuando se completa la inicialización, newla expresión devuelve una referencia al objeto recién creado. A través de esta referencia, podemos acceder y manipular las variables miembro y los métodos del objeto .

Aquí hay newun código de muestra para crear objetos usando operadores:

ClassName object = new ClassName();

¿ Dónde ClassNameestá el nombre de la clase a instanciar? objectEs una referencia al objeto recién creado, que se puede utilizar para acceder a las variables miembro y a los métodos del objeto.

Cabe señalar que además de usar el constructor predeterminado sin argumentos, también podemos usar el constructor con parámetros para crear objetos. Por ejemplo:

ClassName object = new ClassName(arg1, arg2);

Esto llamará al constructor con parámetros para inicializar el objeto, pasando los parámetros apropiados.

Resumir:
El operador - newse utiliza para asignar espacio en la memoria del montón e inicializar objetos.
El newoperador - realiza tres pasos: asignación de memoria, inicialización y devolución de una referencia.
- newSe puede acceder y manipular los objetos creados a través de operadores utilizando una referencia al objeto.

< 2 > Contraste entre método constructivo y conjunto:En resumen, el método constructor se usa para inicializar el objeto cuando se crea, y el método set se usa para modificar el valor de propiedad del objeto después de que se crea.

构造方法的主要目的是确保对象在创建后具有一致的状态。
	当你创建一个新对象时，构造方法会被自动调用，将提供的参数用于初始化对象的状态。

(1) El constructor (Constructor) es un método especial para la inicialización al crear un objeto. Generalmente se llama cuando se crea una instancia de una clase para asignar memoria para el objeto recién creado e inicializar sus variables miembro .

set 方法通常被定义为公共方法，接受参数并将其值分配给对象的成员变量。
	通过调用set 方法，你可以更改对象的属性值，而不是创建一个新的对象。

(2) El método set (setter) es un método utilizado para establecer el valor de una propiedad de objeto. Suele utilizarse para modificar el estado de un objeto o asignarle un nuevo valor .

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

¿Por qué el código de clase informa un error?

inserte la descripción de la imagen aquí

principal método principal
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
    }
}
¿Dónde está mal el código de clase anterior? + mejoras:

(1) Los métodos setName y setAge deben ser métodos de instancia, no métodos estáticos. Porque sirven para establecer propiedades de instancia, no propiedades de clase. Por lo tanto, es necesario eliminar la palabra clave estática en la declaración del método.

(2) El tipo de retorno del método getName debe ser String, no char[]. Porque el atributo de nombre es una cadena, no una matriz de caracteres. Por lo tanto, el tipo de retorno en la declaración del método debe cambiarse de char[] a String.

(3) El tipo de retorno del método getAge debe ser int, no char[]. Porque la propiedad de edad es un número entero, no una matriz de caracteres. Por lo tanto, el tipo de retorno en la declaración del método debe cambiarse de char[] a 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;
    }

    // 其他方法...
}

Resultado cambiado
inserte la descripción de la imagen aquí

<3> Asigne valores a las variables miembro al crear objetos: cuando use la nueva palabra clave para crear objetos, se llamará al constructor correspondiente

Un constructor es un método especial que se llama automáticamente cuando se crea un objeto y se utiliza principalmente para inicializar las variables miembro del objeto.El proceso de creación e inicialización de objetos se puede combinar mediante el método de construcción., haciendo que el código sea más conciso y legible.

Por lo tanto, podemos considerar el método de construcción como un método de inicialización especial, que se utiliza para asignar valores iniciales a las variables miembro del objeto.
De esta manera, al crear un objeto, puede llamar directamente al constructor para inicializar las propiedades del objeto sin asignar valores manualmente a cada propiedad, lo que mejora la eficiencia y la mantenibilidad del código.

<4> ¿Por qué la asignación directa en el constructor requiere una construcción con parámetros, y aquellos sin parámetros pueden ni siquiera necesitar aquellos sin parámetros?

Si no se define ningún constructor en la clase, Java generará automáticamente un constructor predeterminado para la clase.
El constructor predeterminado no contiene ningún parámetro y el cuerpo del método está vacío.
Un constructor sin parámetros también se denomina constructor nulo porque no toma ningún parámetro.
Sólo el constructor sin argumentos generado automáticamente por el compilador se denomina constructor predeterminado.
Si escribe un constructor sin parámetros ni contenido específico, es solo un constructor vacío y no se cuenta como el constructor predeterminado.

[ 0 ] Constructor se refiere a un constructor sin argumentos que el compilador agrega automáticamente cuando:

  1. Cuando no se declara explícitamente ningún constructor en una clase, el compilador genera automáticamente un constructor predeterminado.

  2. Cuando una clase contiene otros constructores (constructores con parámetros), pero no proporciona un constructor sin parámetros, en algunos casos (como no pasar parámetros al crear una instancia de objeto), el compilador agregará automáticamente un constructor predeterminado.

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

【1】Aquellos con referencia:

(1) Cuando uno o más constructores se definen explícitamente en una clase, el compilador de Java ya no proporcionará un constructor predeterminado sin argumentos.
这意味着如果你在类中定义了至少一个构造方法，并且没有显式地定义无参构造方法,
	那么在创建该类的对象实例时，只能使用已定义的构造方法来传递必要的参数。

A través del método de construcción, puede asignar valores a las variables miembro cuando se crea el objeto y realizar algunos preparativos necesarios para garantizar que el objeto esté en un proceso de inicialización válido y utilizable después de la creación.

使用构造方法的方式可以灵活地根据需求来初始化对象，并允许在对象创建的过程中传递必要的参数。

Sin embargo, a veces es posible que necesitemos admitir la creación de instancias de objetos sin parámetros, como en algunos casos sin pasar ningún parámetro para crear objetos. En este caso, debe definir explícitamente un constructor sin argumentos para admitir la creación de instancias de objetos sin argumentos.

有参构造函数与无参构造函数相比，它接受一个或多个参数，并用这些参数来初始化类的对象。
	不论有无显式定义的构造方法，编译器会自动提供一个默认的无参构造方法。
根据实际需求，选择合适的构造方法来创建对象，并通过显式定义构造方法来满足特定的需求。
(2) La definición de un constructor parametrizado es la siguiente:
public class ClassName {
    
    
    // 有参构造函数
    public ClassName(参数类型 参数1, 参数类型 参数2, ...) {
    
    
        // 初始化代码
    }
}

Entre ellos, el tipo de parámetro y el nombre del parámetro se definen según las necesidades, y se pueden pasar parámetros de diferentes tipos y cantidades según las necesidades específicas.

Cuando utilizamos un constructor parametrizado, podemos realizar diferentes operaciones de inicialización según los diferentes parámetros necesarios para la creación del objeto. Esto nos permite personalizar el proceso de creación de objetos y garantizar que los objetos se inicialicen correctamente.

Cuando se define un constructor parametrizado, si también queremos utilizar un constructor sin parámetros para crear un objeto, entonces debemos definir explícitamente un constructor sin parámetros en la clase al mismo tiempo. De lo contrario, los objetos sólo se pueden crear utilizando constructores con parámetros.

Tenga en cuenta lo siguiente:
  • Una clase puede definir varios constructores al mismo tiempo, incluidos constructores sin argumentos y constructores con argumentos.
  • Dentro del constructor, puedes usar los parámetros pasados ​​para inicializar las propiedades del objeto.
  • El constructor no tiene tipo de retorno, incluido el tipo void, y no es necesario escribirlo.
  • Cuando se utiliza un constructor específico para crear un objeto, se deben proporcionar los parámetros correspondientes de acuerdo con el tipo de parámetro y el número del constructor.
    inserte la descripción de la imagen aquí

【2】Sin parámetros:

Un constructor sin argumentos en Java es un constructor especial que no tiene ningún parámetro. Se utiliza para crear un objeto de una clase y realizar algunas operaciones de inicialización. Cuando no definimos explícitamente ningún constructor en una clase, Java proporcionará automáticamente un constructor predeterminado sin argumentos.

El constructor sin argumentos se define de la siguiente manera:
public class ClassName {
    
    
    // 无参构造函数
    public ClassName() {
    
    
        // 初始化代码
    }
}
Precauciones:
  • El constructor sin argumentos tiene el mismo nombre que el nombre de la clase.
  • El constructor sin argumentos no tiene ningún tipo de retorno, incluido el tipo void, y no es necesario escribirlo.
  • Si un constructor con parámetros (constructor de parámetros) se define explícitamente en la clase, pero no se define ningún constructor sin parámetros, entonces el compilador no proporcionará automáticamente un constructor sin parámetros.
  • Cada clase puede tener varios constructores, incluidos constructores sin argumentos y constructores con parámetros.inserte la descripción de la imagen aquí

(1) Explicación:

构造方法是用来初始化对象的特殊方法。具体使用取决于需求。

En el código, se crea un objeto de la clase Estudiante y se utiliza el constructor predeterminado para inicializar el objeto.
Se crea un nuevo objeto Estudiante y el objeto se inicializa utilizando el constructor parametrizado.

在默认的构造方法中，对象的属性会被初始化为默认值。
  有参构造方法中，可以通过传入参数来指定对象的属性值。

En el código, se utiliza el método de construcción sin argumentos para crear el objeto y luego los valores de propiedad del objeto se establecen llamando a los métodos setName y setAge del objeto.

Si desea especificar los valores de propiedad del objeto al crear el objeto, puede utilizar el método de construcción parametrizado.
Un método de construcción parametrizado puede aceptar parámetros y asignar los valores de los parámetros a las propiedades del objeto.
Mientras crea el objeto, inicialice los valores de propiedad con los valores que desee.

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

(2) El constructor sin argumentos de Java no se utiliza para modificar el valor predeterminado, sino para realizar algunas operaciones específicas o inicializar variables de instancia al crear un objeto.

无参构造方法是指没有参数的构造方法，它不接受任何输入参数，因此无法通过参数传递值来修改默认值。
[ 0 ] Se utiliza principalmente en las siguientes situaciones:

  1. Se deben realizar operaciones específicas al crear un objeto: el constructor sin argumentos puede realizar algunas operaciones necesarias cuando se crea el objeto, como abrir un archivo, establecer una conexión a la base de datos, etc.

  2. Inicializar variables de instancia: el constructor sin argumentos puede establecer el valor inicial de la variable de instancia, pero esto no es para modificar el valor predeterminado, sino para asignar un valor inicial a la variable de instancia.

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] Esta palabra clave se utiliza en Java para referirse al objeto actual. En este código, la palabra clave this se utiliza en dos lugares diferentes. -------->Al usar la palabra clave this para llamar al constructor parametrizado y pasar los valores de los parámetros predeterminados, el constructor sin parámetros puede usar estos valores de los parámetros para inicializar las propiedades del objeto.

[1] El constructor sin argumentos public BOOK()llama internamente al constructor argumento-argumento public BOOK(String author1, String title, double price, String publisher, int i).Un constructor sin parámetros puede usar estos valores de parámetros para inicializar las propiedades de un objeto llamando al constructor parametrizado con la palabra clave this y pasando valores de parámetros predeterminados.

[2] En el constructor parametrizado public BOOK(String author1, String title, double price, String publisher, int i), esto se usa para hacer referencia a las propiedades del objeto actual. Esto es para distinguir entre los parámetros del constructor y las propiedades del objeto. Al utilizar la palabra clave this, los valores de los parámetros pasados ​​al constructor se pueden asignar a las propiedades del objeto.
inserte la descripción de la imagen aquí

Entonces, cuando crea un objeto BOOK, si no se proporcionan argumentos, se llamará al constructor sin argumentos e inicializará las propiedades del objeto con los valores de argumento predeterminados.

[2] modificado, después del valor predeterminado:

inserte la descripción de la imagen aquí

[1] Formato básico: en una clase, el método con el mismo nombre que la clase es el método de construcción.

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

Características: El método de construcción no se puede modificar mediante estático, final, sincronizado, abstracto y nativo (similar a abstracto). No utilice return en el constructor para devolver el objeto de la clase actual, porque el valor de retorno del constructor está implícito.

El método de construcción es un tipo especial de método, que es el mismo que el nombre de la clase y tiene el mismo caso . No tiene ningún tipo de valor de retorno, ni siquiera nulo, y no tiene un valor de retorno específico (los datos del resultado no pueden ser devueltos por el declaración de devolución).

构造方法的作用是在创建对象时自动执行，用于初始化对象的属性和成员变量，
	为对象设置默认值，以确保对象在创建时具有正确的状态和属性。

El método de construcción tiene las siguientes características:

  1. El nombre del método debe ser el mismo que el nombre de la clase y no tiene tipo de retorno.
  2. El constructor se llama automáticamente cuando se crea el objeto y no se puede llamar manualmente.
  3. Puede haber varias versiones sobrecargadas y se seleccionan diferentes métodos de construcción según los parámetros pasados.
  4. El método de construcción se puede utilizar para inicializar variables miembro y otras propiedades del objeto, y también puede establecer valores predeterminados para garantizar que el estado inicial de las propiedades sea correcto cuando se crea el objeto.
  5. El constructor puede acceder a las propiedades y métodos privados de la clase, pero no puede acceder a variables de clase no estáticas ni a métodos no estáticos.
  6. Una vez creado el objeto, el constructor devuelve una referencia al objeto a la persona que llama.

En resumen, un constructor es un tipo especial de método que se utiliza para crear e inicializar un objeto. Su función principal es ejecutar automáticamente cuando se crea el objeto, completar la inicialización del objeto y garantizar que el objeto tenga el estado y las propiedades correctos.

Cómo funciona: (1) Llamado por la máquina virtual, el constructor no se puede llamar manualmente. (2) Cada vez que se crea un objeto, se llamará al constructor una vez

Un constructor es un tipo especial de método que inicializa el estado de un objeto y realiza la configuración necesaria. En Java, cuando usamos una palabra clave newpara crear un objeto, la máquina virtual llama automáticamente al constructor apropiado para crear el objeto 1 . Este es un proceso que el compilador y el entorno de ejecución manejan automáticamente.

profundizar la comprensión

Los constructores se llaman cuando se crea una instancia de un objeto. Es decir, cuando usamos la palabra clave "nuevo" para crear un objeto, Java llamará automáticamente al constructor del objeto. En el método de construcción, podemos realizar algunas operaciones de inicialización, como establecer el estado inicial del objeto, asignar espacio de memoria, etc. Por lo tanto, el momento de ejecución del método de construcción puede considerarse como el momento en que se crea el objeto.

[2] Construcción argumental y construcción no argumental.

Entre ellos, el nombre de la clase es el mismo que el nombre del método de construcción, no hay ningún tipo de valor de retorno y el cuerpo del método de construcción puede estar vacío. La lista de parámetros formal puede contener varios parámetros, separados por comas.

(1) Cuando se trata de métodos de construcción, la diferencia entre explícito e implícito radica principalmente en la definición y el método de llamada del método de construcción.

1. Constructor explícito:

Los constructores explícitos son constructores que el desarrollador define explícitamente en una clase. Puede definir constructores con diferentes parámetros según sea necesario y escribir una lógica de inicialización específica en ellos.

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

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

En el ejemplo anterior, definimos explícitamente dos constructores: un constructor parametrizado y un constructor sin parámetros. El constructor parametrizado se usa para pasar el nombre y la edad para la inicialización, mientras que el constructor sin parámetros se puede usar para la inicialización predeterminada.

2. Constructor implícito:

El constructor implícito es el constructor predeterminado generado automáticamente por el sistema. Cuando no define explícitamente un constructor, el sistema proporcionará un constructor predeterminado sin argumentos. Por lo general, realiza una inicialización predeterminada simple. Aquí hay un código de muestra:

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

    // 默认的隐式构造方法

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

Como no definimos explícitamente un constructor, el sistema proporcionará un constructor predeterminado sin argumentos. Este constructor predeterminado inicializará el nombre y la edad de forma predeterminada, como inicializar el nombre en nulo y la edad en 0.

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

Llame al constructor predeterminado sin argumentos Person person = new Person();

3. Cuando se utilizan estos constructores para crear objetos, las diferencias son las siguientes:

La diferencia entre explícito e implícito es si la definición del constructor se escribe manualmente, no cómo se llama al constructor.

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

A través del método de construcción explícito, puede inicializar según sus propias necesidades, y a través del método de construcción implícito, el sistema proporcionará un método de inicialización predeterminado.

(2) La construcción sin argumentos es un método en una clase que no tiene parámetros. Un constructor que no toma parámetros y se llama cuando se crea un objeto.

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

public student() {
    
    
	空参构造
}

1. ¿Por qué la máquina virtual nos agrega un método de construcción de parámetros vacíos si nosotros mismos no hemos escrito ningún método de construcción?

En Java, si no escribimos explícitamente un constructor para la clase, la máquina virtual Java nos proporciona un constructor de parámetros vacío predeterminado. Esto se debe a que cada clase necesita un constructor, que se utiliza para crear objetos de esa clase.

Un constructor es un método especial utilizado para inicializar un objeto, tiene el mismo nombre que la clase y no tiene tipo de retorno. Cuando creamos una instancia de una clase, se llama automáticamente al constructor para inicializar el estado del objeto.

Si no definimos ningún constructor, el compilador de Java generará automáticamente un constructor de parámetros vacío predeterminado para nosotros. Este constructor predeterminado no toma parámetros y no hace más que simplemente crear una instancia de objeto.

El propósito de proporcionar un constructor de argumentos nulos predeterminado es garantizar que no se produzcan errores al crear objetos. Si no hay un constructor predeterminado, cuando usamos un constructor sin parámetros para crear un objeto, el compilador no podrá encontrar un constructor adecuado, lo que provocará un error de compilación.

En resumen, la máquina virtual Java nos proporciona un método de construcción de parámetros vacíos predeterminado para garantizar que el proceso de creación de instancias de la clase se desarrolle normalmente, incluso si no definimos explícitamente el método de construcción.

2.==Por resolver: Cómo conocer los atributos en el parámetro vacío, cómo llamarlo==

(3) Una construcción parametrizada es un método de una clase que contiene al menos un parámetro. Puede pasar parámetros al crear un objeto y crear diferentes objetos en función de diferentes parámetros.

Este método de construcción se puede utilizar para inicializar variables de instancia del objeto y puede aceptar parámetros pasados ​​externamente. Los parámetros de una construcción parametrizada se suelen utilizar para establecer el estado del objeto.

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

[3] Precauciones

  1. El constructor debe tener el mismo nombre que la clase y no tener ningún tipo de retorno.
  2. Los constructores pueden tener modificadores de acceso, pero ningún tipo de retorno.
  3. Si no se define ningún método de construcción, el compilador de Java generará automáticamente un método de construcción sin argumentos predeterminado, pero si usted mismo define un método de construcción sin argumentos, deberá escribir un método de construcción sin argumentos usted mismo.
  4. Si usted mismo define un método de construcción parametrizado, debe definir explícitamente un método de construcción sin argumentos; de lo contrario, no podrá utilizar el método de construcción sin argumentos de esta clase.
  5. El constructor puede estar sobrecargado, es decir, la misma clase puede tener múltiples constructores con el mismo nombre pero con diferentes parámetros.
  6. En el método de construcción, se pueden llamar otros métodos de construcción, usando la palabra clave this (debe ser la declaración de la primera línea).
  7. No puede definir variables estáticas o métodos estáticos en el constructor porque pertenecen a la clase y el constructor pertenece al objeto.
  8. Los constructores se pueden utilizar para inicializar variables de instancia o realizar otras operaciones, como abrir archivos.
  9. Los constructores no se pueden heredar, pero las subclases pueden usar constructores de clases principales.
  10. El constructor debe llamarse cuando se crea el objeto y no puede llamarse manualmente.

otros aspectos:

(1) Definición del método de construcción
Si no se define ningún método de construcción, el sistema proporcionará un método de construcción predeterminado sin parámetros.
Si se define un método de construcción, el sistema ya no proporcionará un método de construcción predeterminado.
Una vez que se define un constructor de parámetros, no construcción de parámetros El constructor desapareció, por lo que necesita escribir su propio constructor sin parámetros
(2) El constructor sobrecargado con parámetros
y el constructor sin parámetros tienen el mismo nombre de método pero diferentes parámetros. Esto se llama constructor Sobrecarga
(3) Cómo utilizar: Escriba manualmente el parámetro vacío y el método de construcción con todos los parámetros en cualquier momento.
Independientemente de si se usa o no, escriba manualmente el método de construcción sin parámetros y el método de construcción con todos los parámetros.
Cuando se define cualquier clase, viene con un constructor sin parámetros de forma predeterminada, ya sea que esté escrito o no.

[4] Sobrecarga de métodos: clases y objetos Java

La sobrecarga de métodos significa que en la misma clase se pueden definir varios métodos con el mismo nombre de método pero con diferentes listas de parámetros. Estos métodos se distinguen por diferentes tipos de parámetros, número de parámetros u orden de los parámetros. Al llamar a este método, el compilador determinará el método específico que se ejecutará de acuerdo con el tipo de parámetro pasado. Esto mejora la reutilización y legibilidad del código.

La sobrecarga de métodos debe cumplir las siguientes condiciones:

  • Los nombres de los métodos deben ser los mismos.
  • Las listas de parámetros deben ser diferentes, que pueden ser diferentes combinaciones de tipos de parámetros, diferentes números de parámetros o diferentes órdenes de parámetros.
  • Los tipos de devolución pueden ser iguales o diferentes.

A continuación se muestra un ejemplo que muestra el concepto de sobrecarga de métodos:

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;
    }
}

En el ejemplo anterior, Calculatorla clase define tres addmétodos nombrados con diferentes listas de parámetros. El primer método recibe dos parámetros enteros y devuelve su suma; el segundo método recibe dos parámetros de punto flotante de doble precisión y devuelve su suma; el tercer método recibe tres parámetros enteros y devuelve su suma. De esta forma, al utilizar Calculatorla clase, puedes elegir el addmétodo adecuado según las diferentes necesidades.

Con todo, la sobrecarga de métodos nos permite usar el mismo nombre de método para manejar diferentes tipos y números de parámetros, lo que proporciona un diseño de código y métodos de llamada más flexibles.

Resumir

En Java, cada clase tiene un constructor predeterminado sin argumentos, si no se define explícitamente ningún constructor. Por supuesto, también puedes crear uno o más constructores parametrizados para inicializar objetos. Cuando creas un nuevo objeto, lo inicializas usando el constructor definido. Si no proporciona ningún constructor, Java proporcionará automáticamente un constructor sin argumentos para inicializar las variables de instancia del objeto.

4._.clase JavaBean

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

La clase JavaBean es una clase especial en el lenguaje Java, generalmente utilizada para representar algún tipo de objeto de entidad. Una clase JavaBean generalmente consta de un conjunto de propiedades (properties) y métodos de acceso (getters y setters) para estas propiedades, y también puede contener constructores, métodos, controladores de eventos y más. La clase JavaBean se utiliza generalmente para encapsular, transmitir y almacenar datos. Dichas clases deben seguir un contrato específico, incluido el uso de constructores públicos, proporcionar métodos de establecimiento y obtención públicos, etc. La clase JavaBean es un componente común en los programas Java y se puede utilizar para crear aplicaciones GUI complejas, aplicaciones web y otros tipos de aplicaciones Java.

[1] especificación

Bien, este es un ejemplo de una clase que cumple con la especificación JavaBean:
1. Nombre de clase: CamelCase
2. Las variables miembro se modifican con privado
3. Se proporcionan al menos dos métodos de construcción: método de construcción sin parámetros + método de construcción con todos los parámetros
4. Método de miembro: proporciona setXxx()/getXxx() correspondiente a cada variable miembro

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.");
    }
}

Entre ellos, la variable miembro se modifica con privado y se proporciona el método de construcción 一个无参构造方法和一个带全部参数; cada variable miembro proporciona el setXxx()/getXxx()método correspondiente. Además, se proporcionan dos comportamientos: estudiar() y dormir().

tecla de acceso directo, acceso directo

(1) Editor común de Java: alt + insertar
(2) Vscode: haga clic derecho - vaya al lugar que se muestra en la imagen 2inserte la descripción de la imagen aquí

[2] La clase JavaBean normalmente contiene los siguientes métodos:

1. Constructor:

Una clase JavaBean debe proporcionar un constructor sin parámetros para que newse pueda crear una instancia de la clase usando la palabra clave. Además del constructor sin parámetros, se pueden proporcionar otros constructores sobrecargados para admitir diferentes métodos de inicialización.

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

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

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

La clase Persona proporciona un constructor sin parámetros y un constructor parametrizado. El constructor sin parámetros se puede utilizar para crear el objeto Persona predeterminado, mientras que el constructor parametrizado puede establecer tanto el nombre como la edad al crear el objeto.

2. Métodos de acceso a la propiedad (Getter y Setter):

Las clases JavaBean generalmente proporcionan métodos de acceso público correspondientes para cada propiedad privada, es decir, métodos getter y setter. El método getter se utiliza para obtener el valor de la propiedad y el método setter se utiliza para establecer el valor de la propiedad.

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;
    }
    
    // 其他方法和属性...
}

En el ejemplo anterior, la clase Persona proporciona los métodos getName() y setName() para obtener y establecer el nombre, y los métodos getAge() y setAge() para obtener y establecer la edad.

3. equals()Y hashCode()método:

Las clases de JavaBean generalmente anulan los métodos equals()y hashCode()para operar adecuadamente al comparar objetos. Esto permite realizar comparaciones y hashes en función del contenido del objeto en lugar de la dirección de referencia.

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);
    }
    
    // 其他方法...
}

En el ejemplo anterior, el método equals() compara nombres y edades para determinar si los objetos son iguales y utiliza el método Objects.equals() para manejar propiedades que pueden ser nulas. El método hashCode() utiliza el método Objects.hash() para calcular el valor hash de un objeto, incluido el nombre y la edad.

4. toString()Método:

Las clases JavaBean normalmente anulan toString()los métodos para devolver la representación del contenido del objeto como una cadena. Esto es muy útil al depurar y registrar.

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

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

En el ejemplo anterior, el método toString() devuelve una representación de cadena que contiene el nombre y la edad, lo cual es conveniente para depurar y registrar.

5. clone()Método:

La clase JavaBean puede implementar Cloneablela interfaz y reescribir clone()el método para admitir la operación de clonación del objeto. Esto hace posible crear nuevos objetos duplicando los existentes.

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

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

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

En el ejemplo anterior, la clase Person implementa la interfaz Cloneable y anula el método clone(). Cree una copia superficial del objeto llamando a super.clone().

[3] Destrucción de objetos Java

La destrucción de objetos en Java la maneja automáticamente Garbage Collector. El recolector de basura es responsable de detectar y limpiar los objetos a los que ya no se hace referencia y liberar la memoria que ocupan.

Un objeto se marca como reciclable cuando ya no se hace referencia a él, es decir, cuando no hay referencias variables que apunten a él. Cuando se ejecuta el recolector de basura, escanea los objetos en la memoria del montón y recupera los objetos sin referencia.

El proceso de trabajo del recolector de basura es el siguiente:

  1. Fase de marcado: el recolector de basura comienza desde el objeto raíz (como variables estáticas, subprocesos activos, etc.), atraviesa recursivamente todas las cadenas de referencia y marca todos los objetos a los que aún se hace referencia como objetos activos.
  2. Fase de limpieza: el recolector de basura limpia y recupera aquellos objetos que no están marcados como objetos vivos. Se liberará la memoria ocupada por los objetos recuperados.
  3. Fase de organización: después de la fase de limpieza, el recolector de basura puede organizar la memoria del montón para eliminar la fragmentación de la memoria y hacer más eficiente la asignación de espacio de memoria continua.

La destrucción de objetos la gestiona automáticamente el recolector de basura; no podemos destruir un objeto manualmente. System.gc()Sin embargo , se puede recomendar al recolector de basura que realice operaciones de recolección de basura llamando al método, pero no se puede garantizar que se realice de inmediato.

Cabe señalar que la destrucción de objetos solo implica la liberación de espacio en la memoria, no otras operaciones de limpieza (como cerrar archivos o conexiones de red, etc.). Para la liberación de estos recursos, debemos usar el código apropiado para manejarlos manualmente, como finallycerrar operaciones en bloques.

Resumir:

  • La destrucción de objetos en Java la maneja automáticamente el recolector de basura.
  • La destrucción de objetos ocurre cuando ya no se hace referencia a un objeto y el recolector de basura lo marca como reciclable.
  • El recolector de basura realiza operaciones de recolección de basura a través de las fases de marcar, barrer y ordenar.
  • No podemos destruir manualmente un objeto, pero podemos afectar indirectamente el momento de la destrucción del objeto sugiriendo que el recolector de basura realice la recolección de basura.

En Java, las situaciones en las que un objeto se recolecta como basura se pueden dividir en las siguientes categorías:

  1. Ya no se hace referencia a los objetos: cuando un objeto no tiene referencias variables que apunten a él, es decir, no hay referencias raíz al objeto, se convierte en basura. Esto incluye todas las referencias al objeto que se establece como nulo o que sale del alcance y ya no es accesible.

  2. Cadena de referencia rota: si un objeto tiene una referencia circular y esta referencia circular no tiene una cadena de referencia conectada a otros objetos, entonces la combinación de objetos formada por estas referencias circulares se convertirá en basura. Porque no son accesibles a través de ninguna referencia existente.

  3. Anulación explícita: al establecer la referencia de un objeto en nula, puede indicar explícitamente que el objeto ya no es necesario. Cuando esto sucede, el recolector de basura recupera el objeto a su debido tiempo.

  4. Enforce System.gc(): el System.gc()método de llamada puede recomendar al recolector de basura que realice operaciones de recolección de basura. Sin embargo, no garantiza que todos los objetos basura se recopilen inmediatamente y exigir la recolección de basura no es una buena práctica.

Cabe señalar que la recolección de basura la maneja automáticamente el recolector de basura y no podemos destruir un objeto manualmente. El recolector de basura verifica y elimina periódicamente los objetos basura a los que ya no se hace referencia.

En la programación real, debemos evitar la creación de objetos inútiles y liberar recursos a tiempo para ayudar al recolector de basura a reciclar objetos basura de manera más eficiente.

otro

inserte la descripción de la imagen aquí

¿Qué es @Override y por qué se genera?

@OverrideEs una anotación (Anotación), que se utiliza para indicar que el método debe anular (reescribir) el método en la clase principal o implementar la interfaz. Es un mecanismo de metadatos proporcionado por el lenguaje Java para proporcionar información adicional para compiladores y herramientas de desarrollo.

El motivo para generar @Overrideanotaciones es mejorar la legibilidad y el mantenimiento del código. Cuando escribimos un método en una subclase con la intención de anular el método de la clase principal o implementar la interfaz, al agregar anotaciones, podemos @Overridedecirle claramente al compilador y a otros desarrolladores que pretendemos anular el método en la clase o interfaz principal. , En lugar de crear accidentalmente un nuevo método.

Si usamos anotaciones por error @Override, pero en realidad no anulamos los métodos en la clase o interfaz principal, el compilador informará un error y nos recordará que debemos verificar la lógica del código.

En resumen, @Overridela anotación es un tipo de metadatos que se utiliza para identificar la cobertura del método (anulación), lo que nos ayuda a detectar errores en el momento de la compilación y proporciona una mejor legibilidad del código.

estudiar

1.>
Método de acceso de grupo (captador) (método lector/método captador): el método utilizado para obtener el valor de propiedad del objeto.
acción: Una operación o función que un objeto puede realizar.
atributo: Una característica o dato de un objeto.
Comportamiento (comportamiento): La función y el modo de operación del objeto.
constructor (método de construcción): el método para crear e inicializar un objeto, que se llama cuando se crea una instancia del objeto.
campo de fecha (campo de datos): un atributo utilizado para almacenar información de fecha u hora.
encapsulación de campos de datos (encapsulación de campos de datos): encapsula campos de datos y operaciones dentro de objetos, ocultando detalles de implementación.
constructor predeterminado (método de construcción predeterminado): un método de construcción que no requiere parámetros. Si no se define explícitamente ningún método de construcción, se proporcionará de forma predeterminada.
operador de punto (operador de punto): un operador utilizado para acceder a las propiedades y métodos de un objeto, como object.property.
instancia (instancia): un objeto concreto de la clase.
variable de instancia: un atributo o variable que existe en una instancia de una clase.

2.>
Creación de instancias de grupo (instanciación): el proceso de crear una instancia de una clase.
método mutador (setter) (método setter/método modificador): método utilizado para modificar el valor de una propiedad de objeto.
constructor sin argumentos (constructor sin parámetros): un constructor sin parámetros.
Programación orientada a objetos (OOP): un paradigma de programación que organiza programas como colecciones de objetos para permitir la encapsulación, la herencia y el polimorfismo.
Lenguaje de modelado unificado (UML): un lenguaje gráfico estándar para visualizar, formalizar y escribir diseños de software.
paquete privado (acceso al paquete) (paquete privado/acceso al paquete): restringe el acceso solo a clases en el mismo paquete.
privado (privado): modificador de acceso, restringiendo el acceso solo dentro de la misma clase.
propiedad (característica): una característica de un objeto, generalmente a la que se accede a través de métodos getter y setter.
Variable de referencia: variable que almacena una referencia a un objeto.
tipo de referencia: especifica el tipo de objeto al que puede hacer referencia la variable.
estado (estado): la colección de valores de atributos de un objeto, que determina el comportamiento y las características del objeto.
Método estático: un método que pertenece a una clase en lugar de a una instancia y puede ser llamado directamente por el nombre de la clase.
Variable estática: una variable que pertenece a una clase en lugar de a una instancia.

Resumir

· Una clase es una plantilla para un objeto. Define las propiedades de un objeto y proporciona constructores para crear objetos y métodos para manipular objetos.
Una clase también es un tipo de datos. Se puede utilizar para declarar variables de referencia de objetos. Una variable de referencia de objeto parece contener un objeto, pero en realidad contiene sólo una referencia a ese objeto. Estrictamente hablando, las variables de referencia de objetos y los objetos son diferentes, pero la mayoría de las veces la diferencia es insignificante.
· Los objetos son instancias de clases. Puede usar el nuevo operador para crear un objeto y usar el operador de punto (.) para acceder a los miembros del objeto a través de la variable de referencia del objeto.
· Una variable o método de instancia pertenece a una instancia de una clase. Su uso está asociado a la instancia respectiva. Las variables estáticas son compartidas por todas las instancias de la misma clase. Se pueden llamar métodos estáticos sin utilizar una instancia.
`Cada instancia de una clase puede acceder a las variables estáticas y a los métodos estáticos de esta clase. Sin embargo, para mayor claridad, es mejor utilizar "classname.variable" y "classname.method" para llamar a variables estáticas y métodos estáticos.

· Los modificadores especifican cómo se accede a las clases, métodos y datos. Cualquier cliente puede acceder a clases, métodos o datos públicos (públicos), solo se puede acceder a métodos o datos privados (privados) dentro de la clase. Se puede proporcionar un método get o un método set para que el cliente pueda ver o modificar los datos. En términos sencillos, el método get se denomina lector (o descriptor de acceso) y el método set se denomina definidor (o modificador).
El método get tiene la firma pública returnType getPropertyName(). Si el tipo de retorno (returnType) es booleano, el método get debe definirse como booleano público isPropertyName(). El método set tiene la firma public void setPropertyName(dataType propertyValue).
Todos los parámetros pasados ​​al método se pasan por valor. Para parámetros de tipos primitivos, se pasa el valor real, mientras que si el parámetro es un tipo de datos de referencia, se pasa una referencia al objeto.
Una matriz Java es un objeto que contiene valores de tipos primitivos o tipos de objetos. Cuando se crea una matriz de objetos, a sus elementos se les asigna el valor predeterminado de nulo.

¿Por qué el nombre del constructor es el mismo que el nombre de la clase?

El nombre del constructor es el mismo que el nombre de la clase es una de las convenciones y regulaciones del lenguaje Java. Esta elección de diseño permite llamar automáticamente a los constructores cuando se crean los objetos.

Cuando se utiliza newla palabra clave para crear una instancia de una clase, el compilador busca un constructor que coincida con el nombre de la clase y lo llama automáticamente para inicializar el objeto. Por lo tanto, el nombre del constructor es el mismo que el nombre de la clase, lo que permite identificar y asociar cómodamente el constructor con la clase a la que pertenece.

Además, tener el mismo nombre de constructor que el nombre de la clase también ayuda a mejorar la legibilidad y comprensibilidad del código. Al usar el mismo nombre, el programador puede saber intuitivamente qué método utiliza el constructor para crear el objeto.

Tenga en cuenta que aunque los constructores tienen el mismo nombre que la clase, sus firmas (tipos de parámetros y orden) deben ser únicas. Por lo tanto, si se definen varios constructores en la misma clase, deben tener listas de parámetros diferentes para que puedan distinguirse según los parámetros pasados. Este es el concepto de sobrecarga de métodos en Java, que distingue métodos o constructores con el mismo nombre a través de diferentes listas de parámetros.

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);
    }
}

El constructor se llama automáticamente cuando se crea el objeto, solo se llamará una vez y no tiene tipo de retorno.

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);
    }
}

Aquí hay una BOOKclase Java llamada , que tiene las siguientes variables miembro y métodos:

Variables miembro:

  • author: Indica el autor del libro.
  • title: Indica el título del libro.
  • price: Indica el precio del libro.
  • publisher: Indica la editorial del libro.
  • publishedYear: Indica el año de publicación del libro.

Constructor:

  • BOOK(): Constructor sin argumentos, utilizado para crear un BOOKobjeto vacío.
  • BOOK(String author, String title, double price, String publisher, int publishedYear): Constructor con parámetros para BOOKinicializar variables miembro al crear un objeto.

método:

  • Métodos Getter y Setter: se utilizan para obtener y establecer el valor de las variables miembro.
  • showDisplayBook(): Se utiliza para imprimir detalles del libro, incluido el autor, el título, el precio, la editorial y el año de publicación.

Esta clase proporciona una manera conveniente de representar y manipular objetos de libros. Puede crear un BOOKobjeto y usar el constructor para establecer valores de propiedad y luego usar los métodos proporcionados para obtener y modificar propiedades y mostrar detalles del libro.

Tenga en cuenta que, de acuerdo con las convenciones de nomenclatura de Java, los nombres de las clases deben comenzar con letras mayúsculas (como Bookno BOOK), lo que está más en línea con los estándares de codificación comunes.

showDisplayBook() no es un constructor, es un método de instancia ordinario. El constructor se utiliza para inicializar el estado del objeto y el método showDisplayBook() se utiliza para mostrar los detalles del libro.

El constructor se llama automáticamente cuando se crea el objeto, solo se llamará una vez y no tiene tipo de retorno. En el código que proporcionó, hay dos métodos de construcción: uno es el método de construcción sin argumentos BOOK(), que se utiliza para crear un objeto BOOK vacío, y el otro es el método de construcción BOOK(String Author, String Title, Double precio, editor de cadena, int año publicado), utilizado para inicializar variables miembro al crear un objeto LIBRO.

Y el método showDisplayBook() es un método de instancia pública para imprimir la información detallada del libro. No tiene parámetros ni valor de retorno. Puede llamar a este método después de crear un objeto BOOK para mostrar información sobre el libro.

Cómo se ve el proceso de invocación automática:

Al usar palabras clave newpara crear un objeto, Java realizará los siguientes pasos para llamar automáticamente al constructor:

  1. Asigne espacio para que el objeto en la memoria almacene las variables miembro y los métodos del objeto.
  2. Determina qué constructor utilizar (constructor sin argumentos o parametrizado).
  3. Llame al constructor elegido para inicializar el objeto a su estado inicial.
  4. Devuelve una referencia al objeto recién creado.

El proceso específico es el siguiente:

  1. Los objetos se crean utilizando palabras clave newcomo Book book = new Book();.
  2. Java asignará espacio en la memoria para el objeto.
  3. Según la selección del método de construcción, seleccione el método de construcción correspondiente a llamar.
    • Si se utiliza el constructor sin argumentos, BOOK()se llamará directamente al constructor para inicializar el objeto.
    • Si utiliza un método de construcción con parámetros, coincidirá con el método de construcción apropiado para llamar según el tipo y la cantidad de los parámetros proporcionados, como new Book("Author", "Title", 10.99, "Publisher", 2021);.
  4. Dentro del constructor, puede realizar las operaciones necesarias, como inicializar variables miembro, ejecutar alguna lógica específica, etc.
  5. Una vez que el constructor termina de ejecutarse, devuelve una referencia al objeto recién creado.
  6. Asigne la referencia del objeto a la variable book, de modo que se pueda acceder y manipular las variables miembro y los métodos del objeto a través de la variable.

En resumen, el proceso de llamar automáticamente al constructor es inicializarlo de acuerdo con el constructor seleccionado cuando se crea el objeto y devolver una referencia al objeto recién creado. De esta manera, se puede acceder y manipular sus variables miembro y métodos a través del objeto.

Método getter para obtener el valor de la propiedad.
方法会操作对象并访问他们的实例字段。

Una buena clase necesita:

Datos privados; inicializar datos; conocer el nombre; no permita que una clase asuma demasiada responsabilidad, puede ser fácil de olvidar

¿Qué significa inicializar datos en un constructor en java?

En Java, un constructor es un método especial que se llama automáticamente cuando se crea un objeto. Inicializar datos en el constructor significa asignar valores iniciales a las propiedades o variables del objeto a través del constructor cuando se crea el objeto. Esto asegura que el objeto tenga el estado inicial correcto cuando se crea, de modo que no habrá errores imprevistos en el uso posterior del objeto. Las formas de inicializar datos incluyen asignación directa, llamar a otros métodos para inicializar, leer datos de archivos o bases de datos externos, etc.

Ejemplo:

Supongamos que hay una clase llamada Persona, que contiene los atributos nombre y edad, y ahora estos dos atributos deben inicializarse en el constructor.

  1. Asignación directa:
public class Person {
    
    
    private String name;
    private int age;

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

Al crear un objeto Persona, llame al constructor y pase nombre y edad para asignar valores iniciales a las propiedades de nombre y edad en el constructor.

  1. Llame a otros métodos para inicializar:
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;
    }
}

Llame a los métodos setName y setAge en el constructor para inicializar las propiedades.

  1. Leer datos de un archivo o base de datos externo:
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();
        }
    }
}

Lea los valores de las propiedades de nombre y edad del archivo person.properties en el constructor.

La diferencia y relación entre métodos y clases.

Los métodos y las clases son dos conceptos importantes en la programación orientada a objetos.

Una clase es un concepto abstracto que representa una clase de objetos con atributos y comportamientos similares. Una clase define la estructura y el comportamiento de un objeto y se puede utilizar para crear varios objetos con las mismas propiedades y comportamiento. En el código, las clases normalmente se definen con la palabra clave class.

Un método es un miembro de una clase que define el comportamiento de la clase. Un método es un fragmento de código reutilizable que realiza una tarea específica. Los métodos pueden acceder a las propiedades de una clase y devolver un valor. En el código, los métodos generalmente se definen dentro de una clase y se pueden llamar a través de una instancia de la clase.

Existe la siguiente relación entre clases y métodos:

Una clase puede contener múltiples métodos que definen el comportamiento de la clase.
Los métodos pueden acceder a las propiedades de una clase para realizar tareas específicas.
Las instancias de una clase pueden realizar operaciones específicas llamando a métodos.
Aquí hay un código de muestra que muestra la relación entre clases y métodos:

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
    }
}

En el código anterior, MyClass es una clase que contiene dos métodos setMyProperty y getMyProperty para configurar y obtener el valor de la propiedad myProperty. En el método principal de la clase Main, creamos una instancia myObject de MyClass y establecemos y obtenemos el valor de la propiedad llamando al método.

Tenga en cuenta que debe prestar atención a escribir clases y clases de prueba en un archivo:

1.> No haga públicas la clase y la clase de prueba ni informe un error The public type Dog must be defined in its own file[Según el código y la pregunta que proporcionó, el problema radica en la definición de dos clases públicas en su código, y Java estipula que cada archivo fuente solo puede tener una clase pública cuyo nombre debe ser el mismo que el nombre del archivo. 】

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. Si se trata de una clase de paquete de clase de prueba:
    debe probar la clase usted mismo {llamada PRINCIPAL; clase CLASS}

  2. Si es un caso donde una clase envuelve una clase de prueba:
    es una clase {método de propiedad; llamado en principal}

Estos dos Dog d = new Dog(); ¿Por qué no se afectan entre sí?

  1. Estas dos líneas de código crean dos objetos Perro diferentes, que se asignan a dos variables diferentes d. Aunque tienen el mismo tipo y nombre, son dos instancias separadas.
  2. En el método principal de la clase DogTest, primero se crea un objeto Dog d y luego se llama al método de ejecución de d. Dentro del método de ejecución, se crea un nuevo objeto Dog d y se llama a su método de salto.
  3. Dado que los dos objetos Perro son instancias separadas, no existe una influencia directa entre ellos. Cada objeto tiene su propio espacio de memoria y estado. Por lo tanto, la creación del primer objeto Dog y la llamada al método de ejecución no afectarán al segundo objeto Dog.
    inserte la descripción de la imagen aquí

La comparación entre esto y la creación de objetos:

El código define una clase llamada Dog, que contiene tres métodos: jump(), run() y run1(). En el método run(), se crea un objeto Dog d, luego se llama al método jump() y se imprime un mensaje. En el método run(), se llama al método jump() con la palabra clave this y se imprime un mensaje. En el método run1(), se llama directamente al método jump() y se imprime un mensaje.

Las funciones de estos tres métodos son similares: todos llaman al método jump() e imprimen un mensaje. La diferencia es que se crea un nuevo objeto Dog en el método run(), mientras que el método run() y el método run1() llaman al método jump() en el objeto actual.

[En el método run(), llame al método jump() creando un nuevo objeto Dog. Esto significa que cada vez que se llama al método run(), se crea un nuevo objeto Dog y se llama a su método jump(). Este enfoque puede provocar un desperdicio de memoria, porque cada vez es necesario crear un nuevo objeto.

En el método run(), el método jump() se llama haciendo referencia al objeto que llama al método mediante la palabra clave this. Esto significa que cuando se llama al método run(), se llama al método jump() con el objeto actual. Este método es más eficiente porque no es necesario crear un nuevo objeto, sino utilizar el objeto actual directamente.

Por lo tanto, desde el punto de vista del rendimiento, el método run() es más eficiente porque evita la sobrecarga de crear nuevos objetos. 】

Si desea comparar las diferencias entre estos tres métodos, puede observar que se crea un nuevo objeto Dog en el método run(), mientras que el método run() y el método run1() llaman a jump() en el método del objeto actual. Además, tanto el método run() como el método run() utilizan la palabra clave this para referirse al objeto actual.

run1(), run2() y run3() son tres métodos diferentes en la clase Dog. La siguiente es una explicación de las diferencias y similitudes en su uso: Quiero respuestas en chino·

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

Primero, veamos la definición e implementación de estos tres métodos:

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方法");
}

En el método run1(), creamos un nuevo objeto Dog y llamamos al método jump(). Luego, imprimimos un mensaje. Este método no utiliza la palabra clave this.

En el método run2, this.jump() se usa para llamar al método de salto. La palabra clave this representa el objeto actual, por lo que this.jump() llama al método de salto del objeto actual.

En el método run3, jump () se usa directamente para llamar al método de salto.En la misma clase, puedes llamar directamente al método en la clase., sin utilizar el objeto o esta palabra clave.

Ahora veamos las diferencias y similitudes de estos tres métodos:

Similitudes:

Los tres métodos llaman al método jump().
Los tres métodos imprimieron un mensaje.

La diferencia:

El método run1() crea un nuevo objeto Dog y llama al método jump(). Esto significa que cada vez que se llama al método run1(), se crea un nuevo objeto.

(1) run1()yrun2()
  1. En run1()el método:
  • Dentro del método se crea un nuevo Dogobjeto d.
  • Se invocó el método ddel objeto jump(), donde dhay Doguna instancia de la clase.
  • Esto significa que se llamó al método ddel objeto recién creado jump().
  • Finalmente, envíe un mensaje indicando que run1()el método se está ejecutando.

2. En run2()el método:

  • Úselo para invocar el método en this.jump()el objeto actual ( una instancia de la clase) .Dogjump()
  • thisLa palabra clave se refiere a la instancia actual de la clase, que en este caso run2()es la misma que el objeto que llama.
  • Por lo tanto, se llama al método Dogen el mismo objeto (instancia de la clase) jump().
  • Después de esto, se genera un mensaje indicando que run2()el método se está ejecutando.

En resumen, run1()los run2()métodos y logran el mismo resultado: llaman al método Dogen el mismo objeto (una instancia de la clase) jump(). La diferencia clave es cómo se escribe la llamada al método: se crea una nueva instancia de antes run1()de llamar , mientras que el uso de la palabra clave lo llama directamente en el objeto actual .jump()Dogrun2()thisjump()

(2) run1()yrun3()
  1. En run1()el método:
  • Se crea un nuevo Dogobjeto d.
  • Se llamó al método ddel objeto jump().
  • Muestra un mensaje que indica que run1()el método se está ejecutando.
  1. En run3()el método:
  • El método se llama directamente jump().
  • Debido a que el método está definido en jump()la misma clase , se puede llamar directamente sin utilizar el objeto ni las palabras clave.Dogthis
  • Muestra un mensaje que indica que run3()el método se está ejecutando.

De todos modos, la principal diferencia es que run1()dentro del método Dogse crea un nuevo objeto y jump()se llama al método del objeto. Y llama directamente al método en run3()el objeto actual (suponiendo que se llame en la instancia de la clase) , porque el método de esta clase se puede llamar directamente en la misma clase.Dogjump()

(3) Run2yRun3
  1. En run2()el método:
  • En el método run2, this.jump() se usa para llamar al método de salto. La palabra clave this representa el objeto actual, por lo que this.jump() llama al método de salto del objeto actual.
    – Utilice this.jump() para llamar al método jump() en el objeto actual (una instancia de la clase Dog).
    – La palabra clave this se refiere a la instancia actual de la clase, en este caso, el mismo objeto que llamó a run2().
    – Se llama al método jump() en el mismo objeto (una instancia de la clase Dog).
    – Genera un mensaje que indica que el método run2() se está ejecutando.
  1. En run3()el método:
  • En el método run3, jump () se usa directamente para llamar al método de salto. En la misma clase, puede llamar directamente al método en la clase sin usar el objeto o esta palabra clave.
    —El método jump() se llama directamente.
    – Debido a que el método jump() está definido en la misma clase Dog, se puede llamar directamente sin usar el objeto o esta palabra clave.
    – Genera un mensaje que indica que el método run3() se está ejecutando.

En este ejemplo, dado que los métodos run2 y run3 están definidos en la misma clase, pueden acceder directamente a los métodos de la clase. Por lo tanto, la palabra clave this no tiene ningún efecto o diferencia real aquí.

Sin embargo, cuando hay una variable local con el mismo nombre que la variable miembro de la clase en un método de una clase, el uso de la palabra clave this puede indicar claramente que se debe acceder a la variable miembro de la clase en lugar de a la variable local. Este es un uso común de la palabra clave this.

Comparación final:

  • Método run1(): crea un nuevo objeto Dog d y luego llama al método jump(). Este es un llamado explícito.

  • Método run2(): utilice this.jump() para llamar al método jump() del objeto actual. También una llamada explícita, pero usando la palabra clave this para dejar claro que estamos llamando a un método en el objeto actual.

  • Método run3 (): llame directamente al método jump (), porque en la misma clase, los métodos de la clase se pueden llamar directamente. Este también es un llamado explícito.

Resumir:
  • run1() crea un nuevo objeto para llamar al método jump().
  • Tanto run2() como run3() invocan el método jump() en el objeto actual, donde run2() usa explícitamente la palabra clave this.
    En este ejemplo, los resultados de estos tres métodos de llamada son los mismos, porque en la misma clase, los métodos de la clase se pueden llamar directamente. La diferencia radica en la claridad y expresión semántica del código.
como sigue:

inserte la descripción de la imagen aquí

¿Cómo vscode hace clic en otro archivo en el modo de vista previa? No será reemplazado

La tecla de acceso directo preferida es Ctrl+Mayús+p, ingrese la configuración en el cuadro de búsqueda para buscar, vea la opción Configuración de usuario, haga clic para abrir e ingrese enablePreview para buscar.
inserte la descripción de la imagen aquí

  1. [párrafo 1]: En muchos lenguajes de programación orientados a objetos, incluido Java, la creación de objetos generalmente implica el uso de constructores. Un constructor es un tipo especial de método que inicializa el estado de un objeto y realiza la configuración necesaria. En Java, cuando usamos la palabra clave "nuevo" para crear un objeto, la máquina virtual llama automáticamente al constructor apropiado para crear el objeto. Este es un proceso que el compilador y el entorno de ejecución manejan automáticamente.
    [párrafo 2]: La razón por la que no se puede llamar manualmente al constructor es que el propósito del constructor es realizar las operaciones de inicialización necesarias cuando se crea el objeto. Si llamamos manualmente al constructor, equivale a realizar una operación de inicialización en un objeto existente, lo que puede generar confusión e inconsistencia en el estado del objeto. Además, los métodos constructores pueden contener lógica específica para el proceso de creación de objetos, como asignar memoria, establecer valores predeterminados, etc. Estos pasos son manejados por la máquina virtual para garantizar la correcta creación del objeto.
    [párrafo 3]: Cuando definimos un constructor en una clase, la máquina virtual seleccionará automáticamente el constructor apropiado para llamar cuando se cree el objeto. Dependiendo de los parámetros, puede haber múltiples formas sobrecargadas del constructor. La máquina virtual elige a qué constructor llamar en función del tipo y la cantidad de parámetros que proporcionamos.
    [párrafo 4]: En resumen, la creación de objetos es manejada automáticamente por la máquina virtual, incluida la llamada al constructor apropiado para realizar operaciones de inicialización. No necesitamos llamar al constructor manualmente porque el compilador y el entorno de ejecución lo hacen automáticamente. ↩︎

Supongo que te gusta

Origin blog.csdn.net/m0_74154295/article/details/131384354
Recomendado
Clasificación
Diario
Más
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)

Code World

© 2018 codetd.com