反射部分案例总结

反射部分案例总结


1.基本概念
A:反射
反射就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法
B:Class类
成员变量 Field
构造方法 Constructor
成员方法 Method
C:获取class文件对象的方式
Object类的getClass()方法
数据类型的静态属性class
Class类中的静态方法
public static Class forName(String className)
注意：开发中一般选用第三种，因为第三种需要的参数是字符串，字符串可以方便的配置到配置文件中

2.获取Class文件的三种方式
A:
Person p = new Person();
Class c1 = p.getClass();
B:
Class c2 = Person.class;
C:
Class c3 = Class.forName("cn.itcast_01.Person");

3.获取构造方法并使用
A:常用功能
public Constructor[] getConstructors():获取所有公共构造方法
public Constructor[] getDeclaredConstructors():获取所有构造方法
public Constructor<T> getConstructor(Class<?>...parameterTypes):获取单个构造方法
参数表示的是：要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
返回值：字节码文件对象
setAccessible(true) 反射对象使用时取消Java语言检查(用于使用私有属性的东西)
public T newInstance(Object...Initargs):通过带参构造方法对象创建对象

B:代码演示
public class ReflectDemo{
public static void main(String[] args) rhrows Exception{
//获取字节码文件对象
Class c = Class.forName("cn.incast_01.Person");
//获取公共带参构造方法
Constructor con1 = c.getConstructor(String.class,int.class,String.class);
//通过公共带参构造方法创建对象
Object obj1 = con1.newInstance("小明",20,"北京")；
System.out.println(obj1);

//获取私有带参构造方法
Constructor con2 = c.getDeclaredConstructor(String.class);
//设置取消访问检查
con2.setAccessible(true);
//用私有带参构造方法创建对象
Object obj2 = con2.newInstance("荆轲");
System.out.println(obj2);
}
}

4.获取成员变量并使用
A:常用功能
Field getField(String name)：根据指定名称获取指定公共成员变量的Field对象 
Field[] getFields()：获取公共成员变量的Field数组
Field getDeclaredField(String name) ：根据一定名称获取指定任意成员变量的Field对象
Field[] getDeclaredFields() ：获取所有成员变量的Field数组
public void set(Object obj,Object value)：将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
 
B:代码演示
public class ReflectDemo{
public static void main(String[] args) throws Exception{
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
//通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
//获取公共成员变量并赋值
Field addressField = c.getField("address");
addressField.set(obj,"北京")；
System.out.println(obj);
//获取私有成员变量并赋值
Field nameField = c.getDeclareField("name");
nameField.setAccessible(true);
nameField.set(obj,"扶苏");
System.out.println(obj);
}
}

5.获取成员方法并使用
A:常用功能
Method getMethod(String name, Class<?>... parameterTypes):获取自己包括父类的任一公共方法 
Method[] getMethods():返回自己包括父类的所有公共方法的Method数组
Method getDeclaredMethod(String name, Class<?>... parameterTypes):获取自己的任一方法
Method[] getDeclaredMethods():仅返回自己的所有方法的Method数组
public Object invoke(Object obj,Object...args):调用方法
第一个参数obj表示对象，第二个参数args表示传给该方法的实际参数

B:代码演示
public class ReflectDemo{
public static void main(String[] args) throws Exception{
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
//通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
//获取单个公共无参方法并使用
Method m1 = c.getMethod("show");
m1.invoke(obj);
//获取单个公共带参方法并使用
Method m2 = c.getMethod("method",String.class);
m2.invoke(obj,"hello");
//获取返回值类型为String的公共带参构造方法并使用
Method m3 = c.getMethod("getString",String.class,int.class);
Object objString = m3.invoke(obj,"hello",100);
System.out.println(objString);
//获取单个私有无参方法并使用
Method m4 = c.getDeclareMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}

设计模式部分总结


1.简单工厂模式
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
public class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
}
public class AnimalFactory{
private AnimalFactory(){
}
public static Animal createAnimal(String type){
if("dog".equals(type)){
return new Dog();
}else if("cat".equals(type)){
return new Cat();
}else{
return null;
}
}
}
public class AnimalDemo{
public static void main(String[] args){
Animal a = AnimalFactory.createAnimal("dog");
a.eat();
a = AnimalFactory.createAnimal("cat");
a.eat();
a = AnimalFactory.ctrateAnimal("pig");
if(a != null){
a.eat();
}else{
System.out.println("暂时不提供这种动物！");
}

}
}
2.单例模式
A:单例模式的思想
保证类在内存中只有一个对象
B:如何实现类在内存中只有一个对象？
a:把构造方法私有
b:在成员位置自己创建一个对象
c:通过一个公共的方法提供访问

C:饿汉式(不会出问题的单例模式)
public class Student {
private Student(){
}
private static Student s = new Student();
public static Student getStudent(){
return s;
}
}
public calss StudentDemo{
public static void main(String[] args){
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1 == s2); //true
}
}

D:懒汉式(可能存在线程安全问题)
public calss Student{
private Student(){
}
private static Student s = null;
public synchronized static Student getStudent(){
if(t == null){
t = new Student();
}
return t;
}
}
public class StudentDemo{
public static void main(String[] args){
Student s1 = Student.getStudent();
Student s1 = Student.getStudent();
System.out.println(s1 == s2); //true
}
}