一、反射
1. 反射(Reflection)：允许在程序运行状态中，可以获取任意类中的属性和方法，并且可以操作任意对象内部的属 性和方法，这种动态获取类的信息及动态操作对象的属性和方法对应的机制称为反射机制。
2. 类对象 和 类的对象(实例)
(1) 类的对象：基于某个类 new 出来的对象，也称为实例对象。
(2) 类对象：类加载的产物，封装了一个类的所有信息（包、类名、父类、接口、属性、方法、构造方法等）
3. 获取类对象：通过反射机制
(1) 第一种方式：通过类的对象 获取 类对象
Student s = new Student(); // 实例
Class c1 = s.getClass(); // 类对象
System.out.println(c1);
(2) 第二种方式：类名.class
Class c2 = Student.class;
System.out.println(c2);
System.out.println(c1 == c2);
(3) 第三种方式：通过 静态方法 forName("包名.类名");
Class c3 = Class.forName("testflect.Student");
System.out.println(c3);
4. 通过反射技术，操作类对象的信息
Class c = Class.forName("testflect.Student");
// 通过 反射技术操作类对象信息
System.out.println(c.getName()); // 获取类名
System.out.println(c.getSuperclass().getName());//获取父类类名
System.out.println(c.getPackage().getName()); //获取包名
Class[] iters=c.getInterfaces();// 获取 实现的接口
System.out.println("Student实现的接口数量："+iters.length);
for(Class inter:iters){
System.out.println(inter.getName());
}
Method[] ms=c.getMethods(); // 获取本类+父类中公开方法
System.out.println("Student类中定义方法的个数为："+ms.length);
for(Method m:ms){
System.out.println(m.getName());
}
System.out.println("--------");
Method[] mds = c.getDeclaredMethods();// 获取 自定的方法，包含非公开
for(Method m:mds){
System.out.println(m.getName());
}
System.out.println("---------");
Field[] fs=c.getDeclaredFields(); // 获取 自定义的属性，包含非公开
for(Field f:fs){
System.out.println(f.getName());
}
// 通过反射的技术获取 类的对象-》实例
Class c = Class.forName("testflect.Student");
Object o=c.newInstance();// 默认 采用 无参数的构造方法
Student s = (Student)o;
s.setName("魏语石");
System.out.println(o);
// 利用 有参数的构造方法，借助 反射技术获取对象
Constructor cs=c.getConstructor(String.class,Integer.class,Double.class);
Object obj2=cs.newInstance("宋兵兵",23,99.0);
System.out.println(obj2);
// 反射 操作私有化 内容
Method m=c.getDeclaredMethod("test");// 第一个参数代表方法名, 第二参数：代表参数类型
m.setAccessible(true);
m.invoke(c.newInstance());
5. 反射的优缺点：
(1) 优点：使用反射设计程序，让程序更加灵活和通过，通常应用在框架底层设计
(2) 缺点：利用反射设计程序，让程序更加复杂
二、设计模式
1. 设计模式:是一套被反复使用、多数人知晓、经过分类编目的代码经验总结。
2. 单例模式：
(1) 单例模式(Singleton)：保证在当前JVM中，该类只有一个实例(对象)存在，是一种常见的设计模式。
(2) 单例模式的实现方式：
// 代码实现单例的第一种方式：饿汉式
class ClassA{
private static final ClassA ca = new ClassA();
private ClassA(){}
public static ClassA getClassA(){
return ca;
}
}
// 代码实现单例的第二种方式：懒汉式
class ClassB{
private static ClassB cb;
private ClassB(){}
public synchronized static ClassB getClassB(){
if(cb == null){
cb = new ClassB();
}
return cb;
}
public static void test(){}
}
饿汉式：
优点：线程并发效率较高
缺点：内存空间利用率低
懒汉式：
优点：内存空间利用率高
缺点：线程并发效率较低
2. 工厂设计模式
(1) 工厂设计模式：主要解决的是对象创建的问题,工厂的职责在于创建一个对象
(2) 注意：工厂设计模式通常会利用反射技术，使工厂更加的灵活和通用。
public class TestFactory {
public static void main(String[] args) {
Object obj = MyObjectFactory.getObject("testflect.Student");
System.out.println(obj);
}
}
// 工厂：解决对象创建问题
class MyObjectFactory{
public static Object getObject(String className){
try {
// 获取类对象
Class c = Class.forName(className);
// 类对象 获取 实例
Object obj = c.newInstance();
return obj;
}catch (Exception e){
e.printStackTrace();
return null;
}
}
}
