Página inicial do meu blog pessoal: Se '' pode realmente escapar 1️⃣ diga 1️⃣ página inicial do blog
Sobre aprendizado básico de gramática Java ----> Você pode consultar meu blog: "Eu aprendo Java no VScode"
Sobre mim aprendendo Java no VScode (método Java )

Uma classe é uma coleção de objetos que descrevem um grupo de objetos que possuem as mesmas características (atributos) e comportamentos (métodos).
As características possuídas por um objeto ou entidade são chamadas de atributos de uma classe quando expressas em uma classe. As operações realizadas por um objeto são chamadas de métodos da classe.

Diretório de artigos

Zero._ Programação Orientada a Objetos ----> A importância reside no fato de fornecer um estilo de programação mais modular, reutilizável e de fácil manutenção, o que facilita a organização e o gerenciamento do código, decompondo-o em objetos.
1._.Classe --->== Classe é uma coleção de objetos que descrevem um grupo de objetos com as mesmas características (atributos) e o mesmo comportamento (métodos). == Uma classe é um tipo de dados definido pelo usuário, incluindo membros de dados [atributos de classe] e membros de método [comportamento de classe]. Uma classe define as propriedades e o comportamento de um objeto, e um objeto representa uma instância da classe.
2._.Objeto ---> Você pode criar um objeto criando uma instância de uma classe.

Zero._ Programação Orientada a Objetos ----> A importância reside no fato de fornecer um estilo de programação mais modular, reutilizável e de fácil manutenção, o que facilita a organização e o gerenciamento do código, decompondo-o em objetos.

Programação Orientada a Objetos (OOP) é um paradigma de programação que combina dados e métodos de manipulação de dados para que dados e comportamento possam ser vistos como um todo. A história desse paradigma de programação remonta à década de 1960, mas não se tornou popular até a década de 1980.

Na programação orientada a objetos, os dados e métodos são organizados em classes (Class), que é um tipo de dado abstrato que define um conjunto de propriedades e métodos. Object (Object) é uma instância de uma classe ^, que contém as propriedades e métodos da classe. Ao criar um objeto, podemos usar os métodos definidos na classe para manipular as propriedades do objeto.

(1) Encapsulamento: Combine dados e comportamento e trate-os como uma única entidade. Isso evita que o código externo acesse diretamente os dados do objeto, melhorando a segurança e a capacidade de manutenção do código.

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

O encapsulamento (às vezes chamado de ocultação de informações) é um conceito importante ao trabalhar com objetos. Formalmente, o encapsulamento é a combinação de dados e comportamento em um pacote, e os detalhes específicos da implementação ficam ocultos do usuário do objeto. Os dados em um objeto são chamados de campo de instância e o processo de manipulação dos dados é chamado de método. Como instância de uma classe, um objeto específico possui um conjunto específico de valores de campo de instância. A coleção desses valores é o estado atual do objeto. Sempre que um método é chamado em um objeto, seu estado pode mudar.

A chave para o encapsulamento é que
os métodos em outras classes nunca devem ter permissão para acessar diretamente os campos de instância dessa classe.
Os programas só podem interagir com os dados do objeto por meio dos métodos do objeto. O encapsulamento dá aos objetos um caráter de "caixa preta", que é a chave para aumentar a reutilização e a confiabilidade. Isso significa que uma classe pode mudar completamente a maneira como os dados são armazenados, desde que os dados ainda sejam manipulados da mesma maneira, outros objetos não saberão ou se importarão com as alterações nessa classe.

exemplo de código

define uma classe de aluno


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

Escreva um código de teste para uma classe de aluno

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

Atribuir e emitir DEMO2

Use set e obtenha depois de privado. Na função principal principal, use对象名名称 =new 对象的类（）

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

【2】Ou use 名称.set成员变量（==写想要赋的值==）para atribuição.
, saída diretasy.o.p(名称.get成员变量（））

Resumido da seguinte forma:

(1) A palavra-chave privada é um modificador de permissão que pode modificar membros (variáveis de membro e métodos de membro). Membros modificados por private só podem ser acessados nesta classe
(2) Para variáveis de membro modificadas por private, se elas precisarem ser usadas por outras classes, forneça as operações correspondentes ²

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

(2) Herança (Inheritance): Permite a criação de uma nova classe que herda propriedades e métodos de classes existentes. Isso reduz a duplicação de código e facilita a manutenção do código.

A herança é outro conceito importante na programação orientada a objetos. A herança nos permite definir uma nova classe que herda as propriedades e métodos da classe original. No relacionamento de herança, a classe original é chamada de classe pai, classe base ou superclasse, e a classe recém-criada é chamada de subclasse ou classe derivada.

As subclasses podem herdar todas as propriedades e métodos públicos da classe pai e também podem definir novas propriedades e métodos. A herança nos permite reduzir o esforço de escrever código semelhante repetidamente, reutilizando o código. Além disso, por meio da herança, podemos organizar e projetar melhor a estrutura do programa, tornando o código mais fácil de manter e expandir.

Em Java, a palavra-chave extends é usada para declarar que uma classe herda de outra classe. As subclasses podem substituir os métodos da classe pai para atender às suas próprias necessidades específicas. Além disso, Java também suporta herança múltipla, ou seja, uma subclasse pode herdar as propriedades e métodos de várias classes pai (interfaces) ao mesmo tempo.

A combinação de herança e encapsulamento pode realizar melhor os princípios básicos da programação orientada a objetos, ou seja, o "princípio de abertura e fechamento" e o "princípio de responsabilidade única". O princípio aberto-fechado significa que uma entidade de software (classe, módulo, etc.) deve ser aberta para extensão e fechada para modificação. Por meio da herança, podemos implementar novas funções estendendo a classe pai sem modificar o código original. O Princípio da Responsabilidade Única afirma que uma classe deve ter apenas uma responsabilidade. Por meio da herança, podemos organizar a estrutura do código para que cada classe seja responsável apenas por sua funcionalidade específica.

o código

É uma classe Java chamada Animal.

Ele tem um nome de propriedade protegida e um construtor que inicializa a propriedade de nome. Existe também um método chamado speak na classe, que é usado para produzir a vocalização do 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 é uma classe Cat que herda da classe Animal.

A classe Cat tem um construtor que inicializa sua propriedade name e também tem um método speak que gera as vocalizações do gato. No método speak, o atributo name é usado para exibir o nome do gato e seu som.

código mostra como abaixo:

package PLAYYYYY;

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

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

Esta é uma classe Dog que herda da classe Animal.

A classe Dog tem um construtor que inicializa sua propriedade name e também tem um método speak que gera as vocalizações do cachorro. No método speak, o atributo name é usado para exibir o nome do cachorro e seu som de latido.

código mostra como abaixo:

package PLAYYYYY;

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

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

Esta é uma classe com um método main que cria objetos Animal, Dog e Cat e chama seus métodos speak.

Primeiro, um objeto Animal chamado "Animal Genérico" é criado e "O animal fala." é gerado. Em seguida, um objeto Cachorro chamado "Rufus" é criado, que gera "Rufus diz au!". Finalmente, um objeto Cat chamado "Whiskers" é criado, que gera "Whiskers says meow!".

código mostra como abaixo:

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 (Polimorfismo): Permite a utilização de um mesmo método para tratar diferentes tipos de objetos. Isso melhora a escalabilidade e a reutilização do código.

O polimorfismo é outro conceito importante na programação orientada a objetos. Ele permite que diferentes objetos respondam de maneira diferente à mesma mensagem. Isso significa que o programa pode chamar diferentes métodos de acordo com diferentes objetos sem conhecer o tipo específico do objeto.

Em Java, o polimorfismo pode ser alcançado por meio de sobrecarga de método e substituição de método. A sobrecarga de método refere-se à definição de vários métodos em uma classe com o mesmo nome de método, mas com listas de parâmetros diferentes. Quando o programa chamar esse método, o Java determinará qual método chamar com base na lista de parâmetros. A substituição de método significa que as subclasses substituem os métodos da classe pai para atender às suas próprias necessidades específicas. Quando o programa chamar esse método, o Java determinará qual método chamar com base no tipo real do objeto.

A vantagem do polimorfismo é que ele aumenta a flexibilidade e a escalabilidade do código. Por meio do polimorfismo, podemos escrever um código mais geral, tornando o programa mais reutilizável e de fácil manutenção. Além disso, o polimorfismo também pode tornar os programadores mais bem orientados para a programação abstrata, de modo a entender e projetar sistemas de programas complexos.

Em resumo, encapsulamento, herança e polimorfismo são três conceitos básicos na programação orientada a objetos. Eles podem tornar os programas mais fáceis de entender, manter e estender. No design real, os programadores devem usar esses conceitos de forma flexível de acordo com as necessidades específicas para obter melhor qualidade de código e eficiência no desenvolvimento de software.

Aqui está uma introdução à programação orientada a objetos em C++, Python e Java:

【1】Vantagens e desvantagens

（1）C++：

== Vantagens: ==

C++ roda muito rápido e é adequado para aplicativos que exigem alto desempenho.
C++ fornece uma grande variedade de bibliotecas de classes e estruturas de dados, que podem manipular facilmente os cálculos e operações subjacentes.
A memória pode ser manipulada diretamente, fornecendo um controle mais refinado.
deficiência:

A sintaxe C++ é mais complicada e requer mais aprendizado e acúmulo de experiência.
Como a memória pode ser manipulada diretamente, é fácil causar problemas como vazamentos de memória.

（2）Python：

vantagem:

O código Python é conciso e fácil de entender, fácil de aprender e usar.
O Python fornece uma variedade de bibliotecas de classes e estruturas que podem criar rapidamente vários aplicativos.
O Python oferece suporte a conceitos avançados de programação, como decoradores e fechamentos, que podem aumentar a flexibilidade e a reutilização do código.
== Contras: ==

A velocidade de execução do Python é relativamente lenta e não é adequada para processar grandes quantidades de dados e cálculos de alto desempenho.
O método de gerenciamento de memória do Python é relativamente complicado e propenso a problemas como vazamentos de memória.

（3）Java：

vantagem:

Java é relativamente rápido e adequado para criar aplicativos grandes.
Java fornece poderosas funções de programação orientada a objetos, suportando recursos como polimorfismo, herança e encapsulamento.
Java tem uma boa plataforma cruzada e pode ser executado em diferentes sistemas operacionais.
== Contras: ==

A sintaxe Java é relativamente incômoda e requer mais aprendizado e acúmulo de experiência.
Os aplicativos Java precisam contar com máquinas virtuais para serem executados, o que pode afetar sua eficiência operacional.

[2] Gravata diferente:

C++ e Java exigem gerenciamento de memória explícito, enquanto Python suporta gerenciamento de memória automático.
Tanto o Python quanto o Java oferecem suporte à digitação dinâmica, enquanto o C++ exige que os tipos sejam determinados em tempo de compilação.
C++ e Java suportam programação multithread, e Python suporta programação de co-rotina.
C++ e Java podem escrever código de máquina diretamente, enquanto Python precisa interpretar o código em bytecode antes de executá-lo.

Exemplo de uma classe C++:

Em C++, podemos criar nossos próprios objetos definindo uma classe e usar os métodos definidos na classe para manipular as propriedades do 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;
}

