Java Se---反射

反射

一、概念：

1. 类的对象：基于某个类new出来的一个实例，也称为实例对象。new Dog

2. 类对象：封装了一个类的所有信息（包名、类名、父类、接口、属性、方法、构造方法...）。Student.class

注意：类对象就是一个.class文件，当中包含了一个类的所有信息！

 

3. 获取类对象：

//1.通过类型直接获取类对象

Class c1 = Student.class;//类对象

//2.以静态方法的形式获取类对象

Class c2 = Class.forName("ref.Student");

//3.通过类的实例对象获取类对象

Student stu = new Student();

Class c3 = stu.getClass();

</pre><pre name="code" class="java">package ref;public class TestNewInstance {/** * @param args * @throws Exception  */public static void main(String[] args) throws Exception {Object obj = creatNewInstance("ref.Bus");System.out.println(obj);}public static Object creatNewInstance(String className) throws Exception{Class c = Class.forName(className);Object obj = c.newInstance();return obj;}}

package ref;import java.lang.reflect.Method;public class TestInvokeMethod {/** * 通用编程 * @throws Exception  */public static void main(String[] args) throws Exception {Student s1 = new Student();Class[] paramType = new Class[]{double.class , String.class};invokeAnyMethod(s1 , "study" , paramType , 123.45 , "abcde");invokeAnyMethod(s1 , "study" , new Class[]{int.class} , 123);}//访问所有公开方法的形式public static void invokeAnyMethod(Object obj , String methodName , Class[] classes , Object... param) throws Exception{Class c = obj.getClass();Method method = c.getMethod(methodName, classes);method.invoke(obj,param);}}

package ref;public class TestExchangeLength {public static void main(String[] args) {m1(11, 22, 33, 44, 55);m2("tom", new int[] { 1, 2, 3, 4, 5 } , 100);m3("tom", 1);}public static void m1(int...nums){int sum = 0;for (int i = 0; i < nums.length; i++) {sum += nums[i];}System.out.println(sum);}public static void m2(String name,int[] nums,int d){}public static void m3(String name,int d,int...nums){}}

 

4. 反射的应用：

//1.获取父类Class对象

Class superClass = c.getSuperclass();

//2.获取所有接口的Class对象

Class[] interfaces = c.getInterfaces();

//3. 获取所有公开的属性（包括父类属性）

Field[] fields = c1.getFields();

//4. 获取所有自身声明的属性（包括私有）

Field[] fields = c1.getDeclaredFields();

//5. 获取所有公开的方法（包括父类方法）

Method[] methods = c1.getMethods();

//6. 获取所有自身声明的方法（包括私有）

Method[] methods = c1.getDeclaredMethods();

//7.通过类对象创建实例对象

public Object newInstance()

//8.获取单个公开方法（包括父类）

Method pm = c.getMethod("方法名称","可变长形参类型");

//9.获取单个自身方法（包括私有）

Method sm = c.getDeclaredMethod("方法名称","可变长形参类型");

//8. 执行Method对象：

method.invoke("此方法隶属于的对象","可变长实参");

package ref;import java.io.Serializable;import java.lang.reflect.Method;public class TestInvokeMethods {/** * @param args * @throws Exception  * @throws SecurityException  */public static void main(String[] args) throws Exception {Student s1 = new Student();s1.name = "tom";Class c = Student.class;Method publicMethod1 = c.getMethod("study");Method publicMethod2 = c.getMethod("study",int.class);Method publicMethod3 = c.getMethod("study",double.class,String.class);/*//启用当前方法publicMethod1.invoke(s1);publicMethod2.invoke(s1,10);//Object o = Integer i = 10;publicMethod3.invoke(s1,1.2,"abc");*///获取自身声明的方法Method selfMethod = c.getDeclaredMethod("exam");selfMethod.setAccessible(true);//设置私有的访问权限（反射可以突破封装）selfMethod.invoke(s1);}}class Student implements Serializable,Runnable{public String name;protected Integer age;private Character sex;Double score;public void study(){System.out.println("study() executed");}public void study(int n){System.out.println("study(int n) executed" + n);}public void study(double d ,String s){System.out.println("study(double d ,String s) executed");}@Overridepublic void run() {}public void exam(){System.out.println("exam()");}}

package ref;import java.io.Serializable;import java.lang.reflect.Method;public class TestBaseReflect {/** * @param args * @throws ClassNotFoundException  */public static void main(String[] args) throws ClassNotFoundException {//1.通过类型直接获取类对象Class c1 = Student1.class;//类对象//2.以静态方法的形式获取类对象Class c2 = Class.forName("ref.Student");//3.通过类的实例对象获取类对象Student1 stu = new Student1();Class c3 = stu.getClass();//System.out.println(c3.getName());//获取类的全限定名//System.out.println(c3.getSimpleName());//获取类的简单名称//获取c1的父类信息  superClass代表Object.classClass superClass = c1.getSuperclass();//System.out.println(superClass.getName());//获取c1的所有接口信息 c1Interfaces代表Student.class所实现的所有接口（接口本身也是Class的实例，也是.class文件）Class[] c1Interfaces = c1.getInterfaces();//System.out.println(c1Interfaces.length);//System.out.println(c1Interfaces[0].getName());//System.out.println(c1Interfaces[1].getName());//获取c1的所有公开的属性名称（包括父类属性）//Field[] fields = c1.getFields();//获取c1的所有自身声明的属性（包括私有）//Field[] fields = c1.getDeclaredFields();//for (Field field : fields) {//System.out.println(field.getName());//}//获取c1的所有公开的方法名称（包括父类方法）//Method[] methods = c1.getMethods();Method[] methods = c1.getDeclaredMethods();//获取c1的所有自身声明的方法（包括私有）for (Method method : methods) {System.out.println(method.getName());}}}class Student1 implements Serializable , Runnable{public String name;protected Integer age;private Character sex;Double score;public void study(){System.out.println("study() executed");}public void study(int n){System.out.println("study(int n) executed" + n);}public void study(double d , String s){System.out.println("study(double d , String s) executed");}@Overridepublic void run() {}private void exam(){System.out.println("exam()");}}

 

四、单例模式：

1. 概念：一个类，只能有一个对象。

2. 实现方式：

I. 饿汉式（类加载时创建，天生线程安全）

II. 懒汉式（使用时创建，线程不安全，需添加同步）

package instance;public class TestSingleton {public static void main(String[] args) {}}//饿汉式（类加载时创建，天生线程安全）class HungrySingleton{private static final HungrySingleton instance = new HungrySingleton();private HungrySingleton(){}public static HungrySingleton getInstance(){return instance;}}//懒汉式（使用时创建，线程不安全，需添加同步）class LazySingleton{private static LazySingleton instance = null;private LazySingleton(){}public static synchronized LazySingleton getInstance(){if(instance == null){instance = new LazySingleton();}return instance;}}

五.工厂模式

package ref;import java.io.FileInputStream;import java.io.InputStream;import java.util.Properties;public class TestObjectFactory {public static void main(String[] args) throws Exception {InputStream is = new FileInputStream("Configurations/Properties.txt");Properties prop = new Properties();//Hashtable的子类（操作字符串）prop.load(is);String className = prop.getProperty("className");USB usb = usbFactory(className);usb.service();}public static USB usbFactory(String className) throws Exception{Class c = Class.forName(className);return (USB)c.newInstance();}}interface USB{public void service();}class Fan implements USB{@Overridepublic void service() {System.out.println("通电--旋转");}}class Lamp implements USB{@Overridepublic void service() {System.out.println("通电--照明");}}class UDisk implements USB{@Overridepublic void service() {System.out.println("通电--读写数据");}}class Mouse implements USB{@Overridepublic void service() {System.out.println("通电--移动");}}