Java es un lenguaje puro orientado a objetos (Programa Orientado a Objetos, abreviado OOP) En el mundo orientado a objetos, todo es un objeto. La orientación a objetos es una idea para resolver problemas, que se basa principalmente en la interacción entre objetos para completar una cosa . El uso del pensamiento orientado a objetos para manejar programas está más en línea con la comprensión de las cosas por parte de las personas y es muy amigable para el diseño, expansión y mantenimiento de programas grandes.

【1.2】 Orientado a objetos y orientado a procesos

[Forma tradicional de lavar la ropa]

La atención se centra en el proceso de lavado de ropa . Si falta un eslabón, es posible que no funcione.

Además, diferentes prendas se lavan de diferentes maneras, durante diferentes períodos de tiempo y con diferentes métodos de escurrido, lo que hace que su manipulación sea más problemática. Si vas a lavar tus zapatos en el futuro, esa es otra forma de ponerlos. Escribir código de esta manera será más problemático de expandir o mantener en el futuro .

[Forma moderna de lavar la ropa]

El procesamiento orientado a objetos no se centra en el proceso de lavado de ropa. Los usuarios no necesitan preocuparse por cómo la lavadora lava la ropa y cómo secarla. Solo necesitan poner la ropa en la lavadora, verterla el detergente y enciende el interruptor, es decir, se realiza a través de la interacción entre objetos . Nota: La orientación a procesos y la orientación a objetos no son lenguajes, sino métodos para resolver problemas, no son buenos ni malos y cada uno tiene su propio escenario de aplicación especial.

【2】 Definición y uso de clase

La programación orientada a objetos se centra en objetos, que son entidades de la vida real, como las lavadoras. Pero la computadora no conoce la lavadora y el desarrollador necesita decirle qué es una lavadora.

El lado izquierdo de la imagen de arriba es una descripción simple de la lavadora. Este proceso se llama abstracción del objeto (entidad) de la lavadora (reconocimiento de una cosa compleja) . Sin embargo, estos resultados abstractos simplificados no pueden ser reconocidos por las computadoras. Los desarrolladores pueden utilizar un determinado lenguaje de programación orientado a objetos para describirlo, como el lenguaje Java.

【2.1】Clase de comprensión simple

Las clases se utilizan para describir una entidad (objeto) , que describe principalmente qué atributos (tamaño de apariencia, etc.) y funciones (para qué se utiliza) tiene la entidad (objeto). Una vez completada la descripción, la computadora puede reconocerla.

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

En lenguaje Java, ¿cómo definir la clase de lavadora anterior?

【2.2】Formato de definición de clase

Al definir una clase en Java, debe utilizar la palabra clave class . La sintaxis específica es la siguiente

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

clase es la palabra clave que define la clase, ClassName es el nombre de la clase y {} es el cuerpo principal de la clase.

Los contenidos contenidos en una clase se denominan miembros de la clase. Los atributos se utilizan principalmente para describir clases y se denominan atributos miembro o variables miembro de la clase. Los métodos describen principalmente qué funciones tiene una clase y se denominan métodos miembro de la clase.

[Ejemplo: definir una clase de lavadora]

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("定时功能");
    }
}

La clase de lavadora se define en la computadora usando el lenguaje Java. Después de la compilación de javac, se forma un archivo .class, que la computadora puede reconocer según la JVM.

【Precauciones】

Tenga en cuenta que los nombres de las clases se definen en mayúsculas y minúsculas.
El método de escritura ante los miembros se unifica como público, lo cual se explicará en detalle más adelante.
El método escrito aquí no tiene la palabra clave estática , se explicará en detalle más adelante.

【2.3】Práctica

【2.3.1】Definir una clase de perro

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 una clase de estudiante

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

【Precauciones】

Generalmente, solo se define una clase en un archivo.
La clase donde se encuentra el método principal generalmente debe estar decorada con público (nota: Eclipse buscará el método principal en la clase modificada pública de forma predeterminada).
La clase modificada por público debe ser la misma que el nombre del archivo.
No modifiques fácilmente el nombre de la clase modificada públicamente, si quieres modificarlo, modifícalo a través de herramientas de desarrollo (demostrárselo a tus compañeros).

