Java é uma linguagem pura orientada a objetos (Programa Orientado a Objetos, abreviadamente OOP).No mundo orientado a objetos, tudo é um objeto. Orientado a objetos é uma ideia para resolver problemas, que depende principalmente da interação entre objetos para completar uma coisa . Usar o pensamento orientado a objetos para lidar com programas está mais alinhado com a compreensão das pessoas sobre as coisas e é muito amigável para o design, expansão e manutenção de grandes programas.

【1.2】 Orientado a objetos e orientado a processos

[Maneira tradicional de lavar roupas]

O foco está no processo de lavagem de roupas . Se faltar um elo, pode não funcionar.

Além disso, diferentes roupas são lavadas de diferentes maneiras, por diferentes períodos de tempo e com diferentes métodos de torção, o que torna seu manuseio mais difícil. Se você vai lavar os sapatos no futuro, essa é outra forma de colocá-los. Escrever código dessa maneira será mais difícil de expandir ou manter no futuro .

[Maneira moderna de lavar roupas]

O processamento orientado a objetos não se concentra no processo de lavagem de roupas. Os usuários não precisam se preocupar com como a máquina de lavar lava as roupas e como secá-las. Eles só precisam colocar as roupas na máquina de lavar, despejar o sabão em pó e ligue o interruptor, ou seja, isso é feito através da interação entre os objetos . Nota: Orientado a processos e orientado a objetos não são linguagens, mas métodos de resolução de problemas. Eles não são bons nem ruins e cada um tem seu próprio cenário de aplicação especial.

【2】Definição e uso de classe

A programação orientada a objetos concentra-se em objetos, que são entidades da vida real, como máquinas de lavar. Mas o computador não conhece a máquina de lavar, e o desenvolvedor precisa dizer ao computador o que é uma máquina de lavar.

O lado esquerdo da imagem acima é uma descrição simples da máquina de lavar. Este processo é chamado de abstração do objeto (entidade) da máquina de lavar (reconhecimento de uma coisa complexa). No entanto, esses resultados abstratos simplificados não podem ser reconhecidos pelos computadores. Os desenvolvedores podem usar uma certa linguagem de programação orientada a objetos para descrevê-la, como a linguagem Java.

【2.1】Aula de compreensão simples

As classes são usadas para descrever uma entidade (objeto) , descrevendo principalmente quais atributos (tamanho da aparência, etc.) e funções (para que é usada) a entidade (objeto) possui. Após a conclusão da descrição, o computador pode reconhecê-la.

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
属性：产品品牌，型号，产品重量，外观尺寸，颜色...
功能：洗衣，烘干、定时....

Na linguagem Java, como definir a classe da máquina de lavar acima?

【2.2】Formato de definição de classe

Ao definir uma classe em java, você precisa usar a palavra-chave class . A sintaxe específica é a seguinte

// 创建类
class ClassName{
	field; // 字段(属性) 或者 成员变量
	method; // 行为 或者 成员方法
}

class é a palavra-chave que define a classe, ClassName é o nome da classe e {} é o corpo principal da classe.

Os conteúdos contidos em uma classe são chamados de membros da classe. Os atributos são usados principalmente para descrever classes e são chamados de atributos de membro ou variáveis de membro de classe da classe. Os métodos descrevem principalmente quais funções uma classe possui e são chamados de métodos membros da classe.

[Exemplo: Defina uma classe de máquina de lavar]

class WashMachine{
    // 属性(字段)
    public String brand; // 品牌
    public String type; // 型号
    public double weight; // 重量
    public double length; // 长
    public double width; // 宽
    public double height; // 高
    public String color; // 颜色
    public void washClothes(){ // 洗衣服
        System.out.println("洗衣功能");
    }

    // 行为(方法)
    public void dryClothes(){ // 脱水
        System.out.println("脱水功能");
    }
    public void setTime(){ // 定时
        System.out.println("定时功能");
    }
}

A classe da máquina de lavar é definida no computador em linguagem Java. Após a compilação javac, é formado um arquivo .class, que pode ser reconhecido pelo computador baseado na JVM.

【Precauções】

