类描述
一个类在内存中只有一个一个Class对象
有一个User类，在程序中无论new了多少个User对象，但User对应的Class只有一个
| 类 | 作用 |
|---|---|
| Class | 用来描述类本身 |
| Package | 用来描述类所属的包 |
| Field | 用来描述类中的属性 |
| Method | 用来描述类中的方法 |
| Constructor | 用来描述类的构造方法 |
| Annotation | 用来描述类中的注解 |
获取Class
方法一. Class c=Class.forName(“包名.类名”);
方法二. Class c=类名.class;
方法三. Class c=对象.getClass();//Object中的方法
获取Class信息
public class Demo {
public static void main(String[] args) {
try {
Class c=Class.forName("com.wwj.Person");
//获取修饰符(用int类型表示不同的修饰符，有多个修饰符返回其修饰符的和)
int modifiers = c.getModifiers();
//获取类名
String calssName=c.getName();//返回包名.类名
String simpleName=c.getSimpleName();//返回类名
//获取类所在的包
Package p=c.getPackage();
String pName=p.getName();
//获取父类
Class superClass = c.getSuperclass();
while (superClass!=null){
System.out.println(superClass.getName());
superClass=superClass.getSuperclass();
}
//获得类实现的接口
Class[] interfaces = c.getInterfaces();
for(Class interfaceClass:interfaces)
System.out.println(interfaceClass.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
创建类对象
public class Demo {
public static void main(String[] args) {
try {
Class c=Class.forName("com.wwj.Person");
//相当于调用Person类中的默认无参构造函数
//,若类没有无参构造函数(无参构造函数被有参构造函数重写覆盖..)则报错
Person p=(Person)c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Field类–> Class类中属性操作
public class Person{
public String name;
private int age;
public String toString(){
return "name:"+name+" age:"+age;
}
}
public class Demo {
public static void main(String[] args) {
try {
Class c=Class.forName("com.wwj.Person");
//获取所有属性(只能获得public,包括继承得来的)
System.out.println("获取所有属性(只能获得public,包括继承得来的)");
Field[] fields = c.getFields();
for(Field f:fields)
System.out.println(f.getName());
//获得所有属性(全部,包括继承得来的)
System.out.println("获得所有属性(全部,包括继承得来的)");
Field[] declaredFields = c.getDeclaredFields();
for(Field declaredf:declaredFields)
System.out.println(declaredf.getName());
//根据属性名获得类的属性(只能获得public)
Field nameField=c.getField("name");
//根据属性名获得类的属性(全部)
//获取私有属性,若用getField会报NoSuchFieldException异常。
// NoSuchFieldException异常原因：①没有对应字段；②属性为私有时获取Field用的方法不是getDeclaredField。
Field ageField=c.getDeclaredField("age");
//获取属性修饰符
System.out.println("获取属性修饰符");
int nameModifiers = nameField.getModifiers();
int ageModifiers = ageField.getModifiers();
System.out.println("nameModifiers:"+nameModifiers+" ageModifiers:"+ageModifiers);
//获得属性类型
System.out.println("获取属性修饰符获得属性类型");
Class nameType = nameField.getType();
Class ageType = ageField.getType();
System.out.println("nameType:"+nameType+" ageType:"+ageType);
//获取属性名字
System.out.println("获取属性名字");
String nameName = nameField.getName();
String ageName = nameField.getName();
System.out.println("nameName:"+nameName+" ageName:"+ageName);
Person person=(Person) c.newInstance();
//对象赋值
System.out.println("对象赋值");
//私有属性赋值
//值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
//值为 false 则指示反射的对象应该实施 Java 语言访问检查。
ageField.setAccessible(true);//设为true才能对私有变量进行读取和赋值
ageField.set(person,1);
nameField.set(person,"wwj");
System.out.println(person.toString());
//对象取值
System.out.println("对象取值");
String getName=(String)nameField.get(person);
int getAge=(int)ageField.get(person);
System.out.println("getName:"+getName+" getAge:"+getAge);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出
获取所有属性(只能获得public,包括继承得来的)
name
获得所有属性(全部,包括继承得来的)
name
age
获取属性修饰符
nameModifiers:1 ageModifiers:2
获取属性修饰符获得属性类型
nameType:class java.lang.String ageType:int
获取属性名字
nameName:name ageName:name
对象赋值
name:wwj age:1
对象取值
getName:wwj getAge:1
Method–> Class类中方法操作
public class Person{
public String name;
private int age;
public void eat(){
System.out.println("公共无参");
}
public String eat(String food){
System.out.println("公共有参-带返回值");
return "公共有参-带返回值-->food:"+food;
}
private void eatTwo(){
System.out.println("私有无参");
}
private String eatTwo(String food){
System.out.println("私有有参-带返回值");
return "私有有参-带返回值-->food:"+food;
}
public String toString(){
return "name:"+name+" age:"+age;
}
}
public class Demo {
public static void main(String[] args) {
try {
Class aClass = Class.forName("com.wwj.Person");
Person person=(Person)aClass.newInstance();
/**
* getMethod获得的方法包括父类中继承的方法，只能获得公有方法
*/
//公共无参
System.out.println("公共无参");
Method publicEat=aClass.getMethod("eat");
System.out.println("获得的方法："+publicEat);
int publicEatModifiers = publicEat.getModifiers();
System.out.println("修饰符："+publicEatModifiers);
Class publicEatReturnType = publicEat.getReturnType();
System.out.println("返回类型："+publicEatReturnType);
String publicEatName = publicEat.getName();
System.out.println("方法名："+publicEatName);
Class[] publicEatNameParameterTypes = publicEat.getParameterTypes();
System.out.println("参数列表类型：");
for (Class c:publicEatNameParameterTypes)
System.out.println(" "+c.getName());
System.out.println("方法抛出的异常:");
Class[] publicEatExceptionTypes = publicEat.getExceptionTypes();
for (Class c:publicEatExceptionTypes)
System.out.println(" "+c.getName());
System.out.println("方法执行:");
publicEat.invoke(person);
System.out.println();
//公共有参-带返回值
System.out.println("公共有参-带返回值");
Method publicEatTwo=aClass.getMethod("eat", String.class);
System.out.println("获得的方法："+publicEatTwo);
int publicEatTwoModifiers = publicEatTwo.getModifiers();
System.out.println("修饰符："+publicEatTwoModifiers);
Class publicEatTwoReturnType = publicEatTwo.getReturnType();
System.out.println("返回类型："+publicEatTwoReturnType);
String publicEatTwoName = publicEatTwo.getName();
System.out.println("方法名："+publicEatTwoName);
Class[] publicEatTwoNameParameterTypes = publicEatTwo.getParameterTypes();
System.out.println("参数列表类型：");
for (Class c:publicEatTwoNameParameterTypes)
System.out.println(" "+c.getName());
System.out.println("方法抛出的异常:");
Class[] publicEatTwoExceptionTypes = publicEatTwo.getExceptionTypes();
for (Class c:publicEatTwoExceptionTypes)
System.out.println(" "+c.getName());
System.out.println("方法执行:");
String apple = (String) publicEatTwo.invoke(person, "apple");
System.out.println("方法执行返回结果:"+apple);
System.out.println();
/**
* getDeclaredMethod获得的方法不包括父类中继承的方法，能获得私有方法
*/
//私有无参
System.out.println("私有无参");
Method privateEat=aClass.getDeclaredMethod("eatTwo");
System.out.println("获得的方法："+privateEat);
int privateEatModifiers = privateEat.getModifiers();
System.out.println("修饰符："+privateEatModifiers);
Class privateEatReturnType = privateEat.getReturnType();
System.out.println("返回类型："+privateEatReturnType);
String privateEatName = privateEat.getName();
System.out.println("方法名："+privateEatName);
Class[] privateEatNameParameterTypes = privateEat.getParameterTypes();
System.out.println("参数列表类型：");
for (Class c:privateEatNameParameterTypes)
System.out.println(" "+c.getName());
System.out.println("方法抛出的异常:");
Class[] privateEatExceptionTypes = privateEat.getExceptionTypes();
for (Class c:privateEatExceptionTypes)
System.out.println(" "+c.getName());
System.out.println("方法执行:");
privateEat.setAccessible(true);//权限设定
privateEat.invoke(person);
System.out.println();
//私有有参-带返回值
System.out.println("私有有参-带返回值");
Method privateEatTwo=aClass.getDeclaredMethod("eatTwo",String.class);
System.out.println("获得的方法："+privateEatTwo);
int privateEatTwoModifiers = privateEatTwo.getModifiers();
System.out.println("修饰符："+privateEatTwoModifiers);
Class privateEatTwoReturnType = privateEatTwo.getReturnType();
System.out.println("返回类型："+privateEatTwoReturnType);
String privateEatTwoName = privateEatTwo.getName();
System.out.println("方法名："+privateEatTwoName);
Class[] privateEatTwoNameParameterTypes = privateEatTwo.getParameterTypes();
System.out.println("参数列表类型：");
for (Class c:privateEatTwoNameParameterTypes)
System.out.println(" "+c.getName());
System.out.println("方法抛出的异常:");
Class[] privateEatTwoExceptionTypes = privateEatTwo.getExceptionTypes();
for (Class c:privateEatTwoExceptionTypes)
System.out.println(" "+c.getName());
System.out.println("方法执行:");
privateEatTwo.setAccessible(true);//权限设定
String banana = (String) privateEatTwo.invoke(person, "banana");
System.out.println("方法执行返回结果:"+banana);
System.out.println();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出
公共无参
获得的方法：public void com.wwj.Person.eat()
修饰符：1
返回类型：void
方法名：eat
参数列表类型：
方法抛出的异常:
方法执行:
公共无参
公共有参-带返回值
获得的方法：public java.lang.String com.wwj.Person.eat(java.lang.String)
修饰符：1
返回类型：class java.lang.String
方法名：eat
参数列表类型：
java.lang.String
方法抛出的异常:
方法执行:
公共有参-带返回值
方法执行返回结果:公共有参-带返回值-->food:apple
私有无参
获得的方法：private void com.wwj.Person.eatTwo()
修饰符：2
返回类型：void
方法名：eatTwo
参数列表类型：
方法抛出的异常:
方法执行:
私有无参
私有有参-带返回值
获得的方法：private java.lang.String com.wwj.Person.eatTwo(java.lang.String)
修饰符：2
返回类型：class java.lang.String
方法名：eatTwo
参数列表类型：
java.lang.String
方法抛出的异常:
方法执行:
私有有参-带返回值
方法执行返回结果:私有有参-带返回值-->food:banana
Constructor–> Class类中的构造方法
public class Person{
public String name;
private int age;
// public Person(){
// System.out.println("我是公有无参构造函数");
// }
// private Person(){
// System.out.println("我是私有无参构造函数");
// }
// public Person(String name,int age){
// System.out.println("我是公有有参构造函数 name="+name+" age="+age);
// }
private Person(String name,int age){
System.out.println("我是私有有参构造函数 name="+name+" age="+age);
}
}
public class Demo {
public static void main(String[] args) {
try {
Class aClass = Class.forName("com.wwj.Person");
/**
* 一：调用无参构造函数，若不存在则报错(公有)
*/
// Person person=(Person)aClass.newInstance();
/**
* 二：调用getConstructor
*/
//获得无参构造器(公有)
// Constructor publicConstructor=aClass.getConstructor();
// //执行构造器
// Person person2= (Person) publicConstructor.newInstance();
//
// //获得无参构造器(私有)
// Constructor privateConstructor=aClass.getDeclaredConstructor();
// privateConstructor.setAccessible(true);//权限设置
// Person person3= (Person) privateConstructor.newInstance();
//获得有参构造器(公有)
// Constructor publicConstructorWithParameter=aClass.getConstructor(String.class,int.class);
// Person person4= (Person) publicConstructorWithParameter.newInstance("name",1);
//获得有参构造器(私有)
Constructor privateConstructorWithParameter=aClass.getDeclaredConstructor(String.class,int.class);
privateConstructorWithParameter.setAccessible(true);//权限设置
Person person5= (Person) privateConstructorWithParameter.newInstance("name",1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
扫一扫
2764
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
