La relación entre clase de objeto, clase interna, clase y clase en java

La clase Object es la clase raíz (clase antecesora) en Java;

• Todas las clases heredarán la clase Object y las clases vacías también heredarán;
• Por tanto, el método en Object es una función que pueden tener todas las clases;
• Objeto xxx = nuevo xxx (); El objeto puede ser polimórfico;
• Dado que puede ocurrir polimorfismo, si un método necesita pasar datos, podemos escribir Object cuando no estemos seguros del tipo de datos;
• ¿Cómo aprender un método?

•  1.该方法是谁的？
  

•  2.是什么方法？（成员还是静态）
  

•  3.方法的功能是什么？入参出参是什么？能实现什么，我们需要给它什么，它能给我们提供什么；
  

•  4.方法的覆写，什么情况下覆写？
  

• El propósito del diseño de iguales es comparar si dos objetos son iguales;
• Pero no implementa esta función, necesitamos sobrescribirla según nuestras propias necesidades;
• Los dos objetos pueden ser cualquier cosa, y solo cuando son específicos de la instancia, podemos lograr este método sobrescribiendo;
• @autor MARECLE_YING
• @Fecha 18 de enero de 2021
  * /
  public class _02Equals { // método principal public static void main (String [] args) { // crear objetos s1, s2; // asignarles valores a través de la construcción y asignación parametrizadas Student s1 = new Student (18, "李阳"); Student s2 = new Student (19, "李阳"); // Comparación de salida == comparación es la dirección de memoria false System.out.println (s1 == s2); // equals Compara dos objetos System.out.println (s1.equals (s2)); } } // Crea una clase de estudiante class Student { // Como quieres usar métodos getter / setter, debes privatizar la variable miembro private int age; private String name; // Use métodos getter / setter public int getAge () { return age; } public void setAge (int age) {
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  this.age = age;
  }
  public String getName () { return name; } public void setName (String name) { this.name = name; } // Crear una estructura paramétrica public Student (int age, String name) { super ( ); this.age = age; this.name = name; } // Crear una construcción pública sin argumentos Student () { super (); // TODO Stub de constructor generado automáticamente } // Sobrescribir el método equals de acuerdo con requisitos // Requisitos El mismo nombre es un estudiante @Override public boolean equals (Object arg0) { // 1. Comparar direcciones; direcciones iguales indican que son el mismo objeto y los valores deben ser iguales if (this == arg0 ) { devolver verdadero; }
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  // 2. Determine si el tipo de objeto es el tipo de clase actual; de lo contrario, devuelve falso, las diferentes clases no son comparables;
  si (arg0 instancia de Estudiante) { // 3. Forzar la conversión de tipo, comparar los datos deseados Estudiante s2 = ( Student) arg0; // Determinar si los valores son iguales // if (name.equals (s2.name) && age == s2.age) { if (name.equals (s2.name)) { return true; } } devuelve falso; }
  
  
  
  
  
  
  
  
  
  

}

es igual a

• Propósito del diseño: compare si dos objetos son iguales;
• == y! =: compara tipos de datos básicos y compara el tamaño del valor;

•  					比较引用数据类型，比较内存地址；
  

• igual compara direcciones de memoria por defecto;

•  		   实际中我们常常比较的都是对象的有意义的属性；
  