Exemplo de uma classe Python:

Tudo em Python é um objeto, incluindo números, strings, funções e muito mais. Podemos criar nossos próprios objetos definindo uma classe e usar os métodos definidos na classe para manipular as propriedades do 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()

Exemplo de uma classe Java:

Em Java, todos os tipos de dados são objetos, incluindo tipos de dados básicos (como int, float, etc.) e tipos de dados de referência (como arrays, strings, etc.). Classes e objetos em Java são definidos de maneira semelhante ao 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();

Resumindo, C++, Python e Java são poderosas linguagens de programação orientadas a objetos e também suportam os três recursos básicos de encapsulamento, herança e polimorfismo.
A programação orientada a objetos é um poderoso paradigma de programação que fornece um estilo de programação mais modular, reutilizável e fácil de manter. A programação orientada a objetos é uma forma natural de programação.Podemos criar nossos próprios objetos definindo classes e usar os métodos definidos nas classes para manipular as propriedades dos objetos.

1._.Class —>== class é uma coleção de objetos que descrevem um grupo de objetos com as mesmas características (atributos) e o mesmo comportamento (métodos). == Uma classe é um tipo de dados definido pelo usuário, incluindo membros de dados [atributos de classe] e membros de método [comportamento de classe]. Uma classe define as propriedades e o comportamento de um objeto, e um objeto representa uma instância da classe.

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

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

Uma classe Java é uma estrutura de dados e um objeto é uma instância de uma classe. [A classe deve ser projetada antes que o objeto possa ser obtido. 】Descreve um grupo de objetos com as mesmas características e comportamento.Uma classe define as propriedades e métodos de um objeto, e um objeto é uma instância de uma classe.
Em Java, uma classe é um mecanismo de encapsulamento que fornece uma maneira de combinar dados e comportamento para organizar o código em unidades lógicas. As classes desempenham um papel vital na programação orientada a objetos, que permite aos programadores encapsular dados de código para melhor controlar e gerenciar o comportamento dos aplicativos.

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

Classe é um conceito importante na programação orientada a objetos.É um tipo de dados definido pelo usuário que pode conter atributos e métodos. Uma classe pode ser considerada como uma espécie de modelo ou projeto para a criação de objetos.

Outro princípio da OOP que torna mais fácil para os usuários definir classes Java é que novas classes podem ser construídas estendendo outras classes. Na verdade, Java fornece uma "superclasse mágica" chamada objeto. Todas as outras classes se estendem dessa classe de objeto.

Em Java, definir uma classe precisa conter o seguinte: a classe deve sempre começar com uma letra inicial maiúscula e o nome do arquivo java deve corresponder ao nome da classe.

O modificador de acesso da classe (público, privado, protegido ou padrão)
o nome da classe, usando camelCase maiúsculo (por exemplo, MyClass)
o corpo da classe, envolvendo
os membros da classe com um par de chaves, incluindo campos , métodos, construtores, classes aninhadas etc.

Aqui está um exemplo de uma classe Java simples que incorpora todos os itens acima:

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

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

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

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

Instruções para definir as classes: As classes devem sempre começar com uma letra inicial maiúscula e o nome do arquivo java deve corresponder ao nome da classe.

(1) A classe que escreve o método principal é chamada 测试类Podemos criar um objeto da classe javabean na classe de teste e fazer uma chamada de atribuição.
(2) A classe usada para descrever uma classe de coisas, profissionalmente Javabean类na classe Javabean ³ , não escreve o método principal.

Notas sobre a definição de classes

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

(1) Recomenda-se que a primeira letra do nome da classe seja maiúscula e o nome precisa ser conhecido. Modo Camel
(2) Várias classes podem ser definidas em um arquivo Java e apenas uma classe pode ser modificada publicamente, e o o nome da classe modificada pública deve se tornar o nome do arquivo de código. No desenvolvimento real, é recomendado que um arquivo defina uma classe
(3) O formato de definição completa das variáveis de membro é:修饰符数据类型变量名称 = 初始化值;[Geralmente, não há necessidade de especificar um valor de inicialização e há um valor padrão. 】
insira a descrição da imagem aqui

Em Java, uma definição de classe geralmente consiste nas seguintes partes:

Modificadores para classes: Os modificadores para classes podem ser públicos, privados, protegidos ou padrão (ou seja, sem modificadores). Esses modificadores controlam a visibilidade e o nível de acesso da classe.
Nomes de classe: Os nomes de classe devem começar com letra maiúscula e seguir camelCase.
Classe pai: Uma classe em Java pode herdar outra classe, e essa classe herdada é chamada de classe pai ou superclasse. A herança pode tornar o código mais conciso e reutilizável.
Interfaces implementadas: uma classe em Java pode implementar uma ou mais interfaces, e uma interface define um conjunto de métodos que uma classe deve implementar. As interfaces podem ser usadas para obter polimorfismo e reutilização de código.
Atributos de uma classe: Os atributos de uma classe são variáveis que descrevem o estado de um objeto. Eles podem ser tipos primitivos (como int, double, etc.) ou tipos de objeto (como String, Date, etc.).
Métodos de classe: Os métodos de classe são funções que descrevem o comportamento de um objeto. Eles podem ser estáticos ou não estáticos, podem ter parâmetros e valores de retorno.

Crie uma palavra-chave de classe new para criar um objeto e chame o construtor do objeto para inicializar. Use os métodos e propriedades do objeto para operar.

Em Java, para definir uma classe, você precisa usar a palavra-chave class e especificar o nome da classe. As propriedades e métodos de classe são definidos dentro das chaves da classe. O processo de construção de um objeto a partir de uma classe é chamado de criação de uma instância da classe.

Um modelo para uma classe Java completa, incluindo definições de propriedade e método. Observe que você pode alterar o modificador da classe (public, abstract ou final) como desejar e se ele estende outra classe ou implementa uma interface.

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>) {
    
    
        // 方法体
    }

    ...
}

