3.4 JAVA的枚举和泛型

参考链接：https://blog.csdn.net/qq_27093465/article/details/52180865

3.4 JAVA的枚举和泛型

一、枚举Enumeration（定义好的常量）

1.1使用场景

1.在JDK1.5 之前，我们定义常量都是： public static final.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 常量固定范围

public enum Color {  
  RED, GREEN, BLANK, YELLOW  
} 

2.JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

enum Signal {  
    GREEN, YELLOW, RED  
}  
public class TrafficLight {  
    Signal color = Signal.RED;  
    public void change() {  
        switch (color) {  
        case RED:  
            color = Signal.GREEN;  
            break;  
        case YELLOW:  
            color = Signal.RED;  
            break;  
        case GREEN:  
            color = Signal.YELLOW;  
            break;  
        }  
    }  
} 

3.添加新方法，和覆盖方法

public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
    // get set 方法  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getIndex() {  
        return index;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
} 

    //覆盖方法  
    @Override  
    public String toString() {  
        return this.index+"_"+this.name;  
    } 

4.使用多重枚举（用接口组织枚举）

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  

5.关于枚举集合

关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的。

关于枚举的实现细节和原理请参考：参考资料：《ThinkingInJava》第四版：http://softbeta.iteye.com/blog/1185573

概念：位集合（BitSet）
向量（Vector）
栈（Stack）先进后出
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）

3.泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

 ArrayList<APHero> heros = new ArrayList<APHero>();

ADHero（物理攻击英雄） APHero（魔法攻击英雄）都是Hero的子类
使用泛型的好处：泛型的用法是在容器后面添加<Type>
Type可以是类，抽象类，接口
泛型表示这种容器，只能存放APHero，ADHero就放不进去了。

1.规定相应的类型（向下转型、基本类型）

假设容器的泛型是Hero,那么Hero的子类APHero,ADHero都可以放进去
和Hero无关的类型Item还是放不进去

1.ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型

2.ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型

如果希望只取出，不插入，就使用? extends Hero
如果希望只插入，不取出，就使用? super Hero
如果希望，又能插入，又能取出，就不要用通配符？
子类泛型不能转换为父类泛型
父类泛型不可以转为子类泛型

2."extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d

",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f

",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s
","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

3.泛型类:

public class Box<T> {
   
  private T t; 
  public void add(T t) {
    this.t = t;
  }
  public T get() {
    return t;
  }
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("教程"));
 
    System.out.printf("整型值为 :%d

", integerBox.get());
    System.out.printf("字符串为 :%s
", stringBox.get());
  }
}

4.类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。

import java.util.*;
 
public class GenericTest {  
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}