第12、13、14、15章学习

第12章 枚举

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

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

• 二、switch

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

Java代码

    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;  

            }  

        }  

    }  

• 三、向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

Java代码

    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;  

        }  

    }  

• 四、覆盖枚举的方法
  下面给出一个toString()方法覆盖的例子。
  Java代码

    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;  
        }  
        //覆盖方法  
        @Override  
        public String toString() {  
            return this.index+"_"+this.name;  
        }  
    }  

• 五、实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。
Java代码

    public interface Behaviour {  
        void print();  
        String getInfo();  
    }  
    public enum Color implements Behaviour{  
        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;  
        }  
    //接口方法  
        @Override  
        public String getInfo() {  
            return this.name;  
        }  
        //接口方法  
        @Override  
        public void print() {  
            System.out.println(this.index+":"+this.name);  
        }  
    }  

• 六、使用接口组织枚举

Java代码

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

        /**
         * 测试继承接口的枚举的使用（by 大师兄 or 大湿胸。）
         */
        private static void testImplementsInterface() {
            for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
                System.out.print(dessertEnum + "  ");
            }
            System.out.println();
            //我这地方这么写，是因为我在自己测试的时候，把这个coffee单独到一个文件去实现那个food接口，而不是在那个接口的内部。
            for (CoffeeEnum coffee : CoffeeEnum.values()) {
                System.out.print(coffee + "  ");
            }
            System.out.println();
            //搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。
            //还有就是个“多态”的功能吧，
            Food food = Food.DessertEnum.CAKE;
            System.out.println(food);
            food = CoffeeEnum.BLACK_COFFEE;
            System.out.println(food);
        }

• 七、关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

第13章 操作日期和时间

java.util提供了Date类来封装日期和时间。实例化Date类的两个构造函数，
Date();--当前时间
Date(long millisec);--距离格林威治时间1970年1月1日millisec毫秒的时间
使用SimpleDateFormat格式化日期
```
import java.util.;
import java.text.;

public class DateDemo {
public static void main(String args[]) {

  Date now = new Date( );
  SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

  System.out.println("Current Date: " + ft.format(now));
//Current Date: 火 2016.11.01 at 01:37:56 午後 CST

} }

使用printf格式化日期
printf方法可以很轻松地格式化时间和日期。使用两个字母格式，它以t开头并且以下面转换字符表格中的一个字母结尾。例如：

import java.util.Date;

public class DateDemo {

public static void main(String args[]) {
// 初始化 Date 对象
Date date = new Date();

   // 使用toString()显示日期和时间
   System.out.printf("%1$s %2$tB %2$td, %2$tY",  "Due date:", date);
   //Due date: 11月 01, 2016       

}
}测量时间 结束时间-开始时间=用时。System.currentTimeMillis();--取得系统当前时间秒数。
import java.util.*;

public class TestDataFormat {

public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );
System.out.println(new Date( ) + "\n");
Thread.sleep(6000);//让当前线程休眠(阻塞)6秒,让出CPU的使用,给别的线程利用cpu的机会
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );
long diff = end - start;
System.out.println("Difference is : " + diff);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}```
Calendar类
创建一个Canlendar对象---
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Canlendar对象
Calendar c1= new Calendar.getIntance();
c1.set(2016,11,01);//20161101

第14章 集合框架

Java中的集合框架大类可分为Collection和Map；两者的区别：
1、Collection是单列集合；Map是双列集合
2、Collection中只有Set系列要求元素唯一；Map中键需要唯一，值可以重复
3、Collection的数据结构是针对元素的；Map的数据结构是针对键的。
Collection体系：

collection包括两大体系，List和Set

List的特点：

存取有序，有索引，可以根据索引来进行取值，元素可以重复

Set的特点：

存取无序，元素不可以重复

Set:
Set集合的特点：元素不重复，存取无序，无下标
Set集合下面有：HashSet，LinkedHashSet，TreeSet

第15章 泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型，当然，在逻辑上我们可以理解成多个不同的泛型类型。究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。