A seguir, uma explicação detalhada do modelo de código:

<class_name>: o nome da classe, você pode alterá-lo de acordo com suas necessidades.
abstract|final: O modificador da classe, que pode ser uma classe abstrata ou uma classe final, e você pode alterá-lo conforme sua necessidade.
extends <class_name>: herança de classe, se você precisar herdar outra classe, você pode usar esta opção e substituir <class_name> pelo nome da classe que deseja herdar.
implements <interface_name>: a implementação da classe, se você precisar implementar uma ou mais interfaces, pode usar esta opção e substituir <interface_name> pelo nome da interface a ser implementada.
<property_type>: O tipo da propriedade, que pode ser qualquer tipo de dados Java, como int, double, String, etc.
propriedade, propriedade2, propriedade3: o nome da propriedade, você pode alterá-lo de acordo com suas necessidades.
function1(), function2(), function3(): o nome do método, você pode alterá-lo de acordo com suas necessidades.
<access_modifier>: O modificador de acesso do método, que pode ser público, privado, protegido ou não escrito, e você pode alterá-lo conforme sua necessidade.
<return_type>: O tipo de retorno do método, que pode ser qualquer tipo de dado Java, como int, double, String, etc.
<parameter_list>: A lista de parâmetros do método. Se o método exigir parâmetros, o tipo e o nome dos parâmetros podem ser listados aqui.

Passos para criar uma classe

Os passos para definir uma classe são os seguintes:

Primeiro, determine o nome e o propósito da classe, geralmente para descrever um objeto ou um grupo de objetos relacionados.
Em seguida, determine os atributos da classe, ou seja, os membros de dados da classe, que geralmente refletem o estado do objeto.
Identifique os métodos de uma classe, ou seja, as funções-membro de uma classe, que geralmente refletem o comportamento de um objeto.
Agrupe propriedades e métodos em classes e use modificadores de acesso para definir sua visibilidade e nível de proteção.
Escreva construtores e destruidores de classe (se necessário) e outras funções necessárias.
Instancie objetos desta classe no programa e use-os para chamar métodos da classe.
Quando necessário, estenda a funcionalidade da classe herdando ou implementando a interface.

[1] Use a palavra-chave "class" para declarar o nome de uma classe.

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

[2] Escreva as propriedades e métodos da classe entre as chaves da classe.

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

Por exemplo, para adicionar uma propriedade chamada "name" e um método chamado "sayHello" à classe "Person", você escreveria:

