高新技术知识点总结02

由内省引出JavaBean的讲解、对JavaBean的简单内省操作、对JavaBean的复杂内省操作、使用BeanUtils工具包操作JavaBean：

内省------>了解JavaBean

JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，大家觉得这些方法的名称叫什么好呢？JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。

setId()的属性名?id

isLast()的属性名?last

setCPU的属性名是什么??CPU

getUPS的属性名是什么？?UPS

总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。

一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！好处如下：

在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！

JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。

内省综合案例

演示用eclipse自动生成 ReflectPoint类的setter和getter方法。

直接new一个PropertyDescriptor对象的方式来让大家了解JavaBeanAPI的价值，先用一段代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。

演示用eclipse将读取属性和设置属性的流水帐代码分别抽取成方法：

只要调用这个方法，并给这个方法传递了一个对象、属性名和设置值，它就能完成属性修改的功能。

得到BeanInfo最好采用“obj.getClass()”方式，而不要采用“类名.class”方式，这样程序更通用。

采用遍历BeanInfo的所有属性方式来查找和设置某个RefectPoint对象的x属性。在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法，得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。

 

Beanutils工具包

 

演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。

在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。

用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。

演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。

 

示例：

 

Java代码 

package cn.itcast.day1;

 

import java.beans.BeanInfo;

import java.beans.IntrospectionException;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Map;

 

import org.apache.commons.beanutils.BeanUtils;

import org.apache.commons.beanutils.PropertyUtils;

 

public class IntroSpectorTest {

 

/**

* @param args

*/

public static void main(String[]args) throws Exception {

// TODO Auto-generated method stub

ReflectPoint pt1 = new ReflectPoint(3,5);

 

String propertyName = "x";

//"x"-->"X"-->"getX"-->MethodGetX-->

Object retVal = getProperty(pt1, propertyName);

System.out.println(retVal);

 

Object value = 7;

 

setProperties(pt1, propertyName, value);

 

System.out.println(BeanUtils.getProperty(pt1, "x").getClass().getName());

BeanUtils.setProperty(pt1, "x", "9");

System.out.println(pt1.getX());

/*

//java7的新特性

Map map = {name:"zxx",age:18};

BeanUtils.setProperty(map,"name", "lhm");

*/

BeanUtils.setProperty(pt1, "birthday.time", "111");

System.out.println(BeanUtils.getProperty(pt1, "birthday.time"));

 

PropertyUtils.setProperty(pt1, "x", 9);

System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName());

 

}

 

private static void setProperties(Objectpt1, String propertyName,

Object value) throws IntrospectionException,

IllegalAccessException,InvocationTargetException {

PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());

Method methodSetX = pd2.getWriteMethod();

methodSetX.invoke(pt1,value);

}

 

private static ObjectgetProperty(Object pt1, String propertyName)

throws IntrospectionException,IllegalAccessException,

InvocationTargetException {

/*PropertyDescriptor pd = newPropertyDescriptor(propertyName,pt1.getClass());

Method methodGetX = pd.getReadMethod();

Object retVal = methodGetX.invoke(pt1);*/

 

BeanInfo beanInfo =Introspector.getBeanInfo(pt1.getClass());

PropertyDescriptor[] pds =beanInfo.getPropertyDescriptors();

Object retVal = null;

for(PropertyDescriptor pd : pds){

if(pd.getName().equals(propertyName))

{

Method methodGetX = pd.getReadMethod();

retVal = methodGetX.invoke(pt1);

break;

}

}

return retVal;

}

 

}

Java代码 

package cn.itcast.day1;

 

import java.util.Date;

 

public class ReflectPoint {

private Date birthday = new Date();

 

private int x;

public int y;

public String str1 = "ball";

public String str2 = "basketball";

public String str3 = "itcast";

 

public ReflectPoint(int x, int y){

super();

this.x = x;

this.y = y;

}

 

 

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + x;

result = prime * result + y;

return result;

}

 

 

@Override

public boolean equals(Object obj){

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

final ReflectPoint other =(ReflectPoint) obj;

if (x != other.x)

return false;

if (y != other.y)

return false;

return true;

}

 

 

@Override

public String toString(){

return str1 + ":" +str2 + ":" + str3;

}

 

 

public int getX() {

return x;

}

 

 

public void setX(int x) {

this.x = x;

}

 

 

public int getY() {

return y;

}

 

 

public void setY(int y) {

this.y = y;

}

 

 

public Date getBirthday() {

return birthday;

}

 

 

public void setBirthday(Datebirthday) {

this.birthday = birthday;

}

 

}

了解和入门注解的应用、注解的定义与反射调用、为注解增加各种属性：

了解注解及java提供的几个基本注解

先通过@SuppressWarnings的应用让大家认识和了解一下注解：

通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")

@Deprecated

直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。

