java反射、设计模式

反射

类的对象: 基于定义好的类 创建该类的一个实例对象, 使用new通过一个类创建出的对象

类对象:类加载的产物,封装一个类所有的信息(类名 父类 接口 方法 属性…) 基于Class这个类创建出的对象

一.获取类对象

1.使用该类所创建出的类的对象 通过getClass()来获取

Student stu = new Student();
Class c = stu.getClass();

2.通过 类名.class 来获取一个类的 类对象

Class c = Student.class;

3.通过 Class.forName(“类的全类名/全限定名”); 类的全类名/全限定名:包名+类名

Class c = Class.forName("classes.Student");

4.类加载时机

1.当第一次创建本类对象时 
2.第一次访问静态成员时(静态属性+静态方法)
3.当子类进行类加载时(当子类对象第一次被创建或子类静态成员第一次被访问) 父类会先进行类加载(也就只执行一次)
4.当第一次使用Class.forName()方法来获取一个类的类对象时

二.类对象的使用

1.获取类对象中属性 方法 构造方法的信息

a)获取非私有的信息
	类对象.get Field(名字)/Method(名字)/Constructor();
b)获取私有的信息
	类对象.get Declared Field(名字)/Method(名字)/Constructor();
c)获取所得属性/方法/构造方法信息
	获取所有公开的属性/方法/构造方法信息 包括了父类
	类对象.get Fields/Methods/Constructors();
	获取所有的属性/方法/构造方法信息 不包括父类
	类对象.get Declared Fields/Methods/Constructors();
d)获取有参数的方法 或 构造方法
	类对象.get Method(名字); == 类对象.get Method(名字,null); 
	类对象.get Declared Method(名字);== 类对象.get Declared Method(名字,null);
	如果不指定名字 则获取的都是无参数的方法
	类对象.get Method(名字,参数1,参数2....);
	类对象.get Declared Method(名字,参数1,参数2....);
	参数必须写成 参数类型.class的形式   如果是无参方法 参数位置也可以填写null
	
	类对象.get Constructor(); == 类对象.get Constructor(null); 
	类对象.get Declared  Constructor();== 类对象.get Declared  Constructor(null);
	类对象.get  Constructor(参数1,参数2....);
	类对象.get Declared  Constructor(参数1,参数2....);
	参数必须写成 参数类型.class的形式   如果是无参方法 参数位置也可以填写null
e)使用一个方法
	方法对象.invoke(实际执行对象,实参...); 
f)通过类对象来创建类的对象
	1)类对象.newInstance(); 通过无参构造创建一个对象 返回值时Object类型 所以需要强转
    2)通过获取构造器 再创建对象
    	无参:
			Constructor con = c3.getConstructor();
			Student stu = (Student)con.newInstance();
		有参:
			Constructor con = c3.getConstructor(String.class,int.class);
			Student stu = (Student)con.newInstance("xz",9);

	相当于new的形式
g)使用私有的方法属性
	在使用前
	方法对象/属性对象的.setAccessible(true);忽视所有修饰符
	在进行使用

设计模式

设计模式(Designpatterm)：是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

一.单例模式

​ 单例模式(Singleton)：是一种常见的设计模式，在Java应用中，单例对象必须保证一个JVM中，该对象只有一个实例存在。

​ 都要保证该类的构造方法是私有的

​ 1.饿汉式

class Same{//饿汉式
	public static final Same s = new Same(); 
	//static m1();
	//static m2();
	//static m3();
}
单例的保证是通过类加载只进行一次来实现的
优点:并发效率高
缺点:资源浪费

​ 2.懒汉式

class Same2{
	private static Same2 s;
	public synchronized static Same2 getSame2(){
		if(s==null){
			s = new Same2();
		}
		return s;
	}
	//static m1();
	//static m2();
	//static m3();
}
单例的保证是通过加锁以及非空判断来实现的
优点:资源占用率低
缺点:并发效率低

​ 3.静态内部类

class Same3{
	static class Inner{
		static final Same3 s = new Same3();
	}
	public static Same3 getSame3(){
		return Inner.s;
	}
}
单例的保证是通过静态内部类的类加载来进行实现的
优点:资源占用率低 并发效率高

二.工厂模式

​ 工厂模式：主要解决的是对象创建的问题，工厂对象的职责在于创建一个对象

	public static void main(String[] args) throws Exception, InstantiationException, IllegalAccessException{
		Lamp lamp = new Lamp();
		lamp.setLight(factory());
		lamp.on();
	}
	public static Light factory() throws Exception{
		//读进来 使用文件里的类名
		//FileReader reader = new FileReader("factory.txt");
		FileInputStream is = new FileInputStream("factory.txt");
		Properties p = new Properties();
		//使用properties的load方法 进行读取
		p.load(is);
		Class<?> c = Class.forName(p.getProperty("classname"));
		Light l = (Light)c.newInstance();
		is.close();
		return l;
	}