-
1.png (50.37 KB, 下载次数: 15)
public class Coo {
//Doo的实例对象 以doo表示
Doo doo=new Doo();
}
class Doo{}/*
* Private constructor. Only the Java Virtual Machine creates Class objects.
* This constructor is not used and prevents the default constructor being
* generated.
*/
private Class(ClassLoader loader) {
// Initialize final field for classLoader. The initialization value of non-null
// prevents future JIT optimizations from assuming this final field is null.
classLoader = loader;
}
public class Coo {
//Doo的实例对象 以doo表示
Doo doo=new Doo();
//①可以看出Doo类有一个隐含的静态成员变量class
Class first=Doo.class;
//②已知类的对象，通过getClass获取
Class second=doo.getClass();
//重理解一次：doo代表Doo类的实例对象，first、second代表的是Class的实例对象
//这个Class的实例对象又证明说Doo这个类本身是一个实例对象的存在
//一本正经的胡说八道，那么给一个官方给出的说法是这样的 ：first、second表示了Doo类的类 类型（class type）
//所有东西都是对象，类也是对象，是Class的实例对象，这个对象称为该类的类类型
//就可以分析到，Doo的对象是doo，Doo的类类型是Class的对象first、second
//不管哪种表达方式表示Doo的类类型，一个类只可能是Class类的一个实例对象，所以first == second
//③需要异常处理，参数为类的全称"com.cloud.eureka.Doo"
Class third=null;
{
try {
third = Class.forName("com.cloud.eureka.Doo");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//依然存在 first == second == third
//由此可见，我们可以通过类的类类型创建该类的对象，通过first、second、third创建
//需要异常处理，是谁的类的类类型对象，创建的对象就是谁，需要强转
//newInstance前提需要无参构造方法
{
try {
Doo dooFirst= (Doo) first.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
class Doo{}public class Coo {
Class c0=int.class;
Class c1=String.class;
Class c2=Double.class;
Class c3=void.class;
// package不是在类里面的，error
// Class c4=package.class;
}class Doo{
public static void staticVoidMethod(Object o){
//传递的是什么类型，就是什么类型
Class co=o.getClass();
}
}class Doo {
public static void staticVoidMethod(Object o) {
//传递的是什么类型，就是什么类型
Class co = o.getClass();
System.out.println("类的全名称：" + co.getName());
System.out.println("类的名字：" + co.getSimpleName());
//Method类，方法对象
//一个成员方法 就是 一个Method对象
//getMethods 获取所有public的方法，其中包括父类继承的函数
Method[] allMethods = co.getMethods();
//getDeclaredMethods获取该类自己声明的方法
Method[] thisMethods = co.getDeclaredMethods();
for (Method method : allMethods) {
//method.getReturnType()得到的是类的类类型
//比如返回值是String，那么得到的是String.class的类类型，通过getName获取名称
System.out.println("返回类型：" + method.getReturnType().getName());
System.out.println("方法名称：" + method.getName());
//获取参数类型
Class[] parameterTypes = method.getParameterTypes();
for (Class c : parameterTypes) {
System.out.println("参数类型：" + c.getName());
}
System.out.println("====================================");
}
//成员变量 =》对象
//属于java.lang.reflect.Field
//Field封装了关于成员变量的操作
//getFields获取所有public的成员变量
Field[] field=co.getFields();
//得到自己声明的成员变量
Field[] declaredFields=co.getDeclaredFields();
for (Field fields:field) {
System.out.println("成员变量类型"+fields.getType());
System.out.println("成员变量名称"+fields.getName());
}
}
}public class Coo {
public static void main(String[] args) {
String hello=new String();
Doo.staticVoidMethod(hello);
}
}
类的全名称：java.lang.String
public class MethodReflect {
//获取getMethod方法，获取①号
public static void main(String[] args) {
MethodDemo demo = new MethodDemo();
//1.获取类信息
Class c0 = demo.getClass();
//2.获取方法
try {
//第一种写法
Method method1 = c0.getDeclaredMethod("getMethod", new Class[]{String.class, String.class});
//第二种写法
Method method2 = c0.getDeclaredMethod("getMethod", String.class, String.class);
//平时正常的调用方法： demo.getMethod(str0,str1)
//现在使用method1来调用--public Object invoke(Object obj, Object... args)
//第一个参数是调用的类，第二个参数是可用可无，按定义的方法来录入（str0,str1）
//invoke的方法如果有返回值，则返回Object的值，void的返回值为null
try {
Object object1 = method1.invoke(demo, new Object[]{"hello", " world"});
Object object2 = method2.invoke(demo, "hello", " world");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
class MethodDemo {
//①
public void getMethod(String a, String b) {
System.out.println("concat: " + a + b);
}
//②
public void getMethod(int a, int b) {
System.out.println("sum: " + a + b);
}
}public class Coo {
public static void main(String[] args) {
//无泛型
List list0=new ArrayList();
//String泛型
List<String> list1=new ArrayList<>();
list1.add("hello");
Class c0=list0.getClass();
Class c1=list1.getClass();
//输出
System.out.println(c0==c1);
}
}//获取list1<String> 中的 add方法 ,向里面加一个int类型的值
Method method=c1.getMethod("add",Object.class);
method.invoke(list1,100);
System.out.println(list1.size());
1.png (50.37 KB, 下载次数: 15)
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) | 黑马程序员IT技术论坛 X3.2 |
