Parson类(父类)
package com.yh.reflex;
public class Parson {
/**
* <pre>Parson名字(公开的成员变量)</pre>
*/
public String name;
/**
* <pre>Parson年龄(私有的成员变量)</pre>
*/
private int age;
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;
}
/**
* <pre>Parson eating(公开的成员方法)</pre>
*/
public void eating() {
System.out.println(name+"正在吃饭");
}
@Override
public String toString() {
return "Parson [name=" + name + ", age=" + age + "]";
}
}
Student类(子类)
package com.yh.reflex;
import java.io.Serializable;
public class Student extends Parson implements Serializable{
/**
* <pre>student班级(静态的成员变量)</pre>
*/
public static String school = "java0622";
/**
* <pre>student学号(受保护的成员变量)</pre>
*/
protected String stuNum;
/**
* <pre>student成绩(私有的成员变量)</pre>
*/
private float result;
public Student() {
super();
}
public Student(String stuNum, float result) {
super();
this.stuNum = stuNum;
this.result = result;
}
public Student(String stuNum, float result,String name,int age) {
super();
this.stuNum = stuNum;
this.result = result;
this.name = name;
setAge(age);
}
public static String getSchool() {
return school;
}
public static void setSchool(String school) {
Student.school = school;
}
public String getStuNum() {
return stuNum;
}
public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}
public float getResult() {
return result;
}
public void setResult(float result) {
this.result = result;
}
/**
* <pre>student sleep(公开的成员方法)</pre>
*/
public void sleep() {
System.out.println(name+"正在休息");
}
@Override
public String toString() {
return "Student [stuNum=" + stuNum + ", result=" + result +",toString()="+super.toString()+ "]";
}
}
演示反射，将反射与普通的编码方式进行对比
代码中注释了的是普通写法，没有注释的是反射写法
package com.yh.reflex;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
/**
* 反射，换一种编码方式来：实例化、访问成员变量、访问成员方法
* getContextClassLoader()是当前线程的类加载器
cls = Thread.currentThread().getContextClassLoader().loadClass(className);
getConstructor()获取构造函数 getConstructors()获取全部构造函数
newInstance()执行构造函数 getParameterTypes()获取所有参数类型
getField("name")只能获取类(包括父类)的public字段
getDeclaredField是可以获取一个类的所有字段
两者都可调用set,get方法(静态成员变量的.get方法可以传null)
getMethod("方法名")获取的是类(包括父类)的所有共有方法
getDeclaredMethod("方法名")获取的是类自身声明的所有方法(包括private)
可使用.setAccessible(true);//暴力反射((private的方法 可执行)
invoke(Object)执行该方法(private的方法 不可执行)
* @author 湛锋
*
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//反射的前提Class
Class<?> cls = null;
//得到Class的几种方式;结果都一样
Object s3 = new Student();
cls = s3.getClass();
cls = Student.class;
String className = "com.yh.reflex.Student";
try {
cls = Class.forName(className);
// getContextClassLoader()是当前线程的类加载器
cls = Thread.currentThread().getContextClassLoader().loadClass(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(cls);
// Student s1 = null;
// Student s2 = null;
Object s1 = null;
Object s2 = null;
//类的实例化(怎样创建对象)
// s1 = new Student();
//无参
s1 = cls.newInstance();
s1 = cls.getConstructor().newInstance();
// s2 = new Student("14", 99, "yh", 21);
//有参
Constructor<?> c1 = cls.getConstructor(String.class,float.class,String.class,int.class);
s2 = c1.newInstance("14", 99, "yh", 21);
//getConstructor()获取构造函数 getConstructors()获取全部构造函数
//newInstance()执行构造函数
System.out.println("--------------------");
for (Constructor<?> c: cls.getConstructors()) {
System.out.println(c);
System.out.println("参数："+Arrays.toString(c.getParameterTypes()));
}
System.out.println("--------------------");
//[对象的]成员变量的访问(获取，设置)(比较少用)
// s1.name = "zf";
Field f1 = cls.getField("name");//获取公开的成员变量(包括父类的)
f1.set(s1, "zf");
// s1.stuNum = "16";
// f1 = cls.getField("stuNum");//NoSuchFieldException
f1 = cls.getDeclaredField("stuNum");//获取自身定义的成员变量(不管是不是公开的，都可获取)
f1.set(s1, "16");
s1.result = 90;//不能访问
// f1 = cls.getDeclaredField("result");
// f1.setAccessible(true);//暴力反射
// f1.set(s1, 90);//IllegalAccessException
// System.out.println(s1+"89");
// String name = s2.name;
// System.out.println(name);
f1 = cls.getField("name");
Object name = f1.get(s2);
System.out.println(name);
// String school = Student.school;
// System.out.println(school);
f1 = cls.getField("school");//静态成员变量的访问,get方法中可传null
Object school = f1.get(null);
System.out.println(school);
System.out.println("---------Student的公开的成员变量(包括父类)----------");
for(Field f : cls.getFields()) {
System.out.println(f);
System.out.println("\t变量名"+f.getName());
System.out.println("\t变量类型"+f.getType());
}
System.out.println("-------------------------------------------------");
System.out.println("-----Student的自己定义的成员变量------------");
for(Field f : cls.getDeclaredFields()) {
System.out.println(f);
System.out.println("\t变量名"+f.getName());
System.out.println("\t变量类型"+f.getType());
}
System.out.println("------------------------------------------");
Method m1 = null;
// //[对象的]方法调用
Student.setSchool("sss");//静态方法的调用
s1.setSchool("sss1");//当s1没有new对象时，是可以调用静态方法的
System.out.println(s1.getSchool());
// s1.setAge(20);
// s1.setResult(80);
//
// String num = s2.getStuNum();
// String school = Student.getSchool();
// System.out.println(num);
// System.out.println(school);
// ((Parson) s1).eating();
m1 = cls.getMethod("setAge",int.class);
m1.invoke(s1,20);
Object ret = m1.invoke(s2, 21);//若有返回值，则返回一个返回值，若没有，则返回null
System.out.println("ret="+ret);
// Student.setSchool("sss");//静态方法的调用
m1 = cls.getMethod("setSchool", String.class);//获取公开的方法;后面可以传多个参数
m1 = cls.getDeclaredMethod("setSchool", String.class);//获取自身定义的方法
m1.invoke(null, "sss");//对应getMethod后面传了几个参数，invoke后面就传几个参数
// f1 = cls.getField("school");//静态成员变量的访问,get方法中可传null
// school = f1.get(null);
// System.out.println(school);
m1 = cls.getMethod("getSchool");
String school1 = (String) m1.invoke(s1);
System.out.println(school1);
//s1.eating();
m1 = cls.getMethod("eating");
m1.invoke(s1);
m1.invoke(s2);
System.out.println(s1);
System.out.println(s2);
System.out.println("--------Student的公共的成员方法---------");
for(Method m : cls.getMethods()) {
System.out.println(m);
System.out.println("\t方法名"+m.getName());
System.out.println("\t参数"+Arrays.toString(m.getParameterTypes()));
System.out.println("\t返回类型"+m.getReturnType());
System.out.println("\t申明的异常"+m.getExceptionTypes());
System.out.println("\t修饰符"+m.getModifiers());
}
System.out.println("--------------------------------------");
System.out.println("------Student自己定义的成员方法---------");
for(Method m : cls.getDeclaredMethods()) {
System.out.println(m);
System.out.println("\t方法名"+m.getName());
System.out.println("\t参数"+Arrays.toString(m.getParameterTypes()));
System.out.println("\t返回类型"+m.getReturnType());
System.out.println("\t申明的异常"+m.getExceptionTypes());
System.out.println("\t修饰符"+m.getModifiers());
}
System.out.println("---------------------------------------");
System.out.println("-------------关于修饰符-----------------");
for(Method m : cls.getDeclaredMethods()) {
System.out.println(m);
System.out.println("\t修饰符"+m.getModifiers());
System.out.println("\t修饰符"+Modifier.toString(m.getModifiers()));
}
System.out.println("-------------关于修饰符-----------------");
for(int i = 0; i < 16; i++) {
String bitNum = String.format("%0"+(16-i)+"d", 1) + String.format("%016d", 0);
bitNum = bitNum.substring(0,16);
int num1 = Integer.valueOf(bitNum, 2);
System.out.println(bitNum+"\t"+num1+"\t"+Modifier.toString(num1));
}
}
}
下方修饰符的输出
-------------关于修饰符-----------------
public java.lang.String com.yh.reflex.Student.toString()
修饰符1
修饰符public
public void com.yh.reflex.Student.sleep()
修饰符1
修饰符public
public float com.yh.reflex.Student.getResult()
修饰符1
修饰符public
public java.lang.String com.yh.reflex.Student.getStuNum()
修饰符1
修饰符public
public void com.yh.reflex.Student.setStuNum(java.lang.String)
修饰符1
修饰符public
public static java.lang.String com.yh.reflex.Student.getSchool()
修饰符9
修饰符public static
public static void com.yh.reflex.Student.setSchool(java.lang.String)
修饰符9
修饰符public static
public void com.yh.reflex.Student.setResult(float)
修饰符1
修饰符public
-------------关于修饰符-----------------
0000000000000001 1 public
0000000000000010 2 private
0000000000000100 4 protected
0000000000001000 8 static
0000000000010000 16 final
0000000000100000 32 synchronized
0000000001000000 64 volatile
0000000010000000 128 transient
0000000100000000 256 native
0000001000000000 512 interface
0000010000000000 1024 abstract
0000100000000000 2048 strictfp
0001000000000000 4096
0010000000000000 8192
0100000000000000 16384
1000000000000000 32768
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
