发布于 2018-02-05 11:24:22 | 206 次阅读 | 评论: 0 | 来源: 网友投递
Java程序设计语言
java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaEE(j2ee), JavaME(j2me), JavaSE(j2se)）的总称。
java 反射机制：
测试实体类
以Human为例
/**
* Project: Day12_for_lxy
* Created: Lulu
* Date: 2016/8/10
*/
public class Human<T> {
private String name;
private int age;
private float height;
private static int legs = 2;
private Map<String, String> jobs;
private T t;
public int say() {
System.out.println("I'm" + name);
return 0;
}
private void sleep(Human human) {
System.out.println(name + " sleep with " + human.name);
}
public List<Integer> getList() {
return new ArrayList<>();
}
public Human() {
}
private Human(String name, int age, float height) {
this.name = name;
this.age = age;
this.height = height;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 150 || age < 0) {
throw new RuntimeException("age > 150 || age < 0");
}
this.age = age;
}
public float getHeight() {
return height;
}
public void setHeight(float height) {
this.height = height;
}
@Override
public String toString() {
return "Human{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}
测试获取构造方法
/**
* Project: Day12_for_lxy
* Created: Lulu
* Date: 2016/8/10
*/
/*
获取构造方法
*/
public class TestConstructor {
public static void main(String[] args) {
//得到相应的类结构, 这是用来描述Human这个类的类
Class<Human> humanClass = Human.class;
try {
//// 这是在知道构造方法结构的前提下
// //获取都明确参数的构造方法, 获取的是公开的(public)
// Constructor<Human> constructor1 = humanClass.getConstructor(String.class, Integer.TYPE, Float.TYPE);
//
// Human h1 = constructor1.newInstance("小明", 18, 1.85f);
// System.out.println(h1.toString());
//
// //构造方法, 修饰符类型
// int modifiers = constructor1.getModifiers();
// if (Modifier.isPublic(modifiers)) {
// System.out.println("是public");
// }
// ////获取都明确参数的构造方法, 获取的是声明的
// Constructor<Human> constructor2 = humanClass.getDeclaredConstructor(String.class, Integer.TYPE, Float.TYPE);
// //设置可以全部访问
// constructor2.setAccessible(true);
// //这样是可以获取到所有的构造方法, 包括私有的
// Human human2 = constructor2.newInstance("zll", 18, 1.80f);
// System.out.println(human2.toString());
//不知道构造方法的类结构
Constructor<?>[] constructors = humanClass.getDeclaredConstructors();
for (Constructor<?> c : constructors) {
c.setAccessible(true);
System.out.println(c.getName());
System.out.println("===========================");
//参数列表
Class<?>[] types = c.getParameterTypes();
for (Class<?> type : types) {
System.out.println(type.getTypeName());
}
//修饰符类型
int modifiers = c.getModifiers();
if (Modifier.isPublic(modifiers)) {
System.out.println("是公开的");
}else if (Modifier.isPrivate(modifiers)){
System.out.println("是私有的");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试获取字段
/**
* Project: Day12_for_lxy
* Created: Lulu
* Date: 2016/8/10
*/
/*
获取属性:
属性包括:( 属性名 类型 修饰符 泛型 )
父类的属性
自身的属性
*/
public class TestField {
public static void main(String[] args) {
Class<Human> humanClass = Human.class;
Field[] fields = humanClass.getDeclaredFields();
for (Field f : fields) {
//属性名
System.out.print(" 名字: " + f.getName() + " ");
System.out.println();
//类型
System.out.print("类型 :" + f.getType() + " ");
System.out.println();
//修饰符
int modifiers = f.getModifiers();
if (Modifier.isPublic(modifiers)) {
System.out.println("公开的");
} else if (Modifier.isPrivate(modifiers)) {
System.out.println("私有的");
}
}
System.out.println("============================泛型==================================");
try {
//通过类结构获取jobs属性
Field jobs = humanClass.getDeclaredField("jobs");
//泛型
ParameterizedType type = (ParameterizedType) jobs.getAnnotatedType().getType();
Type[] types = type.getActualTypeArguments();
for (Type type1 : types) {
System.out.println(type1);
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("===================设置值, 得到值============================");
try {
Human<Object> human = new Human<>();
//非静态, 你要知道给谁设置属性的值
Field nameField = humanClass.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(human, "路新艺");
System.out.println(human.getName());
//静态
Field legs = humanClass.getDeclaredField("legs");
int modifiers = legs.getModifiers();
legs.setAccessible(true);
if (Modifier.isStatic(modifiers)) {
System.out.println("是静态的");
}
legs.set(null, 4);
System.out.println(legs.get(null));
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试获取方法
/**
* Project: Day12_for_lxy
* Created: Lulu
* Date: 2016/8/10
*/
/*
获取方法:
方法名
修饰符
返回值类型
泛型
静态和非静态
方法的调用
*/
public class TestMethod {
public static void main(String[] args) {
Class<Human> humanClass = Human.class;
//方法名
Method[] ms = humanClass.getDeclaredMethods();
for (Method m : ms) {
m.setAccessible(true);
System.out.print("方法名: " + m.getName() + " " );
int modifiers = m.getModifiers();
if (Modifier.isPublic(modifiers)) {
System.out.println("公开的");
} else if (Modifier.isPrivate(modifiers)) {
System.out.println("私有的");
}
}
//在确定方法参数的情况下 方法名不能唯一的确定, 重载
try {
//普通类型
Method sayM = humanClass.getDeclaredMethod("say");
Class<?> returnType = sayM.getReturnType();
System.out.println(returnType.toString());
//泛型
Method getListM = humanClass.getDeclaredMethod("getList");
System.out.println(getListM.getReturnType());
ParameterizedType type = (ParameterizedType) getListM.getAnnotatedReturnType().getType();
System.out.println(type);
Type[] ts = type.getActualTypeArguments();
for (Type t : ts) {
System.out.println(t);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试获取类信息
public static void main(String[] args) {
printClassInfo(Student.class);
}
public static void printClassInfo(Class c){
//Java中唯一的父类的类时Object
System.out.println(c.getName());
System.out.println(c.getSimpleName());
System.out.println(c.getSuperclass());
Class[] interfaces = c.getInterfaces();
for (Class anInterface : interfaces) {
System.out.println(anInterface);
}
//外部类类只有两种访问权限修饰(public 和 default)
int modifiers = c.getModifiers();
}
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！