Hay 4 formas de clases internas de Java que generalmente usamos: clases internas generales, clases internas locales, clases internas anónimas y clases internas estáticas. La siguiente es una prueba que hice para ilustrar las características de varias clases internas.
Con respecto a las características de las clases internas, el código se explica en detalle, de la siguiente manera.
/** Prueba de clase interna Java** Resultado de reflexión de interobj:** private int i* private interobj $ intera ia* public interbj ()* public static void main (java.lang.string [])* private int geti ()* public void p ()* public void pi ()* public void pp ()* public void void void ppp ()* public pp () ()* public void pi ()* public void pp ()* public void void void ppp () void pppp ()* a continuación se encuentra el compilador generados automáticamente métodos estáticos para acceder a atributos privados o nivel de paquete de método* static int Access $ 0 (INATOBJ)*/public class INATOBJ {private int i = 8; private intera ia = null; public interobj () {ia = new InterA ();} private int p () {Pi (); PP (); Ppp (); PPPP (); PPPP ();}/ * * En las clases, métodos y propiedades internas generales se puede acceder en cualquier nivel de la "clase de capa". La clase de la chaqueta también puede* acceder a los métodos y propiedades en cualquier nivel de la "clase interna". Porque la clase interna puede contener una referencia al objeto de clase de capa. * Para los métodos y atributos privados a los que deben acceder la clase interna, el compilador generará automáticamente los métodos estáticos de nivel "paquete" correspondientes a los * métodos y atributos privados. Estos métodos deben usar el objeto de clase externa como parámetro *, para que pueda acceder a los métodos privados y * atributos en la clase externa en los métodos estáticos de nivel "paquete". * El mismo principio es el mismo para la clase de la chaqueta para acceder a métodos y propiedades privadas en la clase interna. Cuando se compila la clase interna, * generará un método estático de nivel de "paquete" correspondiente a los métodos y propiedades privadas a las que debe acceder a la clase de la chaqueta. * * Resultado de reflexión intera: * private int ia * a continuación se encuentra la referencia del objeto de clase de la capa en poder de la clase interna * interobj final este $ 0 * Use el objeto de clase de la capa como un parámetro en el constructor * interobj $ intera (interobj) * private void pa () * a continuación es el método de compilador automáticamente generoso * pa1 () * */class intera {private int ia = 9; private void pa () {system.out.println ("Esto es intera.pa: ia ="+ia+", interobj.i ="+geti ());} public void pa1 () {System.out.println ("Esto es intera.pa1: ia = "+ia+", interobj.i = "+geti ());}}/ * * Las clases internas locales solo son visibles dentro de los métodos, y otras características son las mismas que las clases internas generales. * Para las variables locales a las que se deben acceder, debe establecerse en final, porque aunque la clase interna local puede contener * referencias al objeto de clase exterior para acceder a las propiedades y métodos, no puede acceder a las variables locales en el método de clase externa. Todos los compiladores "copian" una copia de las variables locales a las que se deben acceder en la clase interna local (pero no hay copia para tipos cuyos tipos básicos int, flotación y cadena * no se cambian). Para garantizar que el valor variable copiado y el objeto * apuntado por el valor de la variable en el método externo sean el mismo objeto, se requiere que esas variables locales utilizadas por la clase local se establezcan en final y no se pueden modificar *, para asegurarse de que las variables copiadas en la parte local y las variables en el método externo apunten al mismo objeto. Configuración de la variable * a solo controles finales que la dirección de objeto señaló por la variable permanece sin cambios, en lugar de que las propiedades internas del objeto al que señala no se pueden cambiar. * * Resultado de reflexión de Interb: * * Private int ib * a continuación se encuentra la referencia del objeto de clase de la capa en poder de la clase interna * Final Interobj Este $ 0 * a continuación es la copia de referencia del objeto de prueba de variable local en el método externo en poder de la clase interna * Private Final Val $ prueba * Usar el objeto de clase de la capa y la prueba variable local como los parámetros en el constructor * interbj $ 1 $ 1 $ 1 $ 1 Interbj, prueba privada) compiler automatically generates a static method for accessing private properties or method package level* static void access$0(InterObj$1$InterB) */public void pi(){final int s=5;final Test test=new Test();class InterB{private int ib=7;private void pB(){System.out.println("this is InterB.pB: ib="+ib+ ", (Método) pi.s ="+s+", test.t ="+test.gett ());}} interb ib = new interb (); // Esto se cambió el estado interno de la prueba de prueba a la que se hace referencia la clase interna local. // Cuando el resultado se llama ib.pb (), la salida es el valor cambiado 100Test.sett (100); Ib.pb ();}/ * * Clase interna estática, utilizada cuando no es necesario mantener una referencia al "Objeto de clase de capa". * * Resultado de reflexión de intercal: (la clase interna estática no tiene una referencia al objeto de clase de capa) * private int ic * interc () * private void pc () */static class interc {private int ic = 6; private void pc () {system.out.println ("Esto es interc.pc: ic ="+ic);}/ * * no static, no puede construir un método in-static intert in static in static intert in static intner. * Puede acceder a cualquier permiso en la clase interna*/public void pp () {intera ia = new InterA (); ia.pa (); ia.pa1 (); interc ic = new Interc (); ic.pc (); // Las clases internas locales solo son visibles dentro del método // Interb ib = new Interb ();}/** Los métodos estatales solo pueden construir las clases internos. * No puede construir clases internas no estáticas porque no hay ningún objeto en el método estático que se refiere a la "clase de capa" para construir * el objeto de clase interna al que debe referenciar el objeto de clase de la capa. */public static void ppp () {// intera ia = new InterA (); // pero se puede construir de la siguiente manera: INATOBJ IOBJ = new InterObj (); intera ia = ioBj.New intera (); ia.pa (); ia.pa1 (); interc ic = new interc (); ic.pc (); // locales, solo visible, solo visible. // interb ib = new interb ();}/ * * Anonymous interna de clase interna */public void pppp () {testInterface tif = new testInterface () {public void pppp () {System.out.Println ("testInterface.nonNeMe");}}; tif.pppp ();}/ * * ejecutando el resultado: * esto es interb.pb.pb: ib = 7, (método) pi.s = 5, test.t = 100 * esto es intera.pa: ia = 9, interobj.i = 8 * esto es intera.pa1: ia = 9, interobj.i = 8 * esto es interc.pc: ic = 6 * esto es intera.pa: ia = 9, interbj.i = 8 * esto es intera.pa1: ia = 9, intera.Pa: ia = 9, interobj.i = 8 * esto es intera.pa1: ia = 9, intera.pa: ia = 9, interobj.i = 8 * esto es intera.pa1: ia = 9, intera.pa: ia = 9, interbj.i = 8 * esto es intera.pa1: ia = 9, intera. Esto es interc.pc: ic = 6*testInterface.noname*/public static void main (string [] args) {interobj io = new Interobj (); io.p ();}}/** Interfaz de interfaz para crear clases internas*/interface testinterface {public void pppp ();}/** clases variables locales para probar las clases internaes internos*/state intitt {intit {9; gett () {return t;} public void sett (int t1) {t = t1;}}Déjame compartir otro ejemplo:
public class InnClass {static toy = new Toy () {String name = "Lao Wu";@anverride public void jump () {system.out.println (nombre+"rompiendo la tierra"); go ();}};/*Clase interna: clase definida dentro de la clase*1. Clase interna del miembro: *1.1 La clase interna del miembro puede acceder directamente a las propiedades de la clase externa *1.2 Acceda al objeto actual de la clase externa a través del nombre de la clase externa. De esta manera * Miembro de clase interna Objeto instanciado: nombre de clase externa. Nombre de la clase interna Nombre de referencia = Clase Externa Object.Nnew Nombre de clase interna (); *2. Clase interna estática*2.1 Los recursos miembros de la clase externa no se pueden acceder dentro de la clase interna estática, y solo pueden acceder a los recursos estáticos de la clase externa a través del nombre de clase*Objeto de instancia de la clase interna estática: nombre de clase externa. Nombre de la clase interna Nombre de referencia = Nuevo nombre de clase externa. Nombre de clase interna (); *3. Clase interna local:*3.1 También puede acceder directamente a las propiedades de la clase externa*3.2 También puede acceder al objeto actual de la clase externa*3.3 La clase interna local solo se puede acceder dentro del método, y el modificador solo puede ser el valor predeterminado*4. Clase interna anónima: cuando se necesita una instancia de subclase específica de una clase, una clase se genera temporalmente usando * nuevo nombre de clase () { * Sobrescribir el método; *}; *4.1 La clase interna anónima accede a las propiedades del método externo, y esta propiedad se convertirá en una constante*4.2 Nuevos atributos y métodos agregados en la clase interna anónima, y solo se puede utilizar dentro de la clase interna anónima **/public static void main (string [] args {persona per = persona ("persona (lao chen", 18); persona.CuPER PC = per. pc1 = nueva persona ("Jian Zihao", 18) .Nnew Computer ("Alien"); Pc.Rungame (); PC1.Rungame (); Person.CuPuter1 PC11 = New Person.Comter1 ("Computadora de Internet Cafe"); PC11.Rungame (); Per.usecomputer (); Computer () {@anular public void RunGame () {// TODO Auto Generado Método stubsystem.out.println (per.age+"año-antirrenador"+per.name+"reproduciendo lalalala demaSita"); system.out.println (str);}}; com.rungame (); // anónimo de clase interna para la clase específica para la clase específica para la clase específica @Override public void jump () {System.out.println ("Breaking fuera de la tierra"); }};*/toy.jump (); toy.jump (); // toy.go (); // system.out.println (juguete.);}} persona de clases {string name; int age; static int age1 = 18; static string name1 = "experto de tiempo completo"; persona pública (nombre de cadena (int a age) {super (); this.name; playgame () {system.out.println (nombre+"juego de juego");} public class Computer {String Name; public Computer (String Name) {super (); this.name = name;} public void RunGame () {System.out.Println (Name+"Run Game"); System.Println (Age+"Yearty"+Person.this.This.Name.Name. "JUEGO);" JUEGO);}); static class Computer1 {String Name; public Computer1 (String Name) {super (); this.name = name;} public void RunGame () {System.out.println (nombre+"Run Game"); System.Println (Person.age1+"" "Person.nnnnner.nerk+" Game Game ");}} public void useComputer () {) {Class de clases {Computer string Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name (String Name; {super (); this.name = name;} public void RunGame () {System.out.println (name+"Run Game"); System.out.println (persona.this.age+""+Person.This.Name+"Juego de juego");}} Computer Comm = NEW COMPUT RunGame ();} public class Toy {public void jump () {System.out.println ("Jump Toy");}}Resumir
Lo anterior es toda la explicación detallada del código de prueba interno de Java en este artículo, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!