泛型和枚举
泛型
jdk1.5版本之后出现的新特性，用于解决安全问题，是一个安全机制.
泛型格式；通过<>定义操作的引用数据类型，在java提供的对象时，什么时候写泛型呢？
通常在集合框架里面很常见，只要有<>就定义泛型。
练习：通过我们的TreeSet练习一下泛型，或者通过ArrayList练习一下泛型。
泛型类
class Worker{
}
/*class Tool{
private Worker w;
public void setWorker(Worker w){
this.w = w;
}
public Worker getWorker(){
return w;
}
}
*/
//泛型前做法
/*class Tool{
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
public Object getObject(){
return obj;
}
}
*/
// 泛型后做法：
class Uitl<T t>{//一个类对应一个工具类 比较麻烦。所以我们不这么定义
private T t;
public void setObject(T t){// 此处可以随便写标识符号，T是type的简称
this.t = t;
}
public Object getObject(){
return t;
}
}
class Demo{
public static void main(String[] agrs){
Tool t = new Tool();
t.setWorker(new Worker);
//Worker w = (Worker)t.getWorker();
//使用泛型后不用强转
Worker w = t.getWorker();
}
}
什么时候使用泛型类？
当类中腰操作的引用数据类型不确定的时候，早起定义Object来完成扩展，现在定义泛型类来扩展。
泛型类定义的泛型，在整个类中有效，如果被方法是用，那么泛型类对象的明确要操作的具体类型。所有方法类型不确定，那么可以将泛型定义在方法上。
泛型方法
public <T> void show(T t){
System.out.println("show方法"+t);
}
public <Q> void print(Q q){
System.out.println("print方法"+t);
}
注意静态泛型方法：
1、静态方法不可以访问类上定义的泛型。
2、如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
public static <T> void menthods(T t){
}
泛型接口：
import java.util.Date;
interface Show<T,U>{
void show(T t,U u);
}
class ShowTest implements Show<String,Date>{
@Override
public void show(String str,Date date) {
System.out.println(str);
System.out.println(date);
}
}
public class TestDemo {
public static void main(String[] args) {
ShowTest showTest=new ShowTest();
showTest.show("Hello",new Date());
}
}
泛型限定：
public class TestDemo {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<Person>();
list.add(new Person("张三",20));
list.add(new Person("李四",20));
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("学生1",20));
list.add(new Student("学生2",20));
}
public static void print(ArrayList<? extends Person> aa){//?称为通配符，也可以叫做占位符。不确定什么类型。? extends Person上限，Person的子类都可以 ? super Student Student的父类都可以叫做下限。
Iterator<? extends Person> it = tr.iterator();//
while(it.hasNext()){
System.out.println(it.next().getName());
}
}
}
练习：用TreeSet装入学生类型和工人类型两种类型，两种类型都要进行排序。要求只有一个比较器。
枚举
enum 的全称为enumeration,是 JDK1.5中引入的新特性，在 java.lang 包中。
语法定义：
创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。
// 枚举定义
public enum Color {//enum是计算机编程语言中的一种数据类型。枚举类型：在实际问题中，有些变量的取值被限定在一个有限的范围内。
RED, GREEN, BLANK, YELLOW
}
// 枚举使用
public static void main(String[] args) {
System.out.println( isRed( Color.BLANK ) ) ; //结果： false
System.out.println( isRed( Color.RED ) ) ; //结果： true
}
// 枚举值的使用
static boolean isRed( Color color ){
if ( Color.RED.equals( color )) {
return true ;
}
return false ;
}
===================================================
public enum Color {
RED, GREEN, BLANK, YELLOW
}
public static void main(String[] args) {
showColor(Color.RED);
}
static void showColor(Color color) {
switch (color) {
case BLANK:
System.out.println(color);
break;
case RED:
System.out.println(color);
break;
default:
System.out.println(color);
break;
}
}
===================================================
//自定义函数
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 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;
}
}
public static void main(String[] args) {
// 输出某一枚举的值
System.out.println(Color.RED.getName());
System.out.println(Color.RED.getIndex());
// 遍历所有的枚举
for (Color color : Color.values()) {
System.out.println(color + " name: " + color.getName() + " index: " + color.getIndex());
}
}
EnumSet，EnumMap 的应用
public class Test {
public static void main(String[] args) {
// EnumSet的使用
EnumSet<EnumTest> weekSet = EnumSet.allOf(EnumTest.class);
for (EnumTest day : weekSet) {
System.out.println(day);
}
// EnumMap的使用
EnumMap<EnumTest, String> weekMap = new EnumMap(EnumTest.class);
weekMap.put(EnumTest.MON, "星期一");
weekMap.put(EnumTest.TUE, "星期二");
// ... ...
for (Iterator<Entry<EnumTest, String>> iter = weekMap.entrySet().iterator(); iter.hasNext();) {
Entry<EnumTest, String> entry = iter.next();
System.out.println(entry.getKey().name() + ":" + entry.getValue());
}
总结：
enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。所以，实际上 enum 就是一个 class，只不过 java 编译器帮我们做了语法的解析和编译而已。
简单讲： 可以把 enum 看成是一个普通的 class，它们都可以定义一些属性和方法，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）。