【3】 Creación de instancias de clase

【3.1】¿Qué es la creación de instancias?

Definir una clase es equivalente a definir un nuevo tipo en la computadora , similar a int y double, excepto que int y double son tipos integrados que vienen con el lenguaje Java, mientras que la clase es un nuevo tipo definido por el usuario. como los anteriores: clase PetDog y clase Student. Todas son clases (un tipo recién definido). Con estos tipos personalizados, puede usar estas clases para definir instancias (u objetos).

El proceso de creación de un objeto utilizando un tipo de clase se llama creación de instancias de la clase . En Java, la nueva palabra clave se utiliza para crear una instancia del objeto con el nombre de la clase.

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();
    }
} 
输出结果：
阿黄: 旺旺旺~~~
阿黄: 摇尾巴~~~
赛虎: 旺旺旺~~~
赛虎: 摇尾巴~~~

【Precauciones】

La nueva palabra clave se utiliza para crear una instancia de un objeto.
Utilice .para acceder a propiedades y métodos de un objeto.
Se pueden crear pares de instancias de la misma clase.

【3.2】Descripción de clases y objetos.

Una clase es simplemente algo parecido a un modelo , que se usa para describir una entidad y limitar los miembros de la clase.
Una clase es un tipo personalizado que se puede utilizar para definir variables.
Una clase puede crear instancias de múltiples objetos, y los objetos instanciados ocupan espacio físico real y almacenan variables miembro de la clase .
Usemos una analogía. Crear instancias de objetos de una clase es como usar dibujos de diseño arquitectónico para construir una casa en la realidad. Una clase es como un dibujo de diseño . Solo diseña lo que se necesita, pero no hay un edificio físico. De manera similar, una clase es solo un diseño que es instanciados Los objetos pueden realmente almacenar datos y ocupar espacio físico.

【4】Referencia de este

【4.1】¿Por qué deberíamos tener esta referencia?

[Veamos primero un ejemplo de clase de cita]

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

El código anterior define una clase de fecha y luego crea tres objetos en el método principal y configura e imprime los objetos a través de los métodos miembros en la clase Fecha. La lógica general del código es muy simple y no hay problemas.

Pero después de una cuidadosa consideración, tengo las siguientes dos preguntas:

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

Entonces, ¿quién asigna valores a quién en el cuerpo de la función? ¿Variable miembro a variable miembro? ¿Parámetro a parámetro? ¿Parámetros de variables miembro? ¿Parámetros de variables miembro? Supongo que ni siquiera puedo entenderlo.

Los tres objetos llaman a las funciones setDate e printDate, pero no hay descripción de los objetos en estas dos funciones.¿Cómo saben las funciones setDate e printDate qué datos de objeto se están imprimiendo?

Dejemos que esta cita revele este misterio.

【4.2】¿Cuál es esta referencia?

Esta referencia apunta al objeto actual (el objeto que llama al método miembro cuando el método miembro se está ejecutando). Se accede a todas las operaciones de variables miembro en el método miembro a través de esta referencia . Es solo que todas las operaciones son transparentes para el usuario, es decir, el usuario no necesita pasarlas y el compilador las completa automáticamente.

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] Esto se refiere al objeto en el que se llama al método miembro .

【4.3】Características de esta referencia

El tipo de this: corresponde a la referencia del tipo de clase, es decir, a qué objeto se llama es el tipo de referencia de ese objeto.
esto sólo se puede utilizar en "métodos miembros".
En un "método miembro", esto solo puede hacer referencia al objeto actual y no puede hacer referencia a otros objetos.
Este es el primer parámetro oculto del "método miembro", y el compilador lo pasará automáticamente. Cuando se ejecuta el método miembro, el compilador será responsable de pasar la referencia del objeto del método miembro que llama al método miembro, y esto será responsable de recibirlo.

