黑马程序员——20Java高新技术2

------------ android培训 、 java培训 、期待与您交流！------------  

 1，javaBean的主要应用 ：如果要在两个模块之间传递多个信息，可以将这些信息封装到一个 JavaBean 中，这种 JavaBean 的实例对象通常称之为值对象（ Value Object  ，简称：VO）。
        将高新技术1中的ReflectPoint.java类作为javaBean，其中的属性x，y需要相应的set，get方法。
        快捷键Ait+Shift+S-->r，自动生成get和set方法 。
        //用内省的方式操作javaBean中的属性。

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 {

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

                ReflectPoint pt1 = new ReflectPoint(3, 5);

                String propertyName = "x";

                //原来的方法"x"-->"X"-->"getX"-->MethodGetX这种方式比较复杂，java已经帮我们封装好了类，直接拿过来用就O啦，IntroSpector和PropertyDescriptor。
 
                //调用自定义的方法，读取出x属性的值。 

                Object retVal = getProperty(pt1, propertyName);

                System.out.println(retVal);
 

                //调用自定义的方法，写入x属性的值。

                Object value = 7;

                setProperty(pt1, propertyName, value);

                System.out.println(pt1.getX());
                
                 // 内省—beanutils工具包， Sun公司的内省API过于繁琐，所以Apache组织结合很多实际开发中的应用场景开发了一套简单、易用的API操作Bean的属性——Beanutils 。

                Beanutils工具包的常用类： BeanUtils 

                                                            PropertyUtils 

                                                            ConvertUtils.regsiter(Converter convert, Class clazz)
                下载beanutils的jar包，复制到工程下Lib文件夹内，右键-->Build Path-->Add to Build Path即可。
                BeanUtils用到了logging日志jar包，同样的方式添加到工程中来。

                BeanUtils.setProperty(pt1, propertyName, "90");    
                //注意：此处设置的新值为字符串。此方法也 返回String类型。
                好处：1）因为在web开发中，我们通过浏览器填写的数字，传给服务器的是一个字符串。自己写程序的话就需要把字符串转换为整数，再把整数设置进去。BeanUtils替我们完成了这个动作。返回同理。

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

                好处：2） 支持属性的级联操作。如果自己做那就比较复杂了。

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

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

                好处：3）BeanUtils中提供了 Map与javaBean可以相互转化的方法。

                Map map = {name : "zhangsan",age :35};      //JDK1.7新特性，对Map直接复制。不用一堆put方法了。爽！

                BeanUtils.setProperty(map, "name", "lisi");
                //注意：PropertyUtils以属性本身的类型进行操作， BeanUtils是以String的形式对javaBean进行操作。如果不想进行类型转化或者转的过程中出错，我们就使用PropertyUtils。

                PropertyUtils.setProperty(pt1, propertyName,  8);

                System.out.println(PropertyUtils.getProperty(pt1, propertyName).getClass().getName());     //返回Integer类型

        }

         //自定义方法，写入x属性的值。

        private static void setProperty(Object obj, String propertyName,

                        Object value) throws IntrospectionException, IllegalAccessException, InvocationTargetException {

                // 获取PropertyDescriptor对象。

                PropertyDescriptor pd = new PropertyDescriptor(propertyName, obj.getClass());
                //反射SetX方法。 

                Method methodSetX = pd.getWriteMethod();

                methodSetX.invoke(obj,value);

        }

         //自定义方法，获取x属性的值。

        private static Object getProperty(Object obj, String propertyName)

                        throws IntrospectionException, IllegalAccessException, InvocationTargetException {

                //第一种方式： PropertyDescriptor 。
                //获取  PropertyDescriptor  对象。

                PropertyDescriptor pd = new PropertyDescriptor(propertyName, obj.getClass());
                //反射GetX方法。

                Method methodGetX = pd.getReadMethod();

                Object retVal = methodGetX.invoke(obj);
 

                //第二种方式：IntroSpector。
                //调用IntroSpector的静态方法得到BeanInfo子类对象 

                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                //通过BeanInfo得到 PropertyDescriptor  对象数组。

                PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
                //定义一个外部变量用来接收返回值。 

                Object retVal = null;
                //遍历对象数组 

                for (PropertyDescriptor pd : pds) {
                        //判断所需要的属性。 

                        if(pd.getName().equals(propertyName)){
                                //利用属性得到对应方法的反射，再利用得到的 方法反射 得到该对象的属性值。

                                retVal=pd.getReadMethod().invoke(obj);

                                break;

                        }

                }

                return retVal;

        }

}

 
2， 注解 Annotation 。JDK1.5新特性。

          EJB (EnterpriseJavaBean)， JPA（Java Persistence API），Spring，Hibernate，Struts2。都是基于注解的。

         JDK为我们提供了三个基本注解：Deprecated，Override，SupressWarnings。

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