public class Person {
    
    
    String name;

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

[1] Variáveis de tipo contidas em uma classe:

(1) Variáveis de instância (também conhecidas como variáveis de membro): O escopo é a classe inteira e pode ser acessado por qualquer método ou construtor da classe.

Uma variável de instância em Java refere-se a uma variável que pertence a uma instância (objeto) de uma classe, também conhecida como variável de membro. Eles são declarados dentro da classe, mas fora do método. Cada instância de uma classe tem seu próprio conjunto de variáveis de instância, que podem ter valores diferentes.
Variáveis de instância podem ser qualquer tipo de dado básico (como int, float, double, etc.) e qualquer tipo de referência (como string, array, etc.). Seus valores podem ser definidos ou recuperados acessando o objeto instância da classe.

o código

Suponha que temos uma classe chamada Person, que possui as variáveis de instância name e age, que podem ser declaradas assim:

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

Neste exemplo, name e age são variáveis de instância da classe Person. Eles são declarados como tipos String e int, então cada objeto Person tem seu próprio nome e valores de idade.
Podemos usar essas variáveis de instância criando um objeto Person e definindo suas propriedades:

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

Neste exemplo, criamos dois objetos Person person1 e person2 e definimos suas propriedades name e age respectivamente. Essas propriedades são variáveis de instância de cada objeto, portanto, cada objeto tem seu próprio nome e valores de idade.

(2) Variáveis estáticas (também conhecidas como variáveis de classe): o escopo é a classe inteira, que pode ser acessada pelo nome da classe ou pelo objeto instância da classe.

Uma variável estática em Java refere-se a uma variável que pertence a uma classe em vez de uma instância, também conhecida como variável de classe. Eles são declarados na classe, mas fora do método, são decorados com a palavra-chave static. Cada classe possui apenas um conjunto de variáveis estáticas e seus valores são os mesmos, não importa quantas instâncias sejam criadas. Variáveis estáticas podem ser qualquer tipo de dado básico (como int, float, double, etc.) e qualquer tipo de referência (como string, array, etc.). Seus valores podem ser definidos ou obtidos acessando a própria classe.
O escopo das variáveis estáticas é a classe inteira, que pode ser acessada por meio do nome da classe ou do objeto de instância da classe. Eles geralmente são usados para representar o estado compartilhado da classe, como constantes, contadores, etc., e também podem ser usados para armazenar dados em cache e implementar o padrão singleton.

o código

Podemos adicionar uma contagem de variáveis estáticas à classe Person para registrar o número de objetos Person criados:

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

Neste exemplo, declaramos uma variável estática count para registrar o número de objetos Person. No construtor, o valor de count é incrementado em 1 cada vez que um objeto é criado. Esta variável estática pode ser acessada pelo nome da classe:

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

Não importa quantos objetos Person sejam criados, todos eles compartilham a mesma variável de contagem, portanto, o resultado de saída é a soma do número de todos os objetos.

Precauções

Variáveis de instância são diferentes de variáveis estáticas.As variáveis de instância pertencem a cada instância, e sua modificação afetará apenas a instância atual e não afetará outras instâncias.

Variáveis estáticas e variáveis de instância são dois tipos de variáveis comumente usadas em Java, e suas diferenças são as seguintes:

Local de armazenamento
As variáveis estáticas são armazenadas na área de método e as variáveis de instância são armazenadas na memória heap.
O ciclo de vida
de uma variável estática é o mesmo de uma classe. Ela é inicializada quando a classe é carregada e destruída quando a classe é descarregada; o ciclo de vida de uma variável de instância é o mesmo de um objeto. É inicializado quando o objeto é criado e destruído quando o objeto é coletado como lixo.
Método de acesso
As variáveis estáticas podem ser acessadas diretamente pelo nome da classe ou por meio de objetos; as variáveis de instância só podem ser acessadas por meio de objetos.
Valor inicial
As variáveis estáticas serão inicializadas como 0 ou null por padrão, enquanto as variáveis de instância não serão inicializadas por padrão e precisam ser inicializadas explicitamente quando o objeto é criado.
Compartilhamento
As variáveis estáticas são compartilhadas por todos os objetos, ou seja, quando vários objetos acessam a mesma variável estática, eles acessam a mesma variável; as variáveis de instância são independentes de cada objeto, ou seja, cada objeto tem sua própria cópia de variável de instância.

(3) Variáveis locais:

Variáveis locais em Java são variáveis declaradas em métodos, blocos de código ou construtores, e só são visíveis nos blocos de código em que são declaradas. O escopo das variáveis locais é limitado ao bloco de código no qual elas estão localizadas e não podem ser acessadas fora do escopo do bloco de código. As variáveis locais devem ser declaradas antes do uso e devem ser inicializadas antes de serem usadas.
Variáveis locais podem ser qualquer tipo de dado básico (como int, float, double, etc.) e qualquer tipo de referência (como string, array, etc.). Seus valores são válidos apenas dentro do bloco de código em que são declarados e seus valores são destruídos assim que saem do escopo do bloco de código. Portanto, as variáveis locais são frequentemente usadas para armazenar dados temporariamente, como contadores de loop, parâmetros de método, etc.

o código

Podemos declarar uma mensagem de variável local em um método para armazenar uma mensagem:

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

Neste exemplo, declaramos uma variável local message para armazenar uma mensagem e imprimi-la no método. Essa variável local só é visível dentro do método printMessage e não pode ser acessada fora do escopo desse método. No método podemos modificar o valor da variável local a qualquer momento, mas fora do método seu valor não existe.

resumir os três

Sim, as variáveis em Java podem ser divididas em três tipos: variáveis de classe, variáveis de instância e variáveis locais. Todas elas podem ser implementadas em uma classe, mas seu escopo e ciclo de vida são diferentes, e você deve escolher qual tipo de variável usar de acordo com a situação específica.

Variáveis de classe: também conhecidas como variáveis estáticas, são variáveis declaradas em uma classe e compartilhadas por todas as instâncias. As variáveis de classe podem ser acessadas diretamente por meio do nome da classe ou por meio de objetos. O escopo das variáveis de classe é a classe inteira e pode ser acessado por qualquer método na classe. As variáveis de classe são inicializadas quando a classe é carregada e retêm seus valores durante toda a duração do programa. As variáveis de classe são freqüentemente usadas para representar o estado compartilhado de uma classe, como constantes, contadores, etc.
Variáveis de instância: também conhecidas como variáveis de membro, são variáveis declaradas em uma classe e pertencem a objetos. As variáveis de instância têm escopo para o objeto inteiro, são inicializadas quando o objeto é criado e são destruídas quando o objeto é destruído. As variáveis de instância podem ser acessadas por qualquer método, mas somente por meio do objeto. Variáveis de instância são freqüentemente usadas para representar propriedades de um objeto, como nome, idade, etc.
Variáveis locais: são variáveis declaradas em um método, bloco de código ou construtor que só são visíveis no bloco de código em que são declaradas. O escopo das variáveis locais é limitado ao bloco de código no qual elas estão localizadas e não podem ser acessadas fora do escopo do bloco de código. As variáveis locais devem ser declaradas antes do uso e devem ser inicializadas antes de serem usadas. Variáveis locais podem ser de qualquer tipo de dado primitivo e qualquer tipo de referência, e geralmente são usadas para armazenamento temporário de dados.
Em geral, o uso de variáveis de classe deve ser minimizado, pois afetam a capacidade de manutenção e testabilidade do programa. Variáveis de instância e variáveis locais devem ser selecionadas de acordo com a situação específica. Se uma variável só precisa ser usada em um método, então uma variável local deve ser usada; se uma variável precisa ser usada em toda a classe, então uma variável de instância deve ser usada.

Quais são as semelhanças e diferenças

As diferenças e semelhanças entre os três são as seguintes:
Diferenças:

O escopo é diferente: o escopo das variáveis de classe é a classe inteira, o escopo das variáveis de instância é o objeto inteiro e o escopo das variáveis locais é limitado ao bloco de código no qual estão localizadas.
O ciclo de vida é diferente: variáveis de classe são inicializadas quando a classe é carregada e mantêm seus valores ao longo do programa; variáveis de instância são inicializadas quando o objeto é criado e destruídas quando o objeto é destruído; variáveis locais são inicializadas quando são declaradas , E será destruído após a execução do bloco de código onde está localizado.
Os métodos de acesso são diferentes: as variáveis de classe podem ser acessadas diretamente pelo nome da classe ou pelo objeto; as variáveis de instância só podem ser acessadas por meio do objeto; as variáveis locais só podem ser acessadas dentro do bloco de código em que são declaradas.
Os cenários de uso são diferentes: variáveis de classe são geralmente usadas para representar o estado compartilhado da classe, como constantes, contadores, etc.; variáveis de instância são geralmente usadas para representar os atributos de objetos, como nome, idade, etc.; variáveis locais geralmente são usadas para armazenar dados temporariamente, como contadores de loop, parâmetros de método, etc.
mesmo ponto:
Ambas são variáveis usadas para armazenar dados.
pode ser implementado em uma classe.
Ambos podem ser qualquer tipo de dado primitivo e qualquer tipo de referência.
Ambos precisam ser declarados antes do uso e devem ser inicializados antes de serem usados.
Deve-se observar que tanto as variáveis de classe quanto as variáveis de instância são variáveis de membro, enquanto as variáveis locais não são variáveis de membro. Variáveis membro são variáveis pertencentes a classes ou objetos, e seus valores podem ser acessados e modificados por vários métodos, enquanto variáveis locais existem apenas em métodos e não podem ser acessadas e modificadas por outros métodos.

在类中声明字段，可以使用访问修饰符（public、private、protected）和其他修饰符（static、final等），

类的属性和声明字段可以使用访问修饰符（public、private、protected）和其他修饰符（static、final等）来控制其可见性和可变性。

public：公共的，可以被任何类访问。
protected：受保护的，可以被同一包内的类和所有子类访问。
default：默认的，可以被同一包内的类访问。
private：私有的，只能被该类内部的方法访问。

访问修饰符用于控制类的成员的可见性。public修饰符表示该成员可以被任何类访问，private修饰符表示该成员只能被同一类中的其他成员访问，protected修饰符表示该成员可以被同一包中的其他类或子类访问。

其他修饰符用于控制类的成员的可变性。static修饰符表示该成员属于类本身而不是类的实例，final修饰符表示该成员的值不能被更改。
以下是一个示例类，其中包含使用不同访问修饰符和其他修饰符声明的属性和字段：

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

在上面的示例中，publicInt属性可以从任何类中访问，privateString字段只能从ExampleClass类中的其他成员访问，protectedBoolean字段可以从同一包中的其他类或ExampleClass的子类中访问，staticDouble属性属于ExampleClass类本身而不是类的实例，finalChar字段的值不能被更改。

private关键字

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

是一个权限修饰符
可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问.

1.private关键字是一个权限修饰符
2.可以修饰成员(成员变量和成员方法
3被private修饰的成员只能在本类中才能访问
4.针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
5.提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
6.提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

【2】编写类的方法。–>即类的成员函数⁴，这些方法通常反映了对象的行为。

Java编写类的方法的目的是为了实现类的功能，将一些操作封装起来，供其他程序调用。在Java中，方法是类中最基本的组成部分之一，它可以执行特定的任务，并返回结果。通过编写类中的方法，可以将类的功能划分为多个部分，提高代码的可读性和可维护性。
需要编写类的方法，需要定义方法的名称、参数列表、返回值类型和方法体。方法体中包含了实现该方法所需的代码逻辑，以及可能的返回值。
举例来说，假设有一个Calculator类，可以实现加、减、乘、除四种运算。可以通过以下示例代码在Calculator类中编写加法计算方法add()：

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

在这个例子中，add()方法的名称为add，参数列表为两个整数a和b，返回值类型为整数int。该方法实现了将a和b两个数相加，并返回结果的功能。在其他程序中，可以通过创建Calculator对象并调用add()方法来实现加法计算。例如：

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

在这个例子中，创建了一个Calculator对象calculator，并调用了它的add()方法，将2和3两个数相加，并将结果赋值给result变量。最后，通过调用System.out.println()方法输出结果。

实例化该类

Por exemplo, se você quiser usar a classe "Pessoa" dentro de outra classe, você pode escrever:

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

Isso criará um objeto chamado "person", definirá seu nome como "John" e chamará seu método "sayHello".

Precauções

Outros conceitos importantes a serem considerados ao declarar classes Java incluem variáveis e métodos estáticos, modificadores de acesso, nomes de pacote, importação de classes, anotações, criação de objeto, herança e polimorfismo, classes e interfaces abstratas, tratamento de exceção, gerenciamento de memória e convenções de programação e estilo.

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

Defina o nome da classe: O nome da classe deve ser um nome significativo, seguir o caso camel e deve começar com uma letra, não um número ou outros caracteres especiais.
Relacionamento de herança: Se esta classe for herdada de outras classes, você precisará usar a palavra-chave extends, seguida do nome da classe herdada. Se não houver relação de herança, esta parte pode ser omitida.
Implementar interface: Se esta classe precisar implementar alguma interface, você precisará usar a palavra-chave implements, seguida do nome da interface. Esta seção pode ser omitida se nenhuma interface for implementada.
Variáveis de membro: Defina variáveis de membro na classe, ou seja, os atributos da classe. Você precisa especificar o tipo e o nome da variável, pode definir o modificador de acesso e o valor inicial.
Método de construção: O método de construção é usado para criar o objeto e inicializar o estado do objeto. Você precisa especificar o nome do método e a lista de parâmetros e pode definir o modificador de acesso.
Método de membro: Defina o comportamento e a função da classe. Você precisa especificar o nome do método e a lista de parâmetros, e pode definir o modificador de acesso e o tipo de valor de retorno.
Classes internas: Java permite que outras classes sejam definidas dentro de uma classe, e essas classes são chamadas de classes internas. A classe interna precisa ser definida com a palavra-chave class, e a classe interna pode acessar as variáveis de membro e os métodos da classe externa.
```
声明类的过程需要遵循Java的语法规则，代码需要放在类的大括号中。
同时，类的声明应该符合Java的面向对象编程思想，即将数据和行为封装在一起，实现高内聚、低耦合的代码结构。
```
Variáveis e métodos estáticos: Variáveis e métodos estáticos podem ser declarados usando a palavra-chave static, que pertence à classe em vez da instância. Variáveis e métodos estáticos podem ser acessados diretamente pelo nome da classe sem primeiro criar um objeto.
Modificadores de acesso: Existem quatro modificadores de acesso em Java, ou seja, público, protegido, padrão e privado. Você precisa definir modificadores de acesso apropriados para controlar o acesso aos membros da classe conforme necessário.
Pacote ⁵ : Para evitar conflitos de nomenclatura, Java pode usar pacotes para organizar as classes. A palavra-chave package precisa ser usada para declarar o nome do pacote, e o nome do pacote deve ser nomeado de acordo com certas regras.
Importar classe: Se você precisar usar classes em outros pacotes, poderá usar a palavra-chave import para importar classes. Você precisa especificar o caminho completo da classe ou usar curingas para importar todas as classes do pacote inteiro.
Comentários: Os comentários podem ser usados em Java para explicar a função do código, para que outros desenvolvedores possam entender e manter o código. Você pode usar // para comentar uma única linha e /* ... */ para comentar várias linhas.
Criação de objeto: Após declarar uma classe, você pode usar a palavra-chave new para criar um objeto da classe. Você precisa especificar o nome da classe e a lista de parâmetros do construtor e pode atribuir o objeto a uma variável para operações subsequentes.
Acesso a objeto: Variáveis de membro e métodos de uma classe podem ser acessados por meio de um objeto. Você precisa usar um ponto (.) para acessar os membros de um objeto e também pode usar a palavra-chave this para se referir ao objeto atual.
Herança e polimorfismo: Herança e polimorfismo de classes são suportados em Java. As subclasses podem herdar as propriedades e métodos da classe pai e podem substituir os métodos da classe pai para atingir o polimorfismo.
Classes e interfaces abstratas: Classes e interfaces abstratas podem ser usadas em Java para definir especificações e restrições e realizar a reutilização e extensão do código.
Tratamento de exceções: O mecanismo de tratamento de exceções pode ser usado em Java para lidar com exceções que podem ocorrer durante a execução do programa. Você precisa usar um bloco de instrução try-catch-finally para capturar e manipular exceções.
Gerenciamento de memória: Java usa o mecanismo de coleta de lixo para gerenciar automaticamente a memória sem liberação manual de memória. No entanto, é necessário evitar vazamentos de memória e uso excessivo de memória, além de melhorar a eficiência operacional e a estabilidade do programa.
Carregamento e execução de classe: o código Java precisa passar por vários estágios, como compilação, carregamento de classe, inicialização de classe e invocação de método em tempo de execução. É necessário entender o princípio de funcionamento da máquina virtual Java e dominar o processo de carregamento e execução de classes.
Normas e estilos de programação: Java possui um conjunto de normas e estilos de programação que precisam ser seguidos para melhorar a legibilidade e a manutenção do código. Você pode consultar os padrões de codificação oficiais da Oracle ou seguir os padrões de codificação de empresas famosas como Google e Alibaba.

O acima é o trabalho preparatório para declarar uma classe em Java. Ele precisa seguir as regras gramaticais de Java e as ideias de programação orientada a objetos e, ao mesmo tempo, seguir as convenções de nomenclatura de Java, usar nomes significativos para representar classes, métodos e variáveis e melhorar legibilidade e manutenção do código.

Expandir pontos de conhecimento

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

Além dos pontos básicos de conhecimento de classes e objetos, Java possui muitos conceitos estendidos de programação orientada a objetos, como:

Herança: Herança é um mecanismo que permite que uma classe herde as propriedades e métodos de outra classe. As subclasses podem substituir os métodos da classe pai ou adicionar novos métodos e propriedades.
Polimorfismo: O polimorfismo é um mecanismo que permite que diferentes objetos respondam de maneira diferente ao mesmo método. O polimorfismo pode ser alcançado por meio de herança e interfaces.
Classes e interfaces abstratas: Classes e interfaces abstratas são mecanismos pelos quais podem ser usadas para definir um conjunto de métodos, mas sem implementação. Uma classe abstrata pode conter métodos implementados, enquanto uma interface pode conter apenas as assinaturas dos métodos.
Classe interna: uma classe interna é uma classe definida dentro de outra classe. Eles fornecem acesso a propriedades e métodos de classes externas e podem ser usados para obter encapsulamento e reutilização de código.

2._.Objeto —> Você pode criar um objeto criando uma instância de uma classe.

[1] criar

(1) Como pegar o objeto da classe 类名对象名 = new 类名();
(2) Como usar o objeto 访问属性: 对象名.成员变量+访问行为: 对象名.方法名(...)

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

[2] Na programação orientada a objetos, um objeto é uma entidade com comportamento, estado e identidade.

(1) Comportamento: O comportamento de um objeto refere-se às operações ou métodos que ele pode executar. Esses métodos definem a funcionalidade e o comportamento do objeto.

O comportamento de um objeto refere-se às operações ou métodos que ele pode realizar. Esses métodos definem a funcionalidade do objeto. Em Java, você define uma classe e define métodos nela. Por exemplo, se você tiver uma classe chamada Car, poderá definir um método chamado drive que executará a ação de dirigir o carro. Aqui está um exemplo:

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

Por exemplo, em uma classe chamada Car, pode haver um método chamado startEngine() que liga o motor do carro.

(2) Estado: O estado de um objeto refere-se a seus atributos ou dados. Essas propriedades descrevem o estado atual do objeto

O estado de um objeto refere-se às suas propriedades ou variáveis. Essas propriedades definem o estado atual do objeto. Em Java, você pode definir variáveis dentro de uma classe. Por exemplo, se você tem uma classe chamada Car, pode definir uma variável chamada color que armazenará a cor do carro.

public class Car {
    
    
  String color;
}

Por exemplo, em uma classe Carro, pode haver uma propriedade chamada velocidade que descreve a velocidade atual do carro.

(3) Identificação: A identificação de um objeto refere-se ao seu identificador único no programa. Isso geralmente é obtido por meio de uma referência a um objeto ou endereço de memória

A identidade de um objeto refere-se à sua singularidade. Cada objeto tem um identificador único que o distingue de outros objetos. Em Java, todo objeto tem uma referência única.

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

Por exemplo, se você criar um objeto Car chamado myCar em seu programa, poderá usar myCar para se referir ao objeto.
No exemplo acima, car1 e car2 são dois objetos diferentes, cada um com seu próprio identificador exclusivo.

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

Neste exemplo, a classe Person tem as seguintes propriedades e métodos:

name e age são os estados do objeto Person, que descrevem o nome e a idade de uma pessoa.
sayHello() é o comportamento do objeto Person, que define um método para uma pessoa dizer olá.
setAge() e getAge() são comportamentos do objeto Person, que definem métodos para definir e obter a idade de uma pessoa.
A própria classe Person é um objeto com seu próprio identificador que pode ser referenciado pelo nome da classe.

resultado

【1】Instruções complementares

A linha 12 é o fim do construtor, portanto não precisa aceitar parâmetros. No construtor, use a palavra-chave "this" para se referir às variáveis de membro da classe para que os parâmetros passados para o construtor sejam atribuídos a elas. Nesse caso, "this.age" é a variável de membro "age" da classe que recebe o parâmetro "age" passado para o construtor. Isso é feito para evitar confusão entre parâmetros e variáveis de membro. Se você não usar a palavra-chave "this", o compilador não será capaz de distinguir entre parâmetros e variáveis de membro e poderão ocorrer erros. Portanto, não há diferença entre "this.age" e "age", mas usar a palavra-chave "this" pode tornar o código mais claro e compreensível.
insira a descrição da imagem aqui

【2】obter+configurar

Por meio dos métodos get e set, podemos acessar e modificar o valor da propriedade privada fora da classe e, ao mesmo tempo, controlar o acesso à propriedade para garantir a segurança da propriedade.

Para cada variável de membro privatizada, os métodos get e set devem ser fornecidos. O
método set atribui valores às variáveis de membro.
O método get: Fornece o valor da variável de membro

Métodos get e set de objetos Java
Em Java, os métodos set e get de objetos são métodos públicos usados para acessar propriedades privadas de um objeto. O método set é usado para definir o valor da propriedade e o método get é usado para obter o valor da propriedade.

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

public class Person {
    
    
    private String name;

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

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

No exemplo acima, o método setName é usado para definir o valor do atributo name e o método getName é usado para obter o valor do atributo name. Observe que esses métodos são métodos públicos, portanto, podem ser acessados de fora da classe.

A vantagem de usar os métodos set e get é que você pode controlar o acesso às propriedades do objeto. Por exemplo, se você deseja validar os valores das propriedades antes de configurá-los, pode adicionar a lógica de validação no método set. Da mesma forma, se você deseja converter o valor da propriedade antes de obtê-lo, pode adicionar a lógica de conversão no método get.
insira a descrição da imagem aqui

Em Java, os métodos get e set são métodos usados para obter e definir propriedades privadas de uma classe. Normalmente, as propriedades privadas não podem ser acessadas diretamente de fora, mas precisam ser acessadas por meio dos métodos get e set.

(1) O método get é utilizado para obter o valor de um atributo privado, e geralmente possui as seguintes características: Por retornar apenas o valor do campo da instância, é chamado de acessador de campo (field accessor)

O nome do método começa com get, seguido do nome da propriedade, com a primeira letra maiúscula.
O tipo de valor de retorno geralmente é o tipo de dados do atributo.
Não há parâmetros.
Código de amostra:

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

O método getter é utilizado para obter o valor do atributo do objeto, geralmente iniciando com get, por exemplo:

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

Esse método pega o valor de uma propriedade inteira chamada idade e o retorna.

(2) O método set é usado para definir o valor de uma propriedade privada, geralmente com as seguintes características:

O nome do método começa com set, seguido do nome do atributo, com a primeira letra maiúscula.
O tipo de valor de retorno geralmente é void.
Há um parâmetro cujo tipo é o tipo de dados do atributo.
Código de amostra:

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

O método setter é utilizado para alterar o valor da propriedade do objeto, geralmente iniciando com set, por exemplo:

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

Este método altera o valor de uma propriedade de string chamada name.

Esses dois métodos podem melhorar o encapsulamento e a segurança do objeto, de modo que as propriedades do objeto só possam ser acessadas e modificadas por meio desses dois métodos. Desta forma, se necessário, algum código lógico pode ser adicionado dentro do método para controlar o acesso e modificação da propriedade.

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

Por que get e set têm void e um não?

Em Java, os métodos get e set são comumente usados para acessar e modificar variáveis privadas de uma classe. O método get é usado para obter o valor da variável e o método set é usado para definir o valor da variável. Portanto, o método get geralmente retorna o valor da variável, enquanto o método set geralmente não retorna nenhum valor (ou seja, void).

Isso ocorre porque o objetivo do método get é obter o valor da variável e o objetivo do método set é definir o valor da variável. Se o método set retornar um valor, pode causar confusão porque parece que está obtendo o valor da variável, quando na verdade está definindo o valor da variável.

[3] esta palavra-chave (insubstituível)não no método estáticoEm uso, porque os métodos estáticos não pertencem a nenhum objeto, eles não podem usar a palavra-chave this.

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

Usar a palavra-chave this para se referir a uma variável de instância é necessário quando o parâmetro do método e a variável de instância têm o mesmo nome. Isso ocorre porque o compilador Java prefere parâmetros de método a variáveis de instância.
Em Java, quando você define uma variável ou método em uma classe, eles são associados por padrão ao objeto atual. Isso significa que cada objeto tem seu próprio conjunto de variáveis de instância e métodos. Quando você cria um novo objeto, Java atribui ao objeto um novo conjunto de variáveis e métodos de instância. Portanto, se você definir uma variável ou método em uma classe, eles serão associados a todos os objetos dessa classe.

Se você usar a palavra-chave this em um método estático, o compilador relatará um erro. Como os métodos estáticos não pertencem a nenhum objeto, eles não podem usar a palavra-chave this.

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

public class MyClass {
    
    
    int x;

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

Além disso, a palavra-chave this também pode ser usada para chamar outros métodos do objeto atual

public class MyClass {
    
    
    int x;

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

Em Java, tanto as variáveis de membro quanto os métodos de uma classe podem ser acessados por outros métodos da mesma classe. Isso ocorre porque todos pertencem à mesma classe, portanto, compartilham o mesmo escopo.
Se você definir o método printX() como estático, não poderá acessar a variável x internamente porque métodos estáticos não podem acessar variáveis de membro não estáticas. Se você deseja acessar a variável x no método estático, precisa definir a variável x como estática.
Demonstra como acessar variáveis estáticas em métodos estáticos:

public class MyClass {
    
    
    static int x;

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

insira a descrição da imagem aqui

(1) Princípio de proximidade [isso pode distinguir variáveis de membro e variáveis locais]

A regra do vizinho mais próximo de Java significa que, quando a sobrecarga do método é executada, quando os tipos de parâmetro não correspondem completamente, um método que esteja mais próximo do parâmetro real (mais próximo) será selecionado para chamada.

O princípio da proximidade se aplica a cenários de sobrecarga de métodos em Java. Quando há vários métodos sobrecarregados, o compilador escolhe qual método chamar com base no tipo e número de parâmetros. Se os tipos de parâmetro não corresponderem exatamente, o compilador converterá automaticamente os tipos de parâmetro para o tipo mais próximo antes de escolher qual método chamar.

Por exemplo, se existirem os dois métodos a seguir:

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

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

Então, quando chamamos foo(3.5), o compilador converterá automaticamente o tipo de parâmetro para o tipo mais próximo, que é o foo(float a)método de chamada.

Resumindo, o princípio de proximidade do Java encontrará automaticamente a correspondência mais próxima para executar o método, o que melhora a flexibilidade e a legibilidade do programa.

especial

Quando uma classe tem variáveis de membro. Quando o nome é o mesmo de uma variável local, se a variável local for chamada diretamente, o valor da variável local é emitido.
Se for output this.变量名称, está gerando variáveis de membro.
insira a descrição da imagem aqui

Por que a variável local de idade sobrescreve diretamente a atribuição de idade referenciada de 123

De acordo com o código que você forneceu, vejo que há uma variável estática age e um construtor na classe Person3, e há um parâmetro age no construtor. No construtor, você usou this.name = name para se referir à variável de membro name na classe, mas não usou this.age = age para se referir à variável estática age na classe. Portanto, quando você declara uma variável local chamada age no método sayHello(), ela substitui o valor da variável estática age. Se você deseja se referir à variável estática age, deve usar Person3.age em vez de declarar uma variável local.

Se quiser fazer referência à variável estática age no construtor, você pode usar Person3.age ou usar age diretamente, porque ambos se referem à variável estática age. No entanto, recomendo que você use Person3.age, pois torna mais claro que você está fazendo referência a uma variável estática.
insira a descrição da imagem aqui

(2) Instância dinâmica VS estática

Em uma instância dinâmica, a palavra-chave this aponta para o objeto que está usando o método no momento. Por exemplo:

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作为参数

Em instâncias estáticas, a palavra-chave this não pode ser usada. Como os métodos estáticos não dependem de nenhum objeto, eles são carregados junto com a classe e só podem acessar membros e métodos estáticos. Por exemplo:

public class MyClass {
    
    
    private static int num;

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

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

(3) Privado e Compartilhado

A palavra-chave this em Java representa o objeto atual, seja o objeto privado ou público.

Em métodos privados e propriedades privadas, a palavra-chave this é usada para se referir às propriedades e métodos privados do objeto atual. Por exemplo:

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引用当前对象的私有方法
   }
}

Em métodos públicos e propriedades públicas, a palavra-chave this também pode ser usada para se referir às propriedades e métodos públicos do objeto atual, mas geralmente a palavra-chave this pode ser omitida. Por exemplo:

public class Person {
    
    
   public String name;

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

（4）inscode

A palavra-chave this em Java é uma referência especial que aponta para o endereço de memória do objeto atual. Em Java, cada objeto tem seu próprio espaço de memória independente, e a palavra-chave this nos permite acessar suas próprias propriedades e métodos dentro do objeto. A sintaxe para usar a palavra-chave this em Java é a seguinte:

1. Use a palavra-chave this para acessar as propriedades do objeto atual:

public class Person {
    
    
    private String name;

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

2. Use a palavra-chave this para chamar o método do objeto atual:

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

3. Use a palavra-chave this no construtor para chamar outros construtores do objeto atual:

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

Use a palavra-chave this para chamar o método do objeto atual:

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

Use a palavra-chave this no construtor para chamar outros construtores do objeto atual:

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

Não há necessidade disso para indicar um 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);
    }
}

Precauções

(1) Instanciar um objeto: Para usar uma classe, você precisa primeiro criar uma instância da classe. Você pode usar a palavra-chave new para instanciar um objeto da seguinte maneira: Person3 person = new Person3("Alice", 25);Isso criará um objeto Person3 chamado person com o nome "Alice" e 25 anos.
(2) Acesse as propriedades do objeto: Para acessar as propriedades do objeto, você pode usar o operador ponto. Da seguinte forma: String name = person.name;
int age = person.age;Isso armazenará o nome e a idade do objeto pessoa nas variáveis nome e idade, respectivamente.
(3) Chame o método do objeto: Para chamar o método do objeto, você pode usar o operador ponto, seguido do nome do método e colchetes, conforme mostrado abaixo: Isso chamará o método sayHello() do objeto person.sayHello();pessoa , que imprimirá o nome e a idade do objeto.
(4) Entenda o ciclo de vida de um objeto: O ciclo de vida de um objeto refere-se a todo o processo desde a criação até a destruição de um objeto. Em Java, o tempo de vida de um objeto é gerenciado pelo coletor de lixo. O coletor de lixo destruirá automaticamente o objeto quando ele não for mais referenciado.

[3] Resumo

Classes e objetos Java são conceitos importantes na programação Java. Uma classe é um modelo ou modelo para a criação de objetos. Objetos são instâncias de classes e possuem estado e comportamento. Para criar uma classe, você precisa usar a palavra-chave "class" seguida do nome da classe e definir variáveis e métodos dentro da classe. Para criar um objeto, você precisa usar a palavra-chave "new" seguida do nome da classe e atribuí-la a uma variável. Para acessar uma variável ou método de um objeto, você precisa usar um ponto (.) seguido do nome da variável ou método. ,

Preste atenção ao uso desta palavra-chave

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

}

Solução 1: alterar variáveis de membro para variáveis 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);
    }
}

