黑马程序员——基础加强第二天

一、内省--了解JavaBean（java.beans ）

概述：

1、IntroSpector：即内省，是对内部进行检查，了解更多的底层细节。

2、内省的作用：主要针对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！

好处如下：

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

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

开场：内省对应的英文单词为IntroSpector，它主要用于对JavaBean进行操作，JavaBean是一种特殊的Java类，其中的某些方法符合某种命名规则，如果一个Java类中的一些方法符合某种命名规则，则可以把它当作JavaBean来使用。请问：一个JavaBean可以当做普通Java类来使用吗？一个普通Java类可以当做JavaBean来使用吗？

java.beans BeanDescriptor  
java.beans.Introspector
java.beans BeanInfo
java.beans.PropertyDescriptor

 package javaBean.cn.itcast;


 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 org.apache.commons.beanutils.BeanUtils;

 public class BeansTest {

     /**
      * @param args
      * @throws Exception
      */
     public static void main(String[] args) throws Exception {
         // TODO Auto-generated method stub
         Person p = new Person();
         p.setName("董方宇");

         String propertiesName = "name";
          String name = extracted(p, propertiesName);//演示了用eclipse抽取方法
          System.out.println(name);

         String propertiesAge = "age";
         int age = 23;
         SetAge(p, propertiesAge, age);

         String name1 = BeanUtils.getProperty(p, "name");//使用beanUtils工具包进行获取和设置属性（尽管这些属性是私有的，可是有方法啊，是不是很方便）
         System.out.println(BeanUtils.getProperty(p, "name").getClass().getName());
         System.out.println(name1);

         BeanUtils.setProperty(p, "age", 19);
         System.out.println(p.getAge());

         /*打印结果
          * 董方宇
            23
            java.lang.String
                   董方宇
           19*/

     }

     private static void SetAge(Person p, String propertiesAge, int age)
             throws IntrospectionException, IllegalAccessException,
             InvocationTargetException {
         PropertyDescriptor bp1 = new PropertyDescriptor(propertiesAge, p.getClass());
         Method methodSetAge = bp1.getWriteMethod();
         methodSetAge.invoke(p,age);
         System.out.println(p.getAge());



     }

     private static String  extracted(Object p, String propertiesName)
             throws IntrospectionException, IllegalAccessException,
             InvocationTargetException {
         /*PropertyDescriptor bp = new PropertyDescriptor(propertiesName, p.getClass());
         Method methodGetName = bp.getReadMethod();
         Object readVal = methodGetName.invoke(p);
         System.out.println(readVal);*/

         BeanInfo beanInfo =  Introspector.getBeanInfo(p.getClass());
         PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
         Object retVal = null;
         for(PropertyDescriptor pd : pds){
             if(pd.getName().equals(propertiesName))
             {
                 Method methodGetX = pd.getReadMethod();
                 retVal = (String)methodGetX.invoke(p);
                 break;
             }
         }
         return (String) retVal;


     }

 }

 

Beanutils工具包

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

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

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

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

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

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

用struts的迭代标签不能迭代出枚举元素的属性，而用jstl的迭代标签则可以。采用BeanUtils去获取带有抽象方法的枚举类的成员对象的属性时，会出现错误，要自己用内省加暴力反射方式才可以获取。主要原因是枚举类的抽象子类不是public类型的。

 

 部分代码：
         String name1 = BeanUtils.getProperty(p, "name");
         System.out.println(BeanUtils.getProperty(p, "name").getClass().getName());
         System.out.println(name1);

         BeanUtils.setProperty(p, "age", 19);
         System.out.println(p.getAge());

         /*打印结果
          * 董方宇
            23
            java.lang.String
                  董方宇
           19*/

二、注解（Annotation）

1、注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记。

    以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。

2、标记可以加在包，类，字段，方法，方法的参数以及局部变量上。

3、一个注解相当于一个类。

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

1)、@SuppressWarning(”deprecation”)--->压制警告