@Override

public boolean equals(Reflect other)方法与HashSet结合讲解

总结：

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。

看java.lang包，可看到JDK中提供的最基本的annotation。

自定义注解及其应用

定义一个最简单的注解：public@interface MyAnnotation {}

把它加在某个类上：@MyAnnotationpublic class AnnotationTest{}

用反射进行测试AnnotationTest的定义上是否有@MyAnnotation

根据发射测试的问题，引出@Retention元注解的讲解，其三种取值：RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME;分别对应：java源文件-->class文件-->内存中的字节码。

思考：@Override、@SuppressWarnings和@Deprecated这三个注解的属性值分别是什么？

演示和讲解@Target元注解

Target的默认值为任何元素，设置Target等于ElementType.METHOD，原来加在类上的注解就报错了，改为用数组方式设置{ElementType.METHOD,ElementType.TYPE}就可以了。

元注解以及其枚举属性值不用记，只要会看jdk提供那几个基本注解的API帮助文档的定义或其源代码，按图索骥即可查到，或者直接看java.lang.annotation包下面的类。

 

为注解增加基本属性

 

什么是注解的属性

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")

定义基本类型的属性和应用属性：

在注解类中增加String color();

@MyAnnotation(color="red")

用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

MyAnnotation a =(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);

System.out.println(a.color());

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象

为属性指定缺省值：

String color() default "yellow";

value属性：

String value() default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。

 

为注解增加高级属性

 

数组类型的属性

int [] arrayAttr() default {1,2,3};

@MyAnnotation(arrayAttr={2,3,4})

如果数组属性中只有一个元素，这时候属性值部分可以省略大括

枚举类型的属性

EnumTest.TrafficLamp lamp() ;

@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

注解类型的属性：

MetaAnnotation annotationAttr() default@MetaAnnotation("xxxx");

@MyAnnotation(annotationAttr=@MetaAnnotation(“yyy”))

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调用代码如下：

 MetaAnnotation ma =myAnnotation.annotationAttr();

 System.out.println(ma.value());

注解的详细语法可以通过看java语言规范了解，即看java的language specification。

 

Java代码 

package cn.itcast.day2;

 

import java.lang.reflect.Method;

 

import javax.jws.soap.InitParam;

 

@ItcastAnnotation(annotationAttr=@MetaAnnotation("flx"),color="red",value="abc",arrayAttr=1)

public class AnnotationTest {

 

/**

* @param args

*/

@SuppressWarnings("deprecation")

@ItcastAnnotation("xyz")

public static void main(String[]args) throws Exception{

// TODO Auto-generated method stub

System.runFinalizersOnExit(true);

if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)){

ItcastAnnotation annotation =(ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);

System.out.println(annotation.color());

System.out.println(annotation.value());

System.out.println(annotation.arrayAttr().length);

System.out.println(annotation.lamp().nextLamp().name());

System.out.println(annotation.annotationAttr().value());

}

 

Method mainMethod =AnnotationTest.class.getMethod("main", String[].class);

ItcastAnnotation annotation2 =(ItcastAnnotation)mainMethod.getAnnotation(ItcastAnnotation.class);

System.out.println(annotation2.value());

}

 

@Deprecated

public static void sayHello(){

System.out.println("hi,传智播客");

}

}

Java代码 

package cn.itcast.day2;

 

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

 

import cn.itcast.day1.EnumTest;

 

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD,ElementType.TYPE})

public @interface ItcastAnnotation{

String color() default "blue";

String value();

int[] arrayAttr() default {3,4,4};

EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;

MetaAnnotation annotationAttr() default @MetaAnnotation("lhm");

}

Java代码 

package cn.itcast.day2;

 

public @interface MetaAnnotation{

String value();

}

入门泛型的基本应用、泛型的内部原理及更深应用、泛型的通配符扩展应用、泛型集合的综合应用案例、自定义泛型方法及其应用、自定义泛型方法的练习与类型推断总结、自定义泛型类的应用、通过反射获得泛型的实际类型参数：

 

体验泛型

 

Jdk 1.5以前的集合类中存在什么问题

 ArrayList collection = new ArrayList();

 collection.add(1);

 collection.add(1L);

 collection.add("abc");

 inti = (Integer) collection.get(1);//编译要强制类型转换且运行时出错！

Jdk 1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据

ArrayList<Integer> collection2 = newArrayList<Integer>();

collection2.add(1);

/*collection2.add(1L);

collection2.add(“abc”);*///这两行代码编译时就报告了语法错误

int i2 = collection2.get(0);//不需要再进行类型转换

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

 

了解泛型

 

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型

参数化类型与原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？

原始类型可以引用一个参数化类型的对象，编译报告警告，例如，Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>();//错误!///不写<Object>没错，写了就是明知故犯