Solução 2: altere o método showDisplayBook para um método não 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);
    }
}

Em Java, métodos estáticos não podem acessar variáveis de membro não estáticas, portanto, no método showDisplayBook, você não pode acessar diretamente this.title, this.price, this.publisher e this.publishedYear.
insira a descrição da imagem aqui

problema resolvido

Aula de livro


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

classe de teste 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 que você tem que usar o objeto para chamar o autor para o privado e usar o objeto ou o método para o estático?

As variáveis de membro privado precisam ser chamadas usando objetos porque as variáveis de membro privado só podem ser acessadas dentro da classe e não podem ser acessadas diretamente fora da classe. Portanto, se você deseja acessar uma variável de membro privada fora da classe, precisa chamá-la por meio do objeto.

As variáveis de membro estáticas podem ser acessadas diretamente pelo nome da classe sem criar um objeto. Isso ocorre porque as variáveis de membro estáticas pertencem à própria classe, não às instâncias da classe. Portanto, você pode acessar variáveis de membros estáticos por nome de classe.

Para métodos estáticos, você pode chamá-los por nome de classe ou objeto. Se você chamar um método estático usando o nome da classe, ele será executado diretamente na classe. Se você chamar um método estático com um objeto, ele será executado no objeto, mas na verdade ignorará o objeto e será executado na classe.

