JAVA高新技术学习<二>

1.JavaBean

/*
* 是一种特殊的类
* int getAge()和void setAge(int age)符合这种规则的类
* 即有get和set的就是javabean
* javabean属性名就是去掉set和get后的那个字母，如过其
* 第二个字母是小写，就把第一个字母也变小写，如果第二个是
* 大写，第一个也是大写
* 如过两个模块之间传递多个信息 ，可以把这些信息封装到一个javabean中
*/

1.1 简单的JavaBean例子

package Itcast.com;

class JavaBn
{
    private int x;
    public int y;
    public JavaBn(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }




    //右键在source里有为x,y添加javabean的快捷方式

}

1.2 利用javabean内省的方式来设置(set方法)javaBn中x的属性

package Itcast.com;


import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;



//利用javabean内省的方式来读取(get方法)javaBn中x的属性
public class JavaBeanTest
{
    public static void main(String[] args) throws Exception
    {
        JavaBn jb=new JavaBn(3,5);
        String propertyName="x";
        //PropertyDescriptor属性描述符
        //把jb类当作javabean来看，从他身上获得属性propertyName，赋予对象pd
        PropertyDescriptor pd=new PropertyDescriptor(propertyName,jb.getClass());
        //获得属性后，再用属性提取get或set方法
        Method methodGetX =pd.getReadMethod();
        //获得get方法后将其实例化，传入一个对象,以获取方法结果
        Object retVal=methodGetX.invoke(jb);
        System.out.println(retVal);

        //利用javabean内省的方式来设置(set方法)javaBn中x的属性

        Object value=7;
        setProperty(jb, pd, value);
   }
        //利用重构来抽取方法,可以把重复性的代码提取出来成为共享方法
    private static void setProperty(JavaBn jb, PropertyDescriptor pd,
            Object value) throws IllegalAccessException,
            InvocationTargetException {
        Method methodSetX =pd.getWriteMethod();
        methodSetX.invoke(jb,value);
        System.out.println(jb.getX());
    }
}

2.注解

/**
* 什么是注解？

*注解的生命周期RetentionPolicy.XXX
*默认的生命值只保留在.CLASS中，其他类调用是无效的
*.SOURCE和.RUNTIME
*@Override重载是在.SOURCE时期,他是给javac看的，在编译期，源代码阶段有用
*@SuppressWarmings给编译期用的，也是在.SOURCE时期
*@Deprecated在.RUNTIME时期，要运行了才知道，扫描二进制
*一个注解相当于一个胸牌，为区分注解，需要注解属性
*/
2.1 自定义注解

package Itcast.com;
import java.lang.annotation.*;
/*
元注解
元数据
元信息
*/
//加一个运行时效注解，即该注解在运行期间都有效，超越class阶段
@Retention(RetentionPolicy.RUNTIME)
//在方法上和类上都可以加target注解，TYPE是CLASS的父类：
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface ItcastAnnotation
{
    //注解的属性
    String color() default "blue";//设置color的缺省属性是蓝色
    String value();
    //数组类型的属性
    int[]arrayAttr() default {3,4,5};
    //枚举类型的属性
    EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED ;
    //注解类型的属性，缺省值就是他的实际对象
    MetaAnnotation annotationAttr() default @MetaAnnotation("1hm");

}

2.2注解演示

package Itcast.com;

import java.lang.annotation.Annotation;

/**
 * 什么是注解？
 */
  //如果数组中只有一个元素，则可以省略大括号
@ItcastAnnotation(annotationAttr=@MetaAnnotation("flx"),color="red",value="abc",arrayAttr=2)//带属性的注解.用的时候自定义属性值
public class AnnotationTest
{
  //"deprecation"是一个特殊的注解属性，可以省略名称等号,因为他只有这一个属性
  @SuppressWarnings("deprecation")//向编译器传递信息，不要再提示过时
  @ItcastAnnotation("xyz")//color设置了两组缺省值，所以这里这样是可以的
  public static void main(String[] args)
  {
      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());
          //显示枚举类型属性值
          System.out.println(annotation.lamp());
          //显示注解类型的属性值
          System.out.println(annotation.annotationAttr().value());
      }
  }
  @Deprecated//加了这句话后下面的方法自动过时
  public static void sayHello()
  {
      System.out.println("旧的方法，要删除");
  }
  //@Override 注解，自动判断你下面的函数是否是覆盖，用于判断自己是否写对了，与重载区分。
  /*
   * 注解类--->应用了注解类的类--->对应用了注解类的类进行反射操作的类
   *
   */
}

