今日份学习:
反射
获取类对象的三种形式
通过类的对象,
Student s=new Student();
Class c=s.getClass();
通过类名
Class c=类名.class;
通过静态方法
Class c=Class.forName("包名.类名");
设计模式
一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
可以简单理解为特定问题的固定解决方法。
单例模式
只允许创建一个该类的对象
重点记方式三,静态内部类写法
public class SingleTon3{
private SingleTon3(){}
private static class Holder{
static SingleTon3 instance=new SingleTon3();
}
public static SingleTon3 getInstance(){
return Holder.instance;
}
}
枚举
枚举是一个引用类型,枚举是一个规定了取值范围的数据类型。
注解
是代码里的特殊标记, 程序可以读取注解,一般用于替代配置文件。开发人员可以通过注解告诉类如何运行。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
public class TestPerson {
public static void main(String[] args) throws Exception {
//通过对象类获取类对象
Person zhangsan=new Person();
Class class1=zhangsan.getClass();
System.out.println(class1.hashCode());
//使用类名.class属性
Class class2=Person.class;
System.out.println(class2.hashCode());
//使用静态方法(最好)
Class class3=Class.forName("Demo.Person");
System.out.println(class3.hashCode());
}
//使用反射类获取类的名字,包名,父类,接口
public static void reflectOpe1() throws Exception {
//获取类对象
Class class1=Class.forName("Demo.Person");
//getName();
System.out.println(class1.getName());
//getPackage();
System.out.println(class1.getPackage().getName());
//getSuperClass();
System.out.println(class1.getSuperclass().getName());
//getInterfaces();
Class[] classes=class1.getInterfaces();
System.out.println(Arrays.toString(classes));
System.out.println(class1.getSimpleName());
System.out.println(class1.getTypeName());
}
//使用反射获取类的构造方法,创建对象
public static void reflectOpe2() throws Exception {
//获取类的类对象
Class class1=Class.forName("Demo.Person");
//获取类的构造方法
Constructor[] cons=class1.getConstructors();
for(Constructor con:cons) {
System.out.println(con.toString());
}
//获取类中的无参构造方法
Constructor con =class1.getConstructor();
Person zhangsan=(Person)con.newInstance();
Person lisi=(Person)con.newInstance();
System.out.println(zhangsan.toString());
System.out.println(lisi.toString());
//简便方法类对象
Person wangwu=(Person)class1.newInstance();
System.out.println(wangwu.toString());
//获取类中带参构造方法
Constructor con2=class1.getConstructor(String.class,int.class);
Person xiaoli=(Person)con2.newInstance("晓丽",20);
System.out.println(xiaoli.toString());
}
//使用反射获取类中的方法,并调用方法
public static void reflectOpe3() throws Exception{
//获取类对象
Class class1=Class.forName("Demo.Person");
Method[] methods=class1.getDeclaredMethods();
for(Method method:methods) {
System.out.println(method.toString());
}
Method eatMethod=class1.getMethod("eat");
Person zhangsan=(Person)class1.newInstance();
eatMethod.invoke(zhangsan);
System.out.println("===============");
//toString
Method toStringMethod=class1.getMethod("toString");
Object result=toStringMethod.invoke(zhangsan);
System.out.println(result);
System.out.println("==============");
//带参的eat
Method eaMethod2=class1.getMethod("eat",String.class);
eatMethod.invoke(zhangsan, "鸡腿");
//获取私有方法
Method privateMethod=class1.getDeclaredMethod("privateMethod");
//设置访问权限无效
privateMethod.setAccessible(true);
privateMethod.invoke(zhangsan);
//获取静态方法
Method staticMathod=class1.getMethod("staticMethod");
//正常调用
staticMathod.invoke(null);
}
public static Object invokeAny(Object obj,String methodName,Class[] types,Object...args)throws Exception{
Class class1=obj.getClass();
Method method =class1.getMethod(methodName, types);
return method.invoke(obj, args);
}
public static void rfflectOpe4() throws Exception{
Class class1=Class.forName("Demo.Person");
Field[] fields=class1.getDeclaredFields();
System.out.println(fields.length);
for(Field field:fields) {
System.out.println(field.toString());
}
Field namefield=class1.getDeclaredField("name");
namefield.setAccessible(true);
Person zhangsan=(Person)class1.newInstance();
namefield.set(zhangsan, "张三");
System.out.println(namefield.get(zhangsan));
}
}