javaSE完结了，加油，有点乱

package 反射机制;
/**
 * java.lang.reflect.Field;类的属性
 * @author lenovo
 *
 */
import java.lang.reflect.*;


public class ReflectTest04 
{
	public static void main(String[] args) throws Exception
	{
		//获取整个类
		Class c = String.class;
		
		//获取属性Field
		/*
		 * 获取所有public修饰的属性
		Field[] fs = c.getFields();
		System.out.println(fs.length);
		System.out.println(fs[0].getName());
		*/
		
		//获取所有的属性？
		Field[] fs = c.getDeclaredFields();
		/*
		for(Field field : fs) {
			
			int i = field.getModifiers();
			//System.out.println(i);
			String strModifier = Modifier.toString(i);
			System.out.println(strModifier);
			
			Class type = field.getType();
			//System.out.println(type.getName());
			System.out.println(type.getSimpleName());
			
			System.out.println(field.getName());
		}
		*/
		
		StringBuffer sb = new StringBuffer();
		sb.append(Modifier.toString(c.getModifiers())+" calss "+c.getSimpleName()+"{");
		for(Field field:fs) {
			sb.append("\n");
			sb.append(Modifier.toString(field.getModifiers())+" ");
			sb.append(field.getType().getSimpleName()+" ");
			sb.append(field.getName()+" ");
		}
		sb.append(";\n"+"}");		
		System.out.println(sb);
	}
}

````package 反射机制;

import java.lang.reflect.*;;

/*java.lang.reflect.Field;
 * 获取某个指定的属性
 */
public class ReflectTest05 
{
	public static void main(String[] args) throws Exception
	{
		/*
		//以前的做法
		User u = new User();
		u.age = 12;
		System.out.println(u.age);
		*/
		
		//获取类
		Class c = User.class;
		
		//获取某个特定
		Field idF = c.getDeclaredField("id");
		
		//获取到某个特定的属性可以用来？set get
		Object o = c.newInstance();
		
		//打破封装
		idF.setAccessible(true);//使用反射机制可以打破封装性，导致java对象的属性不安全
		
		//给o对象的id属性赋值"110"
		idF.set(o, "110");//set
		
		//get
		System.out.println(idF.get(o));
	}
}

package 反射机制;
/*
 * java.lang.reflect.Method
 */
import java.lang.reflect.*;
public class ReflectTest06 
{
	public static void main(String[] args) 
	{
		//获取类
		Class c = CustomerService.class;
		//获取所有的方法
		Method[] ms = c.getDeclaredMethods();
		/*
		for(Method m : ms) {
			//修饰符
			System.out.println(Modifier.toString(m.getModifiers()));
			
			//方法的返回值类型
			Class returnType = m.getReturnType();
			System.out.println(returnType.getSimpleName());
			
			//方法名
			System.out.println(m.getName());
			
			//方法的形式参数列表
			Class[] parameterTypes = m.getParameterTypes();
			for(Class parameterType : parameterTypes) {
				System.out.println(parameterType.getSimpleName());
			}
		}
		*/
		
		//反编译
		StringBuffer sb = new StringBuffer();
		sb.append(Modifier.toString(c.getModifiers())+" class ");
		sb.append(c.getSimpleName()+"\n"+"{"+"\n");
		for(Method m : ms) {
			sb.append(Modifier.toString(m.getModifiers())+" ");
			sb.append(m.getReturnType().getSimpleName()+" ");
			sb.append(m.getName()+"(");
			//形参
			Class[] parameterTypes = m.getParameterTypes();
			for(int i = 0; i < parameterTypes.length; i ++) {
				Class parameterType = parameterTypes[i];
				if(i==parameterTypes.length-1) {
				sb.append(parameterType.getSimpleName());
				}else {
					sb.append(parameterType.getSimpleName()+",");
				}
			}
			sb.append(")");
			
			sb.append("{}"+"\n");
		}
		sb.append("}");
		System.out.println(sb);
	}
}

package 反射机制;
/*
 * 获取某个特定的方法，通过反射机制执行
 * 
 * 	以前：
 * CustomerService cs = new CustomerService();
 * boolean isSuccess = sc.login("admin","123");
 * 
 * 
 * 	通过反射机制？
 */

import java.lang.reflect.*;
public class ReflectTest07 
{
	public static void main(String[] args) throws Exception
	{
		//获取类
		Class c = CustomerService.class;
		
		//获取某个特定的方法
		//通过：方法名+形参列表
		Method m = c.getDeclaredMethod("login", String.class,String.class);
		
		//通过反射机制执行login方法
		Object o = c.newInstance();
		
		//调用o对象的m方法，传递"admin""123"等参数。方法的执行结果是retValue
		Object retValue = m.invoke(o, "admin","123");
		
		System.out.println(retValue);
		
	}
}

package 反射机制;
/**
 * 获取构造方法
 * @author lenovo
 *
 */
