泛型+反射



泛型

1、泛型中 T/E 类型为Object，只有在运行时才知道具体的类型。

eg：Stu<String> stu = new Stu<String>(“你好”);// T/E 的类型为String

2、在C++中称之为：模板编程 ===> 泛型<可读性差，一般在搭框架时使用>

3、如何定义一个泛型类？

class Stu<T> {

public T inf;

public Stu() {

}

public Stu(T inf) 

{

this.inf = inf;

}

public void add(T aa) {

this.inf = aa;

}

}

 

4、如何使用自己定义的泛型？

 

class Teacher {

public void say() {

System.out.println("我是一个老师!");

}

}

public class Test {

private void m1() {

Stu stu = new Stu("你好");//T的类型为Object

String inf = (String) stu.inf;

System.out.println(inf);

}

private void m2() {

Stu stu = new Stu(new Teacher());//T的类型为Object

Teacher inf = (Teacher) stu.inf;

inf.say(); 

}

private void m3() {

Stu<String> stu = new Stu<String>("你好");//T的类型为String

}

public static void main(String[] args) {

Test t = new Test();

t.m2();

}

}

 

 

 

反射

/**

 * 通过Class对象创建对象

 *  1.得到Class对象 

 

/**

 * 得到Class 对象的方式有三种

 *  （1）类名.class 

// 类名.class 得到

Class c1 = Stu.class;// c1封装了 Stu类的代码信息

Class c2 = Teacher.class;// c2封装了 Teacher类的代码信息

Class c3 = Integer.class;// c3封装了Integer类的代码信息

Class c4 = ArrayList.class;// c4封装了ArrayList类的代码信息

Class c5 = HashMap.class;// c5封装了HashMap类的代码信息

 

 *  （2）Class.forName("全类名"); 全类名: “包名.类名”，

 * 例“com.fs.po.Stu” 

// Class.forName("全类名"

Class c6 = Class.forName("com.fs.po.Stu");// c6封装了 Stu类的代码信息

Class c7 = Class.forName("java.util.ArrayList");// c7封装了ArrayList类的代码信息

 

 *  （3）对象.getClass();

// 对象.getClass();

Class c8 = new Stu().getClass();// c8封装了 Stu类的代码信息

 

 *  （4）基本数据类型.class   只适用于基本数据类型         int.class,   char.class,  double.class

// 基本数据类型.class

Class c9 = int.class;

Class c10 = boolean.class;

 * */

 

注意：前3种方法在“实际开发中”中，（2）用的最多，而且推荐使用，它有利于隐藏信息；（3）用的最少，因为没啥用，所以不建议使用。第（4）种方法为引申补充方法

 

 

 

 *  2.得到Constructor对象

Class c = Class.forName("com.fs.po.Stu");// 封装了Stu的信息

Constructor con1 = c.getConstructor();

 

Constructor con2 = c.getConstructor(String.class, Integer.class);

 

 

 

 *  3.使用Constructor的实例方法newInstance(Object... obj); 

 *  4.强转

 

//3,4合并为以下两句

 

Stu stu = (Stu) con1.newInstance();// 调用Stu()创建Stu对象

stu.say2();

 

Stu stu2 = (Stu) con2.newInstance("小明", 100);// 调用Stu(String name, Integer age)创建对象

stu2.say2();

 * */

 

 

反射机制与平常的方法对比

1、正常Java开发：引入包名===>new实例化===>取得实例化对象

2、反射机制：实例化对象===>getClass()方法===>得到完整的包名

 

发射机制所涉及的类

1、Class类：Java反射的源头，Class类的功能就是通过一个对象来找到其所在类的信息。

2、Field类：访问类中的属性<成员变量>

3、Method类：访问类中的方法

4、Constructor类：访问类中的构造方法

 

Constructor类对象的获得方式：

1、得到所有的构造器方法：getConstructors

2、获得指定的构造器：getConstructor

 

反射机制的体现：Class cls ===> constructor c(构造器对象) ===>newInstance（创建对象）

 

反射机制的作用：实例化一个对象，不使用new也可以实例化（类中要有不带参数的构造方法），用newInstance创建对象。

反射相关程序代码如下：

package com.fs.po;

public class Stu {
	private String name;
	private float hight;
	public int age;
	public Stu() {
		System.out.println("Stu()");
	}
	/***
	 * dfsdfdafasd
	 * @param name
	 * @param age
	 */
	public Stu(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	public Stu(String s, String s2, int age) {
		System.out.println("Stu(String s, String s2, int age)");
	}
	private Stu(String name) {
		System.out.println("Stu(String name)...");
	}
	private void say(String name, int age, Teacher t) 
	{
		System.out.println("上.....");
	}
	private void say() 
	{
		System.out.println("下....");
	}
	public void say2() {
		System.out.println("stu say2...."+name);
	}
}




package com.fs.po;

public class Teacher {
	public void teacherSay() {
		System.out.println("good good study");
	}
}

package com.fs.po;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;

public class Test {
	/**
	 * 得到Class 对象的方式有三种
	 *  1.类名.class 
	 *  2.Class.forName("全类名"); 全类名: “包名.类名”，
	 * 例“com.fs.po.Stu” 
	 *  3.对象.getClass();
	 *  4.基本数据类型.class   只适用于基本数据类型         int.class,   char.class,  double.class
	 * */
	private void m1() throws Exception {
		// 类名.class 得到
		Class c1 = Stu.class;// c1封装了 Stu类的代码信息
		Class c2 = Teacher.class;// c2封装了 Teacher类的代码信息
		Class c3 = Integer.class;// c3封装了Integer类的代码信息
		Class c4 = ArrayList.class;// c4封装了ArrayList类的代码信息
		Class c5 = HashMap.class;// c5封装了HashMap类的代码信息

		// Class.forName("全类名"
		Class c6 = Class.forName("com.fs.po.Stu");// c6封装了 Stu类的代码信息
		Class c7 = Class.forName("java.util.ArrayList");// c7封装了ArrayList类的代码信息

		// 对象.getClass();
		Class c8 = new Stu().getClass();// c8封装了 Stu类的代码信息
		
		// 基本数据类型.class
		Class c9 = int.class;
		Class c10 = boolean.class;
	}