Observe que os nomes das classes são definidos em camel case.
O método de redação perante os membros é unificado como público, o que será explicado em detalhes posteriormente.
O método escrito aqui não possui a palavra-chave estática . Será explicado em detalhes posteriormente.

【2.3】Prática

【2.3.1】Definir uma classe de cachorro

class PetDog {
    // 狗的属性
    public String name;//名字
    public String color;//颜色

    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

【2.3.2】Definir uma turma de alunos

class Student {
    // 学生的属性
    public String name;
    public String gender;
    public short age;
    public double score;
    
    // 狗行为
    public void DoClass(){}
    public void DoHomework(){}
    public void Exam(){}
}

【Precauções】

Geralmente, apenas uma classe é definida em um arquivo.
A classe onde o método principal está localizado geralmente deve ser decorada com public (nota: o Eclipse procurará o método principal na classe modificada pelo público por padrão).
A classe modificada por public deve ser igual ao nome do arquivo.
Não modifique facilmente o nome da classe modificada pelo público. Se quiser modificá-lo, modifique-o por meio de ferramentas de desenvolvimento (demonstre aos colegas).

【3】Instanciação da classe

【3.1】O que é instanciação?

Definir uma classe é equivalente a definir um novo tipo no computador , semelhante a int e double, exceto que int e double são tipos integrados que vêm com a linguagem Java, enquanto a classe é um novo tipo definido pelo usuário. como o acima: classe PetDog e classe Student. São todas classes (um tipo recém-definido).Com esses tipos personalizados, você pode usar essas classes para definir instâncias (ou objetos).

O processo de criação de um objeto usando um tipo de classe é chamado de instanciação da classe.Em Java, a palavra-chave new é usada para instanciar o objeto com o nome da classe.

public class Main{
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
} 
输出结果：
阿黄: 旺旺旺~~~
阿黄: 摇尾巴~~~
赛虎: 旺旺旺~~~
赛虎: 摇尾巴~~~

【Precauções】

A palavra-chave new é usada para criar uma instância de um objeto.
Use.para acessar propriedades e métodos em um objeto.
Pares de instâncias da mesma classe podem ser criados.

【3.2】Descrição de classes e objetos

Uma classe é apenas algo semelhante a um modelo , usado para descrever uma entidade e limitar os membros da classe.
Uma classe é um tipo personalizado que pode ser usado para definir variáveis.
Uma classe pode instanciar vários objetos, e os objetos instanciados ocupam espaço físico real e armazenam variáveis de membros da classe .
Vamos usar uma analogia. Instanciar objetos de uma classe é como usar desenhos de projeto arquitetônico para construir uma casa na realidade. Uma classe é como um desenho de projeto . Ela projeta apenas o que é necessário, mas não há construção física. Da mesma forma, uma classe é apenas um projeto que é instanciado. Os objetos podem realmente armazenar dados e ocupar espaço físico.

【4】Referência deste

【4.1】Por que deveríamos ter esta referência?

[Veja primeiro um exemplo de aula de data]

public class Date {
    // 成员属性
    public int year;
    public int month;
    public int day;
    
    // 成员方法
    public void setDate(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }
    public void printDate() {
        System.out.println(year + "年" + month + "月" + day + "日");
    }
    
    public static void main(String[] args) {
        Date date1 = new Date();
        date1.year = 2022;
        date1.month = 12;
        date1.day = 12;
        
        Date date2 = new Date();
        date2.year = 2022;
        date2.month = 11;
        date2.day = 11;
        
        Date date3 = new Date();
        date3.year = 2022;
        date3.month = 10;
        date3.day = 10;
        
        date1.printDate();
        date2.printDate();
        date3.printDate();
    }
}

O código acima define uma classe de data e, em seguida, cria três objetos no método principal e define e imprime os objetos por meio dos métodos membros da classe Date.A lógica geral do código é muito simples e não há problemas.

Mas depois de uma consideração cuidadosa, tenho as duas perguntas a seguir:

public void setDay(int year, int month, int day){
	year = year;
	month = month;
	day = day;
}

Então, quem atribui valores a quem no corpo da função? Variável de membro para variável de membro? Parâmetro para parâmetro? Parâmetros para variáveis de membro? Parâmetros variáveis de membro? Acho que nem consigo descobrir.

Todos os três objetos estão chamando as funções setDate e printDate, mas não há descrição dos objetos nessas duas funções.Como as funções setDate e printDate sabem qual dado do objeto está sendo impresso?

Deixe esta citação desvendar esse mistério.

【4.2】Qual é esta referência?

Esta referência aponta para o objeto atual (o objeto que chama o método membro quando o método membro está em execução).Todas as operações de variáveis de membro no método membro são acessadas por meio desta referência . Só que todas as operações são transparentes para o usuário, ou seja, o usuário não precisa passar, o compilador completa automaticamente.

public class Date {
    // 成员属性
    public int _year;
    public int _month;
    public int _day;