import java.lang.reflect.*;
public class ReflectTest08 
{
	public static void main(String[] args) throws Exception
	{
		//1.获取类
		Class c = Class.forName("java.lang.String");
		
		//2.获取所有内容
		Constructor[] cs = c.getDeclaredConstructors();
		
		/*
		for(Constructor con : cs) {
			
			//获取修饰符
			System.out.println(Modifier.toString(con.getModifiers()));
			
			//获取构造方法名
			System.out.println(c.getName());
			
			//构造方法的形式参数列表
			Class[] parameterTypes = con.getParameterTypes();
			for(Class parameterType : parameterTypes ) {
				System.out.println(parameterType.getSimpleName());
			}
			
		}
		*/
		
		//反编译
		StringBuffer sb = new StringBuffer();
		
		sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");
		
		//构造方法
		for(Constructor con : cs) {
			sb.append("\n\t");
			sb.append(Modifier.toString(con.getModifiers())+" ");
			sb.append(c.getSimpleName()+"(");
			//形参
			Class[] parameterTypes = con.getParameterTypes();
			for(int i = 0; i < parameterTypes.length; i ++) {
				Class parameterType = parameterTypes[i];
				if(i == parameterTypes.length - 1) {
					sb.append(parameterType.getSimpleName());
				}else {
					sb.append(parameterType.getSimpleName()+",");
				}
			}
			sb.append("){}\n");
		}
		
		sb.append("\n"+"}");
		System.out.println(sb);
		
	}
}

package 反射机制;

import java.lang.reflect.Constructor;

/*
 * 获取某个特定的构造方法，然后创建对象
 */
public class ReflectTest09 
{
	public static void main(String[] args) throws Exception 
	{
		//获取类
		Class c = Class.forName("Customer");
		
		//获取特定的构造方法
		Constructor con = c.getDeclaredConstructor(String.class,int.class);
		
		//创建对象
		Object o = con.newInstance("张三","25");
		
		System.out.println(o);
	}
}

class Customer
{
	String name;
	int age;
	Customer(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public String toString() {
		return "[Customer"+name+","+age+"]";
	}
}

package 反射机制;
/*
 * 关于获取父类和父接口
 */
public class ReflectTest10 
{
	//通过反射机制获取String类的父类和父类接口
	public static void main(String[] args) throws Exception
	{
		Class c = Class.forName("java.lang.String");
		
		//获取父类
		Class superClass = c.getSuperclass();
		
		System.out.println(superClass);
		
		//获取父接口
		Class[] ins = c.getInterfaces();
		
		for(Class in : ins) {			
			System.out.println(in.getName());
		}
	}
}

package 反射机制;
/*
 * 关于获取父类和父接口
 */
public class ReflectTest10 
{
	//通过反射机制获取String类的父类和父类接口
	public static void main(String[] args) throws Exception
	{
		Class c = Class.forName("java.lang.String");
		
		//获取父类
		Class superClass = c.getSuperclass();
		
		System.out.println(superClass);
		
		//获取父接口
		Class[] ins = c.getInterfaces();
		
		for(Class in : ins) {			
			System.out.println(in.getName());
		}
	}
}

package 反射机制;

import java.util.Date;

/*
 * 关于java中的可变长参数
 */
public class 可变长参数Test01 
{
	//m1方法中有一个int类型的可变长参数
	public static void m1(int... a) //m1方法在调用的时候，传递的实参可以是0-N个
	{
		System.out.println("Test");
	}
	
	//如果有精确的匹配的方法，则调用该方法，不会再去执行可变长参数的那个方法
	public static void m1(int i) 
	{
		System.out.println(i);
	}
	
	//可变长参数可以等同看做数组
	public static void m2(String... args)
	{
		for(int i = 0; i < args.length; i ++) {
			System.out.println(args[i]);
		}
	}
	
	public static void m3(Class... args) throws Exception
	{
		for(int i = 0; i < args.length; i ++) {
			Class c = args[i];
			System.out.println(c.newInstance());
		}
	}
	
	//可变长参数只能出现一次，并且只能出现在所有参数的最后一位
	public static void m4(int i, String... args){}
	
	public static void main(String[] args) throws Exception
	{
		m1();
		m1(1);
		m1(1,2);
		m1(1,2,3);
		
		m2("体育","音乐","旅游","美食");
		String[] s = {"体育","音乐","旅游","美食"};
		m2(s);
		
		m3(Date.class,Employee.class);
	}
}

package 反射机制;

import java.io.FileReader;
import java.util.Properties;

public class 反射机制andIOandProperties 
{
	public static void main(String[] args) throws Exception
	{
		//1.创建属性对象
		Properties p = new Properties();
		
		//2.创建流
		FileReader fr = new FileReader("E:\\eclipse-workspace\\Note\\src\\反射机制\\classInfo.properties");
		
		//3.加载
		p.load(fr);

		//4.关闭
		fr.close();
		
		//通过key获取value
		String className = p.getProperty("calssName");
		
		//System.out.println(className);
		
		//通过反射机制创建对象
		Class c = Class.forName(className);
		
		//创建对象
		Object o = c.newInstance();
		
		System.out.println(o);
		}
}

配置文件

package 反射机制;

public class User 
{
	private String id;
	public int age;
	protected String addr;
	boolean sex;
}

package 反射机制;

public class Employee 
{
	//Field
	private String name;
	
	//Constructor
	public Employee() {
		System.out.println("无参数构造方法执行！");
	}
	
	public Employee(String name) 
	{
		this.name = name;
	}
	
	//方法
	public void work()
	{
		System.out.println(name+"在工作！");
	}
}

package 反射机制;

public class CustomerService 
{
	//登录
	public boolean login(String name,String pwd)
	{
		if("admin".equals(name) && "123".equals(pwd)) {
			return true;
	 	}
		return false;
	}
	
	//退出
	public void logout() 
	{
		System.out.println("系统已安全退出！");
	}
	
}