Análise resumida baseada em reflexão em java

teste de classe {

}

demonstração de classe pública {
public static void main(String[] args) {
Teste t = novo Teste();
System.out.println(t.getClass());
System.out.println(t.getClass().getName());
}
}

}

demonstração de classe pública {
public static void main(String[] args) {
//Método 1:
Teste t = novo Teste();
Classe<? estende Teste> c1 = t.getClass();
System.out.println(c1);

//Método 2:
//Para evitar especificidade, a classe Test não é usada aqui, mas a classe String na biblioteca java é usada.
Classe<String> c2 = String.class;
System.out.println(c2);

//Método 3:
//o método forName() lançará uma exceção
Classe<?> c3 = nulo;
tentar {
c3 = Class.forName("Teste");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(c3);
}
}

//Gera uma referência para uma string
String s = nulo;
tentar {
//Downcast do objeto construído para a classe String
//método newInstance() lançará exceção
s = (String) c.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println("Comprimento da string: " + s.length());
}
}

demonstração de classe pública {
//Os métodos a seguir lançam muitas exceções Por uma questão de compactação do código, eles são lançados diretamente na máquina virtual aqui.
public static void main(String[] args) lança exceção {
Classe<?> c = nulo;
tentar {
c = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
char[] ch = {'h','e','l','l','o'};
String s = nulo;
//Obtém o construtor parametrizado do objeto Class. Os parâmetros entre colchetes são escritos como: type.class.
Construtor<?> con = c.getConstructor(char[].class);
//Use este método de construção para construir um novo objeto string, o parâmetro é um array char
s = (String) con.newInstance(ch);
System.out.println("String construída: " + s);
}
}

demonstração de classe pública {
//Os métodos a seguir lançam muitas exceções Por uma questão de compactação do código, eles são lançados diretamente na máquina virtual aqui.
public static void main(String[] args) lança exceção {
Classe<?> c = nulo;
tentar {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//O método getConstructors() aqui retorna um array Construtor
Construtor<?>[] cons = c.getConstructors();
//Você mesmo pode escrever o método de impressão. Por conveniência, eu uso Arrays.toString() para fazer isso.
System.out.println(Arrays.toString(cons));
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Classe<?> c = nulo;
tentar {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Classe<?>[] in = c.getInterfaces();
System.out.println(Arrays.toString(in));
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Classe<?> c = nulo;
tentar {
c = Class.forName("java.lang.Boolean");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Método[] m = c.getMethods();
//Ok, desta vez serei misericordioso e escreverei uma lista de impressão.
for (int i = 0; i < m.comprimento; i++) {
System.out.println(m[i]);
}
}
}

classe Pessoa {
nome da string privada;
idade interna privada;
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Classe<?> c = nulo;
tentar {
c = Class.forName("Pessoa");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Campo[] f = c.getDeclaredFields();
for (int i = 0; i < f.length; i++) {
System.out.println(f[i]);
}
}
}

classe Pessoa {
nome da string pública;
idade interna privada;

public Person(String nome, int idade) {
este.nome = nome;
esta.idade = idade;
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Pessoa p = new Pessoa("zhangsan",12);

Classe<?> c = p.getClass();

//Obtém o valor do atributo público
Campo f1 = c.getField("nome");
//get(p) indica qual valor do objeto deve ser obtido
String str = (String) f1.get(p);
System.out.println("Nome: " + str);

//Obtém o valor do atributo privado
Campo f2 = c.getDeclaredField("idade");
//idade é uma propriedade privada, então defina a verificação de segurança como verdadeira
f2.setAccessible(verdadeiro);
int idade = (int) f2.get(p);
System.out.println("Idade: " + idade);
}
}

classe Pessoa {
nome da string privada;

pessoa pública (nome da string) {
este.nome = nome;
}

string pública paraString() {
return "Nome: " + this.name;
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Pessoa p = new Pessoa("王二狗");
System.out.println(p);
Classe<?> c = p.getClass();

//Define as propriedades a serem modificadas
Campo f = c.getDeclaredField("nome");
f.setAccessible(verdadeiro);
//Modifica as propriedades e passa o objeto e o valor a ser definido
f.set(p, "Zhang Erdan");
System.out.println(p);
}
}

classe Pessoa {
impressão pública void(int i) {
System.out.println("Estou escrevendo números: " + i);
}

public static void dizer(String str) {
System.out.println("Estou dizendo: " + str);
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
Pessoa p = new Pessoa();
Classe<?> c = p.getClass();

//O método getMethod() precisa passar o nome do método e o tipo de parâmetro
Método m1 = c.getMethod("print", int.class);
//invoke() significa chamar e precisa passar objetos e parâmetros
m1.invoke(p, 10);

Método m2 = c.getMethod("dizer", String.class);
//O nulo aqui significa não chamado pelo objeto, ou seja, um método estático
m2.invoke(null, "sua irmã");
}
}

demonstração de classe pública {
public static void main(String[] args) lança exceção {
int[] arr = {1,2,3,4,5};
Classe<?> c = arr.getClass().getComponentType();

System.out.println("Tipo de array: " + c.getName());
int len ​​​​= Array.getLength(arr);
System.out.println("Comprimento da matriz: " + len);
System.out.print("Percorrer o array: ");
for (int i = 0; i < len; i++) {
System.out.print(Array.get(arr, i) + " ");
}
System.out.println();
//modifica matriz
System.out.println("O primeiro elemento antes da modificação: " + Array.get(arr, 0));
Array.set(arr, 0, 3);
System.out.println("O primeiro elemento modificado: " + Array.get(arr, 0));
}
}