myjavareflection1

package com.azure.java;
import
java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.Modifier;
public static TestReflection
{
/*
* 反射 java.lang.Class 是反射的根源 Class是大写 定义一个类，通过javac.exe命令，生成.class文件（字节码文件）如
* Person.class 通过java.exe（JVM类加载器）文件来加载.class文件，加载到内存中去，
* 这个字节码文件（.class）就是一个运行时类，运行时类就是Class类的一个实例 运行时类只会加载一次
* 通过Class可以完整地得到一个类中的完整结构，属性，方法，构造器 ,包名，类名，抛出的异常，注解等等
*/
public static void main(String[] args) throws Exception
{
}
//获取运行时类的三种方式
public static void test() throws Exception{
// 方式一，使用 对象名.getClass（）方法
Person p=new Person();
Class clazz=p.getClass();
Class strClazz=”111”.getClass();
System.out.println(clazz);
//调用类的名字 加上路径 下面会输出 com.azure.java.Person System.out.println(clazz.getName()); System.out.println(clazz);
System.out.println();
//第二种方法 类名.class
Class clazz1=Person.class; System.out.println(clazz1);
System.out.println();
//第三种 使用 Class.forname(“完整的类名”) Class clazz2=Class.forName(“com.azure.java.Person”);
System.out.println(clazz2);
Class strclazz2=Class.forName(“java.lang.String”);
System.out.println(strclazz2);
System.out.println(clazz == clazz1);
System.out.println(clazz == clazz2);
//clazz==clazz1==clazz2
}
//获取了运行时，就得到他的完整结构，属性，方法，构造器，包名，异常，注解等
public static void test1()
{
Class clazz=Person.class;
//获取属于属性getFields()可以获取运行时类所有的public 属性 另外还有其父类的public方法
Field[] fields=clazz.getFields();
for(Field f:fields)
{
System.out.println(f);
}
System.out.println();
getDeclaredFiles() 可以获取运行时类的所有属性，属性的类型是Field
Field[] fields1=clazz.getDeclaredFiles();
for(Field f:fields1)
{
System.out.println(f.getName());
//输出属性的访问权限
System.out.println(Modifier.tosstring(f.getModifers()));
//输出属性的类型
System.out.println(f.getType());
System.out.println(“###############”);

}
}
(https://img-blog.csdn.net/20160901233551230)
//获取了运行时类，就得到了他的完整的结构
public static void test2()
{
Class clazz=Person.class;
//获取自己及父类所有的的public方法
Method[] method=clazz.getMethod();
for(Method m:method)
{
System.out.println(m);
}
Method[] method1=clazz.getDeclaredMethods();
System.out.println(“111”);
for(Method m:method1)
{
System.out.println(m);
}
}
//获取了运行时类，就得到了他的完整的结构
public static void test3()
{
Class clazz=Person.class;
//获取自己及父类所有的构造函数
Constructor[] cons=clazz.getConstructors();
for(Constructor t:cons)
{
System.out.println(t);
}
}

}
//以下是类
class Person extends biology {
private String name;
int age;
public String sex;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public String getSex() {
    return sex;
}

public void setSex(String sex) {
    this.sex = sex;
}

public Person(String name, int age, String sex) {
    super();
    this.name = name;
    this.age = age;
    this.sex = sex;
}

public Person() {
    super();
    System.out.println("调用我");

}

@Override
public String toString() {
    return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
public void eat()
{
    System.out.println("eating");
}
void walk()
{
    System.out.println("walking");
}
private String sayHello(String str)
{
    System.out.println(str);
    return str;
}
public static void aa()
{
    System.out.println("aa");
}

}
class biology
{
public double weight;
}