《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!
public Student(){
}
private Student(String name){
this.name = name;
}
Student(String name,int age){
this.name = name;
this.age = age;
}
public Student(String name,int age,String hobby){
this.name = name;
this.age = age;
this.hobby = hobby;
}
public void test(){
System.out.println(“public修饰的无参的方法”);
}
public String show(String name,int age){
System.out.println(“public修饰的含参的方法”);
return name + “—” + age;
}
void function(String name){
System.out.println("默认修饰符的含参的方法,姓名是 "+name);
}
private void demo(String hobby){
System.out.println("private修饰的含参的方法,爱好是 "+hobby);
}
@Override
public String toString() {
return “Student{” +
“name='” + name + ‘’’ +
“, age=” + age +
“, hobby='” + hobby + ‘’’ +
‘}’;
}
}
这里的Student就相当于Class,这里的s就相当于Class类型对象
package test.reflexDemo;
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException {
//这里的Student就相当于Class,这里的s就相当于Class类型对象
Student s = new Student();
//方式一,getClass()方法,获得该对象的运行时类
Class<? extends Student> c1 = s.getClass();
Student s1 = new Student();
Class<? extends Student> c2 = s1.getClass();
System.out.println(c1==c2); // true
//这里结果为true的原因,同一个class可以new出来多个对象,但是只会对应一个Class类型对象
//所以c1和c2是一样的,但是s和s1是不一样的
System.out.println(s==s1); // false
System.out.println(“-----------------------------”);
//方式二,通过类名获得静态属性class
Class c3 = Student.class;
System.out.println(c3 == c1); //true
System.out.println(c3 == c2); //true
System.out.println(“-----------------------------”);
//方式三,利用Class类中的静态方法forName(String className)
//这个方法会返回给定字符串名称className的类或接口相关联的类对象,然后通过类对象调用类的方法和变量
//注意这里的className需要写类在项目中的具体位置
Class<?> c4 = Class.forName(“test.reflexDemo.Student”);
System.out.println(c4 == c3); //true
System.out.println(c4 == c2); //true
System.out.println(c4 == c1); //true
//Class后面的泛型可以不添加
//这样看起来更直接一些,c5是Class类型
Class c5 = Class.forName(“test.reflexDemo.Student”);
System.out.println(c5 == c4); //true
}
}
根据Class类型对象来创建类的实例
上面成功获得了Class类型对象,那么如何通过Class类型对象来创建对应的class类的对象呢?
思路是通过Class类型对象,来获得对应类的构造方法,然后再用构造方法来创建类的实例。
批量获取构造方法
package test.reflexDemo;
import java.lang.reflect.Constructor;
public class Demo2 {
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(“test.reflexDemo.Student”);
//public Constructor<?>[] getConstructors()
// 返回文件中的所有public修饰的构造方法,不会获取private或者默认修饰的构造方法
Constructor[] constructors = c.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println(“----------------------”);
//public Constructor<?>[] getDeclaredConstructors()
//返回所有的构造方法,包括private和默认修饰的构造方法
//另外这里获取的private修饰的构造方法也可以构建对象
Constructor[] dcs = c.getDeclaredConstructors();
for (Constructor d : dcs) {
System.out.println(d);
}
}
}
获取单个的构造方法
package test.reflexDemo;
import java.lang.reflect.Constructor;
public class Demo3 {
public static void main(String[] args) throws Exception {
Class c = Class.forName(“test.reflexDemo.Student”);
//public Constructor getConstructor(Class<?>… parameterTypes)
//括号里的参数是指具体数据类型对应的类,比如String要写成String.class
//什么都没写就是获取默认无参构造方法
Constructor cons1 = c.getConstructor();
System.out.println(“无参构造方法”+cons1);
Constructor cons2 = c.getConstructor(String.class,int.class,String.class);
System.out.println(“有参构造方法”+cons2);
//同样的,这样只能获得public类型,要想获得private类型需要改为
//getDeclaredConstructor
Constructor cons3 = c.getDeclaredConstructor(String.class);
System.out.println(“private修饰的有参构造方法”+cons3);
System.out.println(“--------------------------”);
//根据获得的构造方法创建实例
//public T newInstance(Object… initargs)
//括号里面写要传入构造方法中的参数
Object o1 = cons1.newInstance();
System.out.println(o1);
//这里可以向下转型
Student s = (Student)o1;
System.out.println(s);
//虽然获得了Private修饰的构造方法,但不能直接写入,会报权限不足的异常
//需要强行获取权限,暴力访问
cons3.setAccessible(true);
Object o2 = cons3.newInstance(“张”);
System.out.println(o2);
}
}
结果为
获取成员变量
批量获得成员变量
package test.reflexDemo;
import java.lang.reflect.Field;
public class Demo4 {
public static void main(String[] args) throws Exception{
Class c = Class.forName(“test.reflexDemo.Student”);
//获取所有的成员变量
//getFields()返回一个Field类型的数组,包含所有public修饰的成员变量
Field[] fields = c.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println(“--------------------”);
//getDeclaredFields()获取所有的成员变量,包括被private和默认修饰等类型修饰的变量
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
}
}
获取单个成员变量并修改变量的值
package test.reflexDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class Demo5 {
public static void main(String[] args) throws Exception{
Class c = Class.forName(“test.reflexDemo.Student”);
//getField(String name)根据变量名获取变量
Field hobby = c.getField(“hobby”);
System.out.println(hobby);
//set(Object obj, Object value)将指定obj对象的类的变量的值改为value
//这个方法由上面获取的Field变量对象来调用
Constructor constructor = c.getConstructor();
Object o = constructor.newInstance();
hobby.set(o,“敲代码”);
System.out.println(o);
System.out.println(“------------------------”);
//如果要修改被private修饰的变量,同样需要强行修改权限
Field name = c.getDeclaredField(“name”);
name.setAccessible(true);
name.set(o,“姓名是张”);
System.out.println(o);
}
}
结果是
获取成员方法
批量获取成员方法
package test.reflexDemo;
import java.lang.reflect.Method;
public class Demo6 {
public static void main(String[] args) throws Exception{
Class c = Class.forName(“test.reflexDemo.Student”);
//批量获取成员方法
//只能获取public修饰的方法
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println(“-------------------”);
面试题总结
其它面试题(springboot、mybatis、并发、java中高级面试总结等)
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!
throws Exception{
Class c = Class.forName(“test.reflexDemo.Student”);
//批量获取成员方法
//只能获取public修饰的方法
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println(“-------------------”);
面试题总结
其它面试题(springboot、mybatis、并发、java中高级面试总结等)
[外链图片转存中…(img-05c2TjXj-1714691471413)]
[外链图片转存中…(img-dnytXgde-1714691471414)]
[外链图片转存中…(img-iZpH8sGR-1714691471414)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!