第十三章 类加载和反射

一、类加载

形参数组可以用“...”来代替 int ...整型数组

1.加载类文件。产生class对象

jvm.ddl，运行JVM虚拟机。

加载跟类加载器，核心API加载

加载扩展加载器，加载扩展API

加载系统加载器，加载运行的程序

获得class对象

2.连接

校验：检查2进制文件中是否有语法错误，与其他类是否协调一致

准备：为静态static 的分配内存空间。默认值0

解析：将文件中的符号引用替换为直接引用。

3.初始化

静态属性赋值：初始化static的值

检查并加载当前类的直接父类；里面是否有static的代码块，有的话加载

二、反射

反射就是：在运行时探究和使用编译时未知的类

是java的灵魂，可以使得程序更加灵活。

1.获得class对象的方法三种方式：

最常用的:Class.forName("完整类名的字符串表示")

实例对象.getClass()

类型.class

2.使用class对象了解未知类信息

构造器的class对象获取：类class对象.get/Declared/Constructor/s(形参class对象)，获得指定的单个构造器class对象时，才需要传递参数，否则返回一个数组。Declared声明的，包括所有的。

属性的class对象获取：类class对象.get/Declared/Field/s(字段名的字符串表示)，一样

方法的class对象获取：类class对象.get/Declared/Method/s(方法名的字符串表示)，一样

3.使用未知类

构造器的使用：构造器class对象.newInstance(实参)

属性的使用：属性class对象.set(实例化对象，实参)

方法的使用：方法class对象.invoke(实例化对象，实参)

三、垃圾回收

垃圾回收的线程是JVM的一个守护线程，java中的垃圾回收机制与程序分离，不需要程序员手动操作，解放了程序员的同时。也使得程序员不能直接对内存操作。

不过java中有一个通信机制，程序员可以通过它与垃圾回收器沟通

System.gc()；可以通知垃圾回收器回收无用的资源。

四、动态数组

Array.newInstance(类型class对象，大小)

Array.set(实例化对象，下标，值)

 

列子：

public class Dog extends Animal {
	private String name;
	public int age;
	protected String hfj;
	
	public Dog(){
		System.out.println(this);
	}
	
	public Dog(String name){
		this.name = name;
		System.out.println(this);
	}
	
	public Dog(String name,int age,String h){
		this.name = name;
		this.age = age;
		this.hfj = h;
		System.out.println(this);
	}
	public void laugth(){
		System.out.println("the "+this.name+" is laught");
	}
	
	private void laugth( String ho){
		System.out.println(ho+this.name+" is laught");
	}

	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + ", hfj=" + hfj + "]";
	}
	
}

 

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.*;
import java.util.Properties;
import java.util.Scanner;
import java.util.Set;


public class TestReflect {

	private static final Class String = null;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Properties properties = new Properties();
		
		try {
			properties.setProperty("we", "jfdif");
			System.out.println(properties.setProperty("w", "1111111"));
			System.out.println(properties.setProperty("e", "jf"));
			properties.list(System.out);
			Object[] values = properties.values().toArray();
			for(int i=0 ;i <values.length;i++){
				System.out.println("value:"+values[i]);
			}
			properties.store(new FileOutputStream("user.properties"), "用户数据");
			Object[] name = properties.keySet().toArray();
			for(int i=0 ;i <name.length;i++){
				System.out.println("key:"+name[i]);
			}
		} catch (FileNotFoundException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		Scanner scan = new Scanner(System.in);
		Class class1 = int.class;//第一种
		
		Class class2 = new Animal().getClass();//第二种
		System.out.println(class2);
		System.out.println("请输入完整类名");
		String  className = scan.next();
		Constructor[] classCons = null;
		Method[] classMeths = null;
		Field[] classFields = null;
//		Dog dog = null;
//		Dog dog1 = null;
		try {
			Class  inputClass = Class.forName(className);
			
			classCons = inputClass.getDeclaredConstructors();
			classFields = inputClass.getDeclaredFields();
			classMeths = inputClass.getDeclaredMethods();
			
			System.out.println("构造方法------");
			for(int i=0;i<classCons.length;i++){
				System.out.println(classCons[i].toString());
			}
			Dog dog1 = (Dog) inputClass.newInstance();
			dog1.laugth();
			Constructor c1 = inputClass.getConstructor(String.class);
			Dog dog2 = (Dog) c1.newInstance("小狗");
			Constructor c2 = inputClass.getConstructor(String.class,int.class,String.class);
			Dog dog3 = (Dog) c2.newInstance("小狗",8,"hapi");
			
			System.out.println("属性");
			for(int i=0;i<classFields.length;i++){
				System.out.println(classFields[i].getName());
				System.out.println(inputClass.getDeclaredField(classFields[i].getName()));
			}
			System.out.println(dog1);
			Field field1 = inputClass.getDeclaredField("name");//私有属性
			field1.setAccessible(true);//设置权限，才能访问私有属性
			field1.set(dog1, "黑狗2");
			System.out.println(dog1);
			Field field2 = inputClass.getField("age");//公共属性
			field2.set(dog1, 12);
			System.out.println(dog1);
			
			System.out.println("普通方法");
			for(int i=0;i<classMeths.length;i++){
				System.out.println(classMeths[i].toString());
			}
			Method m1 = inputClass.getDeclaredMethod("laugth");
			m1.invoke(dog1);
			Method m2 = inputClass.getDeclaredMethod("laugth",String.class);
			m2.setAccessible(true);
			m2.invoke(dog1,"我要吃鱼");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}