java---泛型和反射机制

泛型的基本概念

   泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类，接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

  

   案例：

package com.panhui;

import java.util.*;

 

public classDemo10_8 {

 

    public static void main(String[] args) {

        // TODO Auto-generated method stub

       

        ArrayListal = new ArrayList();

        //创建一支狗

        Dogdog1= newDog();

       

        //放入集合中

        al.add(dog1);

       

        //取出

        Cat temp = (Cat)al.get(0);

 

    }

 

}

 

class Cat

{

   privateString color;

   privateintage;

   

   publicString 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

{

   privateString color;

    private int age;

   

   publicString getColor() {

        return color;

    }

    public void setColor(String color) {

        this.color = color;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

 

   

}

这段代码里。

      ArrayList al = new ArrayList();

        //创建一支狗

        Dogdog1= newDog();

       

        //放入集合中

        al.add(dog1);

       

        //取出

        Cat temp = (Cat)al.get(0);

类中放置的是Dog的类型，而取出来的时候放入的temp是Cat类型，只有在编译的的时候会报错，

类型使用错误，此时就可以使用泛型。

好处：在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

   ArrayList<Dog>al = new ArrayList<Dog>();

  Dog dog1 = newDog();

取出这个对象的时候就不需要再强制转换了，一旦类型使用错误的时候，会自动报错。

总结：

如果没有泛型，那么通过对类型Object的引用来实现参数的“任意化”，就是要做强制类型转换，而且这种转换是要求开发者对实际参数类型可以预知的情况下进行的。

比如：//创建一支狗

        Dogdog1= newDog();

       

        //放入集合中

        al.add(dog1);

       

        //取出，强制转换。

        Dogtemp= (Dog)al.get(0);

对于强制转换类型错误的情况，编译器可能不提示错误，在运行的时候才出现异常。如上例代码。

 

 

反射机制:比如一下代码，Gen类可以定义对象的类型，通过Gen的函数得知这个对象类型的相应内容，就能给予类的名称就知道它的内部内容，如成员函数的名称，类变量之类的。函数入下图

 

代码：反映反射机制。

package com.panhui;

 

import java.lang.reflect.Method;

 

public classDemo10_8_2 {

 

    public static void main(String[] args) {

        // TODO Auto-generated method stub

       

        Gen<Bird>gen1= newGen<Bird>(newBird());

 

//调用Gen类的函数，得到类的成员函数名，以及类型。

        gen1.shoeTypeName();

    }

 

}

 

class Bird

{

   publicvoidtest1()

   {

    System.out.println("aaa");

   }

   

   publicvoidcount(inta,int b)

   {

    System.out.println(a+b);

   }

}

 

 

class Gen<T>

{

   //可以随意定义o的类型

    //

    private T o;

   

   //构造函数

   publicGen(T a)

   {

        o = a;

   }

   

   //得到T的类型名称

   publicvoidshoeTypeName()

   {

    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]);

        }

   }

}

 

 

 

使用泛型的优点：

1， 类型安全

2， 向后兼容

3， 层次清晰

4， 性能较高，