1. Introdução
A reflexão Java é um mecanismo que nos permite obter informações internas dos métodos de classe, propriedades, classes de pais, interfaces etc. em tempo de execução. Em outras palavras, a reflexão é essencialmente um processo "reverso". Quando criamos uma instância de uma classe através de new , ela é realmente construída pela máquina virtual Java com base Class dessa classe em tempo de execução, e a reflexão é obter suas informações de definição através Class de uma classe, para que possamos acessar suas propriedades e métodos, conhecer a classe pai dessa classe, que interfaces são implementadas e outras informações.
2. Classe
Sabemos que o uso do JAVAC pode compilar arquivos .java em arquivos .class, que contêm nossas informações de definição original para a classe (classe pai, interface, construtor, propriedades, métodos etc.). O arquivo .class será carregado na Java Virtual Machine (JVM) ClassLoader no tempo de execução. Quando um arquivo .class é carregado, a JVM gera um objeto de classe para ele. Os objetos que instanciamos no novo no programa são realmente construídos com base no objeto de classe correspondente em tempo de execução. Para ser preciso, esse objeto de classe é na verdade uma instância da classe genérica java.lang.Class<T> . Por exemplo, Class<MyClass> é uma instância Class<T> que encapsula as informações de definição MyClass . Como java.lang.Class<T> não possui um construtor público, não podemos instanciar diretamente essa classe. Podemos obter um objeto de classe através do seguinte método.
Na explicação a seguir, faremos a aula de pessoas e a aula de estudante como exemplos:
public class People {private String Name; private Int Age; Pessoas públicas (nome da string, Int Age) {this.name = name; this.age = idade; } public int getage () {Age de retorno; } public string getName () {return name; } public void setage (int Age) {this.age = Age; } public void setName (nome da string) {this.name = name; } public void speak () {System.out.println (getName () + "" + getage ()); }} A classe pública estudante estende as pessoas {private Int Grade; estudante público (nome da string, Int Age) {super (nome, idade); } public student (nome da string, Int Age, Int Grade) {super (nome, idade); this.Grade = GRADE; } public int getGrade () {return Grade; } public void setGrade (int gray) {this.gRade = gray; } private void Learn (curso da string) {System.out.println (nome + "Learn" + curso); }} Obtenha o objeto de classe por nome de classe
Se soubermos o nome de uma aula durante o período de compilação, podemos obter seu objeto de classe como este:
Classe <People> peopleclass = People.class;
Há também um método para obter objetos de classe com base no nome completo do caminho da classe da seguinte maneira:
// Suponha que a classe People esteja na classe de pacote com.
Observe que o parâmetro do método Class.forName() deve ser o nome do caminho completo de uma classe. De fato, desde que "importemos com.test.people", podemos obter diretamente seu objeto de classe através de " People.class " sem ter que escrever o caminho completo. (Se a classe correspondente não for encontrada no classpath ao chamar Class.forName() , ClassNotFoundException será lançado.)
Obtenha seu objeto de classe através do próprio objeto
Pessoas pessoas = novas pessoas ("Bill", 18); classe <People> peopleclass = People.getClass (); Obtenha o construtor da classe por reflexão
Depois de obtermos o objeto de classe das People , podemos obter as informações de definição original da classe People através deste objeto de classe. Primeiro, vamos obter o objeto construtor da aula People . Com esse objeto construtor, podemos construir um objeto People . Por exemplo, podemos adicionar o seguinte código em Student.java:
public static void main (string [] args) {classe <Peoples> pclass = People.class; tente {Constructor <Peoples> construtor = pclass.getConstructor (string.class, int.class); Pessoas pessoas = construtor.NewInstance ("Bill", 18); obj.speak (); } catch (Exceção e) {}} No exposto, chamamos getConstructor para obter um objeto construtor da classe People . Como o construtor, queremos obter os parâmetros formais da String de tipo e int , passamos em String.class e int.class . Com o objeto construtor, podemos chamar o método newInstance para criar um objeto people .
Observe que quando o Constructor , Method e os objetos Field da classe são obtidos através da reflexão, antes de chamar os métodos desses objetos, o sinalizador accessible desse objeto é definido como true para cancelar a verificação de acesso à linguagem Java, que pode melhorar a velocidade de reflexão. Conforme mostrado no código a seguir:
Construtor <Peoples> construtor = peopleclass.getConstructor (string.class, int.class); // Defina a propriedade acessível do construtor para cancelar o acesso ao Java Access construtor.setAccessible (true);
Obtendo métodos declarados em sala de aula através da reflexão
Obtenha o método declarado na classe atual (excluindo herdado da classe pai)
Para obter todos os métodos declarados na classe atual, você pode usar a função getDeclaredMethods na classe. Ele receberá todos os métodos declarados na classe atual (incluindo métodos private , public , static e outros). Ele retornará uma variedade de objetos Method e cada objeto Method representa o método declarado em uma classe. Para obter o método especificado, você pode chamar getDeclaredMethod(String name, Class...<T> parameterTypes) .
Conforme mostrado no código a seguir:
ShowDecLaredMethods () {Student Student = New Student ("Bill", 18); // obtém todos os métodos declarados pelo método da classe do aluno [] métodos = student.getclass (). GetDecLaredMethods (); tente {// obtenha o objeto LearnMethod (encapsulado o método de aprendizado) Método LearnMethod = student.getClass (). getDecLaredMethod ("Learn", String.class); // Obtenha a lista de parâmetros do método Learn e imprima -o a classe <?> [] Paramclasses = LearnMethod.getParameterTypes (); para (classe <?> classe: paramclasses) {System.out.println ("Learn Method Parameters:" + class.getName ()); } // julgue se o método de aprendiz é privado system.out.println (LearnMethod.getName () + "é privado" + modifier.isprivate (LearnMethod.getModifiers ())); // Ligue para o método de aprendizado LearnMethod.invoke (aluno, "java reflexão"); } catch (Exceção e) {}} Obtenha métodos públicos declarados na classe atual e na classe pai
Para obter a classe atual e todos os métodos public declarados na classe pai, você pode chamar a função getMethods e, para obter um método public especificado, você pode chamar o método getMethod . Consulte o seguinte código:
ShowMethods de void estático privado () {Student Student = New Student ("Mr.Simple"); // Obtenha todos os métodos públicos (incluindo o próprio aluno e herdado da classe pai) Métodos [] Métodos = Student.getClass (). GetMethods (); tente {// observe que apenas métodos públicos podem ser obtidos através do getMethod. Se você tentar obter um método privado, uma exceção será lançada. Método LearnMethod = Student.getClass (). GetMethod ("Learn", String.class); } catch (Exceção e) {}} Obtenha os atributos definidos na classe por reflexão
Obter atributos é semelhante ao obter métodos, exceto que os métodos getMethods() / getDeclaredMethods() são substituídos por uma chamada para os métodos getFields() / getDeclaredFields() .
Obtenha os atributos definidos na classe atual (excluindo atributos herdados da classe pai)
Para obter todos os atributos definidos na classe atual (incluindo vários atributos como private , public , static etc.), você pode chamar a função getDeclaredFields do objeto de classe; Para obter os atributos especificados, você pode ligar para getDeclaredField .
Conforme mostrado no código a seguir:
ShowDecLaredFields () {Student Student = New Student ("Bill", 18); // obtém todos os atributos definidos no campo de classe atual [] campos = student.getclass (). GetDecLaredFields (); tente {// Obtenha o atributo especificado Campo GradeField = student.getClass (). getDecaredField ("Grade"); // Obtenha o Sistema de Valor do Atributo.out.println ("A nota é:" + GRADEFIELD.GETINT (Student)); // Defina o valor do atributo GRADEFIELD.SET (aluno, 10); } catch (Exceção e) {}} Obtenha os atributos públicos definidos na classe atual e na classe pai
Para obter todas as propriedades public definidas na classe atual e na classe pai, você pode chamar a função getFields do objeto Class . Para obter uma propriedade public especificada, você pode chamar getField , conforme mostrado no código a seguir:
Showfields de void estático privado () {Student Student = New Student ("Bill", 18); // Obtenha todas as propriedades públicas do campo atual da classe e da classe pai [] publicfields = student.getclass (). Getfields (); } Reflexão para obter a classe pai da classe e a interface implementada pela classe
Obtenha a classe pai
Basta chamar o método getSuperClass do objeto Class , conforme mostrado no código a seguir:
Aluno estudante = novo aluno ("Bill", 18); classe <?> Superclass = student.getclass (). GetSuperclass (); Obtenha a interface implementada
Para saber quais interfaces uma classe implementa, basta chamar o método getInterfaces do objeto Class , conforme mostrado no código a seguir:
ShowInterfaces de void estático privado () {Student Student = New Student ("Bill", 19); Classe <?> [] Interfaces = student.getclass (). GetInterfaces ();}Resumir
O acima é o conteúdo inteiro deste artigo. Espero que seja útil para estudar e trabalhar de todos.