Existem 4 formas de classes internas Java que geralmente usamos: classes internas gerais, classes internas locais, classes internas anônimas e classes internas estáticas. A seguir, é apresentado um teste que fiz para ilustrar as características de várias classes internas.
Em relação às características das classes internas, o código é explicado em detalhes, como segue.
/** Java Teste de classe interna** Resultado da reflexão interobj:** privado int i* private interobj $ interra ia* public interobj ()* public static void main (java.lang.string [])* private int geti ()* public void P ()* public void Pi ()* public void pp ()** void pppp ()* abaixo está o compilador Métodos estáticos gerados automaticamente para acessar atributos privados ou nível de pacote de métodos* estático int Access $ 0 (interobj)*/public class InterObj {private int i = 8; private interra ia = null; public interobj () {ia = new interra ();} private inti () {public; p () {pi (); pp (); ppp (); pppp (); pppp ();}/ * * em classes, métodos e propriedades internos gerais podem ser acessados em qualquer nível na "classe do casaco". A aula de jaqueta também pode* acessar métodos e propriedades em qualquer nível na "classe interna". Porque a classe interna pode manter uma referência ao objeto de classe do casaco. * Para os métodos e atributos privados que precisam ser acessados pela classe interna, o compilador gerará automaticamente os métodos estáticos de nível "pacote" correspondentes aos * métodos e atributos privados. Esses métodos precisam usar o objeto de classe externa como o parâmetro *, para que você possa acessar os métodos privados e * atributos na classe externa no "pacote"-métodos estáticos no nível. * O mesmo princípio é o mesmo para a classe de jaqueta acessar métodos e propriedades privados na classe interna. Quando a classe interna for compilada, * gerará um método estático de nível "pacote" correspondente aos métodos e propriedades privadas que precisam ser acessadas pela classe de jaqueta. * * Resultado da reflexão intera: * privado int ia * abaixo está a referência do objeto de classe do casaco mantido pela classe interna * interobj final, esse $ 0 * use o objeto de classe do casaco como um parâmetro no construtor * interobj $ interra (interobj) * private vazio PA () * abaixo do compilador gera automaticamente um método estático para acessar o acesso privado pa1 () * */classe intera {private int ia = 9; private void pa () {system.out.println ("Isso é interra.pa: ia ="+ia+", interobj.i ="+geti ());} public void pa1 () {system.out.println ("this Isa.pa ia = "+ia+", interobj.i = "+geti ());}}/ * * As classes internas locais são apenas visíveis métodos internos, e outros recursos são os mesmos das classes internas gerais. * Para variáveis locais que precisam ser acessadas, elas devem ser definidas como final, porque, embora a classe interna local possa manter * referências ao objeto de classe externa para acessar propriedades e métodos, não pode acessar variáveis locais no método de classe externa. Todos os compiladores "copiam" uma cópia das variáveis locais que precisam ser acessadas na classe interna local (mas não há cópia para tipos cujos tipos básicos int, float e string * não são alterados). A fim de garantir que o valor variável copiado e o objeto * apontado pelo valor da variável no método externo sejam o mesmo objeto, é necessário que as variáveis locais usadas pela classe local sejam definidas como final e não possam ser modificadas *, de modo a garantir que as variáveis copiadas na parte local e as variáveis no método externo aponte para o mesmo objeto. Definir a variável * como final controla apenas que o endereço do objeto apontado pela variável permanece inalterado, e não que as propriedades internas do objeto que ele aponta não pode ser alterado. * * Reflexão resultado do interb: * * privado int ib * abaixo está a referência do objeto de classe do casaco mantido pela classe interna * final interobj, este $ 0 * abaixo está a cópia de referência do objeto de teste de variável local no método externo mantido pela classe interna * private Test Val $ test * use o objeto de classe de casaco e o teste de variável local como parâmetros no constrtor * O compilador gera automaticamente um método estático para acessar propriedades privadas ou nível do pacote de método * acesso estático de vazio $ 0 (interobj $ 1 $ interb) */public void pi () {final int s = 5; teste final Teste = new Test (); classe interb {private int ib = 7; private Isb () IB ISB () IB IB () IB IB () IB () IB IB IB IB IB IBS ISB ISB () IB () IB IB IB IB IB IB IBS INB () IB () IB () IB IB () IRB IB IB IB IST IRB () IB () IRB IRB IB (FINAL; ", (Método) pi.s ="+s+", test.t ="+test.gett ());}} interb ib = new interb (); // Isso é alterado o estado interno do teste de teste referenciado pela classe interna local. // Quando o resultado é chamado IB.pb (), a saída é o valor alterado 100test.sett (100); ib.pb ();}/ * * classe interna estática, usada quando não há necessidade de manter uma referência ao "objeto de classe do casaco". * * Resultado da reflexão intercurgente: (A classe interna estática não tem uma referência ao objeto da classe do casaco) * privado int iC * intercoc () * private void pc () */classe estática interc {private int iC = 6; private void pc () {system.out.println ("Este é interc.pc: ic ="+ic);}}/não. * Você pode acessar quaisquer permissões na classe interna*/public void pp () {intera ia = new intera (); ia.pa (); ia.pa1 (); intercoc = new interc (); ic.pc (); // classes internas locais* são visíveis dentro do método // interb IB = novo (); * Você não pode construir classes internas não estáticas porque não há objeto no método estático que se refere à "classe do casaco" para construir * o objeto de classe interna que precisa ser referenciado pelo objeto da classe do casaco. */public static void ppp () {// intera ia = new intera (); //, mas pode ser construído da seguinte forma: interobj iobj = new interobj (); interra ia = iobj.new interra (); ia.pa (); ia.Pa1 (); interc); ib = new interb ();}/ * * Teste de classe interna anônima */public void pppp () {TestInterface tif = new TestInterface () {public void pppp () {System.out.println ("TESTInterface.noname");}}; tif.pppP (); ib = 7, (método) pi.s = 5, test.t = 100 * Isso é interra.pa: ia = 9, interobj.i = 8 * Isso é interra.pa1: ia = 9, interobj.i = 8 * Isto é interc.pc: ic = 6 * this interra.a: ia = 9, interrobj.iA = 8 * this interra.a.a: ia = 9, interrobj.iA = 8 * this interra.a.a: ia = 9, interrobj.iA = 8 * this interra. Isso é interc.pc: ic = 6*testInterface.noname*/public static void main (string [] args) {interobj io = new interobj (); io.p ();}}/** interface para criação de classes internas*/interface Testinterface {public void pppp ();}/** gett () {return t;} public void Sett (int t1) {t = t1;}}Deixe -me compartilhar outro exemplo:
classe pública INNERCLASS {STATIC Toy Toy = new Toy () {String name = "Lao wu";@substituir public void Jump () {System.out.println (nome+"Breaking Out of the Earth"); Go ();}};/*Classe Inner: Classe definida na classe*1. Classe interna do membro: *1.1 Classe interna do membro pode acessar diretamente as propriedades da classe externa *1.2 Acesse o objeto atual da classe externa através do nome da classe externa. Desta forma * Membro da classe interna Objeto instanciado: Nome da classe externa. Nome da classe interna Nome de referência = classe externa Object.Now Nome da classe interna (); *2. Classe interna estática*2.1 Os recursos membros da classe externa não podem ser acessados dentro da classe interna estática e só podem acessar os recursos estáticos da classe externa através do nome da classe*Objeto de instanciação da classe interna estática: nome da classe externa. Nome da classe interna Nome de referência = novo nome da classe externa. Nome da classe interna (); *3. Classe interna local:*3.1 Você também pode acessar diretamente as propriedades da classe externa*3.2 Você também pode acessar o objeto atual da classe externa*3.3 A classe interna local só pode ser acessada dentro do método, e o modificador pode ser apenas o padrão*4. Classe interna anônima: quando uma instância de subclasse específica de uma classe é necessária, uma classe é gerada temporariamente usando * novo nome da classe () { * Método de substituição; *}; *4.1 Classe interna anônima acessa as propriedades do método externo, e essa propriedade será convertida em uma constante*4.2 Novos atributos e métodos adicionados na classe interna anônima e só pode ser usado dentro da classe interna anônima **/public static void main (string [] args) {PERS PER = New Pessoa ("lao chen", 18, 18), PER = PERSON.CONTE). Computador ("alien"); person.computer pc1 = nova pessoa ("jian zihao", 18) .New Computer ("Alien"); pc.rungame (); pc1.rungame (); pessoa.computer1 pc11 = novo; "Rokudou"; computador com = new Computer () {@substituir public void rungame () {// TODO Método Gerado Auto STUBSYSTEM.OUT.println (por.age+"ano"+por.name+"tocando lalalalala Demasita"); SystemUng.ImonM.Println (Str); Classes/*Toy Toy = new Toy () {@Override public void Jump () {System.out.println ("Quebrando fora da Terra"); }};*/Toy.jump (); Toy.jump (); // Toy.go (); // System.out.println (Toy.);}} classe PERSON {Nome da String; Int Age; Static Int Age1 = 18; Static String Name1 = "Expert em tempo integral"; Public Pessoa (Nome da String, Int Age) {(); playgame () {System.out.println (nome+"play game");} public class Computer {Nome da String; Public Computer (String Name) {super (); this.name = name;} public void rungame () {System.out.println (nome+"Run Game); Classe estática Computer1 {Nome da String; Public Computer1 (Nome da String) {super (); this.name = name;} public void rungame () {System.out.println (name+"Run Game"); System.out.println (PERSON.AGE1+""+PERSON.NAMEER1+"Playing Game");}}}} {super (); this.name = name;} public void rungame () {System.out.println (name+"Run Game"); System.out.println (Pessoa.This.Age+""+PERSON.TELTEM.RUNG+"jogo"; rungame ();} classe pública Toy {public void Jump () {System.out.println ("Jump Toy");}}Resumir
O exposto acima é toda a explicação detalhada do código de teste interno da Java neste artigo, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!