Aprendo clases y objetos de Java en VScode (clases y objetos de Java, esta palabra clave) la primera serie

La página de inicio de mi blog personal: si '' realmente puede escapar 1️⃣ diga 1️⃣ página de inicio del blog
Acerca del aprendizaje de gramática básica de Java ----> Puede consultar mi blog: "Aprendo Java en VScode"
Acerca de mí aprendiendo Java en VScode (método del método Java )

Una clase es una colección de objetos que describen un grupo de objetos que tienen las mismas características (atributos) y comportamientos (métodos).
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.

Zero._.Programación Orientada a Objetos ----> La importancia radica en que proporciona un estilo de programación más modular, reutilizable y fácil de mantener, lo que facilita la organización y gestión del código al descomponerlo en objetos.

La programación orientada a objetos (OOP) es un paradigma de programación que combina datos y métodos de manipulación de datos para que los datos y el comportamiento se puedan ver como un todo. La historia de este paradigma de programación se remonta a la década de 1960, pero no se hizo popular hasta la década de 1980.

En la programación orientada a objetos, los datos y métodos se organizan en clases (Class), que es un tipo de datos abstracto que define un conjunto de propiedades y métodos. Object (Objeto) es una instancia de una clase ^, que contiene las propiedades y métodos de la clase. Al crear un objeto, podemos usar los métodos definidos en la clase para manipular las propiedades del objeto.

(1) Encapsulación: combine datos y comportamiento y trátelos como una sola entidad. Esto evita que el código externo acceda directamente a los datos del objeto, lo que mejora la seguridad y el mantenimiento del código.

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

La encapsulación (a veces denominada ocultación de información) es un concepto importante al trabajar con objetos. Formalmente, la encapsulación es la combinación de datos y comportamiento en un paquete, y los detalles de implementación específicos están ocultos para el usuario del objeto. Los datos de un objeto se denominan campo de instancia y el proceso de manipular los datos se denomina método. Como instancia de una clase, un objeto particular tiene un conjunto particular de valores de campo de instancia. La colección de estos valores es el estado actual del objeto. Cada vez que se llama a un método en un objeto, su estado puede cambiar.

La clave de la encapsulación es que
nunca se debe permitir que los métodos de otras clases accedan directamente a los campos de instancia de esta clase.
Los programas solo pueden interactuar con los datos del objeto a través de los métodos del objeto. La encapsulación otorga a los objetos un carácter de "caja negra", que es la clave para una mayor reutilización y confiabilidad. Esto significa que una clase puede cambiar completamente la forma en que se almacenan los datos, siempre que los datos se sigan manipulando de la misma manera, otros objetos no sabrán ni se preocuparán por los cambios en esta clase.

ejemplo de código

define una clase de estudiante

public class Student {
    
    
    // 定义了一个私有的字符串类型数据成员name，只能在当前类中被访问。
    private String name;
    // 定义了一个私有的整型数据成员age，只能在当前类中被访问。
    private int age;

    // 定义了一个公共的方法setName，用于设置name的值，这里的void表示此方法没有返回值，String
    // name表示在调用此方法时需要传入一个字符串类型的参数。
    public void setName(String name) {
    
    
        // 在setName方法中将传入的参数值name赋值给Student类中的name数据成员。
        this.name = name;
    }

    // 定义了一个公共的方法setAge，用于设置age的值，这里的void表示此方法没有返回值，int age表示在调用此方法时需要传入一个整型参数。
    public void setAge(int age) {
    
    
        // 在setAge方法中将传入的参数值age赋值给Student类中的age数据成员。
        this.age = age;
    }

    // 定义了一个公共的方法getName，用于获取name的值，这里的String表示此方法的返回值为字符串类型。
    public String getName() {
    
    
        // 在getName方法中返回Student类中的name数据成员的值。
        return name;
    }

    // 定义了一个公共的方法getAge，用于获取age的值，这里的int表示此方法的返回值为整型。
    public int getAge() {
    
    
        // 在getAge方法中返回Student类中的age数据成员的值。
        return age;
    }

Escribir un código de prueba para una clase de estudiante

public class Student_test {
    
    
    public static void main(String[] args) {
    
    
        // 创建一个Student类的对象，这里使用了默认的构造方法来初始化对象。
        Student student = new Student();
        // 调用Student类中的setName方法设置学生的姓名为Tom。
        student.setName("Tom");
        // 调用Student类中的setAge方法设置学生的年龄为20。
        student.setAge(20);
        // 使用System.out.println方法输出学生的姓名，这里使用了+来连接字符串和方法返回值。
        System.out.println("Student name: " + student.getName());
        // 使用System.out.println方法输出学生的年龄，这里使用了+来连接字符串和方法返回值。
        System.out.println("Student age: " + student.getAge());
    }

resultado
Student name: Tom
Student age: 20

Asignar y generar DEMO2

Utilice establecer y obtener después privado. En la función principal principal, use对象名 名称 =new 对象的类（）

[1] Use 名称.set成员变量（==写 想要赋的值==）para asignar,
y luego use数据类型 数据名称 = 名称.get成员变量（）
在输出sy.o.p(数据名称）

【2】O usar 名称.set成员变量（==写 想要赋的值==）para asignación.
, salida directasy.o.p(名称.get成员变量（））

Resumido de la siguiente manera:

(1) La palabra clave privada es un modificador de permisos que puede modificar miembros (variables de miembros y métodos de miembros). Solo se puede acceder a los miembros modificados por private en esta clase
(2) Para las variables miembro modificadas por private, si necesitan ser utilizadas por otras clases, proporcione las operaciones correspondientes ²

提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

(2) Herencia (Inheritance): Permite la creación de una nueva clase que hereda propiedades y métodos de clases existentes. Esto reduce la duplicación de código y facilita el mantenimiento del código.

La herencia es otro concepto importante en la programación orientada a objetos. La herencia nos permite definir una nueva clase que hereda las propiedades y métodos de la clase original. En la relación de herencia, la clase original se denomina clase padre, clase base o superclase, y la clase recién creada se denomina subclase o clase derivada.

Las subclases pueden heredar todas las propiedades y métodos públicos de la clase principal y también pueden definir nuevas propiedades y métodos por sí mismas. La herencia nos permite reducir el esfuerzo de escribir repetidamente código similar reutilizando el código. Además, a través de la herencia, podemos organizar y diseñar mejor la estructura del programa, haciendo que el código sea más fácil de mantener y expandir.

En Java, la palabra clave extends se usa para declarar que una clase hereda de otra clase. Las subclases pueden anular los métodos de la clase principal para satisfacer sus propias necesidades específicas. Además, Java también admite herencia múltiple, es decir, una subclase puede heredar las propiedades y métodos de varias clases principales (interfaces) al mismo tiempo.

La combinación de herencia y encapsulación puede realizar mejor los principios básicos de la programación orientada a objetos, a saber, el "principio de apertura y cierre" y el "principio de responsabilidad única". El principio abierto-cerrado significa que una entidad de software (clase, módulo, etc.) debe estar abierta para la extensión y cerrada para la modificación. A través de la herencia, podemos implementar nuevas funciones extendiendo la clase principal sin modificar el código original. El principio de responsabilidad única establece que una clase debe tener una sola responsabilidad. A través de la herencia, podemos organizar la estructura del código para que cada clase solo sea responsable de su propia funcionalidad específica.

el código

Es una clase de Java llamada Animal.

Tiene un nombre de propiedad protegido y un constructor que inicializa la propiedad de nombre. También hay un método llamado hablar en la clase, que se usa para dar salida a la vocalización del animal.

package PLAYYYYY;

public class Animal {
    
    
    // 受保护的属性name
    protected String name;

    // 构造函数，用于初始化name属性
    public Animal(String name) {
    
    
        this.name = name;
    }

    // 动物发声的方法
    public void speak() {
    
    
        System.out.println("The animal speaks.");
    }
}

Esta es una clase Gato que hereda de la clase Animal.

La clase Cat tiene un constructor que inicializa su propiedad de nombre y también tiene un método de habla que emite las vocalizaciones del gato. En el método de hablar, el atributo de nombre se usa para generar el nombre del gato y su sonido.

el código se muestra a continuación:

package PLAYYYYY;

// 继承自Animal类
class Cat extends Animal {
    
    
    public Cat(String name) {
    
    
        // 调用父类的构造函数，初始化name属性
        super(name);
    }

    // 猫的发声方法
    public void speak() {
    
    
        System.out.println(name + " says meow!");
    }
}

Esta es una clase Perro que hereda de la clase Animal.

La clase Perro tiene un constructor que inicializa su propiedad de nombre y también tiene un método de hablar que emite las vocalizaciones del perro. En el método de habla, el atributo de nombre se utiliza para emitir el nombre del perro y su sonido de ladrido.

el código se muestra a continuación:

package PLAYYYYY;

// 继承自Animal类
class Dog extends Animal {
    
    
    public Dog(String name) {
    
    
        // 调用父类的构造函数，初始化name属性
        super(name);
    }

    // 狗的发声方法
    public void speak() {
    
    
        System.out.println(name + " says woof!");
    }
}

Esta es una clase con un método principal que crea objetos Animal, Dog y Cat y llama a sus métodos de habla.

Primero, se crea un objeto Animal llamado "Animal genérico" y se emite "El animal habla". Luego se crea un objeto Perro llamado "Rufus", que genera "¡Rufus dice guau!". Finalmente, se crea un objeto Cat llamado "Bigotes", que genera "¡Bigotes dice miau!".

el código se muestra a continuación:

package PLAYYYYY;

public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 创建Animal对象并调用它的speak方法
        Animal animal = new Animal("Generic Animal");
        animal.speak();

        // 创建Dog对象并调用它的speak方法
        Dog dog = new Dog("Rufus");
        dog.speak();

        // 创建Cat对象并调用它的speak方法
        Cat cat = new Cat("Whiskers");
        cat.speak();
    }
}

(3) Polimorfismo (Polymorphism): Permite el uso del mismo método para manejar diferentes tipos de objetos. Esto mejora la escalabilidad y la reutilización del código.

El polimorfismo es otro concepto importante en la programación orientada a objetos. Permite que diferentes objetos respondan de manera diferente al mismo mensaje. Esto significa que el programa puede llamar a diferentes métodos según diferentes objetos sin conocer el tipo específico del objeto.

En Java, el polimorfismo se puede lograr mediante la sobrecarga de métodos y la anulación de métodos. La sobrecarga de métodos se refiere a la definición de múltiples métodos en una clase con el mismo nombre de método pero diferentes listas de parámetros. Cuando el programa llama a este método, Java determinará qué método llamar en función de la lista de parámetros. La anulación de métodos significa que las subclases anulan los métodos de la clase principal para lograr sus propias necesidades específicas. Cuando el programa llama a este método, Java determinará qué método llamar en función del tipo real del objeto.

La ventaja del polimorfismo es que aumenta la flexibilidad y escalabilidad del código. A través del polimorfismo, podemos escribir código más general, haciendo que el programa sea más reutilizable y mantenible. Además, el polimorfismo también puede hacer que los programadores se orienten mejor hacia la programación abstracta, para comprender y diseñar mejor los sistemas de programas complejos.

En resumen, la encapsulación, la herencia y el polimorfismo son tres conceptos básicos en la programación orientada a objetos. Pueden hacer que los programas sean más fáciles de entender, mantener y ampliar. En el diseño real, los programadores deben usar estos conceptos de manera flexible de acuerdo con las necesidades específicas para lograr una mejor calidad de código y eficiencia en el desarrollo de software.

Aquí hay una introducción a la programación orientada a objetos en C++, Python y Java:

【1】Ventajas y desventajas

(1) C++:

== Ventajas: ==

C++ se ejecuta muy rápido y es adecuado para aplicaciones que requieren un alto rendimiento.
C ++ proporciona una gran cantidad de bibliotecas de clases y estructuras de datos, que pueden manejar fácilmente los cálculos y operaciones subyacentes.
La memoria se puede manipular directamente, proporcionando un control más detallado.
defecto:

La sintaxis de C++ es más engorrosa y requiere más aprendizaje y acumulación de experiencia.
Dado que la memoria se puede manipular directamente, es fácil causar problemas como pérdidas de memoria.

(2) Pitón:

ventaja:

El código de Python es conciso y fácil de entender, fácil de aprender y usar.
Python proporciona una gran cantidad de bibliotecas de clases y marcos que pueden crear varias aplicaciones rápidamente.
Python admite conceptos de programación avanzados, como decoradores y cierres, que pueden aumentar la flexibilidad y la reutilización del código.
== Contras: ==

La velocidad de ejecución de Python es relativamente lenta y no es adecuada para procesar grandes cantidades de datos y cálculos de alto rendimiento.
El método de administración de memoria de Python es relativamente complicado y es propenso a problemas como pérdidas de memoria.

(3)Java:

ventaja:

Java es relativamente rápido y adecuado para crear aplicaciones grandes.
Java proporciona potentes funciones de programación orientada a objetos, que admiten funciones como polimorfismo, herencia y encapsulación.
Java tiene una buena multiplataforma y puede ejecutarse en diferentes sistemas operativos.
== Contras: ==

La sintaxis de Java es relativamente engorrosa y requiere más aprendizaje y acumulación de experiencia.
Las aplicaciones Java necesitan depender de máquinas virtuales para ejecutarse, lo que puede afectar su eficiencia operativa.

[2] Corbata diferente:

C++ y Java requieren una gestión de memoria explícita, mientras que Python admite la gestión de memoria automática.
Tanto Python como Java admiten la tipificación dinámica, mientras que C++ requiere que los tipos se determinen en el momento de la compilación.
C++ y Java admiten la programación multiproceso, y Python admite la programación corrutina.
C++ y Java pueden escribir código de máquina directamente, mientras que Python necesita interpretar el código en bytecode antes de ejecutarlo.

Ejemplo de una clase C++:

En C++, podemos crear nuestros propios objetos definiendo una clase y usar los métodos definidos en la clase para manipular las propiedades del objeto.

#include <iostream>
using namespace std;

class Person {
    
    
private:
    string name;
    int age;

public:
    Person(string name, int age) {
    
    
        this->name = name;
        this->age = age;
    }