• Para comparar cadenas de igualdad, se debe usar igual, porque == compara direcciones de memoria;
• Anule el método equals en la clase String y compare el valor, no la dirección de memoria;
• Por tanto, también podemos usar iguales para comparar las propiedades de dos objetos del mismo tipo sobrescribiendo;
• Los diferentes tipos de objetos no son comparables;
• Método de implementación: cualquier comparación de tipo de referencia debe convertirse a un tipo básico para la comparación, a menos que desee comparar si dos direcciones son iguales;
• Orientado a objetos es una forma de encapsulación de datos básica, por lo que debemos convertir a una comparación de tipos básica cuando comparamos;
• @autor MARECLE_YING
• @Date 18 de enero de 2021
  /
  public class _01Equals { // método principal public static void main (String [] args) { // Crear dos objetos de tipo String s1 s2 s3 String s1 = new String ("998"); String s2 = new String ("1088"); String s3 = new String ("1088"); // Genere el resultado de la comparación, la comparación es la dirección de memoria, la dirección debe ser diferente; falso System.out.println (s1 = = s2 ); // igual compara el tamaño del valor // Estructura sintáctica: objeto 1.equals (objeto 2) // los valores son diferentes, falso System.out.println (s1.equals (s2)); // valores Son iguales, True System.out.println (s2.equals (s3)); } } paquete _16_Object_Finalize; /
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  *

finalizar la función del método

• Garbage llama a este método en el último paso de la colección, lo que desea lograr sobreescribir Object;
• ①finalizar es un método para cada objeto, porque eventualmente se convertirán en basura y serán reciclados;
• ②No necesita ser llamado por el programa, el sistema llama automáticamente
• ③ ¿Qué es la basura? En Java, si no hay más referencias a este objeto, entonces este objeto no tiene valor y el sistema lo tratará como datos basura;
• A la espera de ser reciclado, antes de reciclar, llame automáticamente al método de finalización
• ④ Vale la pena señalar que finalizar no tiene nada que ver con la recolección de basura, pero su ejecución en realidad se establece en el último paso de la recolección de basura, que es equivalente a un método miembro que se ejecuta automáticamente en este momento;
• ⑤ Generalmente se usa para operaciones de destrucción de datos antes de que se reciclen algunos objetos (escenarios de aplicación)
• @autor MARECLE_YING
• @Date 18 de enero de 2021
  /
  public class _01Finalize { // método principal public static void main (String [] args) { // instanciar el objeto Animal animal = new Animal (); // establecer la dirección del animal en un valor vacío Animal = null; // El programador recomienda al recolector de basura que recicle el jvm para recolectar basura. // Se recomienda reciclar, y puede que no haya reciclaje. System.gc (); // Cuando hay demasiada basura, no se necesita un consejo y el sistema se recicla automáticamente // Use un bucle for para crear 999999 objetos para (int i = 0; i <999999; i ++) { new Animal (); } } } // Cree una clase Animal Animal { / / Crear un método de finalización // Este lugar es solo Es a través del método de finalización que nos muestra si se recolecta la basura .// De hecho, la recolección de basura no tiene nada que ver con este método. La condición de activación de la recolección es la objeto. Si hay más objetos, el sistema automáticamente recicla public void finalize () {
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  System.out.println (this + "Quiero ser recuperado, sálvame ^_ ");
  }
  }
  Penalización de paquete para _16_Object_HashCode;
  / *

código hash

Propósito del diseño: generar un identificador único para cada objeto
*

• Hash: el mismo objeto genera varios valores hash y el valor debe ser el mismo;

•  				多个对象生成多个hash值时，值可能会相同，不能确保生成的hash值不同，这种情况被称作哈希冲突；
  

• Dado que existe un conflicto de hash, el valor de hash no puede garantizar la unicidad de los datos;
• Para garantizar la unicidad de los datos, primero comparamos los valores hash;
• Diferentes hashes indican diferentes objetos;
• El hash es el mismo, lo que indica que los objetos pueden ser iguales, por lo que debemos comparar si los objetos son iguales (iguales)
• ¿Qué más se debe tener en cuenta al sobrescribir hashCode? es igual a
• Al anular iguales, también considere hashCode;
• Entonces, en Java, la unicidad del objeto está representada por hashCode y es igual a
• Algoritmo hash: un algoritmo de cifrado seguro que convierte un valor de longitud variable en un valor de longitud fija, la desventaja es que existe un conflicto de hash;
• @autor MARECLE_YING
• @Date 18 de enero de 2021
  * /
  public class _01HashCode { // método principal public static void main (String [] args) { // instanciar un objeto _01HashCode hc = new _01HashCode (); // definir variables miembro y objetos Asignar el hash valor de hc a él int hash = hc.hashCode (); // El sistema El sistema es la máquina virtual JVM de java // El valor del hash de salida debe ser el valor de hash de hc. La dirección de memoria // Dirección de memoria decimal System.out.println (hash); // Genera la dirección de memoria de hc System.out.println (hc); // Genera el valor del hash de la variable miembro, conviértelo a hexadecimal y genera System.out.println (Integer. toHexString (hash)); } // Overwrite hashCode // El valor de retorno aquí puede cambiar el valor de hashCode @Override public int hashCode () { // TODO Código auxiliar de método generado automáticamente
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  // devuelve super.hashCode ();
  regreso 1999;
  }

}

