实训--day01枚举，泛型

实训第一天记录：枚举，泛型。

暑假实训第一天：上午枚举，下午泛型。

1：枚举：实例对象固定而且有限的对象可以成为枚举类，用关键字enum。

     今天一天课上下来，觉得枚举跟一般的类对象差不多，只是枚举对象的类型是enum类型，一般类对象的类型是class对象。所以在获取枚举对象的形势上有所不同。

     class对象获得对象可以通过new的形势，而enum对象的获取有两个方法：第一个是 枚举.variable获取对象，这个方法返回的是单个枚举对象；第二个方法是 枚举.values。这         个方法可以获取所有的枚举对象，返回的是一个枚举类型的数组，如果要获得每个枚举对象，就使用高级for循环来获取。

     获取到枚举对象之后，对对象的操作方式就和一般Java类差不多了。可以像一般的Java类一样，设置属性，进行数据的逻辑处理。只是在枚举类中不能有main方法。

放一个课堂上的联系：输入相应的数字，输出对应的星期数。这里我没有用switch case语句（jdk几以后可以使用String类型的变量，具体不清楚，百度答案感觉不准确），而是直接给每个星期一个id，如果输入的id和星期的id相同，则输出星期。

枚举类：

[java]  view plain  copy

 print ?

1. public enum Enum2  
2. {  
3.     MON(1,"星期一"),TUE(2,"星期二"),WENDS(3,"星期三"),THURS(4,"星期四"),FRI(5,"星期五"),SATU(6,"星期六"),SUN(7,"星期天");  
4.     private int id;  
5.     private String name;  
6.     public String getName() {  
7.         return name;  
8.     }  
9.     public void setName(String name) {  
10.         this.name = name;  
11.     }  
12.     private Enum2(int id,String name)  
13.     {  
14.         this.name=name;  
15.         this.id=id;  
16.     }  
17.     public int getId() {  
18.         return id;  
19.     }  
20.     public void setId(int id) {  
21.         this.id = id;  
22.     }  
23.       
24. }  

测试运行类：

[java]  view plain  copy

 print ?

1. import java.util.Scanner;  
2.   
3. public class Test2 {  
4.   
5.     public static void main(String[] args)   
6.     {  
7.         // TODO Auto-generated method stub  
8.         Enum2 [] e2=Enum2.values();  
9.         Scanner in=new Scanner(System.in);  
10.         int input=in.nextInt();  
11.         for(Enum2 e:e2)  
12.         {  
13.             int id=e.getId();  
14.             if(input==id)  
15.             {  
16.                 System.out.println(e.getName());  
17.             }  
18.         }  
19.     }  
20.   
21. }  

2：泛型：即参数化类型，是jdk1.5以后出现的新特性，增加了程序的安全性。

举个栗子：在没有使用泛型之前，集合可以存放各种类型的参数，加入一个集合存放了不同类型的参数，使用集合的时候要想不报错，只有靠程序员的直觉，因为这个错误在编译时是不会报错的，只会在运行时抛出运行时异常;ClassCastException等。但是加入泛型之后，就强制规定每个集合只能装那个类型的参数，就不会出现类型转换异常了。

泛型的定义一般有三种：定义在类上，定义在方法上，定义在接口上。

定义在类上，for example：

泛型类：在定义的类上限定了，类中的方法只能接受类上面定义类型的参数

[java]  view plain  copy

 print ?

1. public class Demo1 <T>  
2. {  
3.     private T name;  
4.   
5.     public T getName() {  
6.         return name;  
7.     }  
8.     public void setName(T name) {  
9.         this.name = name;  
10.     }  
11.       
12. }  

测试类：

[java]  view plain  copy

 print ?

1. public class Demo  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.                 Demo1<Integer> d=new Demo1<Integer>();  
6.         d.setName(1);  
7.         System.out.println(d.getName());  
8.         }  
9. }  

限定Integer之后，往里面设置值的时候，就只能放置integer类型的，如果不是integer类型的，在编写代码的时候就会直接报错

定义在方法上：借用上课的一道题，输入不同类型的数据，也能进行相加，但是输入的数据只能是 int、long、float、double类型。自己写的时候纠结很久没想出来，也是参考了网上一篇博客的。博客地址：http://blog.csdn.net/justdb/article/details/7470690。

补充一个基本数据类型转换的顺序：byte,short,char-->int-->long-->float-->double，即为了不损失精度，都是由小精度向大的精度进行转换。

[java]  view plain  copy

 print ?

1. public class Homework  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.         Scanner in=new Scanner(System.in);  
6.         int i1=in.nextInt();  
7.         int i2=in.nextInt();  
8.         System.out.println(add(i1,i2));  
9.           
10.         long l1=in.nextLong();  
11.         long l2=in.nextLong();  
12.         System.out.println(add(l1, l2));  
13.           
14.         float f1=in.nextFloat();  
15.         float f2=in.nextFloat();  
16.         System.out.println(add(f1, f2));  
17.           
18.         double d1=in.nextDouble();  
19.         double d2=in.nextDouble();  
20.         System.out.println(add(d1, d2));  
21.   
22.     }  
23.     public static <T extends Number> double add(T input1,  T input2)  
24.     {  
25.         return input1.doubleValue()+input2.doubleValue();  
26.     }  
27.   
28. }  

其实我想写成，不论是输入什么类型的两个数，可以是不同类型的两个数，都可以进行相加，但是我找了一下scanner的方法，好像每个键盘录入都是带类型的，所以最后也没有写出来。如果两两结合输入再判断，感觉代码很烦，我又没想到优化的方式，就没有写。

最后一个，定义在接口上：定义在接口上的泛型一般都是API中定义的，这个只要看到的时候知道就好。