    public void setDate(int year, int month, int day) {
        this._year = year;
        this._year = month;
        this._year = day;
    }

    // 成员方法
    public void printDate() {
        System.out.println(_year + "年" + _month + "月" + _day + "日");
    }

    public static void main(String[] args) {
        Date date1 = new Date();
        date1._year = 2022;
        date1._month = 12;
        date1._day = 12;

        Date date2 = new Date();
        date2._year = 2022;
        date2._month = 11;
        date2._day = 11;

        Date date3 = new Date();
        date3._year = 2022;
        date3._month = 10;
        date3._day = 10;

        date1.printDate();
        date2.printDate();
        date3.printDate();
    }
}

[Nota] Isto se refere ao objeto no qual o método membro é chamado .

【4.3】Características desta referência

O tipo deste: corresponde à referência do tipo de classe, ou seja, qual objeto é chamado é o tipo de referência daquele objeto.
isso só pode ser usado em "métodos membros".
Em um "método membro", this só pode se referir ao objeto atual e não pode se referir a outros objetos.
Este é o primeiro parâmetro oculto do "método membro", e o compilador irá passá-lo automaticamente. Quando o método membro for executado, o compilador será responsável por passar a referência do objeto do método membro chamador para o método membro, e este será responsável por recebê-lo.

Uma demonstração simples em nível de código --->Nota: A classe Date no lado direito da imagem abaixo também pode ser compilada.

【5】Construção e inicialização de objetos

【5.1】Como inicializar objetos

Pelo conhecimento anterior, sabemos que ao definir uma variável local dentro de um método Java, ela deve ser inicializada, caso contrário a compilação falhará.

public static void main(String[] args) {
	int a;
	System.out.println(a);
} 
// Error:(26, 28) java: 可能尚未初始化变量a

Para compilar o código acima é muito simples: basta definir um valor inicial para a antes de usá-lo oficialmente. Se for um objeto:

public static void main(String[] args) {
	Date d = new Date();
	d.printDate();
	d.setDate(2021,6,9);
	d.printDate();
} 
// 代码可以正常通过编译

Você precisa chamar o método SetDate escrito antes para definir a data específica no objeto. Dois problemas foram descobertos através dos exemplos acima:

É problemático chamar o método SetDate para definir uma data específica toda vez que o objeto é criado . Como o objeto deve ser inicializado?
Variáveis locais devem ser inicializadas antes de serem usadas. Por que elas ainda podem ser usadas sem fornecer um valor após o campo ser declarado?

【5.2】Método de construção

【5.2.1】Conceito

O método construtor (também chamado de construtor) é um método membro especial cujo nome deve ser igual ao nome da classe. Ele é chamado automaticamente pelo compilador quando o objeto é criado e é chamado apenas uma vez durante todo o ciclo de vida do objeto .

public class Date {
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day) {
        this._year = year;
        this._month = month;
        this._day = day;
    }

    // 成员方法
    public void printDate() {
        System.out.println(_year + "年" + _month + "月" + _day + "日");
    }

    // 成员属性
    public int _year;
    public int _month;
    public int _day;

    /* 入口函数Main */
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date date1 = new Date(2022,12,12);  // 输出Date(int,int,int)方法被调用了
        date1.printDate();
    }
}

[Nota] A função do método construtor é inicializar os membros do objeto e não é responsável por abrir espaço para o objeto.

【5.2.2】Características