Una demostración simple a nivel de código ---> Nota: La clase Fecha en el lado derecho de la imagen a continuación también se puede compilar.

【5】Construcción e inicialización de objetos.

【5.1】Cómo inicializar objetos

Por los puntos de conocimiento anteriores, sabemos que al definir una variable local dentro de un método Java, se debe inicializar; de lo contrario, la compilación fallará.

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

Para compilar el código anterior, es muy simple: simplemente establezca un valor inicial para a antes de usarlo oficialmente. Si es un objeto:

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

Debe llamar al método SetDate escrito antes para establecer la fecha específica en el objeto. Se descubrieron dos problemas a través de los ejemplos anteriores:

Es problemático llamar al método SetDate para establecer una fecha específica cada vez que se crea el objeto.¿Cómo se debe inicializar el objeto?
Las variables locales deben inicializarse antes de poder usarse. ¿Por qué se pueden seguir usando sin dar un valor después de declarar el campo?

【5.2】Método de construcción

【5.2.1】Concepto

El método constructor (también llamado constructor) es un método miembro especial cuyo nombre debe ser el mismo que el nombre de la clase. El compilador lo llama automáticamente cuando se crea el objeto y solo se llama una vez durante todo el ciclo de vida del 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] La función del método constructor es inicializar los miembros del objeto y no es responsable de abrir espacio para el objeto.

【5.2.2】Características

El nombre debe ser el mismo que el nombre de la clase.
No hay ningún tipo de valor de retorno y configurarlo como anulado no funcionará.
El compilador lo llama automáticamente cuando se crea un objeto y solo se llama una vez durante el ciclo de vida del objeto (equivalente al nacimiento de una persona, cada persona solo puede nacer una vez)
El constructor se puede sobrecargar (los usuarios proporcionan diferentes parámetros al constructor según sus propias necesidades)

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

Los dos constructores anteriores tienen el mismo nombre pero diferentes listas de parámetros, formando así una sobrecarga de métodos .

Si el usuario no lo define explícitamente, el compilador generará un constructor predeterminado, y el constructor predeterminado generado no debe tener 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();
    }
}

En la clase Date anterior, no se define ningún constructor y el compilador generará un constructor sin parámetros de forma predeterminada .

[Nota] Una vez definido por el usuario, el compilador ya no lo generará.


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
    找到: 没有参数
    原因: 实际参数列表和形式参数列表长度不同
 */

En el constructor, puedes llamar a otros constructores a través de esto para simplificar el 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;
    }
}

【Aviso】

this(...) debe ser la primera declaración en el constructor.
No se puede formar un anillo.

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

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

En la mayoría de los casos, la modificación se usa pública y la modificación privada se usa en escenarios especiales (lo encontrará cuando hablemos del modo singleton más adelante).

【5.3】Inicialización predeterminada

La segunda pregunta planteada anteriormente: ¿Por qué las variables locales deben inicializarse cuando se usan, pero las variables miembro no?

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 comprender este proceso, necesita saber algo de lo que sucede detrás de la nueva palabra clave:

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

A nivel de programa, es solo una declaración simple, y a nivel de JVM, hay muchas cosas por hacer, aquí hay una breve introducción:

Compruebe si la clase correspondiente al objeto está cargada y, en caso contrario, cárguela.
Asigne espacio de memoria para el objeto.
Para abordar problemas de seguridad de concurrencia, como: varios subprocesos solicitan objetos al mismo tiempo, la JVM debe garantizar que el espacio asignado al objeto no entre en conflicto.
Inicializar el espacio asignado

Es decir: después de solicitar el espacio del objeto, los miembros contenidos en el objeto ya han establecido sus valores iniciales, como por ejemplo:

tipo de datos	valor por defecto
byte	0
carbonizarse	'\u0000'
corto	0
En t	0
largo	0L
booleano	FALSO
flotar	0.0f
doble	0.0
referencia	nulo

[Java SE] Clases y objetos

clases y objetos

【1】 Comprensión preliminar de la orientación a objetos

【1.1】 ¿Qué es la orientación a objetos?