SupressWarning是告知编译器或开发工具等提示指定的编译器警告；

”deprecation”是告知具体的信息即方法已过时。

2)、@Deprecated（过时的方法，对于不再使用的方法，可能别人或别的地方有调用这个方法，不能删除完事）

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

@SuppressWarnings("deprecation") （用这个可以告诉 程序说，我知道调用的方法过时了）

3)、@Override--->提示覆盖（父类方法）

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

   像person类，覆盖父类的equals 和hashCode方法，人家接收的参数是Object，人们习惯总是传入自己的对象，造成覆盖失败，变成重载！

注解的应用结构图

演示和讲解@Target元注解

Target（告诉编译器，自定义的注解类可以用在方法还是类....），设置Target等于ElementType.METHOD，原来加在类上的注解就报错了，改为用数组方式设置{ElementType.METHOD,ElementType.TYPE}就可以了。

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

 （自定义注解）示例代码：
 @Retention(RetentionPolicy.RUNTIME)//告诉程序说，这个注解要保存到运行时期
 @Target({ElementType.METHOD,ElementType.TYPE})//告诉编译器，这个注解可以用在方法上，也可以用在类上

 public @interface MyAnnotation {
     String color() default "yellow";//默认缺省值为yellow
     String value() ;//不指定
     int [] arrayAttr() default {1,2};//默认为{1,2}
     EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;//枚举类
     MetaAnnotation annotationAttr() default @MetaAnnotation("xxx");//属性中加注解，用@。可以在对别的类加注解时，改变值
 }

 

为注解增加基本属性

（可以是八种基本数据类型，String ，数组，枚举，注解，Class）

什么是注解的属性?

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

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

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

@MyAnnotation(color="red")

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

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

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

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

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

枚举和注解都是特殊的类，不能用new 创建它们的实例对象，创建枚举的实例对象就是在其中增加元素。

在程序中如何创建出一个注解的实例对象啊？直接用@放上一个标记即可

 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);
 //获取String类上main函数上的注解

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


 @Deprecated//告诉调用者，这个方法过期了。
     public static void sayHello()
     {
         System.out.println("hello,传智播客");
     }
 }


 -----------------------------------------------------

 MetaAnnotation注解的定义：
 public @interface MetaAnnotation {
    String value();
 }

 

看java语言规范：

打开j3toc.html页面后，搜索annotation，进入9.6节，在其中的第5个Discussion部分就有属性类型的讲解说明，可以知道枚举的属性类型包括：基本数据类型，String，Class，枚举，其他注解，以及这些类型的数组。

三、泛型

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

ArrayList collection = new ArrayList();

collection.add(1);

collection.add(1L);

collection.add("abc");

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

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

ArrayList collection2 = new ArrayList();

collection2.add(1);

/*collection2.add(1L);

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

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

泛型是提供给javac编译器使用的，

利用反射穿透泛型限制 （暴力反射）

泛型能绝对保证集合中存入数据都是它限定的类型吗？先看下边的代码 

 ArrayList<Integer> collection2 = new ArrayList<Integer>();
 System.out.println(collection1.getClass()==collection2.getClass());
 collection2.add（“真暴力”）；//这句会报错
 collection2.getClass().getMethod("add", Object.class).invoke(collection2, "真暴力");
 System.out.println(collection2.get(0)); //结果却为真暴力
 已经限制集合中元素的类型为Integer，可用反射却能将String存入，为什么？ 这是因为泛型是给编译器用的，运行时就没有这些泛型信息了，这叫做“去泛型化”，所以可以通过反射，获取集合字节码加入非指定的类型。

 

了解泛型（genericity）

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

整个称为ArrayList泛型类型

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

整个ArrayList称为参数化的类型

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

ArrayList中的<>念着typeof

ArrayList称为原始类型

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

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection c = new Vector(); //可不可以，不就是编译器一句话的事吗？，为了兼容原来的代码嘛

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

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

Vector v = new Vector