对泛型、反射的理解

什么是泛型？

泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

运行时的强制转换不安全，在编译时引入泛型是为了安全

编译结束后不存在泛型，可以用javap -c 类名 反编译来验证。

package com.generics.lesson;

import java.util.ArrayList;
import java.util.List;

/*
 * 泛型
 */
public class Test {
	public static void main(String[] args) {
		My<String> my = new My<String>();
		my.print("213");
		System.out.println(my.show(123));
		List<Shape> list = new ArrayList<Shape>();
		list.add(new Shape("1"));
		list.add(new Shape("2"));
		List<Shape> list2 = new ArrayList<Shape>();
		list2.add(new Circle("a"));
		list2.add(new Circle("b"));
		my.print(list);
		my.print(list2);

		Shape c1 = new Circle("1");
		Circle c2 = new Circle("1");
		Shape c3 = new Shape("3");
		System.out.println(c1 == c2);
		System.out.println(c1.equals(c2));
		System.out.println(c1.getClass()==c3.getClass());
		System.out.println(c1.getClass().equals(c3.getClass()));
		System.out.println(c1 instanceof Circle);
	}

}

/* 泛型类 */
class My<T> {
	public void print(T t) {
		System.out.println(t);
	}

	// 通配符
	public void print(List<? extends Shape> shapes) {
		for (Shape shape : shapes) {
			shape.print();
		}
	}

	// 动态返回类型
	public <T> T show(T t) {
		return t;
	}
}

class Shape {
	protected String name;

	public Shape() {
	}

	public Shape(String name) {
		this.name = name;
	}

	public void print() {
		System.out.println("shape:" + name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

class Circle extends Shape {
	@Override
	public String getName() {
		return super.getName();
	}

	@Override
	public void setName(String name) {
		super.setName(name);
	}

	public Circle() {
	}
	public Circle(String name) {
		this.name = name;
	}

	@Override
	public void print() {
		System.out.println("circle:" + name);
	}

	// 覆盖Object类的equals方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return super.equals(obj);
		if (obj instanceof Shape) {
			if (((Shape) obj).getName() == this.getName())
				return true;
		}
		return false;
	}
	
}

package com.generics.test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 得到要调用类的class
 * 得到要调用的类中的方法（Method）
 * 方法调用（invoke）
 *
 */
public class Main {
	public static void main(String[] args) throws Exception {
		Class cls = Class.forName("com.generics.test.Student");
		@SuppressWarnings("unchecked")
		Method m = cls.getDeclaredMethod("hi",new Class[]{int.class,String.class});
		m.invoke(cls.newInstance(), 20,"prs");
		//方法调用中的参数类型	int 不可更改为INteger
		@SuppressWarnings("unchecked")
		Method setMethod = cls.getDeclaredMethod("setAge", int.class);
		setMethod.invoke(cls.newInstance(), 14);
		//static方法的反射调用
		@SuppressWarnings("unchecked")
		Method staticMethod = cls.getDeclaredMethod("hi", int.class,String.class);
		staticMethod.invoke(cls, 20,"qq"); //这里不需要newInstance()
		//private 的成员变量赋值
		Object student = cls.newInstance();
		Field field = cls.getDeclaredField("age");
		field.setAccessible(true);//直接访问不行必须设置访问许可
		field.set(student, 10);
		System.out.println(field.get(student));
	}
}