Encadenar:

• Propósito del diseño: para devolver la representación de cadena del objeto, a través de este método, se pueden mostrar los datos de cada objeto
• Cuando se genera un tipo de referencia, se llama automáticamente al método toString del objeto;
• @autor MARECLE_YING
• @Fecha 18 de enero de 2021
  * /
  public class _01toString { public static void main (String [] args) { // instanciar el objeto s1 y asignar string String s1 = new String ("String"); // por qué no Dirección de memoria (porque toString se sobrescribe en la clase String) System.out.println (s1); // crea una instancia del objeto p1 y lo asigna a través del parámetro de construcción Person p1 = new Person (18, "Li Yang"); // salida Es la dirección of p1 System.out.println (p1); // Nombre de salida: Li Yang; edad: 18 // Puede optimizar la salida sobrescribiendo toString System.out.println ("Nombre:" + p1.getName () + " ; Edad: "+ p1.getAge ()); } } // Crea una clase Person { // Usa sentencias getter / setter para manipular el valor private int age; private String name; public int getAge () { return age;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  }
  public void setAge (int age) { this.age = age; } public String getName () { return name; } public void setName (String name) { this.name = name; } // El método de construcción tiene parámetros para recibir lo anterior El valor pasado public Person (int age, String name) { super (); this.age = age; this.name = name; } // Anular toString para optimizar la salida @Override public String toString () { // TODO Código auxiliar de método generado automáticamente // return super.toString (); return "nombre:" + nombre + "; edad:" + edad; }
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

}

Clase interior

• En pocas palabras, es crear una nueva clase en un cuerpo de clase;
• ① Clase interna de miembro (no estática)
• ② Clase interna de miembro estático
• ③Clase interna local
• ④ Clase interna anónima (parámetro real de participación formal)
• Escenario de aplicación: cuando se necesita una estructura completa para describir la parte interna de una cosa, se puede crear una clase interna;

•  			  java中 允许一个类定义在一个类的内部，前者称为内部类，后者成为外部类；
  

•  			  外部类调用内部类是，必须给出完整的名称让系统找到它；
  

• Las características de la clase interna: puede acceder a los datos privados de la clase externa;
• variable:

•  成员变量：成员内部类；
  

•  静态变量：静态内部类；
  

•  局部变量：局部内部类；
  

•  形参与实参变量：匿名内部类；
  

Clase interna de miembro:

•  1.可以等同看作成员变量
  

•  2.成员内部类中不能有静态声明
  

•  3.成员内部类中可以直接访问外部类所有的属性
  

• @autor MARECLE_YING

• @Date 18 de enero de 2021
  * /
  public class _01_InnerClass { // variable de miembro privatizado // static private static String s1 = "A"; // no estático privado String s2 = "B";
  
  
  
  
  

   // 创建内部类
   // private public protected 都可以使用
   // 编译后的类名为 外部类类名$内部类类名
   // _01_InnerClass$_01_InnerClass
   	public class InnerClass{
   		//内部类不能有静态声明(静态类和静态方法)
   		//static int x;
   		// public static void m1(){}
   		public void m1(){
   			// 内部类可以直接访问外部类的所有属性
   			System.out.println(s1);
   			System.out.println(s2);
   	}
   }
   // main方法
   public static void main (String[]args){
   	//创建外部类对象
   	_01_InnerClass wb = new _01_InnerClass();
   	//通过外部类去创建内部类对象
   	InnerClass nb = wb.new InnerClass();
   	nb.m1();
   }
  

}
paquete _18_InnerClass;
/ **

• Clase interna estática

• 1. Puede verse como una variable estática
• 2. En la clase interna estática, no se puede acceder directamente a los datos del miembro y se requiere el objeto.
• 3. Cualquier variable se puede declarar en una clase interna estática.
• @autor MARECLE_YING
• @ Fecha 18 de enero de 2021
  * /
  clase pública _02_InnerClass { // Crear variable privada // Cadena estática privada estática s1 = "Soy una variable miembro estática"; // Cadena privada no estática s2 = "Soy una variable miembro" ; // Crear una clase interna estática static declarar una clase estática privada estática InnerClass { // Crear un método estático m1 public static void m1 () { // Puede acceder directamente a las propiedades del miembro estático System.out.println (s1); // No se puede acceder directamente a los atributos de los miembros // System.out.println (s2); // Necesita usar la llamada de objeto // Crear una clase de objeto en la clase relativa a un tipo de objeto s es equivalente a su valor _02_InnerClass s = new _02_InnerClass (); // Usa un objeto para llamar a la salida System.out.println (s.s2); } // No se puede acceder directamente a los atributos de los miembros public void m2 () { // No se pueden acceder directamente a los atributos de los miembros, independientemente del método es estático o no;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  // System.out.println (s2);
  System.out.println ("Soy un método de miembro m2");
  }
  }
  // Escribe el método principal
  public static void main (String [] args) { // Ruta completa : Clase externa. Clase interna. Static _02_InnerClass.InnerClass.m1 (); // Al acceder a las propiedades estáticas de la clase actual, se puede omitir el nombre de la clase (para clases externas) // m1 es un método estático InnerClass.m1 ( ); // Sí Objeto de instanciación de InnerClass InnerClass x = new _02_InnerClass.InnerClass (); // De manera similar en la clase actual, la clase externa estática se puede omitir InnerClass x1 = new InnerClass (); // Usar el objeto de clase interna para llamar sus propios métodos de miembro x1.m2 (); } }
  
  
  
  
  
  
  
  
  
  
  
  
  

La relación entre clase y clase:

• ①Relación de herencia / relación de generalización;
• ②Relación de realización, múltiples realizaciones de clases e interfaces;
• ③Dependencia; llamar a otra clase en un método;
• ④ Relación de asociación; las variables miembro de una clase son referencias a objetos de otra clase;
• ⑤ Relación de agregación; cada miembro tiene la capacidad por sí solo, juntos se convierten en la organización para hacer grandes cosas y pueden hacer cosas por sí mismos sin la organización;
• ⑥ Relación de combinación, las partes forman una combinación y se convierten en un todo, para la parte es inútil separarse del todo, si el todo muere, la parte morirá;
• @autor MARECLE_YING
• @Date 18 de enero de 2021
  * /
  public class _01ClassRelation { // La relación de asociación Una variable miembro de una clase es una referencia a otro objeto de clase; // La relación de asociación ocurre en el cuerpo de la clase // Siempre que el tipo de La variable miembro no es un tipo de datos básico, entonces es la relación. // Aunque A es una clase, su valor es relativo al tipo A. Su valor es a. Este objeto A a = new A (); public static void main ( String [] args) { // Dependencia Invocar otra clase en un método es equivalente a que una variable local sea una referencia a otro objeto de clase // La dependencia ocurre en el cuerpo del método // Invocar otra clase en el método principal A a2 = new A (); } } // Crear clase clase A {
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

}
// Relación de herencia La clase secundaria B hereda la clase principal A La herencia de la clase y la clase es herencia única La
clase B se extiende A {

}
// Crear interfaz de
interfaz C {

}
interfaz D {

}
// Hay herencia múltiple entre interfaces, separadas por comas
interfaz E extiende C, D {

}
// Implementa múltiples implementaciones de clases de relación e interfaces. La
clase F implementa C, D {

}