O nome deve ser igual ao nome da classe
Não há tipo de valor de retorno e defini-lo como void não funcionará.
É chamado automaticamente pelo compilador quando um objeto é criado e é chamado apenas uma vez durante o ciclo de vida do objeto (equivalente ao nascimento de uma pessoa, cada pessoa só pode nascer uma vez)
O construtor pode estar sobrecarregado (os usuários fornecem aos construtores parâmetros diferentes de acordo com suas próprias necessidades)

public class Date {
    // 无参构造方法
    public Date() {
        System.out.println("我是一个无参的构造方法");
    }
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        System.out.println("我是一个带3个参数的构造方法");
        this._year = year;
        this._month = month;
        this._day = day;
    }

    // 成员方法
    public void printDate() {
        System.out.println(_year + "年" + _month + "月" + _day + "日");
    }

    // 成员属性
    public int _year;
    public int _month;
    public int _day;

    /* 入口函数Main */
    public static void main(String[] args) {
        Date date1 = new Date(2022,12,12);  
        date1.printDate();
    }
}

Os dois construtores acima têm o mesmo nome, mas listas de parâmetros diferentes, formando assim uma sobrecarga de método .

Se o usuário não o definir explicitamente, o compilador gerará um construtor padrão, e o construtor padrão gerado deverá ser sem parâmetros.

public class Date {
    public int year;
    public int month;
    public int day;
    
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
}

Na classe Date acima, nenhum construtor é definido e o compilador irá gerar um construtor sem parâmetros por padrão .

[Nota] Uma vez definido pelo usuário, o compilador não irá mais gerá-lo.


public class Date {
    public int year;
    public int month;
    public int day;
    
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
    
    public static void main(String[] args) {
    // 如果编译器会生成，则生成的构造方法一定是无参的
    // 则此处创建对象是可以通过编译的
    // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
    }
} 
/*
    Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
    需要: int,int,int
    找到: 没有参数
    原因: 实际参数列表和形式参数列表长度不同
 */

No construtor, você pode chamar outros construtores através disso para simplificar o código.

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
	// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
	// 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
	//System.out.println(year); // 注释取消掉，编译会失败
    this(1900, 1, 1);     		// 必须在第一场调用其他构造函数
	//this.year = 1900;
	//this.month = 1;
	//this.day = 1;
    } 
    
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

【Perceber】

this(...) deve ser a primeira instrução no construtor.
Não é possível formar um anel.

public Date(){
	this(1900,1,1);
}
public Date(int year, int month, int day) {
	this();
} 

/* 无
参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
 */

Na maioria dos casos, o público é usado para modificação, e a modificação privada é usada em cenários especiais (você o encontrará quando falarmos sobre o modo singleton mais tarde).

【5.3】Inicialização padrão

A segunda questão levantada acima: Por que as variáveis locais precisam ser inicializadas quando usadas, mas as variáveis de membro não precisam ser?

public class Date {
    public int year;
    public int month;
    public int day;
    
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
    }
    
    public static void main(String[] args) {
        // 此处a没有初始化，编译时报错：
        // Error:(24, 28) java: 可能尚未初始化变量a
        // int a;
        // System.out.println(a);
        Date d = new Date(2021,6,9);
    }
}

Para entender esse processo, você precisa saber um pouco do que acontece por trás da nova palavra-chave:

Date d = new Date(2021,6,9);

No nível do programa, é apenas uma declaração simples. No nível da JVM, muitas coisas precisam ser feitas. Aqui está uma breve introdução:

Verifique se a classe correspondente ao objeto está carregada e, caso contrário, carregue-a.
Aloque espaço de memória para o objeto.
Para lidar com problemas de segurança de simultaneidade, como: vários threads solicitando objetos ao mesmo tempo, a JVM deve garantir que o espaço alocado para o objeto não entre em conflito.
Inicialize o espaço alocado

Ou seja: após a solicitação do espaço do objeto, os membros contidos no objeto já possuem seus valores iniciais definidos, como:

tipo de dados	valor padrão
byte	0
Caracteres	'\u0000'
curto	0
interno	0
longo	0L
boleano	falso
flutuador	0,0f
dobro	0,0
referência	nulo

[Java SE] Classes e objetos

classes e objetos

【1】Compreensão preliminar de orientação a objetos

【1.1】O que é orientado a objetos