Java 基础8 泛型 generic 反射机制

在跟 coursera 上边的 普林斯顿的算法课， 都开到第四周了，我进度还在第二周 哭了

复习一下泛型   内容来自 韩顺平的视频

本质是参数化类型。也就是所操作的数据类型被指定为一个参数，可用在 类  接口  方法 中

泛型类  泛型接口  泛型方法

首先定义两个类  

class Cat{
	private String color;
	private int age;
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
class Dog{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

泛型的必要性  

public class Generic_demo {
	public static void main(String[] args) {
		
		ArrayList al= new ArrayList();
        //创建一只狗
		Dog dog1 = new Dog();
		//放入集合
		al.add(dog1);
		//Dog temp = (Dog)al.get(0);
		Cat temp =(Cat)al.get(0);
		
	}
}

实际上是dog的类  但是写成cat了

编译不会出错  但是运行时候，会报错  类型转换错误

Exception in thread "main" java.lang.ClassCastException:test.Dog
at test.Generic_demo.main(Generic_demo.java:14)

改变方法  

public class Generic_demo {
	public static void main(String[] args) {
		
		ArrayList<Dog> al= new ArrayList<Dog>();
        //创建一只狗
		Dog dog1 = new Dog();
		//放入集合
		al.add(dog1);
		//Dog temp = (Dog)al.get(0);
		Dog temp = al.get(0);//不需要强行转换了 不用 craft
		
	}
}

第二部分 反射机制

//定义一个类    传进去什么类 就是什么类 

class Gen<T>
{
	private T o;
	//构造函数
	public Gen(T a){
		o=a;
		}
	//得到T的类型名称
	public void showTypeName()
	{
		System.out.println("类型是："+ o.getClass().getName());
	}
}

传进去 String

public class Generic_demo {
	public static void main(String[] args) {
		
	Gen<String> gen1=new Gen<String>("aaa");
	gen1.showTypeName();
	
	}
}

结果      类型是：java.lang.String

传进去integer

public class Generic_demo {
	public static void main(String[] args) {
		
	Gen<Integer> gen1=new Gen<Integer>(222);
	gen1.showTypeName();
	
	}
}

结果 类型是：java.lang.Integer

自己定义的类 也可以显示 

//定义一个bird
class Bird
{
	public void test1()
	{
		System.out.println("aa");
	}
	public void count(int a,int b){
		System.out.println(a+b);
		
	}
}

public class Generic_demo {
	public static void main(String[] args) {
		
	Gen<Bird> gen1=new Gen<Bird>(new Bird());
	gen1.showTypeName();
	
	}
}

类型是：test.Bird

放大招 

反射机制 得到方法的名称

class Gen<T>
{
	private T o;
	//构造函数
	public Gen(T a){
		o=a;
		}
	//得到T的类型名称
	public void showTypeName()
	{
		System.out.println("类型是："+ o.getClass().getName());
		//通过反射机制，我们可以得到T这个类型的很多信息（比如得到成员函数名）
		Method []m=o.getClass().getDeclaredMethods();
		//打印 
		for(int i = 0 ;i <m.length;i++){
			System.out.println(m[i].getName());	
		}
	}
}

class Bird
{
	public void test1()
	{
		System.out.println("aa");
	}
	public void count(int a,int b){
		System.out.println(a+b);
		
	}
}

public class Generic_demo {
	public static void main(String[] args) {
		
	Gen<Bird> gen1=new Gen<Bird>(new Bird());
	gen1.showTypeName();
        }
}

结果 ：

类型是：test.Bird
count
test1

什么时候用泛型    不知道到底是什么类型  

好处 安全 代码复用率