	private Class getClassByName(String name) {
		Class c = null;
		try {
			c = Class.forName(name);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return c;
	}

	/**
	 * 通过Class对象创建对象
	 *  1.得到Class对象 
	 *  2.得到Constructor对象
	 *  3.使用Constructor的实例方法newInstance(Object... obj); 
	 *  4.强转
	 * */
	private void m2() throws Exception {/** 体现强转 */
		Class c = Class.forName("com.fs.po.Stu");// 封装了Stu的信息
		/** 通过c对象创建Stu类的对象 */
		// 得到 Stu()构造方法信息
		Constructor con1 = c.getConstructor();
		Stu stu = (Stu) con1.newInstance();// 调用Stu()创建Stu对象
		stu.say2();
		System.out.println("======================");
		// 得到public Stu(String name, int age)信息
		Constructor con2 = c.getConstructor(String.class, Integer.class);
		Stu stu2 = (Stu) con2.newInstance("小明", 100);// 调用Stu(String name, Integer age)创建对象
		stu2.say2();
	}

	private void m3() throws Exception {/** 体现泛型 */
		Class c = Class.forName("com.fs.po.Stu");// 封装了Stu的信息
		/** 通过c对象创建Stu类的对象 */
		// 得到 Stu()构造方法信息
		Constructor<Stu> con1 = c.getConstructor();
		Stu stu = con1.newInstance();// 调用Stu()创建Stu对象
		stu.say2();
		System.out.println("======================");
		// 得到public Stu(String name, int age)信息
		Constructor<Stu> con2 = c.getConstructor(String.class, Integer.class);
		Stu stu2 = con2.newInstance("小明", 100);// 调用Stu(String name, int
												// age)创建对象
		stu2.say2();
	}

	
	//通过Stu类的private构造方法创建Stu对象
	private void m4() throws Exception {
		Class c = Class.forName("com.fs.po.Stu");// 封装了Stu的信息
		//private Stu(String name)
		Constructor<Stu> con1 = c.getDeclaredConstructor(String.class);
		con1.setAccessible(true);//修改访问权限为可访问
		Stu stu = con1.newInstance("小明2343");// 调用Stu()创建Stu对象
		stu.say2();
	}
	//能过Stu(String s, String s2, int age)创建Stu对象
	private void m5() throws Exception {
		Class c = Class.forName("com.fs.po.Stu");// 封装了Stu的信息
		//public Stu(String s, String s2, int age)
		Constructor<Stu> con1 = c.getDeclaredConstructor(String.class, String.class, int.class);
		Stu stu = con1.newInstance("ss", "ss", 100);
		stu.say2();
	}
	
	public static void main(String[] args) throws Exception {
		Test test = new Test();
		test.m5();
	}
}

package com.fs.po;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test2 {
	/**访问私有的成员变量
	 * @throws Exception 
	 * @throws NoSuchMethodException */
	private void m1() throws Exception {
		Class c = Stu.class;
		Constructor<Stu> con = c.getConstructor();//public Stu() 
		Stu stu = con.newInstance();
		
		stu.age = 100;
		System.out.println(stu.age);//100
		
		//访问成员变量private String name信息
		Field nameField = c.getDeclaredField("name");// 
		nameField.setAccessible(true);//设置可访问
		//修改stu对象中name的值
		nameField.set(stu, "小华");
		//得到stu对象中name的值
		String name = (String)nameField.get(stu);//取出stu对象中name的值
		System.out.println("name-->" + name);
	}
	/**访问私有的成员方法
	 */
	private void m2() throws Exception {
		Class c = Stu.class;
		Constructor<Stu> con = c.getConstructor();//public Stu() 
		Stu stu = con.newInstance();
		
		//private void say(String name, int age, Teacher t)
		Method method1 = c.getDeclaredMethod("say", String.class, int.class, Teacher.class);
		method1.setAccessible(true);
		//使用stu对象调用say(String name, int age, Teacher t)方法
		method1.invoke(stu, "小明", 100, new Teacher());
		
		//private void say()
		Method method2 = c.getDeclaredMethod("say");
		method2.setAccessible(true);
		//使用stu对象调用say()方法
		method2.invoke(stu);
		
	}
	public static void main(String[] args) throws Exception {
		new Test2().m1();
	}
}