Vector<Object> v = newVector<String>(); //也错误!

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

 Vector<Integer> vectorList[] = newVector<Integer>[10];

思考题：下面的代码会报错误吗？

Vector v1 = new Vector<String>();

Vector<Object> v = v1;

 

泛型中的？通配符

 

问题：

定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？

错误方式：

public static voidprintCollection(Collection<Object> cols) {

 for(Object obj:cols) {

  System.out.println(obj);

  }

  /*cols.add("string");//没错

 cols = new HashSet<Date>();//会报告错误！*/

}

正确方式：

public static voidprintCollection(Collection<?> cols) {

 for(Object obj:cols) {

  System.out.println(obj);

  }

 //cols.add("string");//错误，因为它不知自己未来匹配就一定是String

 cols.size();//没错，此方法与类型参数没有关系

 cols = new HashSet<Date>();

 }

总结：

使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

 

泛型中的？通配符的扩展

 

限定通配符的上边界：

正确：Vector<? extendsNumber> x = new Vector<Integer>();

错误：Vector<? extendsNumber> x = new Vector<String>();

限定通配符的下边界：

正确：Vector<? superInteger> x = new Vector<Number>();

错误：Vector<? superInteger> x = new Vector<Byte>();

提示：

限定通配符总是包括自己。

?只能用作引用，不能用它去给其他变量赋值

 Vector<? extends Number> y = newVector<Integer>();

 Vector<Number> x = y;

 上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，

 只能通过强制类型转换方式来赋值。

 

泛型集合类的综合案例

 

能写出下面的代码即代表掌握了Java的泛型集合类：

HashMap<String,Integer> hm = newHashMap<String,Integer>();

hm.put("zxx",19);

hm.put("lis",18);

Set<Map.Entry<String,Integer>>mes= hm.entrySet();

for(Map.Entry<String,Integer> me :mes) {

System.out.println(me.getKey() +":" + me.getValue());

}

对在jsp页面中也经常要对Set或Map集合进行迭代：

<c:forEach items=“${map}”var=“entry”>

 ${entry.key}:${entry.value}

</c:forEach>

 

由C++的模板函数引入自定义泛型

 

如下函数的结构很相似，仅类型不同：

int add(int x,int y) {

  return x+y;

 }

float add(float x,float y) {

  return x+y; 

 }

double add(double x,double y) {

  return x+y; 

 }

C++用模板函数解决，只写一个通用的方法，它可以适应各种类型，示意代码如下：

 template<class T>

 Tadd(T x,T y) {

  return (T) (x+y);

 }

 

定义泛型方法

 

Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译：

<T> T add(T x,T y) {

 return (T) (x+y);

 //return null;

 }

用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。

交换数组中的两个元素的位置的泛型方法语法定义如下：

static <E> void swap(E[] a, int i,int j) {

 E t= a[i];

 a[i]= a[j];

 a[j]= t;

}//或用一个面试题讲：把一个数组中的元素的顺序颠倒一下

只有引用类型才能作为泛型方法的实际参数，swap(newint[3],3,5);语句会报告编译错误。

除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界，如<V extendsSerializable & cloneable> void method(){}

普通方法、构造方法和静态方法中都可以使用泛型。

也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，例如：

public static <K,V> V getValue(K key){ return map.get(key);}

 

泛型方法的练习题

 

编写一个泛型方法，自动将Object类型的对象转换成其他类型。

定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。

采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。

在这种情况下，前面的通配符方案要比范型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用范型方法。

定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。

定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。

 

类型参数的类型推断

 

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

 swap(new String[3],3,4) ? static <E>void swap(E[] a, int i, int j)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

 add(3,5) ? static <T> T add(T a, T b)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

 fill(new Integer[3],3.5f) ? static <T>void fill(T[] a, T v)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

 intx =(3,3.5f) ? static <T> T add(T a, T b)

参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

 copy(new Integer[5],new String[5]) ? static<T> void copy(T[] a,T[] b);

 copy(new Vector<String>(), newInteger[5]) ? static <T> void copy(Collection<T> a , T[] b);

 

定义泛型类型

 

如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

 public class GenericDao<T> {

 private T field1;

 public void save(T obj){}

 public T getById(int id){}

 }

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;

new genericDao<String>();

注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？

 

泛型的继承

 

继承时，对泛型父类的类型参数不实例化

代码…

继承时，对泛型父类的类型参数实例化

代码…

 

 

通过反射获得泛型的参数化类型

 

示例代码：

 Class GenericalReflection {

   privateVector<Date> dates = new Vector<Date>();

   publicvoid setDates(Vector<Date> dates) {

   this.dates= dates;

   }

   publicstatic void main(String[] args) {

   MethodmethodApply =GenericalReflection.class.getDeclaredMethod("applyGeneric",Vector.class);

   ParameterizedTypepType = (ParameterizedType)

   (methodApply.getGenericParameterTypes())[0];

   System.out.println("setDates("

   +((Class) pType.getRawType()).getName() + "<"

   +((Class) (pType.getActualTypeArguments()[0])).getName()

   +">)" );

   }

 }

 