    void sayHello() {
    
    
        cout << "Hello, my name is " << this->name << " and I am " << this->age << " years old." << endl;
    }
};

int main() {
    
    
    Person person("Alice", 25);
    person.sayHello();
    return 0;
}

Ejemplo de una clase de Python:

Todo en Python es un objeto, incluidos números, cadenas, funciones y más. Podemos crear nuestros propios objetos definiendo una clase y usar los métodos definidos en la clase para manipular las propiedades del objeto.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sayHello(self):
        print("Hello, my name is " + self.name + " and I am " + str(self.age) + " years old.")

person = Person("Alice", 25)
person.sayHello()

Ejemplo de una clase Java:

En Java, todos los tipos de datos son objetos, incluidos los tipos de datos básicos (como int, float, etc.) y los tipos de datos de referencia (como matrices, cadenas, etc.). Las clases y los objetos en Java se definen de manera similar a Python

class Person {
    
    
    private String name;
    private int age;

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
    
    
        System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
    }
}

Person person = new Person("Alice", 25);
person.sayHello();

En resumen, C++, Python y Java son potentes lenguajes de programación orientados a objetos y también admiten las tres funciones básicas de encapsulación, herencia y polimorfismo.
La programación orientada a objetos es un paradigma de programación poderoso que proporciona un estilo de programación más modular, reutilizable y fácil de mantener. La programación orientada a objetos es una forma natural de programar. Podemos crear nuestros propios objetos definiendo clases y usar los métodos definidos en las clases para manipular las propiedades de los objetos.

1._.Clase —>== 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). == Una clase es un tipo de datos definido por el usuario, que incluye miembros de datos [atributos de clase] y miembros de métodos [comportamiento de clase]. Una clase define las propiedades y el comportamiento de un objeto, y un objeto representa una instancia de la clase.

类是一种用户定义的数据类型，它包含数据成员和方法成员。

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

