黑马程序员------java中的泛型、增强for循环、可变参数、静态导入、自动拆装箱、枚举

android培训、java培训、

泛型  Generic
1,什么时候定义泛型类：当类中要操作的引用数据类型不确定的时候。
  泛型类的定义方法：
  class Tool<T>{
    private T t;
    public void setObject(T t){
      this.t = t;
    }
    public T getObject(){
      return t;
    }
  }
2,泛型方法的定义方法：
  泛型定义在返回类型之前。
  class Tool{
    public <T> T show(T t){
      return t;
    }
    public <E> void print(E e){
      System.out.println(e);
    }
  }
3,静态方法的泛型：
  静态方法不可以访问类上定义的泛型，因为静态方法是随着类的加载而加载的，而类上的泛型须要new对象时才定义。
  如果静态方法需要使用泛型，可以将泛型定义在方法上。定义方法如下：
  public static <T> void add(int a,int b){
    System.out.println(a+b);
  }
4,泛型定义在接口上：
  定义方法如下：
  interface inter<T>{
    void show(T t);
  }
  public class InterImplement implements inter<String>{
    pulic void show(String str){
      System.out.println(str);
    }
  }
  public class InterImplement<T> implements inter<T>{
    public void show(T t){
      System.out.println(t);
    }
  }
5,泛型中的站位符用法：
  public static void printA(ArrayList<?> al){
    Iterator<?> it = al.iterator();
    while(it.hasNext()){
      System.out.println(it.next());
    }
  }
  public static void printA(ArrayList<? extends E> al){  //E和它的子类。
    Iterator<? extends E> it = al.iterator();
    while(it.hasNext()){
      System.out.println(it.next());
    }
  }
  public static void printA(ArrayList<? super E> al){  //E和它的父类。
    Iterator<? super E> it = al.iterator();
    while(it.hasNext()){
      System.out.println(it.next());
    }
  }
  
增强for循环：
  在jdk5以前，遍历数组或集合中的元素需要先获取数组的长度或集合的迭代器，比较麻烦，所以jdk5
  定义了一个新的语法，增强for循环，增强for循环只能用于数组和实现Iterator接口的集合类中。
  格式：
  for(数据类型 变量名 ：被遍历的集合或数组){
  
  }
  例如：
  int[] arr = {1,2,3,4,5};
  for(int x : arr){
   System.out.println(x);
  }
  List<Integer> list = ArrayList<Integer>();
  list.add(1);
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  for(Integer i : list){
   System.out.println(i);
  }
  Map<Integer,String> map = new LinkedHashMap<Integer,String>();
  map.put(1,"aaa");
  map.put(2,"bbb");
  map.put(3,"ccc");
  map.put(4,"ddd");
  map.put(5,"eee");
  for(Integer key : map.keySet()){
    String value = map.get(key);
    System.out.println(key+"="+value);
  }
  for(Map.Entry<Integer,String> entry : map.entrySet()){
    Integer key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+"="+value);
  }
  注意：对集合进行遍历的时候只能获取元素不能改变元素。
        与传统for循环的区别：增强for循环必须要有被遍历的目标。
        遍历数组时建议使用传统for，因为传统for可以利用角标对数组进行操作。  
       
可变参数
用法如下：public static void show(int...arr){  //其实就是数组的简写形式。
            System.out.println(arr); 
         }
         public static void show(String，int...arr){  //不一样的类型写前面，后面的可以用可变参数形式表示。
            System.out.println(arr); 
         }
         例如：
         public int sum(int...nums){  //可以传进随便几个参数。
           int sum = 0;
           for(int i : nums){
             sum+=i;
           }
           return sum;
         }
         public void test(String str,int...nums){
           int sum = 0;
           for(int i : nums)
             sum+=i ;
           System.out.println(str+":"+sum);
         }
        
         String[] arr = {"aaa","bbb","ccc","ddd","dbc","add"};
         List list1 = Arrays.asList(arr);
         LIst list2 = Arrays.asList("aaa","bbb","ccc","ddd","dbc","add");
         //list1和list2的打印结果是一样的，说明可变参数可以看做一个数组来用。
         int nums = {1,2,3,4,5};
         List list3 = Arrays.asList(nums);
         //list3打印的结果不是1,2,3,4,5，原因是asList接收的是对象，所以将int改为Integer即可。
        
静态导入
用法如下：import static java.util.Arrays.*; 
          //导入某个类下的所有静态方法。
          //导入后，用到Arrays下的静态方法时，可以直接使用该方法而不用Array.。  
         
自动拆装箱：
   自动装箱是指开发人员可以一个基本数据类型直接赋给一个包装类。
     例如：Integer i = 1; 等同于 Integer i = new Interger(1);
   自动拆箱是指开发人员可以把一个对象直接赋给一个基本数据类型。 
     例如：int j = i;  //把对象直接赋给基本类型。
     
枚举：枚举是一个特殊类型的java类，枚举中的每一个值代表一个类对象，枚举的构造函数须是private，
   枚举限定应用者在调用方法时只能应用指定的值，jdk5以前，会定义一个类，将其构造函数私有，并
   定义一些固定的值，用static final修饰，以达到让应用者只能使用固定值的目的。jdk5定义了
   新特性，枚举，用关键字enum定义一个类即可。
   例如
   enum Grade{
     A("100-90")，B("90-80")，C("80-70")，D("70-60")，E("60-0");
     private String value;
     privete Grade(String value){
       this.value = value ;
     }
     public String getValue(){
       return this.value;
     }
   }
   public static void print(Grade g){
     System.out.println(g.getValue());
   }
   print(Grade.A);  //返回的是100-90 。
   
   带抽象方法的枚举：
   enum Grade(
     
     A("100-90"){
       public String getLocalValue(){
         return "优";
       }
     }，B("90-80"){
       public String getLocalValue(){
         return "良";
       }
     }，C("80-70"){
       public String getLocalValue(){
         return "及格";
       }
     }，D("70-60"){
       public String getLocalValue(){
         return "差";
       }
     }，E("60-0"){
       public String getLocalValue(){
         return "不及格";
       }
     };
     private String value;
     private Grade(String value){  //构造每一个枚举对象时需要传入一个String类型的参数value。
       this.value =value;
     }
     public abstract String getLocalValue();   //抽象方法每个枚举实例都需要实现此方法。
   )
   public static String getGrade(Grade g){
     return g.getLocalValue();   
   }
   getGrade(Grade.C); //返回值为"及格"。
   
   枚举中的常见方法：以Grade枚举为例。
   Grade.C.name(); //获取此枚举的名称。
   Grade.A.ordinal(); //获取此枚举的角标位置。
   String str = "C";
   Grade g = Grade.valueOf(str);  //将一个字符串转成枚举值，如果此字符串不是枚举，则抛出异常。
   Grade[] gs = Grade.values(); //返回此枚举中的所有值。