泛型DAO的应用：

public abstract class DaoBaseImpl<T>implements DaoBase<T> {

 protected Class<T> clazz;

 public DaoBaseImpl() {

 Type type = this.getClass().getGenericSuperclass();

 ParameterizedType pt = (ParameterizedType) type;

 this.clazz = (Class) pt.getActualTypeArguments()[0];

 System.out.println("clazz = " + this.clazz);

 }

 }

public class ArticleDaoImpl extendsDaoBaseImpl<Article> implements ArticleDao {

 }

 

示例：

 

Java代码 

package cn.itcast.day2;

 

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import java.util.Vector;

 

import cn.itcast.day1.ReflectPoint;

 

public class GenericTest {

 

/**

* @param args

*/

public static void main(String[]args) throws Exception {

// TODO Auto-generated method stub

ArrayList collection1 = new ArrayList();

collection1.add(1);

collection1.add(1L);

collection1.add("abc");

//int i = (Integer)collection1.get(1);

 

ArrayList<String> collection2 = new ArrayList<String>();

//collection2.add(1);

//collection2.add(1L);

collection2.add("abc");

String element = collection2.get(0);

 

//new String(newStringBuffer("abc"));

Constructor<String> constructor1 =String.class.getConstructor(StringBuffer.class);

String str2 =constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));

System.out.println(str2.charAt(2));

 

ArrayList<Integer> collection3 = new ArrayList<Integer>();

System.out.println(collection3.getClass()== collection2.getClass());

//collection3.add("abc");

collection3.getClass().getMethod("add",Object.class).invoke(collection3, "abc");

System.out.println(collection3.get(0));

 

printCollection(collection3);

 

//Class<Number> x =String.class.asSubclass(Number.class);

Class<?> y;

Class<String> x;//Class.forName("java.lang.String");

 

HashMap<String,Integer> maps = new HashMap<String,Integer>();

maps.put("zxx", 28);

maps.put("lhm", 35);

maps.put("flx", 33);

 

Set<Map.Entry<String,Integer>>entrySet = maps.entrySet();

for(Map.Entry<String, Integer> entry: entrySet){

System.out.println(entry.getKey() + ":" +entry.getValue());

}

 

add(3,5);

Number x1 = add(3.5,3);

Object x2 = add(3,"abc");

 

swap(new String[]{"abc","xyz","itcast"},1,2);

//swap(new int[]{1,3,5,4,5},3,4);

 

Object obj = "abc";

String x3 = autoConvert(obj);

 

copy1(new Vector<String>(),new String[10]);

copy2(new Date[10],new String[10]);

//copy1(new Vector<Date>(),new String[10]);

 

GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();

dao.add(new ReflectPoint(3,3));

//String s = dao.findById(1);

 

//Vector<Date> v1 = newVector<Date>();

Method applyMethod =GenericTest.class.getMethod("applyVector", Vector.class);

Type[] types =applyMethod.getGenericParameterTypes();

ParameterizedType pType =(ParameterizedType)types[0];

System.out.println(pType.getRawType());

System.out.println(pType.getActualTypeArguments()[0]);

}

 

public static void applyVector(Vector<Date>v1){

 

}

 

 

private static <T> void fillArray(T[]a,T obj){

for(int i=0;i<a.length;i++){

a[i] = obj;

}

}

private static <T> TautoConvert(Object obj){

return (T)obj;

}

private static <T> void swap(T[]a,int i,int j){

T tmp = a[i];

a[i] = a[j];

a[j] = tmp;

}

 

private static <T> T add(Tx,T y){

return null;

}

 

public static void printCollection(Collection<?>collection){

//collection.add(1);

System.out.println(collection.size());

for(Object obj : collection){

System.out.println(obj);

}

}

 

public static <T> void printCollection2(Collection<T>collection){

//collection.add(1);

System.out.println(collection.size());

for(Object obj : collection){

System.out.println(obj);

}

 

}

 

 

public static <T> void copy1(Collection<T>dest,T[] src){

 

}

 

public static <T> void copy2(T[]dest,T[] src){

 

}

}

Java代码 

package cn.itcast.day2;

 

import java.util.Set;

 

//dao data access object--->crud

public class GenericDao<E>{

public void add(E x){

 

}

 

public E findById(int id){

return null;

}

 

public void delete(E obj){

 

}

 

public void delete(int id){

 

}

 

public void update(E obj){

 

}

 

public static <E> void update2(Eobj){

 

}

 

public E findByUserName(String name){

return null;

}

public Set<E>findByConditions(String where){

return null;

}

}