Una clase Java es una estructura de datos y un objeto es una instancia de una clase. [La clase debe diseñarse antes de que se pueda obtener el objeto. 】Describe un grupo de objetos con las mismas características y comportamiento.Una clase define las propiedades y métodos de un objeto, y un objeto es una instancia de una clase.
En Java, una clase es un mecanismo de encapsulación que proporciona una forma de combinar datos y comportamiento para organizar el código en unidades lógicas. Las clases juegan un papel vital en la programación orientada a objetos, lo que permite a los programadores encapsular datos de código para controlar y administrar mejor el comportamiento de las aplicaciones.

//public是访问修饰符，表示该类可以被其他类访问。ClassName是类的名称，遵循驼峰命名法。
public class ClassName {
    
    
//在类的主体中，可以定义字段、构造函数和方法。
   // Fields
   // Constructors
   // Methods
}

字段是类的属性，用于存储数据。在Java中，字段可以是任何数据类型，包括原始类型（如int和double）和引用类型（如String和Object）。以下是一个示例：

//Person类有两个字段：name和age。
public class Person {
    
    
   String name;
   int age;
}

构造函数是用于创建对象的特殊方法。在Java中，构造函数的名称必须与类的名称相同，并且没有返回类型。构造函数可以接受任意数量和类型的参数，并且可以执行任何必要的初始化操作。	

//Person类有一个构造函数，它接受两个参数：name和age。this关键字用于引用当前对象。
public class Person {
    
    
   String name;
   int age;

   public Person(String name, int age) {
    
    
      this.name = name;
      this.age = age;
   }
}

方法是类的行为，用于执行操作。在Java中，方法可以接受任意数量和类型的参数，并且可以返回任何类型的值。以下是一个示例：

//Person类有一个方法sayHello()，它打印出一个问候语，包括对象的名称和年龄。
public class Person {
    
    
   String name;
   int age;

   public Person(String name, int age) {
    
    
      this.name = name;
      this.age = age;
   }

   public void sayHello() {
    
    
      System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
   }
}

La clase es un concepto importante en la programación orientada a objetos, es un tipo de datos definido por el usuario que puede contener atributos y métodos. Se puede pensar en una clase como una especie de plantilla o modelo para crear objetos.

Otro principio de la programación orientada a objetos que facilita a los usuarios la definición de clases de Java es que se pueden crear nuevas clases mediante la ampliación de otras clases. De hecho, Java proporciona una "superclase mágica" llamada objeto. Todas las demás clases se extienden desde esta clase de objeto.

En Java, la definición de una clase debe contener lo siguiente: la clase siempre debe comenzar con una letra inicial mayúscula y el nombre del archivo java debe coincidir con el nombre de la clase.

El modificador de acceso de la clase (public, private, protected o default)
El nombre de la clase, usando mayúsculas camelCase (por ejemplo, MyClass)
El cuerpo de la clase, encerrando
los miembros de la clase con un par de llaves, incluidos los campos , métodos, constructores, clases anidadas, etc.

Aquí hay un ejemplo de una clase Java simple que incorpora todo lo anterior:

public class MyClass {
    
    
    // 字段
    private int myField;

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

    // 方法
    public int getMyField() {
    
    
        return myField;
    }

    // 嵌套类
    private static class MyNestedClass {
    
    
        // ...
    }
}

Instrucciones para definir clases: Las clases siempre deben comenzar con una letra inicial en mayúscula, y el nombre del archivo java debe coincidir con el nombre de la clase.

(1) La clase que escribe el método principal se llama 测试类Podemos crear un objeto de la clase javabean en la clase de prueba y hacer una llamada de asignación.
(2) La clase utilizada para describir una clase de cosas, profesionalmente en la clase ³Javabean类 de Javabean , no escribe el método principal.

Notas sobre la definición de clases

public class 类名{
    
    
1、成员变量 (代表属性)
2、成员方法(代表行为)
}

(1) Se recomienda que la primera letra del nombre de la clase esté en mayúscula, y el nombre debe ser conocido.Modo camello
(2) Se pueden definir varias clases en un archivo Java, y solo una clase se puede modificar públicamente, y el El nombre de la clase pública modificada debe convertirse en el nombre del archivo de código. En el desarrollo real, se recomienda que un archivo defina una clase
(3) El formato de definición completo de las variables miembro es:修饰符 数据类型 变量名称 = 初始化值;[Por lo general, no es necesario especificar un valor de inicialización y hay un valor predeterminado. 】

En Java, una definición de clase generalmente consta de las siguientes partes:

Modificadores para clases: los modificadores para clases pueden ser públicos, privados, protegidos o predeterminados (es decir, sin modificadores). Estos modificadores controlan la visibilidad y el nivel de acceso de la clase.
Nombres de clase: los nombres de clase deben comenzar con una letra mayúscula y seguir camelCase.
Clase principal: una clase en Java puede heredar otra clase, y esta clase heredada se denomina clase principal o superclase. La herencia puede hacer que el código sea más conciso y reutilizable.
Interfaces implementadas: una clase en Java puede implementar una o más interfaces, y una interfaz define un conjunto de métodos que debe implementar una clase. Las interfaces se pueden utilizar para lograr polimorfismo y reutilización de código.
Atributos de una clase: Los atributos de una clase son variables que describen el estado de un objeto. Pueden ser tipos primitivos (como int, double, etc.) o tipos de objetos (como String, Date, etc.).
Métodos de clase: Los métodos de clase son funciones que describen el comportamiento de un objeto. Pueden ser estáticos o no estáticos, pueden tener parámetros y valores de retorno.

Cree una palabra clave de clase nueva para crear un objeto y llame al constructor del objeto para inicializar. Utilice los métodos y propiedades del objeto para operar.

En Java, para definir una clase, debe usar la palabra clave class y debe especificar el nombre de la clase. Las propiedades y los métodos de clase se definen dentro de las llaves de la clase. El proceso de construir un objeto a partir de una clase se denomina creación de una instancia de la clase.

Una plantilla para una clase completa de Java, incluidas las definiciones de propiedades y métodos. Tenga en cuenta que puede cambiar el modificador de la clase (público, abstracto o final) como desee, y si amplía otra clase o implementa una interfaz.

public abstract|final class <class_name> extends <class_name> implements <interface_name> {
    
    
    // 定义属性部分
    <property_type> <property1>;
    <property_type> <property2>;
    <property_type> <property3>;
    ...

    // 定义方法部分
    public void function1() {
    
    
        // 方法体
    }

    <access_modifier> <return_type> function2(<parameter_list>) {
    
    
        // 方法体
    }

    private <return_type> function3(<parameter_list>) {
    
    
        // 方法体
    }

    ...
}

La siguiente es una explicación detallada de la plantilla de código:

<class_name>: el nombre de la clase, puedes cambiarlo según tus necesidades.
abstract|final: El modificador de la clase, que puede ser una clase abstracta o una clase final, y puedes cambiarlo según tus necesidades.
extiende <nombre_clase>: herencia de clase, si necesita heredar otra clase, puede usar esta opción y reemplazar <nombre_clase> con el nombre de la clase que desea heredar.
implementa <interface_name>: la implementación de la clase, si necesita implementar una o más interfaces, puede usar esta opción y reemplazar <interface_name> con el nombre de la interfaz que se implementará.
<tipo_propiedad>: el tipo de la propiedad, que puede ser cualquier tipo de datos de Java, como int, double, String, etc.
propiedad, propiedad2, propiedad3: el nombre de la propiedad, puede cambiarlo según sus necesidades.
function1(), function2(), function3(): el nombre del método, puede cambiarlo según sus necesidades.
<access_modifier>: El modificador de acceso del método, el cual puede ser público, privado, protegido o no escrito, y puedes cambiarlo según tus necesidades.
<return_type>: el tipo de retorno del método, que puede ser cualquier tipo de datos de Java, como int, double, String, etc.
<parameter_list>: la lista de parámetros del método. Si el método requiere parámetros, el tipo y el nombre de los parámetros se pueden enumerar aquí.

Pasos para crear una clase

Los pasos para definir una clase son los siguientes:

1. Primero, determine el nombre y el propósito de la clase, generalmente para describir un objeto o un grupo de objetos relacionados.
2. Luego, determine los atributos de la clase, es decir, los miembros de datos de la clase, que generalmente reflejan el estado del objeto.
3. Identificar los métodos de una clase, es decir, las funciones miembro de una clase, que generalmente reflejan el comportamiento de un objeto.
4. Agrupa propiedades y métodos en clases y usa modificadores de acceso para establecer su visibilidad y nivel de protección.
5. Escriba constructores y destructores de clases (si es necesario) y otras funciones necesarias.
6. Crea instancias de objetos de esta clase en el programa y utilízalos para llamar a métodos de la clase.
7. Cuando sea necesario, amplíe la funcionalidad de la clase heredando o implementando la interfaz.

[1] Utilice la palabra clave "clase" para declarar el nombre de una clase.

//类名应该以大写字母开头，遵循驼峰命名法
public class MyClass {
    
    
  // class body
}

[2] Escriba las propiedades y métodos de la clase en las llaves de la clase.

类的属性是指类的变量，而类的方法是指类的函数。属性和方法都可以是公共的，私有的或受保护的。
公共属性和方法可以从类的任何地方访问，而私有属性和方法只能从类内部访问。
受保护的属性和方法可以从类内部和子类中访问。

Por ejemplo, para agregar una propiedad llamada "nombre" y un método llamado "diHola" a la clase "Persona", escribiría:

public class Person {
    
    
    String name;

    public void sayHello() {
    
    
        System.out.println("Hello, my name is " + name);
    }
}

[1] Escriba las variables contenidas en una clase:

(1) Variables de instancia (también conocidas como variables miembro): el alcance es la clase completa y se puede acceder a ella mediante cualquier método o constructor de la clase.

Una variable de instancia en Java se refiere a una variable que pertenece a una instancia (objeto) de una clase, también conocida como variable miembro. Se declaran dentro de la clase, pero fuera del método. Cada instancia de una clase tiene su propio conjunto de variables de instancia, que pueden tener diferentes valores.
Las variables de instancia pueden ser cualquier tipo de datos básico (como int, float, double, etc.) y cualquier tipo de referencia (como cadena, matriz, etc.). Sus valores se pueden establecer o recuperar accediendo al objeto de instancia de la clase.

el código

Supongamos que tenemos una clase llamada Persona, que tiene variables de instancia nombre y edad, que se pueden declarar así:

public class Person {
    
    
    String name; // 实例变量：姓名
    int age; // 实例变量：年龄
}

En este ejemplo, el nombre y la edad son variables de instancia de la clase Person. Se declaran como tipos String e int, por lo que cada objeto Person tiene su propio nombre y valores de edad.
Podemos usar estas variables de instancia creando un objeto Person y configurando sus propiedades:

Person person1 = new Person();
person1.name = "张三";
person1.age = 25;
Person person2 = new Person();
person2.name = "李四";
person2.age = 30;

En este ejemplo, creamos dos objetos Person, persona1 y persona2, y establecemos sus propiedades de nombre y edad respectivamente. Estas propiedades son variables de instancia de cada objeto, por lo que cada objeto tiene su propio nombre y valores de antigüedad.

(2) Variables estáticas (también conocidas como variables de clase): el alcance es la clase completa, a la que se puede acceder a través del nombre de la clase oa través del objeto de instancia de la clase.

Una variable estática en Java se refiere a una variable que pertenece a una clase en lugar de una instancia, también conocida como variable de clase. Se declaran en la clase, pero fuera del método se decoran con la palabra clave static. Cada clase tiene solo un conjunto de variables estáticas, y sus valores son los mismos sin importar cuántas instancias se creen. Las variables estáticas pueden ser cualquier tipo de datos básico (como int, float, double, etc.) y cualquier tipo de referencia (como cadena, matriz, etc.). Sus valores se pueden establecer u obtener accediendo a la propia clase.
El ámbito de las variables estáticas es toda la clase, a la que se puede acceder a través del nombre de la clase oa través del objeto de instancia de la clase. Por lo general, se usan para representar el estado compartido de la clase, como constantes, contadores, etc., y también se pueden usar para almacenar datos en caché e implementar el patrón singleton.

el código

Podemos agregar un conteo de variables estáticas a la clase Person para registrar la cantidad de objetos Person creados:

public class Person {
    
    
    String name; // 实例变量：姓名
    int age; // 实例变量：年龄
    static int count; // 静态变量：对象数量
    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
        count++; // 每次创建对象时增加count的值
    }
}

En este ejemplo, declaramos un conteo de variables estáticas para registrar el número de objetos Person. En el constructor, el valor de count se incrementa en 1 cada vez que se crea un objeto. Se puede acceder a esta variable estática por el nombre de la clase:

System.out.println(Person.count); // 输出对象数量

No importa cuántos objetos Person se creen, todos comparten la misma variable de conteo, por lo que el resultado de salida es la suma del número de todos los objetos.

Precauciones

Las variables de instancia son diferentes a las variables estáticas, las variables de instancia pertenecen a cada instancia, y su modificación solo afectará a la instancia actual y no afectará a otras instancias.

Las variables estáticas y las variables de instancia son dos tipos de variables comúnmente utilizadas en Java, y sus diferencias son las siguientes:

1. Ubicación de almacenamiento
   Las variables estáticas se almacenan en el área de métodos y las variables de instancia se almacenan en la memoria del montón.
2. El ciclo de vida
   de una variable estática es el mismo que el de una clase, se inicializa cuando se carga la clase y se destruye cuando se descarga la clase, el ciclo de vida de una variable de instancia es el mismo que el de un objeto, es se inicializa cuando el objeto se crea y se destruye cuando el objeto se recolecta como basura.
3. Método de acceso A
   las variables estáticas se puede acceder directamente a través del nombre de la clase oa través de objetos, a las variables de instancia solo se puede acceder a través de objetos.
4. Valor inicial
   Las variables estáticas se inicializarán en 0 o nulas de forma predeterminada, mientras que las variables de instancia no se inicializarán de forma predeterminada y deberán inicializarse explícitamente cuando se cree el objeto.
5. Compartir
   Las variables estáticas son compartidas por todos los objetos, es decir, cuando varios objetos acceden a la misma variable estática, acceden a la misma variable; las variables de instancia son independientes de cada objeto, es decir, cada objeto tiene su propia copia de variable de instancia.

(3) Variables locales:

Las variables locales en Java son variables declaradas en métodos, bloques de código o constructores, y solo son visibles en los bloques de código en los que se declaran. El alcance de las variables locales está limitado al bloque de código en el que se encuentran y no se puede acceder a ellas fuera del alcance del bloque de código. Las variables locales deben declararse antes de su uso y deben inicializarse antes de que puedan usarse.
Las variables locales pueden ser cualquier tipo de datos básico (como int, float, double, etc.) y cualquier tipo de referencia (como cadena, matriz, etc.). Sus valores solo son válidos dentro del bloque de código en el que se declaran, y sus valores se destruyen una vez que salen del alcance del bloque de código. Por lo tanto, las variables locales a menudo se usan para almacenar datos temporalmente, como contadores de bucles, parámetros de métodos, etc.

el código

Podemos declarar un mensaje de variable local en un método para almacenar un mensaje:

public void printMessage() {
    
    
    String message = "Hello, world!";
    System.out.println(message);
}

En este ejemplo, declaramos un mensaje de variable local para almacenar un mensaje e imprimirlo en el método. Esta variable local solo es visible dentro del método printMessage y no se puede acceder a ella fuera del alcance de ese método. En el método podemos modificar el valor de la variable local en cualquier momento, pero fuera del método su valor no existe.

suma los tres

Sí, las variables en Java se pueden dividir en tres tipos: variables de clase, variables de instancia y variables locales. Todos se pueden implementar en una clase, pero su alcance y ciclo de vida son diferentes, y debe elegir qué tipo de variable usar según la situación específica.

1. Variables de clase: también conocidas como variables estáticas, son variables declaradas en una clase y compartidas por todas las instancias. Se puede acceder a las variables de clase directamente a través del nombre de clase oa través de objetos. El ámbito de las variables de clase es toda la clase y se puede acceder a ellas mediante cualquier método de la clase. Las variables de clase se inicializan cuando se carga la clase y conservan su valor durante la duración del programa. Las variables de clase a menudo se usan para representar el estado compartido de una clase, como constantes, contadores, etc.
2. Variables de instancia: también conocidas como variables miembro, son variables declaradas en una clase y pertenecen a objetos. Las variables de instancia se limitan a todo el objeto, se inicializan cuando se crea el objeto y se destruyen cuando se destruye el objeto. Se puede acceder a las variables de instancia por cualquier método, pero solo a través del objeto. Las variables de instancia se utilizan a menudo para representar las propiedades de un objeto, como el nombre, la edad, etc.
3. Variables locales: son variables declaradas en un método, bloque de código o constructor que solo son visibles en el bloque de código en el que se declaran. El alcance de las variables locales está limitado al bloque de código en el que se encuentran y no se puede acceder a ellas fuera del alcance del bloque de código. Las variables locales deben declararse antes de su uso y deben inicializarse antes de que puedan usarse. Las variables locales pueden ser de cualquier tipo de datos primitivos y cualquier tipo de referencia, y generalmente se utilizan para el almacenamiento temporal de datos.
   En general, el uso de variables de clase debe minimizarse ya que afectan la mantenibilidad y la capacidad de prueba del programa. Las variables de instancia y las variables locales deben seleccionarse de acuerdo con la situación específica. Si solo se necesita usar una variable en un método, se debe usar una variable local; si se necesita usar una variable en toda la clase, se debe usar una variable de instancia.

¿Cuáles son las similitudes y diferencias

Las diferencias y similitudes entre los tres son las siguientes:
Diferencias:

1. El alcance es diferente: el alcance de las variables de clase es la clase completa, el alcance de las variables de instancia es el objeto completo y el alcance de las variables locales se limita al bloque de código en el que se encuentran.
2. El ciclo de vida es diferente: las variables de clase se inicializan cuando se carga la clase y conservan sus valores a lo largo del programa; las variables de instancia se inicializan cuando se crea el objeto y se destruyen cuando se destruye el objeto; las variables locales se inicializan cuando se declaran , y será destruido tras la ejecución del bloque de código donde se encuentra.
3. Los métodos de acceso son diferentes: se puede acceder a las variables de clase directamente a través del nombre de la clase o a través del objeto; solo se puede acceder a las variables de instancia a través del objeto; solo se puede acceder a las variables locales dentro del bloque de código en el que están declaradas.
4. Los escenarios de uso son diferentes: las variables de clase suelen utilizarse para representar el estado compartido de la clase, como constantes, contadores, etc., las variables de instancia suelen utilizarse para representar los atributos de los objetos, como el nombre, la edad, etc.; Las variables locales generalmente se usan para almacenar datos temporalmente, como contadores de bucle, parámetros de métodos, etc.
   Mismo punto:
5. Ambas son variables utilizadas para almacenar datos.
6. se puede implementar en una clase.
7. Ambos pueden ser cualquier tipo de datos primitivos y cualquier tipo de referencia.
8. Ambos deben declararse antes de su uso y deben inicializarse antes de que puedan usarse.
   Cabe señalar que tanto las variables de clase como las variables de instancia son variables miembro, mientras que las variables locales no son variables miembro. Las variables miembro son variables que pertenecen a clases u objetos, y sus valores pueden ser accedidos y modificados por múltiples métodos, mientras que las variables locales solo existen en los métodos y no pueden ser accedidas ni modificadas por otros métodos.

Para declarar un campo en una clase, puede usar modificadores de acceso (público, privado, protegido) y otros modificadores (estático, final, etc.),

Las propiedades y los campos declarados de una clase pueden usar modificadores de acceso (público, privado, protegido) y otros modificadores (estático, final, etc.) para controlar su visibilidad y mutabilidad.

público: público, puede ser accedido por cualquier clase.
protegido: protegido, se puede acceder por clases y todas las subclases en el mismo paquete.
predeterminado: por defecto, las clases pueden acceder a él en el mismo paquete.
privado: privado, solo se puede acceder mediante métodos dentro de la clase.

Los modificadores de acceso se utilizan para controlar la visibilidad de los miembros de una clase. El modificador public significa que cualquier clase puede acceder al miembro, el modificador private significa que solo otros miembros de la misma clase pueden acceder al miembro, y el modificador protected significa que otras clases o subclases pueden acceder al miembro. el mismo paquete.

Se utilizan otros modificadores para controlar la mutabilidad de los miembros de una clase. El modificador estático indica que el miembro pertenece a la clase en sí y no a una instancia de la clase, y el modificador final indica que el valor del miembro no se puede cambiar.
Aquí hay una clase de ejemplo con propiedades y campos declarados con diferentes accesos y otros modificadores:

public class ExampleClass {
    
    
    public int publicInt;
    private String privateString;
    protected boolean protectedBoolean;
    static double staticDouble;
    final char finalChar = 'c';
}

En el ejemplo anterior, se puede acceder a la propiedad publicInt desde cualquier clase, solo se puede acceder al campo privateString desde otros miembros de la clase ExampleClass, se puede acceder al campo protectedBoolean desde otras clases en el mismo paquete o subclases de ExampleClass, y el La propiedad staticDouble pertenece a ExampleClass La clase en sí misma en lugar de una instancia de la clase, el valor del campo finalChar no se puede cambiar.

palabra clave privada

对象代表什么，就得封装对应的数据，并提供数据对应的行为

Es un modificador de permisos
que puede modificar miembros (variables de miembro y métodos de miembro).Los
miembros modificados por privado solo se pueden acceder en esta clase.

1. La palabra clave private es un modificador de permisos
2. Puede modificar miembros (variables de miembros y métodos de miembros
3. Solo se puede acceder a los miembros modificados por private en esta clase
4. Para las variables de miembros modificadas por private, si necesitan ser utilizadas por otras clases, proporcione las operaciones correspondientes
5. Proporcione el método "setXxx (parámetro)" para asignar valores a las variables miembro, el método se modifica con public 6.
Proporcione el método "getXxx ()" para obtener el valor de las variables miembro, y el el método se modifica con public

[2] Escribe el método de la clase. ^{–> Es decir, la función miembro 4} de la clase , estos métodos suelen reflejar el comportamiento del objeto.

El propósito de escribir métodos de clase en Java es realizar las funciones de la clase y encapsular algunas operaciones para que las llamen otros programas. En Java, un método es uno de los componentes más básicos de una clase que realiza una tarea específica y devuelve un resultado. Al escribir los métodos en la clase, la función de la clase se puede dividir en varias partes para mejorar la legibilidad y el mantenimiento del código.
Debe escribir el método de la clase, debe definir el nombre del método, la lista de parámetros, el tipo de valor de retorno y el cuerpo del método. El cuerpo del método contiene la lógica del código necesaria para implementar el método, así como los posibles valores de retorno.
Por ejemplo, supongamos que hay una clase Calculadora que puede implementar cuatro operaciones de suma, resta, multiplicación y división. El método de cálculo de suma add() se puede escribir en la clase Calculator a través del siguiente código de ejemplo:

public class Calculator {
    
    
    // 定义加法计算方法
    public int add(int a, int b) {
    
    
        return a + b;
    }
}

En este ejemplo, el nombre del método add() es add, la lista de parámetros son dos enteros a y b, y el tipo de retorno es un entero int. Este método implementa la función de sumar dos números a y b y devolver el resultado. En otros programas, los cálculos de suma se pueden implementar creando un objeto Calculadora y llamando al método add(). Por ejemplo:

Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
System.out.println(result);  // 输出5

En este ejemplo, se crea una calculadora de objetos Calculator y se llama a su método add() para sumar los dos números 2 y 3, y asignar el resultado a la variable de resultado. Finalmente, envíe el resultado llamando al método System.out.println().

instanciar la clase

Por ejemplo, si quisiera usar la clase "Persona" dentro de otra clase, podría escribir:

Person person = new Person();
person.name = "John";
person.sayHello();

Esto creará un objeto llamado "persona", establecerá su nombre en "Juan" y llamará a su método "sayHello".

Precauciones

Otros conceptos importantes a tener en cuenta al declarar clases Java incluyen variables y métodos estáticos, modificadores de acceso, nombres de paquetes, clases de importación, anotaciones, creación de objetos, herencia y polimorfismo, clases e interfaces abstractas, manejo de excepciones, manejo de memoria y convenciones de programación y estilo.

以下是Java中声明一个类需要做以下准备：

1. Defina el nombre de la clase: el nombre de la clase debe ser un nombre significativo, debe seguir el estilo camel y debe comenzar con una letra, no con un número u otros caracteres especiales.

2. Relación de herencia: si esta clase se hereda de otras clases, debe usar la palabra clave extends, seguida del nombre de la clase heredada. Si no existe una relación de herencia, esta parte puede omitirse.

3. Implementar interfaz: si esta clase necesita implementar alguna interfaz, debe usar la palabra clave implements, seguida del nombre de la interfaz. Esta sección se puede omitir si no se implementa ninguna interfaz.

4. Variables miembro: Defina variables miembro en la clase, es decir, los atributos de la clase. Debe especificar el tipo y el nombre de la variable, puede establecer el modificador de acceso y el valor inicial.

5. Método de construcción: el método de construcción se utiliza para crear el objeto e inicializar el estado del objeto. Debe especificar el nombre del método y la lista de parámetros, y puede configurar el modificador de acceso.

6. Método miembro: defina el comportamiento y la función de la clase. Debe especificar el nombre del método y la lista de parámetros, y puede establecer el modificador de acceso y el tipo de valor de retorno.

7. Clases internas: Java permite definir otras clases dentro de una clase, y estas clases se denominan clases internas. La clase interna debe definirse con la palabra clave class, y la clase interna puede acceder a las variables miembro y métodos de la clase externa.

   声明类的过程需要遵循Java的语法规则，代码需要放在类的大括号中。
   同时，类的声明应该符合Java的面向对象编程思想，即将数据和行为封装在一起，实现高内聚、低耦合的代码结构。
   

8. Variables y métodos estáticos: las variables y métodos estáticos se pueden declarar utilizando la palabra clave static, que pertenecen a la clase en lugar de a la instancia. Se puede acceder directamente a las variables y métodos estáticos por nombre de clase sin crear primero un objeto.

9. Modificadores de acceso: hay cuatro modificadores de acceso en Java, a saber, público, protegido, predeterminado y privado. Debe configurar los modificadores de acceso apropiados para controlar el acceso a los miembros de la clase según sea necesario.

10. Paquete ⁵ : para evitar conflictos de nombres, Java puede usar paquetes para organizar clases. El paquete de palabras clave debe usarse para declarar el nombre del paquete, y el nombre del paquete debe nombrarse de acuerdo con ciertas reglas.

11. Importar clase: si necesita usar clases en otros paquetes, puede usar la palabra clave importar para importar clases. Debe especificar la ruta completa de la clase o usar comodines para importar todas las clases en el paquete completo.

12. Comentarios: los comentarios se pueden usar en Java para explicar la función del código, de modo que otros desarrolladores puedan entender y mantener el código. Puede usar // para comentar una sola línea y /* ... */ para comentar varias líneas.

13. Creación de objetos: después de declarar una clase, puede usar la palabra clave new para crear un objeto de la clase. Debe especificar el nombre de la clase y la lista de parámetros del constructor, y puede asignar el objeto a una variable para operaciones posteriores.

14. Acceso a objetos: se puede acceder a las variables miembro y los métodos de una clase a través de un objeto. Debe usar un punto (.) para acceder a los miembros de un objeto, y también puede usar la palabra clave this para referirse al objeto actual.

15. Herencia y polimorfismo: La herencia y el polimorfismo de clases son compatibles con Java. Las subclases pueden heredar las propiedades y los métodos de la clase principal y pueden anular los métodos de la clase principal para lograr el polimorfismo.

16. Clases e interfaces abstractas: las clases e interfaces abstractas se pueden usar en Java para definir especificaciones y restricciones, y realizar la reutilización y extensión del código.

17. Manejo de excepciones: el mecanismo de manejo de excepciones se puede usar en Java para manejar las excepciones que pueden ocurrir cuando el programa se está ejecutando. Debe usar un bloque de instrucciones try-catch-finally para capturar y manejar las excepciones.

18. Gestión de la memoria: Java utiliza el mecanismo de recolección de elementos no utilizados para gestionar automáticamente la memoria sin liberación manual de la memoria. Sin embargo, es necesario evitar pérdidas de memoria y uso excesivo de memoria, y mejorar la eficiencia operativa y la estabilidad del programa.

19. Carga y ejecución de clases: el código Java debe pasar por varias etapas, como la compilación, la carga de clases, la inicialización de clases y la invocación de métodos en tiempo de ejecución. Es necesario comprender el principio de funcionamiento de la máquina virtual Java y dominar el proceso de carga y ejecución de clases.

20. Normas y estilos de programación: Java tiene un conjunto de normas y estilos de programación que deben seguirse para mejorar la legibilidad y el mantenimiento del código. Puede consultar los estándares de codificación oficiales de Oracle o seguir los estándares de codificación de compañías famosas como Google y Alibaba.

    Lo anterior es el trabajo preparatorio para declarar una clase en Java. Debe seguir las reglas gramaticales de Java y las ideas de programación orientada a objetos y, al mismo tiempo, seguir las convenciones de nomenclatura de Java, usar nombres significativos para representar clases, métodos y variables, y mejorar legibilidad y mantenibilidad del código.

Ampliar puntos de conocimiento

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

Además de los puntos básicos de conocimiento de objetos y clases, Java tiene muchos conceptos extendidos de programación orientada a objetos, tales como:

Herencia: La herencia es un mecanismo que permite que una clase herede las propiedades y métodos de otra clase. Las subclases pueden anular los métodos de la clase principal o agregar nuevos métodos y propiedades.
Polimorfismo: El polimorfismo es un mecanismo que permite que diferentes objetos respondan de manera diferente al mismo método. El polimorfismo se puede lograr a través de la herencia y las interfaces.
Clases e interfaces abstractas: Las clases e interfaces abstractas son mecanismos mediante los cuales se pueden utilizar para definir un conjunto de métodos, pero sin implementación. Una clase abstracta puede contener métodos implementados, mientras que una interfaz solo puede contener las firmas de los métodos.
Clase interna: una clase interna es una clase definida dentro de otra clase. Brindan acceso a propiedades y métodos de clases externas y se pueden usar para lograr la encapsulación y la reutilización de código.

2._.Objeto —> Puedes crear un objeto creando una instancia de una clase.

[1] crear

(1) Cómo obtener el objeto de la clase 类名 对象名 = new 类名();
(2) Cómo usar el objeto 访问属性: 对象名.成员变量+访问行为: 对象名.方法名(...)

public class 类名 {
    
    
成员变量 (代表属性)
成员方法 (代表行为)
构造器 
代码块 
内部类 
}

[2] En la programación orientada a objetos, un objeto es una entidad con comportamiento, estado e identidad.

(1) Comportamiento: El comportamiento de un objeto se refiere a las operaciones o métodos que puede realizar. Estos métodos definen la funcionalidad y el comportamiento del objeto.

El comportamiento de un objeto se refiere a las operaciones o métodos que puede realizar. Estos métodos definen la funcionalidad del objeto. En Java, define una clase y define métodos en ella. Por ejemplo, si tiene una clase llamada Coche, puede definir un método llamado conducción que realizará la acción de conducción del coche. Aquí hay un ejemplo:

public class Car {
    
    
  public void drive() {
    
    
    // code to drive the car
  }
}

Por ejemplo, en una clase llamada Car, puede haber un método llamado startEngine() que enciende el motor del auto.

(2) Estado: El estado de un objeto se refiere a sus atributos o datos. Estas propiedades describen el estado actual del objeto.

El estado de un objeto se refiere a sus propiedades o variables. Estas propiedades definen el estado actual del objeto. En Java, puede definir variables dentro de una clase. Por ejemplo, si tiene una clase llamada Coche, puede definir una variable llamada color que almacenará el color del coche.

public class Car {
    
    
  String color;
}

Por ejemplo, en una clase de automóvil, puede haber una propiedad denominada velocidad que describa la velocidad actual del automóvil.

(3) Identificación: La identificación de un objeto se refiere a su identificador único en el programa. Esto generalmente se logra a través de una referencia a un objeto o una dirección de memoria.

La identidad de un objeto se refiere a su singularidad. Cada objeto tiene un identificador único que lo distingue de otros objetos. En Java, cada objeto tiene una referencia única.

Car car1 = new Car();
Car car2 = new Car();

Por ejemplo, si crea un objeto Car llamado myCar en su programa, puede usar myCar para referirse al objeto.
En el ejemplo anterior, car1 y car2 son dos objetos diferentes, cada uno con su propio identificador único.

el código

public class Person {
    
    
    private String name;
    private int age;
    
    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
    
    
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
    
    public void setAge(int age) {
    
    
        this.age = age;
    }
    
    public int getAge() {
    
    
        return age;
    }
}

En este ejemplo, la clase Person tiene las siguientes propiedades y métodos:

name y age son los estados del objeto Person, que describen el nombre y la edad de una persona.
sayHello() es el comportamiento del objeto Person, que define un método para que una persona diga hola.
setAge() y getAge() son comportamientos del objeto Person, que definen métodos para establecer y obtener la edad de una persona.
La clase Person en sí misma es un objeto con su propio identificador al que se puede hacer referencia mediante el nombre de la clase.

resultado

【1】Instrucciones complementarias

La línea 12 es el final del constructor, por lo que no necesita aceptar parámetros. En el constructor, use la palabra clave "this" para referirse a las variables miembro de la clase para que se les asignen los parámetros pasados ​​al constructor. En este caso, "this.age" es la variable miembro "edad" de la clase a la que se le asigna el parámetro "edad" pasado al constructor. Esto se hace para evitar confusiones entre parámetros y variables miembro. Si no usa la palabra clave "this", el compilador no podrá distinguir entre parámetros y variables miembro, y pueden producirse errores. Por lo tanto, no hay diferencia entre "this.age" y "age", pero usar la palabra clave "this" puede hacer que el código sea más claro y comprensible.

【2】obtener+establecer

A través de los métodos get y set, podemos acceder y modificar el valor de la propiedad privada fuera de la clase, y al mismo tiempo controlar el acceso de la propiedad para garantizar la seguridad de la propiedad.

Para cada variable miembro privatizada, se deben proporcionar los métodos get y set. El
método set asigna valores a las variables miembro.
El método get: Proporciona el valor de la variable miembro.

Métodos de configuración y obtención de objetos de Java
En Java, los métodos de configuración y obtención de objetos son métodos públicos que se utilizan para acceder a las propiedades privadas de un objeto. El método set se usa para establecer el valor de la propiedad y el método get se usa para obtener el valor de la propiedad.

以下是一个示例类，其中包含一个私有属性name和对应的set和get方法：

public class Person {
    
    
    private String name;

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

    public String getName() {
    
    
        return this.name;
    }
}

En el ejemplo anterior, el método setName se usa para establecer el valor del atributo de nombre y el método getName se usa para obtener el valor del atributo de nombre. Tenga en cuenta que estos métodos son métodos públicos, por lo que se puede acceder a ellos desde fuera de la clase.

La ventaja de usar los métodos set y get es que puede controlar el acceso a las propiedades del objeto. Por ejemplo, si desea validar los valores de las propiedades antes de configurarlos, puede agregar una lógica de validación en el método set. Del mismo modo, si desea convertir el valor de la propiedad antes de obtenerlo, puede agregar la lógica de conversión en el método de obtención.

En Java, los métodos get y set son métodos utilizados para obtener y establecer propiedades privadas de una clase. Normalmente, el exterior no puede acceder directamente a las propiedades privadas, pero es necesario acceder a ellas a través de los métodos get y set.

(1) El método get se usa para obtener el valor de un atributo privado, y normalmente tiene las siguientes características: Debido a que solo devuelve el valor del campo de instancia, se le llama field accessor (accesor de campo)

• El nombre del método comienza con get, seguido del nombre de la propiedad, con la primera letra en mayúscula.
• El tipo de valor devuelto suele ser el tipo de datos del atributo.
• No hay parámetros.
  Código de muestra:

public class Person {
    
    
    private String name;
    public String getName() {
    
    
        return name;
    }
}

El método getter se usa para obtener el valor del atributo del objeto, generalmente comenzando con get, por ejemplo:

public int getAge() {
    
    
    return this.age;
}

Este método toma el valor de una propiedad entera llamada edad y lo devuelve.

(2) El método de fijación se utiliza para fijar el valor de una propiedad privada, generalmente con las siguientes características:

• El nombre del método comienza con set, seguido del nombre del atributo, con la primera letra en mayúscula.
• El tipo de valor devuelto suele ser nulo.
• Hay un parámetro cuyo tipo es el tipo de datos del atributo.
  Código de muestra:

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

El método setter se usa para cambiar el valor de propiedad del objeto, generalmente comenzando con set, por ejemplo:

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

Este método cambia el valor de una propiedad de cadena denominada nombre.

Estos dos métodos pueden mejorar la encapsulación y la seguridad del objeto, por lo que solo se puede acceder a las propiedades del objeto y modificarlas a través de estos dos métodos. De esta manera, si es necesario, se puede agregar algún código lógico dentro del método para controlar el acceso y la modificación de la propiedad.

public void setAge(int age) {
    
    
    if (age < 0) {
    
    
        System.out.println("年龄不能小于0");
    } else {
    
    
        this.age = age;
    }
}

¿Por qué get y set tienen vacío y uno no?

En Java, los métodos get y set se usan comúnmente para acceder y modificar variables privadas de una clase. El método get se usa para obtener el valor de la variable, y el método set se usa para establecer el valor de la variable. Por lo tanto, el método get normalmente devuelve el valor de la variable, mientras que el método set normalmente no devuelve ningún valor (es decir, void).

Esto se debe a que el propósito del método get es obtener el valor de la variable y el propósito del método set es establecer el valor de la variable. Si el método set devuelve un valor, puede generar confusión porque parece que está obteniendo el valor de la variable, cuando en realidad está configurando el valor de la variable.

[3] esta palabra clave (irreemplazable)no en método estáticoEn uso, debido a que los métodos estáticos no pertenecen a ningún objeto, no pueden usar la palabra clave this.

使用"this"关键字来引用成员变量。
例如："this.name"可以引用对象的"name"成员变量。

Es necesario usar la palabra clave this para hacer referencia a una variable de instancia cuando el parámetro del método y la variable de instancia tienen el mismo nombre. Esto se debe a que el compilador de Java prefiere los parámetros de método a las variables de instancia.
En Java, cuando define una variable o un método en una clase, se asocian de forma predeterminada con el objeto actual. Esto significa que cada objeto tiene su propio conjunto de variables y métodos de instancia. Cuando crea un nuevo objeto, Java asigna al objeto un nuevo conjunto de variables y métodos de instancia. Entonces, si define una variable o método en una clase, se asociarán con todos los objetos de esa clase.

• Si usa la palabra clave this en un método estático, el compilador informará un error. Debido a que los métodos estáticos no pertenecen a ningún objeto, no pueden usar la palabra clave this.

//this关键字用于引用当前对象的实例变量x：

public class MyClass {
    
    
    int x;

    public void setX(int x) {
    
    
        this.x = x;
    }
}
//setX方法将传递的参数x分配给当前对象的实例变量x。由于方法参数和实例变量具有相同的名称，因此使用this关键字来引用实例变量是必要的。

• Además, la palabra clave this también se puede usar para llamar a otros métodos del objeto actual

public class MyClass {
    
    
    int x;

    public void printX() {
    
    
        System.out.println(this.x);
    }
}
//printX方法使用this关键字来引用当前对象的实例变量x，并将其打印到控制台上。

En Java, tanto las variables miembro como los métodos de una clase pueden ser accedidos por otros métodos en la misma clase. Esto se debe a que todos pertenecen a la misma clase, por lo que comparten el mismo ámbito.
Si define el método printX() como estático, no puede acceder a la variable x internamente porque los métodos estáticos no pueden acceder a las variables miembro no estáticas. Si desea acceder a la variable x en el método estático, debe definir la variable x como estática.
Demuestra cómo acceder a variables estáticas en métodos estáticos:

public class MyClass {
    
    
    static int x;

    public static void printX() {
    
    
        System.out.println(x);
    }
}

(1) Principio de proximidad [esto puede distinguir variables miembro y variables locales]

La regla del vecino más cercano de Java significa que cuando se realiza la sobrecarga de métodos, cuando los tipos de parámetros no coinciden completamente, se seleccionará un método que sea más cercano al parámetro real (el más cercano) para llamar.

El principio de proximidad se aplica a escenarios de sobrecarga de métodos en Java. Cuando hay varios métodos sobrecargados, el compilador elige a qué método llamar según el tipo y la cantidad de parámetros. Si los tipos de parámetros no coinciden exactamente, el compilador convierte automáticamente los tipos de parámetros al tipo más cercano antes de elegir qué método llamar.

Por ejemplo, si existen los siguientes dos métodos:

public void foo(int a) {
    
    
    System.out.println("int");
}

public void foo(float a) {
    
    
    System.out.println("float");
}

Luego, cuando llamemos foo(3.5), el compilador convertirá automáticamente el tipo de parámetro al tipo más cercano, que es el foo(float a)método de llamada.

En resumen, el principio de proximidad de Java encontrará automáticamente la coincidencia más cercana para ejecutar el método, lo que mejora la flexibilidad y la legibilidad del programa.

especial

Cuando una clase tiene variables miembro. Cuando el nombre es el mismo que el de una variable local, si la variable local se llama directamente, se emite el valor de la variable local.
Si es salida this.变量名称, está generando variables miembro.

¿Por qué la variable local de edad sobrescribe directamente la asignación de edad referenciada de 123

De acuerdo con el código que proporcionó, veo que hay una edad de variable estática y un constructor en la clase Person3, y hay una edad de parámetro en el constructor. En el constructor, usó this.name = name para referirse al nombre de la variable miembro en la clase, pero no usó this.age = age para referirse a la variable estática age en la clase. Entonces, cuando declaras una variable local llamada edad en el método sayHello(), anula el valor de la variable estática edad. Si desea hacer referencia a la edad de la variable estática, debe usar Person3.age en lugar de declarar una variable local.

Si desea hacer referencia a la edad de la variable estática en el constructor, puede usar Person3.age o usar la edad directamente, porque ambos se refieren a la edad de la variable estática. Sin embargo, le recomiendo que use Person3.age ya que deja más claro que está haciendo referencia a una variable estática.

(2) Instancia dinámica VS estática

En una instancia dinámica, la palabra clave this apunta al objeto que actualmente está usando el método. Por ejemplo:

public class MyClass {
    
    
    private int num;

    public void setNum(int num) {
    
    
        this.num = num; // 使用this关键字指向当前对象的num属性
    }
}

MyClass obj = new MyClass();
obj.setNum(10); // 调用setNum方法，并传入10作为参数

En instancias estáticas, no se puede usar esta palabra clave. Debido a que los métodos estáticos no dependen de ningún objeto, se cargan junto con la clase y solo pueden acceder a miembros y métodos estáticos. Por ejemplo:

public class MyClass {
    
    
    private static int num;

    public static void setNum(int num) {
    
    
        MyClass.num = num; // 直接使用类名引用静态属性
    }
}

MyClass.setNum(10); // 调用setNum方法，并传入10作为参数

(3) Privado y Compartido

La palabra clave this en Java representa el objeto actual, ya sea que el objeto sea privado o público.

En métodos privados y propiedades privadas, la palabra clave this se usa para referirse a las propiedades y métodos privados del objeto actual. Por ejemplo:

public class Person {
    
    
   private String name;

   public void setName(String name) {
    
    
     this.name = name; //使用this引用当前对象的私有属性
   }

   private void printName() {
    
    
     System.out.println("My name is " + this.name); //使用this引用当前对象的私有方法
   }
}

En métodos públicos y propiedades públicas, la palabra clave this también se puede usar para hacer referencia a las propiedades y métodos públicos del objeto actual, pero generalmente se puede omitir esta palabra clave. Por ejemplo:

public class Person {
    
    
   public String name;

   public void printName() {
    
    
     System.out.println("My name is " + name); //直接引用公有属性，省略this关键字
   }
}

(4) código interno

La palabra clave this en Java es una referencia especial que apunta a la dirección de memoria del objeto actual. En Java, cada objeto tiene su propio espacio de memoria independiente, y la palabra clave this nos permite acceder a sus propias propiedades y métodos dentro del objeto. La sintaxis para usar esta palabra clave en Java es la siguiente:

1. Use la palabra clave this para acceder a las propiedades del objeto actual:

public class Person {
    
    
    private String name;

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

2. Use la palabra clave this para llamar al método del objeto actual:

public class Person {
    
    
    public void sayHello() {
    
    
        System.out.println("Hello, my name is " + this.getName());
    }
}

3. Use la palabra clave this en el constructor para llamar a otros constructores del objeto actual:

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

    public Person() {
    
    
        this("", 0); // 调用另一个构造函数
    }

    public Person(String name) {
    
    
        this(name, 0); // 调用另一个构造函数
    }

    public Person(int age) {
    
    
        this("", age); // 调用另一个构造函数
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
}
```Java中的this关键字是一个特殊的引用，它指向当前对象的内存地址。在Java中，每个对象都有自己独立的内存空间，this关键字可以让我们在对象内部访问自身的属性和方法。在Java中使用this关键字的语法如下：

1. 使用this关键字访问当前对象的属性：

```java
public class Person {
    
    
    private String name;

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

2. Use la palabra clave this para llamar al método del objeto actual:

public class Person {
    
    
    public void sayHello() {
    
    
        System.out.println("Hello, my name is " + this.getName());
    }
}

3. Use la palabra clave this en el constructor para llamar a otros constructores del objeto actual:

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

    public Person() {
    
    
        this("", 0); // 调用另一个构造函数
    }

    public Person(String name) {
    
    
        this(name, 0); // 调用另一个构造函数
    }

    public Person(int age) {
    
    
        this("", age); // 调用另一个构造函数
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
}

No es necesario que esto indique un campo implícito.

package work629;

public class BOOK {
    
    
    private String author;
    private String title;
    
    public BOOK() {
    
    
    }

    public BOOK(String author1, String title) {
    
    
        author1 = author;
        this.title = title;
    }

    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 void showDisplayBook() {
    
    
        System.out.println("Author: " + author);
        System.out.println("Title: " + this.title);
    }
}

Precauciones

(1) Instanciar un objeto: para usar una clase, primero debe crear una instancia de la clase. Puede usar la nueva palabra clave para instanciar un objeto de la siguiente manera: Person3 person = new Person3("Alice", 25);Esto creará un objeto Person3 llamado persona con el nombre "Alice" y 25 años.
(2) Acceder a las propiedades del objeto: Para acceder a las propiedades del objeto se puede utilizar el operador punto. De la siguiente manera: String name = person.name;
int age = person.age;Esto almacenará el nombre y la edad del objeto persona en las variables de nombre y edad respectivamente.
(3) Llamar al método del objeto: para llamar al método del objeto, puede usar el operador punto seguido del nombre del método y corchetes, como se muestra a continuación: Esto llamará al método sayHello() del objeto person.sayHello();persona , que imprimirá el nombre y la edad del objeto.
(4) Comprender el ciclo de vida de un objeto: el ciclo de vida de un objeto se refiere a todo el proceso desde la creación hasta la destrucción de un objeto. En Java, el recolector de basura administra la vida útil de un objeto. El recolector de basura destruirá automáticamente el objeto cuando ya no se haga referencia a él.

[3] Resumen

Las clases y los objetos de Java son conceptos importantes en la programación de Java. Una clase es una plantilla o modelo para crear objetos. Los objetos son instancias de clases y tienen estado y comportamiento. Para crear una clase, debe usar la palabra clave "clase" seguida del nombre de la clase y definir variables y métodos dentro de la clase. Para crear un objeto, debe usar la palabra clave "nuevo" seguida del nombre de la clase y asignarlo a una variable. Para acceder a una variable o método de un objeto, debe usar un punto (.) seguido del nombre de la variable o método. ,

Presta atención al uso de esta palabra clave

package work629;

public class BOOK {
    
    
    private static 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) {
    
    
        BOOK.author = author;
        this.title = title;
        this.price = price;
        this.publisher = publisher;
        this.publishedYear = publishedYear;
    }

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

    public void setAuthor(String author) {
    
    
        BOOK.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 static void showDisplayBook() {
    
    
        System.out.println("Author: " + BOOK.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);
    }

}

Solución 1: cambie las variables miembro a variables estáticas

package work629;

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

    // 省略其他代码...
    
    public static void showDisplayBook() {
    
    
        System.out.println("Author: " + BOOK.author);
        System.out.println("Title: " + BOOK.title);
        System.out.println("Price: " + BOOK.price);
        System.out.println("Publisher: " + BOOK.publisher);
        System.out.println("Published Year: " + BOOK.publishedYear);
    }
}

Solución 2: Cambie el método showDisplayBook a un método no estático

package work629;

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

    // 省略其他代码...
    
    public void showDisplayBook() {
    
    
        System.out.println("Author: " + BOOK.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);
    }
}

En Java, los métodos estáticos no pueden acceder a las variables miembro no estáticas, por lo que en el método showDisplayBook, no puede acceder directamente a this.title, this.price, this.publisher y this.publishedYear.

problema resuelto

RESERVAR clase

package work629;

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

    // 省略其他代码...

    public void showDisplayBook() {
    
    
        // System.out.println("Author: " + BOOK.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);
    }
}

Clase de prueba BOOKTest

package work629;

public class BOOKTest {
    
    
    public static void main(String[] args) {
    
    
        // BOOK book1 = new BOOK();
        // BOOK book2 = new BOOK();
        System.out.println("作者" + BOOK.author);
        BOOK.author = "Author Name";
        System.out.println(BOOK.author);
        // " 书名" + book1.getTitle() + " 价格" + book1.getPrice() + " 出版社"
        // + book1.getPublisher() + " 出版年间" + book1.getPublishedYear());

        // book1.showDisplayBook();
    }
}

¿Por qué tienes que usar el objeto para llamar al autor para el privado y usar el objeto o el método para el estático?

Las variables de miembros privados deben llamarse usando objetos porque solo se puede acceder a las variables de miembros privados dentro de la clase y no se puede acceder directamente fuera de la clase. Por lo tanto, si desea acceder a una variable miembro privada fuera de la clase, debe llamarla a través del objeto.

Se puede acceder a las variables de miembros estáticos directamente por nombre de clase sin crear un objeto. Esto se debe a que las variables miembro estáticas pertenecen a la clase en sí, no a las instancias de la clase. Por lo tanto, puede acceder a las variables miembro estáticas por nombre de clase.

Para métodos estáticos, puede llamarlos por nombre de clase u objeto. Si llama a un método estático utilizando el nombre de la clase, se ejecutará directamente en la clase. Si llama a un método estático con un objeto, se ejecuta en el objeto, pero en realidad ignora el objeto y se ejecuta en la clase.

---

1. Una instancia de Java se refiere a una instancia específica de un objeto o clase creada en un programa. En Java, una clase es un concepto abstracto y un objeto es una instancia concreta de una clase. La creación de una instancia de una clase Java requiere el uso de la palabra clave "nuevo" para asignar memoria e inicializar propiedades y métodos de la clase. Al crear una instancia de una clase Java, se puede acceder a las propiedades y métodos de la clase y modificarlos en el programa para lograr las funciones requeridas.

   La programación orientada a objetos tiene tres características básicas: ↩︎

2. Si una variable miembro se declara como privada, solo se puede acceder a ella en la clase actual y otras clases no pueden acceder a ella. Si necesita usar esta variable miembro en otras clases, puede proporcionar los métodos de obtención y configuración correspondientes. El método getter se usa para obtener el valor de la variable miembro, y el método setter se usa para establecer el valor de la variable miembro. De esta forma, otras clases pueden acceder indirectamente a las variables miembro privadas llamando a los métodos getter y setter. Este enfoque puede garantizar la seguridad de las variables miembro privadas, pero también proporciona una forma segura de usarlas y modificarlas. ↩︎

3. Una clase JavaBean es un tipo especial de clase Java que sigue algunas convenciones de nomenclatura y diseño para su uso en la plataforma Java. Las clases de JavaBean se utilizan normalmente para representar objetos de datos en aplicaciones, como usuarios, pedidos o productos. Contienen propiedades privadas (variables miembro) y métodos públicos (captadores y definidores) que se utilizan para acceder y modificar estas propiedades. Las clases JavaBean también pueden implementar la interfaz serializable para que puedan serializarse en flujos de bytes para su transmisión a través de la red o almacenamiento en disco. La convención de nomenclatura para las clases de JavaBean suele ser que el nombre de la clase comienza con una letra mayúscula y el nombre de la propiedad comienza con una letra minúscula, mientras que la convención de nomenclatura para los métodos getter y setter comienza con get y set seguido del nombre de la propiedad. ↩︎

4. Una función miembro es una función definida en una clase, también conocida como método de clase. Las funciones miembro de una clase pueden acceder a las variables miembro de la clase y también pueden llamar a otras funciones miembro. Las funciones de los miembros pueden ser públicas, privadas o protegidas, según sus modificadores de acceso. Hay dos tipos de funciones miembro en una clase: funciones de instancia y funciones estáticas.
   Una función de instancia es una función definida en una clase que debe llamarse a través de una instancia de la clase. Las funciones de instancia pueden acceder a variables de instancia y métodos de instancia en la clase, y pueden hacer referencia a la instancia actual a través de esta palabra clave.
   Una función estática es una función definida en una clase que no necesita ser llamada a través de una instancia de la clase. Las funciones estáticas pueden acceder a variables estáticas y métodos estáticos en la clase, y no pueden hacer referencia a la instancia actual a través de esta palabra clave.
   El papel de la función miembro es realizar la función de la clase y encapsular algunas operaciones para que las llamen otros programas. A través de las funciones miembro, la función de la clase se puede dividir en varias partes, lo que mejora la legibilidad y la capacidad de mantenimiento del código. Las funciones miembro pueden implementar cualquier tarea, como computación, salida, modificación del estado de un objeto, etc.
   Por ejemplo, supongamos que hay una clase Person, que contiene dos atributos, nombre y edad, y dos métodos setName() y setAge(), puede definir una función miembro sayHello() a través del siguiente código: ```java public class Persona
   { private String nombre; private int edad;
   
   

   // 定义sayHello方法
   public void sayHello() { System.out.println("Hola, mi nombre es " + nombre + ", tengo " + edad + " años.”); }
   
   

   // Definir el método setName
   public void setName(String name) { this.name = name; } // Definir el método setAge public void setAge(int age) { this.age = age; }}``En este ejemplo, sayHello ( ) es una función de instancia que genera el nombre y la edad del objeto. Los métodos setName() y setAge() también son funciones de instancia, que se utilizan para establecer el nombre y la edad del objeto. En otros programas, puede generar la información del objeto creando un objeto Person y llamando al método sayHello(). Por ejemplo: En este ejemplo, se crea un objeto Person, y el nombre y la antigüedad del objeto se establecen llamando a los métodos setName() y setAge(). Finalmente, genera la información del objeto llamando al método sayHello(). ↩︎
   
   
   
   
   
   
   Person person = new Person();
person.setName("Tom");
person.setAge(20);
person.sayHello(); // 输出Hello, my name is Tom, I am 20 years old.
   

5. Los paquetes en Java son un mecanismo para organizar y administrar clases e interfaces. Los paquetes pueden contener otros paquetes y clases. Son una forma de espacios de nombres en Java y pueden ayudar a evitar conflictos de nombres.

   En Java, la declaración del paquete debe ser la primera línea del archivo, como sigue: package com.example.mypackage;
   Esta declaración le dice al compilador que todas las clases en este archivo pertenecen al com.example.mypackagepaquete.

   En Java, la convención de nomenclatura para paquetes es el nombre de dominio inverso. Esto significa que debe prefijar el paquete con el nombre de su dominio u organización, seguido del nombre de su proyecto. Por ejemplo, si su nombre de dominio es example.com, el nombre de su proyecto es myproject, el nombre de su paquete debería ser com.example.myproject.
   Puede usar paquetes para organizar su código y hacerlo más manejable. Por ejemplo, podría poner todas sus clases relacionadas con la base de datos com.example.myproject.dben un paquete llamado . De esta manera, puede encontrar y mantener estas clases más fácilmente. ↩︎