1.Class类
1.在面向对象的世界里,万事万物皆对象。
java语言中,静态的成员,普通的数据类型不是对象
问:类是不是对象呢?类是(哪个类的对象呢?)谁的对象呢?
答:类也是对象,是java.lang.Class类的实例对象
基本数据类型 void关键字 都存在类类型
获取类类型的三种方式:
01.类名.Class
02.对象名.getClass();
03.Class.forName("完整的限定名"); 推荐使用
package com.ltc; /** * Class类的使用 */ public class ClassDemo1 { class Foo{ void print(){ System.out.println("foo"); } public static void main(String[] args) { //Foo的实例对象如何表示 Foo foo1 = new Foo(); //Foo这个类 也是一个实例对象,Class类的实例对象,如何表示出来 //任何一个类都是Class的实例对象,这个实例对象有三种表达方式 //第一种表示方式==》实际再告诉我们任何一个类都有一个隐含的静态成员变量class Class c1 = Foo.class; //第二种表达方式 已经知道该类的对象通过getClass方法 Class c2 = foo1.getClass(); /** * 官网c1和c2表示了Foo类的类类型(class type) * 万事万物皆对象 * 类也是对象,是Class类的实例对象 * 这个对象我们称之为该类的类类型 */ //不管c1 or c2都代表了Foo类的类类型,一个类只可能是Class类的一个实例对象 System.out.println(c1==c2); //第三种表达方式 Class c3 = null; try { c3 = Class.forName("com.ltc.Foo"); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(c2==c3); //我们完全可以通过类的类类型创建该类的对象示例==》通过c1 or c2 or c3创建Foo的实例对象 Foo foo; try { foo = (Foo)c1.newInstance(); foo.print(); } catch (InstantiationException | IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
java动态加载类
Class.forName("完整限定名");
不仅表示了类类型,还代表了动态加载类
区分编译、运行
编译时刻加载类是静态加载类,运行时加载类是动态加载类
new创建对象,是静态加载类,在编译时刻就需要加载所有的可能使用到的类
通过动态加载类可以解决该问题,有效防止一个类对象加载错误导致整个程序不能运行
功能型的
反射:
在运行期间,对任意一个类,我们都能知道这个类中所有的属性和方法(包括私有的)
这种动态获取类的信息和动态调用对象的方法或者属性的功能===》java反射机制
但是破坏了封装的安全性。
创建一个Student对象
package com.ltc; import java.util.Date; public class Student { public int age; // 年龄 protected String name; // 姓名 private char sex = '男'; // 性别 Date birthday = new Date();// 出生日期 static { System.out.println("这是Student类中的静态代码块!"); } { System.out.println("这是Student类中的普通代码块!"); } public Student() { System.out.println("这是Student类中的无参构造!"); } // 私有的方法 private double getSum(double num) { return num + 10; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } }
01.利用反射获取该类的包名、限定名he修饰符
@org.junit.Test public void test01(){ try { //动态加载类 Class c = Class.forName("com.ltc.Student"); System.out.println("所在的包名:"+c.getPackage().getName()); System.out.println("完整限定名:"+c.getName()); System.out.println("简写的类名:"+c.getSimpleName()); //获取修饰符会返回一个int类型的数字,Modifier.toString(int num);方法把数字解析成对应的修饰符 int num = c.getModifiers(); String result = Modifier.toString(num); System.out.println("获取该类的修饰符:"+result); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
输出结果
02.获取类的属性
/** * getFileds():只能获取public修饰的属性 * getDeclaredFields():所有属性字段的集合 */ @org.junit.Test public void test02(){ try { Class c = Class.forName("com.ltc.Student"); Field[] fields = c.getFields(); for (int i = 0; i < fields.length; i++) { System.out.println(fields[i].getName()); System.out.println("对应的修饰符是==》"+Modifier.toString(fields[i].getModifiers())); } System.out.println("**********************************************************"); Field[] fields2 = c.getDeclaredFields(); for (int i = 0; i < fields2.length; i++) { System.out.println(fields2[i].getName()); System.out.println("对应的修饰符是==》"+Modifier.toString(fields2[i].getModifiers())); } } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
输出结果
03.获取类的方法
/** * c.getMethods() :获取所有public修饰的方法 * c.getDeclaredMethods():获取所有的方法 */ @org.junit.Test public void test03(){ try { Class c = Class.forName("com.ltc.Student"); Method[] methods = c.getDeclaredMethods(); for (int i = 0; i < methods.length; i++) { System.out.println("方法的名称==》"+methods[i].getName()); } } catch (ClassNotFoundException e) { e.printStackTrace(); } }
输出结果
04.获取类的私有属性值
@org.junit.Test public void test04(){ try { Class c = Class.forName("com.ltc.Student"); Student stu = (Student)c.newInstance(); //stu.sex 获取不到私有的属性和私有方法 Field field = c.getDeclaredField("sex"); //打开访问私有属性或者方法的开关 field.setAccessible(true); System.out.println(field.get(stu)); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
输出结果
05.获取类的私有方法
方法反射的操作
method.invoke(对象,参数列表)
@org.junit.Test public void test05(){ try { Class c = Class.forName("com.ltc.Student"); Student stu = (Student)c.newInstance(); Method methods = c.getDeclaredMethod("getSum", double.class); methods.setAccessible(true); double result = (double) methods.invoke(stu, 50.0); System.out.println(result); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } }
输出结果
升华
@org.junit.Test public void test06(){ ArrayList list = new ArrayList(); ArrayList<String> list1 = new ArrayList<String>(); list1.add("hello"); //list1.add(20);错误的 Class c1 = list.getClass(); Class c2 = list1.getClass(); System.out.println(c1 == c2); //反射的操作都是编译之后的操作 /* * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的 * Java中集合的泛型,是防止错误输入的,只在编译阶段有效, * 绕过编译就无效了 * 验证:我们可以通过方法的反射来操作,绕过编译 */ try { Method m = c2.getMethod("add", Object.class); m.invoke(list1, 20);//绕过编译操作就绕过了泛型 System.out.println(list1.size()); System.out.println(list1); /*for (String string : list1) { System.out.println(string); }*///现在不能这样遍历 } catch (Exception e) { e.printStackTrace(); } }
输出结果