1）先自定义一个注解类。

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import com.itheima.day1.EnumTest;

一个注解的生命周期有三个阶段：

               RetentionPolicy.SOURCE---> RetentionPolicy.CLASS(默认)---> RetentionPolicy.RUNTIME

@Retention(RetentionPolicy.RUNTIME)       //元注解

@Target({ElementType.METHOD,ElementType.TYPE})      //元注解，TYPE接口JDK1.5新特性。

public @interface ItheimaAnnotation {

        String color() default "blue";      //为color属性指定默认值。

        String value();      //此方法非常特殊，当调用时只须给此属性赋值时，可省略value=。

        // 数组类型的属性。

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

        //枚举类型的属性。

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

        //注解类型的属性。

        MetaAnnotation annotationAttr()default @MetaAnnotation("hi,I am annotationAttr");

        //Class类型的属性

        Class clazz();

}

2）应用了注解类的类。

import java.util.Arrays;

//注解加在类上。

@ItheimaAnnotation(clazz=String.class,annotationAttr=@MetaAnnotation("Hi,I am new annotationAttr"),color="red",value="abc",arrayAttr=/*{*/1/*,2,3}*/)      //数组属性是有一个值，不用写大括号。

public class AnnotationTest {

        // 注解，向编译器传递信息

        @SuppressWarnings("deprecation")      //禁止警告，JDK为我们提供的。 一个注解就是一个类。用到注解就相当于一个实例对象。

        @ItheimaAnnotation("efg")

        3）对应用了“注解类的类”进行反射操作的类，主函数写在哪个类中从思想上来说无所谓。

        public static void main(String[] args) {

                System.runFinalizersOnExit(true);

                //判断指定类型的注解是否存于该元素上。

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

                       //利用反射得到注解。

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

                         //测试打印各注解

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

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

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

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

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

              }

        }

      @Deprecated       //标识该方法为已过时，不建议使用。

       public static void hiHeima() {

              System.out.println("嗨，黑马");

       }

}

//定义一个注解类，在上述定义的注解类中把此注解类作为它的一个注解类型的属性。

public @interface MetaAnnotation {

       String value();

}

查阅langspec，注解类属性的类型有：原子类型，String，Class，any invocation of Class，枚举，注解，以上类型的数组。

               3，泛型Generic。JDK1.5新特性。

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

java 中的泛型类型（或者泛型）类似于 c++ 中的模板，但是这种相似性仅限于表面， java 语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦出（ erasure ）（编译器使用泛型类型信息保证类型安全，然后再生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为 java 厂商升级器 JVM 造成难以逾越的障碍，所以， java 的泛型采用了可以完全在编译器中实现的擦出方法。 

//导入下面程序需要的各种包

import java.lang.reflect.*;

import java.util.*;

import com.itheima.day1.ReflectPoint;

public class GenericTest {

        public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {

               ArrayList collection1 = new ArrayList();

               collection1.add(1);

               collection1.add(1L);

               collection1.add("abc");

               int i = (Integer)collection1.get(1);    //返回Object，强转Integer。编译通过，运行时报错。因为取出是一个long类型。

//集合中使用泛型

                ArrayList collection2 = new ArrayList();

//collection2.add(1);    // 编译报错

//collection2.add(1L);

               collection2.add("abc");

               //ArrayList collection5=collection2;

               //System.out.println(collection5);

               //System.out.println(collection5.get(1));

               String element = collection2.get(0);       //取出时不需要对类型进行强转

//反射中使用泛型

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

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

                String str2=constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));   //此处不需要强转。

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

                 //泛型只存在于源码中，编译器检查完会去掉泛型标识。称为“去类型化”。

               ArrayList collection3 = new ArrayList();

               System.out.println(collection2.getClass() == collection3.getClass());    //true，内存中只有一份字节码

              //通过反射突破参数化的类型的实际参数的限制

              collection2.getClass().getMethod("add", Object.class).invoke(collection2, 8);

               System.out.println(collection2.size()+"::::"+collection2.contains(8));

               System.out.println(collection2);

                printCollection(collection2);

               Class y=null;

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

               //y=x;        //错误，相当于Class y=Class x;参数化类型没有继承关系

               x=y;