3.泛型

/**
* 没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储
* 进同一个集合中，使用泛型集合，可以将一个集合中的元素限定为
* 一个特定类型，集合中织女呢个存储同一个类型的对象，更安全
* 获取时，编译器也可以知道元素类型，不需要强制类型转换
* 泛型只是提供给编译器使用，以挡住非法输入，编译器在编译已经审查放进来
* 的集合时会去掉类型信息，使程序运行效率不受影响。
* 运行的时候就不知道 元素的类型了
* 因此，跳过编译后用反射方式把已加入的元素类型改掉，也是可以的
* 参数化类型不考虑类型参数的继承关系，必须一致，或者右边缺省泛型，除此外不一致就不行，传不进去
* 泛型中的通配符限定：
* 上边界：<? extends Number>仅限于Number和其子类，number是顶
* 下边界：<? super Integer>仅限于Interger和其父类，Integer是底
*/

package Itcast.com;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.net.Proxy.Type;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Vector;


//泛型
public class GenericTest
{
    public static void main(String[] args) throws Exception
    {
        //解决类型繁多，只接受一个类型
        ArrayList<String> collection1 =new ArrayList<String>();
        //collection1.add(1);
        //collection1.add(1L);//长整数
        collection1.add("abc");
        //取出来的都转为整数
        //int i= (Integer)collection1.get(1);这句编译不通过，因为返回类型不统一，无法都转为一个类型
        //String element=collection1.get(1);
        //用反射的方法 向<Integer>集合里加入字符串的 元素，骗过了泛型审查
        ArrayList<Integer> collection2 =new ArrayList<Integer>();
        collection2.getClass().getMethod("add",Object.class).invoke(collection2,"abc");
        System.out.println(collection2.get(0));

        //泛型中的通配符：？
        priColl(collection2);//利用通配符成功打印其中的各个元素

        //泛型的嵌套，用途1：用来遍历取出Map集合的元素
        HashMap<String,Integer> maps=new HashMap<String,Integer>();
        maps.put("lsk", 25);
        maps.put("ssk", 35);
        maps.put("ksk", 45);
        Set<Map.Entry<String,Integer>> entrySet=maps.entrySet();
        //对该集合进行迭代取值
        for(Map.Entry<String,Integer> entry :entrySet)
        {
            System.out.println(entry.getKey()+entry.getValue());
        }
        System.out.println(add(3,5.4));
        //交换数组第1个和第2个元素的位置
        sawp(new String[]{"abc","xyz","123"},1,2);
        GenericDao<ReflactPoint> dao = new GenericDao<ReflactPoint>();
        //dao.add(new ReflactPoint(3,3));


        /**
         * 用反射的方式得到Vector里面到底装的是什么类型数据
         */
        //Vector<Date> v1=new Vector<Date>();无法得到
        //1.根据方法名（applyVector）获得使用Vector的方法的字节码文件
        Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
        //2.通过getGenericParameterTypes()得到这个方法的参数列表中所有的泛型化了的参数类型，赋给数组types
        java.lang.reflect.Type[] types= applyMethod.getGenericParameterTypes();
        //3.只取这个元素为参数类型的数组的第一个元素（因为这里就只有一个Vector）
        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> T add(T x,T y)
    {
        /**
         * 类型推断，返回值类型是x与y类型的最大公约数
         */
        return y;
    }
    //只有引用类型才能作为泛型的实际参数，基本类型不可以

    //交换数组T第i个和第j个元素的位置
    private static <T> void sawp(T [] a,int i, int j)
    {
        T tmp =a[i];
        a[i] = a[j];
        a[j] =  tmp;
    }
     //通配符定义的变量可以指向其他任意参数化的类型
    public static void priColl(Collection<?> collection)
    {
        System.out.println(collection.size());
        for(Object obj:collection)
        {
            System.out.println(obj);
        }
    }

}