黑马程序员_java基础反射类型与应用2

------ <a href="http://www.itheima.com" target="blank">Windows Phone 7手机开发</a>、<a href="http://www.itheima.com" target="blank">.Net培训</a>、期待与您交流！ -------

//利用Class获取类的属性信息
public class reflect {
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

class A {

}
interface B{
}
interface C{

}
public class BaseDemo extends A implements B,C {

public class C{}
public interface D{}
public static void main(String[] args){
//类可以，接口也可以
Class<BaseDemo> c =BaseDemo.class;
System.out.println(c);
//得到包名
System.out.println(c.getPackage());
//得到全限定名
System.out.println(c.getName());
//得到类的简称
System.out.println(c.getSimpleName());
//得到父类
System.out.println(c.getSuperclass().getSimpleName());
System.out.println(c.getInterfaces());
//得到接口
Class[] arr = c.getInterfaces();
for(Class cla:arr){
System.out.println(cla);
}
//获得public修饰的类
Class[] c1 =c.getClasses();
System.out.println(c1.length);//在内部类没有加上public修饰时候长度为0，加上就是2（获取的是公共的）
for(Class class1:c1){
System.out.println(class1);
}
//获得修饰符
int i = c.getModifiers();
System.out.println(i);//常量值1表示public
System.out.println(Modifier.toString(i));
}
}
//反射创建对象
class User {
public String toString(){
return "User对象创建成功！"；
}
}
public class NewInstance {
public static void main(String[] args) throws Exception {
//传统方式创建对象
System.out.println(new User());
//使用反射的方式
Class<User> c = User.class;
User u=c.newInstance();
//直接newInstance的话必须保证默认的构造方法正常存在，也就是没有被私有化！
System.out.println(u);
}
}
/*1 获取该类的Class对象
2 利用Class对象的getContructor()方法来获取指定的构造方法。
3 申请访问（）设置为可访问
4 调用Constructor(构造方法)的newInstance（）方法创建对象。*/

class Per {
private String name;
private int age;
private Per(){
}
private Per(String name){
}
public String toString(){
return "对象！！！"；
}
}
public class NewInstanceDemo {
public static void main(String[] args) throws Exception {
Class<Per> c =Per.class;
Constructor <Per>con =c.getDeclaredConstructor();
System.out.println(con);
con.setAccessible(true);
Per p =con.newInstance();

System.out.println("无参构造方法"+p);

con = c.getDeclaredConstructor(String.class);
System.out.println(con);

con.setAccessible(true);//运行访问
p= con.newInstance("liuzhao");
System.out.println("String构造方法"+p);
}
}
//使用反射调用可变参数


class VaryMethod {
public static void show(int...args){
System.out.println("基本数据类型传递过来了");
}
public static void show(String...args){
System.out.println("引用数据类型传递过来了");
}
}
public class InvokeVaryDemo {
public static void main(String[] args)throws Exception {
Class<VaryMethod> c = VaryMethod.class;

Method m =c.getMethod("show",int[].class);
m.invoke(null, new int {1,2,3});
m =c.getMethod("show",String[].class);
m.invoke(null,(Object)new String[]{"A","B","C"});
m.invoke(null,new Object[]{new String[]{"A","B","C"}});
}
}


//使用反射操作字段
/*1 获取类
Class<Xxx> clz = Xxx.class;
2 获取字段
Field[] f =clz.getDeclaredFields();
Field fi = clz.getDeclaredField("name");


3 赋值（set（c.newInstance(),""））;{如果为私有的话设置可接受}
Xxx.c = clz.newInstance();
fi.set(c,21);
*/


class Cat{
private String name;
public int age;
private String color;
}
public class FieldDemo {
public static void main(String[] args) throws Exception {
Class<Cat> clz =Cat.class;
Field[] f=clz.getDeclaredFields();

for(Field field:f){
System.out.println(field);
}

Field fi=clz.getDeclaredField("name");
System.out.println(fi);

System.out.println(fi.getName());
//核心开始
Cat c = clz.newInstance();
fi.setAccessible(true);
fi.set(c, "刘昭");
Object o =fi.get(c);
System.out.println(o);

fi=clz.getDeclaredField("age");
fi.setAccessible(true);
fi.set(c,21);

int i =fi.getInt(c);
//左边的接收类型已经写出int,右边的返回类型也必须是int
System.out.println(i);//获取成功
}
}


//利用反射来获取泛型的类型（泛型信息）
/*步骤：
1 获取当前类
2 获取目标字段
3 获取包含泛型类型的类型 getGenericType()
4 强转至子类 ParameterizedType 因为Type没有任何对应的方法
5 获得泛型真正的类型 getActualTypeArguments()
*/