编写高质量代码之读书笔记2

建议 90：

　　 @Retention：注解的保留位置　　　　　　　　　

　　　　　　@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含

　　　　　　@Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

　　　　　　@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到

　　@Target:注解的作用目标

　　　　　　　　@Target(ElementType.TYPE) //接口、类、枚举、注解

　　　　　　　　@Target(ElementType.FIELD) //字段、枚举的常量

　　　　　　　　@Target(ElementType.METHOD) //方法

　　　　　　　　@Target(ElementType.PARAMETER) //方法参数

　　　　　　　　@Target(ElementType.CONSTRUCTOR) //构造函数

　　　　　　　　@Target(ElementType.LOCAL_VARIABLE)//局部变量

　　　　　　　　@Target(ElementType.ANNOTATION_TYPE)//注解

　　　　　　　　@Target(ElementType.PACKAGE) ///包   

  @Document：说明该注解将被包含在javadoc中

　 @Inherited：说明子类可以继承父类中的该注解

建议 91:

注解与枚举结合：经典场景（访问控制设计）

建议：92:

@override

在java 1.5版本上，不能覆盖接口的方法，1.6之后可以

建议：93：

     java 泛型的类型是类型擦除的

     范型数组初始化时不能声明泛型类型

     instanceof 不允许存在泛型参数

建议：94:

     如何初始化泛型数组

     

public class Foo< T> {

    private  T  t;
    private  T[]  tArray;
    private List< T>  list =  new ArrayList< T>();


    public Foo(Class< T> tType){
        try {
            t = ( T) tType.newInstance();
            tArray = ( T[]) Array. newInstance(tType, 5);
        }  catch (InstantiationException e) {
            e.printStackTrace();
        }  catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

}

调用的时候，把T的类型传入就可以了

Foo<BaseCityInfo> f =  new Foo<BaseCityInfo>(BaseCityInfo. class);

建议 95:强制生命泛型的实际类型

像在工具类的static方法中，不能将泛型加到类上了，这是可以加到方法的前面。

public class ArrayUtils {
    public static < T> List< T> asList( T...t){
        List< T> list =  new ArrayList< T>();
        Collections. addAll(list, t);
        return list;
    }

}

当我们在使用的时候，

List<String> list1 =  new ArrayUtils(). asList( "A", "B");
List list2 = ArrayUtils. asList();
List<Number> list3 = ArrayUtils.<Number> asList( 1, 2, 3.2);
list2.add( 11);
list2.add( "dd");

String a = list1.get(0);

String b = (String) list2.get(0);  //由于这里没有做强制类型转换，所以在取时转换

Number c = list3.get( 0);

println(list1);
println(list2);
println(list3);

println l=class java.lang.String

println l=A

println l=class java.lang.String

println l=B

println l=class java.lang.Integer

println l=11

println l=class java.lang.String

println l=dd

println l=class java.lang.Integer

println l=1

println l=class java.lang.Integer

println l=2

println l=class java.lang.Double

println l=3.2

private void println(List<?  extends Object> list){
    for(Object l :list){

      System.out.println("println   l="+l.getClass());

      System.out.println( "println   l="+l);

   }

}

当然输出还可以按照下面这样写，但是这样写的话，在list2取的时候，强制转化就不能都转string了。

private < E>  void println2(List<?  extends  E> list){
    for( E l :list){
      Log. v( "XPC", "println   l="+l.getClass());
      Log. v( "XPC", "println   l="+l);
   }

}

建议 96:

泛型extends VS super

在一般的讲解中，extends说的是子类，上界，

                         super说的是父类，下界。（我想不可能这么多人一起写错，所以应该是我理解有问题，希望有人可以指出）

我的理解是这样的，无论extends还是super，泛型出来的类型都是子类，

只是extends 涉及到get，也就是读取相关，就是说只能读取，不能写入

而super涉及的事put，就是写入，当然他就不能读取了。

比较典型的是Collections.copy方法

public static < T>  void copy(List<?  super  T> dest,List<?  extends  T> src){
    for( int i= 0;i< srcSize;i++){
        dest.set(i,src.get(i));
    }

}

自我理解测试例子：

song s =  new song();
person p =  new person();
Parent pa =  new Parent();

List<? super Parent> list = new ArrayList<>();

list.add(s);   //add 只有super可以，如果是extends是编译不过的。

list.add(p);
list.add(pa);

song s1 = (song) list.get(0);

Parent s3 = (Parent) list.get(2);//super get出来的类型都是Object的，所以无论什么都要转型，

当然如果是

        List<?  extends Parent> list =  new ArrayList<>();
//        list.add(s);  add 肯定是编译不过的
//        list.add(p);
//        list.add(pa);

        song s1 = (song)list.get(0);//这个返回的类型是Parent，

        Parent s3 = list.get( 2);

建议 98 ：建议采用顺序是 List<T>，List<?>,List<Object>

建议 99:严格限定泛型类型采用多重限界

public static <T extends Staff & Passenger> void discount(){...}