Uma instância Java refere-se a uma instância específica de um objeto ou classe criada em um programa. Em Java, uma classe é um conceito abstrato e um objeto é uma instância concreta de uma classe. A criação de uma instância de uma classe Java requer o uso da palavra-chave "new" para alocar memória e inicializar propriedades e métodos da classe. Ao criar uma instância de uma classe Java, as propriedades e métodos da classe podem ser acessados e modificados no programa para obter as funções necessárias.

A programação orientada a objetos possui três características básicas: ↩︎
Se uma variável de membro for declarada como privada, ela só poderá ser acessada na classe atual e outras classes não poderão acessá-la. Se você precisar usar essa variável de membro em outras classes, poderá fornecer os métodos getter e setter correspondentes. O método getter é usado para obter o valor da variável membro e o método setter é usado para definir o valor da variável membro. Dessa forma, outras classes podem acessar indiretamente variáveis de membros privados chamando os métodos getter e setter. Essa abordagem pode garantir a segurança de variáveis de membros privados, mas também fornece uma maneira segura de usá-las e modificá-las. ↩︎
Uma classe JavaBean é um tipo especial de classe Java que segue algumas convenções de nomenclatura e design para uso na plataforma Java. As classes JavaBean são normalmente usadas para representar objetos de dados em aplicativos, como usuários, pedidos ou produtos. Eles contêm propriedades privadas (variáveis de membro) e métodos públicos (getters e setters) que são usados para acessar e modificar essas propriedades. As classes JavaBean também podem implementar a interface Serializable para que possam ser serializadas em fluxos de bytes para transmissão pela rede ou armazenamento em disco. A convenção de nomenclatura para classes JavaBean geralmente é que o nome da classe começa com uma letra maiúscula e o nome da propriedade começa com uma letra minúscula, enquanto a convenção de nomenclatura para os métodos getter e setter começa com get e set seguido pelo nome da propriedade. ↩︎
Uma função de membro é uma função definida em uma classe, também conhecida como método de classe. As funções de membro em uma classe podem acessar variáveis de membro na classe e também podem chamar outras funções de membro. As funções de membro podem ser públicas, privadas ou protegidas, dependendo de seus modificadores de acesso. Existem dois tipos de funções de membro em uma classe: funções de instância e funções estáticas.
Uma função de instância é uma função definida em uma classe que precisa ser chamada por meio de uma instância da classe. As funções de instância podem acessar variáveis de instância e métodos de instância na classe e podem se referir à instância atual por meio da palavra-chave this.
Uma função estática é uma função definida em uma classe que não precisa ser chamada por meio de uma instância da classe. As funções estáticas podem acessar variáveis estáticas e métodos estáticos na classe e não podem se referir à instância atual por meio da palavra-chave this.
O papel da função de membro é realizar a função da classe e encapsular algumas operações para outros programas chamarem. Por meio de funções de membro, a função da classe pode ser dividida em várias partes, o que melhora a legibilidade e a manutenção do código. As funções de membro podem implementar qualquer tarefa, como computação, saída, modificação do estado de um objeto e assim por diante.
Por exemplo, suponha que haja uma classe Person, que contém dois atributos, nome e idade, e dois métodos setName() e setAge(), você pode definir uma função membro sayHello() através do seguinte código: ```java public class Pessoa
{ private String nome; private int idade;

// 定义sayHello方法
public void sayHello() { System.out.println("Olá, meu nome é " + nome + “, tenho " + idade + " anos.”); }

// Definir o método setName
public void setName(String name) { this.name = name; } // Definir o método setAge public void setAge(int age) { this.age = age; }}``Neste exemplo, sayHello ( ) é uma função de instância que gera o nome e a idade do objeto. Os métodos setName() e setAge() também são funções de instância, usadas para definir o nome e a idade do objeto. Em outros programas, você pode gerar as informações do objeto criando um objeto Person e chamando o método sayHello(). Por exemplo: Neste exemplo, uma pessoa do objeto Person é criada e o nome e a idade do objeto são definidos chamando os métodos setName() e setAge(). Por fim, imprima as informações do objeto chamando o 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.
Pacotes em Java são um mecanismo para organizar e gerenciar classes e interfaces. Os pacotes podem conter outros pacotes e classes. Eles são uma forma de namespaces em Java e podem ajudar a evitar conflitos de nomenclatura.

Em Java, a declaração do pacote deve estar na primeira linha do arquivo, conforme a seguir: package com.example.mypackage;
Essa declaração informa ao compilador que todas as classes desse arquivo pertencem ao com.example.mypackagepacote.

Em Java, a convenção de nomenclatura para pacotes é o nome de domínio reverso. Isso significa que você deve prefixar o pacote com o nome do seu domínio ou organização, seguido do nome do seu projeto. Por exemplo, se o seu nome de domínio for example.com, o nome do seu projeto for myproject, o nome do seu pacote deverá ser com.example.myproject.
Você pode usar pacotes para organizar seu código e torná-lo mais gerenciável. Por exemplo, você pode colocar todas as classes relacionadas ao banco de dados com.example.myproject.dbem um pacote chamado . Dessa forma, você pode encontrar e manter essas classes com mais facilidade. ↩︎

Eu aprendo classes e objetos Java em VScode (classes e objetos Java, esta palavra-chave) a primeira série

Diretório de artigos

Zero._ Programação Orientada a Objetos ----> A importância reside no fato de fornecer um estilo de programação mais modular, reutilizável e de fácil manutenção, o que facilita a organização e o gerenciamento do código, decompondo-o em objetos.

(1) Encapsulamento: Combine dados e comportamento e trate-os como uma única entidade. Isso evita que o código externo acesse diretamente os dados do objeto, melhorando a segurança e a capacidade de manutenção do código.

exemplo de código

Atribuir e emitir DEMO2

(2) Herança (Inheritance): Permite a criação de uma nova classe que herda propriedades e métodos de classes existentes. Isso reduz a duplicação de código e facilita a manutenção do código.

o código

É uma classe Java chamada Animal.

Esta é uma classe Cat que herda da classe Animal.

Esta é uma classe Dog que herda da classe Animal.

Esta é uma classe com um método main que cria objetos Animal, Dog e Cat e chama seus métodos speak.

(3) Polimorfismo (Polimorfismo): Permite a utilização de um mesmo método para tratar diferentes tipos de objetos. Isso melhora a escalabilidade e a reutilização do código.

Aqui está uma introdução à programação orientada a objetos em C++, Python e Java:

【1】Vantagens e desvantagens

（1）C++：

（2）Python：

（3）Java：

[2] Gravata diferente:

Exemplo de uma classe C++:

Exemplo de uma classe Python:

Exemplo de uma classe Java:

Em Java, definir uma classe precisa conter o seguinte: a classe deve sempre começar com uma letra inicial maiúscula e o nome do arquivo java deve corresponder ao nome da classe.

Instruções para definir as classes: As classes devem sempre começar com uma letra inicial maiúscula e o nome do arquivo java deve corresponder ao nome da classe.

Notas sobre a definição de classes

Em Java, uma definição de classe geralmente consiste nas seguintes partes:

Crie uma palavra-chave de classe new para criar um objeto e chame o construtor do objeto para inicializar. Use os métodos e propriedades do objeto para operar.

Passos para criar uma classe

[1] Use a palavra-chave "class" para declarar o nome de uma classe.

[2] Escreva as propriedades e métodos da classe entre as chaves da classe.

[1] Variáveis ​​de tipo contidas em uma classe:

(1) Variáveis ​​de instância (também conhecidas como variáveis ​​de membro): O escopo é a classe inteira e pode ser acessado por qualquer método ou construtor da classe.

o código

(2) Variáveis ​​estáticas (também conhecidas como variáveis ​​de classe): o escopo é a classe inteira, que pode ser acessada pelo nome da classe ou pelo objeto instância da classe.

o código

Precauções

(3) Variáveis ​​locais:

o código

resumir os três

Quais são as semelhanças e diferenças

在类中声明字段，可以使用访问修饰符（public、private、protected）和其他修饰符（static、final等），

private关键字

【2】编写类的方法。–>即类的成员函数4，这些方法通常反映了对象的行为。

实例化该类

Precauções

Expandir pontos de conhecimento

2._.Objeto —> Você pode criar um objeto criando uma instância de uma classe.

[1] criar

[2] Na programação orientada a objetos, um objeto é uma entidade com comportamento, estado e identidade.

(1) Comportamento: O comportamento de um objeto refere-se às operações ou métodos que ele pode executar. Esses métodos definem a funcionalidade e o comportamento do objeto.

(2) Estado: O estado de um objeto refere-se a seus atributos ou dados. Essas propriedades descrevem o estado atual do objeto

(3) Identificação: A identificação de um objeto refere-se ao seu identificador único no programa. Isso geralmente é obtido por meio de uma referência a um objeto ou endereço de memória

o código

【1】Instruções complementares

【2】obter+configurar

(1) O método get é utilizado para obter o valor de um atributo privado, e geralmente possui as seguintes características: Por retornar apenas o valor do campo da instância, é chamado de acessador de campo (field accessor)

(2) O método set é usado para definir o valor de uma propriedade privada, geralmente com as seguintes características:

Por que get e set têm void e um não?

[3] esta palavra-chave (insubstituível)não no método estáticoEm uso, porque os métodos estáticos não pertencem a nenhum objeto, eles não podem usar a palavra-chave this.

(1) Princípio de proximidade [isso pode distinguir variáveis ​​de membro e variáveis ​​locais]

especial

Por que a variável local de idade sobrescreve diretamente a atribuição de idade referenciada de 123

(2) Instância dinâmica VS estática

(3) Privado e Compartilhado

（4）inscode

1. Use a palavra-chave this para acessar as propriedades do objeto atual:

2. Use a palavra-chave this para chamar o método do objeto atual:

3. Use a palavra-chave this no construtor para chamar outros construtores do objeto atual:

Não há necessidade disso para indicar um campo implícito

Precauções

[3] Resumo

Preste atenção ao uso desta palavra-chave

Solução 1: alterar variáveis ​​de membro para variáveis ​​estáticas

Solução 2: altere o método showDisplayBook para um método não estático

problema resolvido

Por que você tem que usar o objeto para chamar o autor para o privado e usar o objeto ou o método para o estático?

Acho que você gosta

[1] Variáveis de tipo contidas em uma classe:

(1) Variáveis de instância (também conhecidas como variáveis de membro): O escopo é a classe inteira e pode ser acessado por qualquer método ou construtor da classe.

(2) Variáveis estáticas (também conhecidas como variáveis de classe): o escopo é a classe inteira, que pode ser acessada pelo nome da classe ou pelo objeto instância da classe.

(3) Variáveis locais:

【2】编写类的方法。–>即类的成员函数⁴，这些方法通常反映了对象的行为。

(1) Princípio de proximidade [isso pode distinguir variáveis de membro e variáveis locais]

Solução 1: alterar variáveis de membro para variáveis estáticas