//写一个使用泛型的案例。

              HashMap maps=new HashMap();

              maps .put("age1", 24);

              maps .put("age2", 23);

              maps .put("age3", 27);

Set> entrySet=maps.entrySet();   //还有一种方法使用Set= maps  .keySet();

              for(Map.Entry entry:entrySet){

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

               }

              //类型推断，取交集，最小公倍数。

             Integer i = add(3,7);

             Number num = add(3,7.2);

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

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

             //swap(new int[]{1,46,2,8,3},1,2);  报错，泛型的实际参数只能是引用类型，不能是基本类型。 int[]本来就是对象类型，元素int无法自动装箱。

//调用自定义的方法，自动类型转化。

            Object obj = "abc";

            String str = autoConvert(obj);

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

            //类型推断，参数求交集。最小公倍数Object

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

            //类型推断，参数类型传播性。Vector已经确定参数T的类型。

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

             //使用自定义的泛型类型

            GenericDao dao = new GenericDao();

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

            ReflectPoint s = dao.findById(1);      //添加对象，查询出来也是对象。

          ================ （高难度，以后还要 结合框架再深入理解 ） ================

            //用反射的方式来获取泛型的参数化类型。

            // Vector v1 = new Vector();

            // v1.getClass(). 由于去类型化，这种操作无法实现

            //查阅Hibernate源码，得到如下解决方案：

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

             //反射Method提供了方法来获取泛型参数类型

            Type[] types = applyMethod.getGenericParameterTypes();

            ParameterizedType pType = (ParameterizedType) types[0];

            System.out.println(pType);

            //得到原始的参数类型，即class java.util.Vector

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

             //得到实际的参数类型，即class java.util.Date

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

             注意： 很多框架可以自动生成Date对象然后存入集合中，就是用上述方式获取参数类型，然后把对象转为Date存入。

        }

          //定义一个方法，把对象传进去，因为方法的反射可以获取到参数的泛型类型。

         public static void applyVector(Vector v1){

         }

         //将任意类型数组中的所有元素填充为相应类型的某个对象。

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

                 for(int i=0;i

                        a[i]=obj;

                  }

         }

         //将Object对象转化为任意类型

         private static T autoConvert(Object obj){

                   return (T)obj;

          }

         //交换数组中两个元素的位置。

        private static void swap(T[] arr,int x, int y){

                 T tmp = arr[x];

                 arr[x] = arr[y];

                 arr[y] = tmp;

        }

        private static T add(T x,T y) {

//return x+y;      //编译报错，并不是所有的类型都支持+号运算，这点没有C++强大，C++可以重载运算符。;

                  return y;

         }

         //定义方法，打印任意类型的集合，两种方法：

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

         public static void printCollection(Collection collection){

                //collection.add("ccc");      //不能调用与 参数 类型 有关的方法。

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

                 System.out.println(collection);

          }

方法二： 通配符的方案比泛型类型更有效

          public static void printCollection2(Collection collection,T obj){

                 //collection.add("ccc");

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

                 System.out.println(collection);

                  collection.add(obj);       //可以添加相应元素，而通配符做不到。

            }

         //把一个类型的数组中的元素复制到相应类型的集合中。

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

         }

        //把一个类型的数组中的元素复制到相应类型的数组中。

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

        }

}

           4， ArrayList 类定义和ArrayList类引用中涉及如下术语：

                          整个 ArrayList 称为泛型类型。

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

                          整个 ArrayList 称为参数化的类型。

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

                          ArrayList 中的<>念着typeof 

                          ArrayList 称为原始类型。                         

             参数化类型与原始类型的可以互相兼容。

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

                          Vectorv=new Vector