13.1枚举类型
13.1.1 使用枚举类型设置常
设置常量时，通常将常量放置在接口中，这样在程序中直接使用。该常量不能被修改，因为在接口定义常量时，该常量的修饰符为final与static。常规定义常量的代码如下：
public interface Constants{
public static final int Constants_A=1;
public static final int Constants_B=12;
}
枚举类型出现后，逐渐取代了上述常量定义方式。使用枚举类型定义常量的语法如下：
public enum Constants{
Constants_A,
Constants_B,
}
其中，enum是定义枚举类型的关键字。当需要在程序中使用该常量时，可以是使用Constants.Constants_A来表示
例题13.1
package shisanzhang; //例题13.1
interface SeasonInterface{ //四季接口
int SPRING=1,SUMMER=2,AUTUMN=3,WINTER=4;
}
enum SeasonEnum{ //四季枚举
SPRING,SUMMER,AUTUMN,WINTER
}
public class SeasonDemo {
public static void printSeason1(int season) {
switch(season) {
case SeasonInterface.SPRING:
System.out.println("这是春季");break;
case SeasonInterface.SUMMER:
System.out.println("这是夏季");break;
case SeasonInterface.AUTUMN:
System.out.println("这是秋季");break;
case SeasonInterface.WINTER:
System.out.println("这是冬季");break;
default:
System.out.println("这不是四季的常量值");
}
}
public static void printSeason2(SeasonEnum season) {
switch(season) {
case SPRING:
System.out.println("这是春季");break;
case SUMMER:
System.out.println("这是夏季");break;
case AUTUMN:
System.out.println("这是秋季");break;
case WINTER:
System.out.println("这是冬季");break;
}
}
public static void main(String[] args) {
printSeason1(SeasonInterface.SPRING); //使用接口常量做参数
printSeason1(3); //可以使用数字做出参数
printSeason1(-1); //使用接口常量值意外的数字“冒充”常量
printSeason2(SeasonEnum.WINTER); //使用枚举做参数，只能用枚举中有的值，无法“冒充”
}
}运行结果如下：
13.1.2 深入了解枚举类型
枚举类型的常用方法如下：
1.values()方法
枚举类型实例包含一个values()方法，该方法可以将枚举类型成员以数组的形式返回
例题13.2
package shisanzhang; //例题13.2
enum SeasonEnum{ //四季枚举
SPRING,SUMMER,AUTUMN,WINTER
}
public class ShowEnum {
public static void main(String[] args) {
// TODO Auto-generated method stub
SeasonEnum es[]=SeasonEnum.values();
for(int i=0;i<es.length;i++) {
System.out.println("枚举常量："+es[i]);
}
}}
运行结果如下：
2. valueOf()方法与compareTo()方法
枚举类型中静态方法valueOf()方法可以将普通字符串转换为枚举类型，而compareTo()方法用于比较两个枚举类型对象定义时的顺序。
例题13.3
package shisanzhang; //例题13.3
enum SeasonEnum{ //四季枚举
SPRING,SUMMER,AUTUMN,WINTER
}
public class EnumMethodTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
SeasonEnum tmp=SeasonEnum.valueOf("SUMMER"); //根据字符串创建一个枚举值
SeasonEnum es[]=SeasonEnum.values(); //获取所有枚举值
for(int i=0;i<es.length;i++) {
String message=""; //待输出的消息
int result=tmp.compareTo(es[i]); //记录两个枚举的比较结果
if (result<0) {
message=tmp+"在"+es[i]+"的前"+(-result)+"个位置";
}else if(result>0) {
message=tmp+"在"+es[i]+"的后"+result+"个位置";
}else if(result==0) {
message=tmp+"与"+es[i]+"是同一个值";
}
System.out.println(message);
}
}
}运行结果如下：
3.ordinal()方法
枚举类型中的ordinal()方法用于获取某个枚举对象的位置索引值
例题13.4
package shisanzhang; //例题13.4
enum SeasonEnum{ //四季枚举
SPRING,SUMMER,AUTUMN,WINTER
}
public class EnumIndexTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
SeasonEnum es[]=SeasonEnum.values();
for(int i=0;i<es.length;i++) {
System.out.println(es[i]+"在枚举类型中位置索引值"+es[i].ordinal());
}
}
}运行结果如下：
4.枚举类型中的构造方法
枚举类型定义的构造方法语法如下：
enum 枚举类型名称{
Constants_A("我是枚举成员A"),
Constants_B("我是枚举成员B"),
Constants_C("我是枚举成员C"),
Constants_D("3"),
private String description;
private Constants2(){ //定义默认构造方法
}
private Constants2(String description){ //定义带参数的构造方法，参数类型为字符串类型
this.description = description;
}
private Constants2(int i){ //定义带参数的构造方法，参数类型为整型
this.i=this.i+i;
}
}
无论是有无参构造方法还是有参构造方法，修饰权限都为private.
例题13.5
//例题13.5
enum SeasonEnum{ //四季枚举
SPRING("万物复苏"),
SUMMER("烈日炎炎"),
AUTUMN("秋草枯黄"),
WINTER("白雪皑皑");
private String remarks; //枚举的备注
private SeasonEnum(String remarks) { //构造方法
this.remarks="我是"+this.toString()+",我来之后"+remarks+"。";
}
String getRemarks() { //获取备注
return remarks;
}
}
public class EnumConstructTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
SeasonEnum es[]=SeasonEnum.values();
for(int i=0;i<es.length;i++) {
System.out.println(es[i].getRemarks());
}
}
}运行结果如下：
13.1.3 使用枚举类型的优势
特点：
类型安全。
紧凑有效的数据定义。
可以和程序其他部分完美交互。
运行效率高。
泛型
泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前，Java也提供了对object类型的引用“任意化” 操作，这种“任意化”操作就是对object类型引用进行向下转型及向下转型操作，但某些强制类型转换的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转换存在安全隐患，所以在此提供了泛型机制
回顾向上转型与向下转型
在介绍泛型之前，先来看一个例子，在项目中创建Test类，在该类中使基本类型向上转型为object类型
public class Test {
private Object b; //定义object类型成员变量
public Object getB() { //设置相应的getXXX（）方法
return b;
}
public void setB(Object b) { //设置相应的setXXX（）方法
this.b = b;
}
public static void main(String[] args) {
Test t = new Test();
t.setB(Boolean.valueOf(true)); //向上转型操作
System.out.println(t.getB());
t.setB(Float.valueOf("12.3")); //向下转型操作
Float f = (Float)t.getB();
System.out.println(f);
}
}运行结果如下：
在本实例中，Test类中定义了私有的成员变量b，它的类型为Object类型，同时为其定义了相应的setXXX（）与getXXX()方法。在类的主方法中，将Boolean.valueOf(true)作为setB（）方法的参数，向下转型会出现错误，语法错误没有出现编译器会接受此段代码，，但执行时会出现ClassCastException异常，而泛型机制就有效解决了这一问题。
例如以下代码：
t.setB(Float.valuesOf("12.3"));
Integer f = (Integer)t.getB();
System.out.println(f);
定义泛型类
Object类为最上层的父类，为了提前预防发生异常，Java提供了泛型机制其语法如下
类名<T>
例题13.6
public class Book<T> { //定义带泛型的Book<T>类
private T bookInfo; //类型形参：书籍信息
public Book(T bookInfo) { //参数为类型形参的构造方法
this.bookInfo = bookInfo; //为书记信息赋值
}
public T getBookInfo() { //获取书籍信息的值
return bookInfo;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建参数为String类型的书名对象
Book<String>bookName =new Book<String>("《Java从入门到精通》");
//创建参数为String类型的作者对象
Book<String>bookAuthor =new Book<String>("明日科技");
//创建参数为String类型的价格对象
Book<String>bookPrice =new Book<String>("69.8");
//创建参数为Boolean类型的附赠源码
Book<Boolean>hasSource =new Book<Boolean>(true);
//控制台输出书名、作者、价格和是否附赠光盘
System.out.println("书名："+bookName.getBookInfo());
System.out.println("作者："+bookAuthor.getBookInfo());
System.out.println("价格："+bookPrice.getBookInfo());
System.out.println("是否附赠源代码？"+hasSource.getBookInfo());
}
}运行结果如下：
泛型的常规用法
1.定义泛型类时声明多个类型。语法如下：
class MyClass<T1,T2>{ }
T1,T2为可能被定义的类型
在实例化指定类型的对象时就可以指定多个类型，例如：
MyClass<Boolean,Float> m = new MyClass <Boolean,Float>();
2.定义类型类时声明数组类型
定义泛型类时也可以声明数组类型。
例题13.7定义泛型数组
package b;
public class ArrayClass<T> {
private T[] array; //定义泛型数组
public T[] getArray() {
return array;
}
public void setArray(T[] array) {
this.array =array;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayClass<String>demo =new ArrayClass<String>();
String value[] = {"成员1","成员2","成员3","成员4","成员5"};
demo.setArray(value);
String array[]=demo.getArray();
for (int i =0;i<array.length;i++) {
System.out.println(array[i]);
}
}
}运行结果如下：
可以在使用泛型机制时声明一个数组，但是不可以使用泛型来建立数组的实例
3.集合类声明容器的元素
JDK中的集合接口、集合类都被定义了泛型，其中List<E>的泛型E实际上就是element元素的首字母，Map<K,V>的泛型K和V就是key键和value值的首字母。常用的被泛型化的集合类如下表：
例题13.8
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class AnyClass {
public static void main(String[] args) {
// 定义ArrayList容器，设置容器内的值类型为Integer
ArrayList<Integer> a = new ArrayList<Integer>(); // 为容器添加新值
a.add(1);
for (int i = 0; i < a.size(); i++) {
// 根据容器的长度，循环显示容器内的值
System.out.println("获取ArrayList容器的值：" + a.get(i));
}
// 定义HashMap容器，设置容器的键名与键值类型分别为Integer与String型
Map<Integer, String> m = new HashMap<Integer, String>();
for (int i = 0; i < 5; i++) { // 为容器填充键名与键值
m.put(i, "成员" + i);
}
for (int i = 0; i < m.size(); i++) {
System.out.println("获取Map容器的值" + m.get(i)); // 根据键名获取键值
}
}
}
//例题13.8运行结果如下：
13.2.4 泛型的高级用法
泛型的高级用法包括限制泛型可用类型和使用类型通配符等。
1.限制泛型可用类型
默认可以使用任何类型来实例化一个泛型类对象，但Java中也对泛型类实例的类型做了限制，语法如下：
class 类名称<T extends anyClass>
例题13.9
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
public class LimitClass <T extends List>{
public static void main(String[]args) {
// 可以实例化已经实现List接口的类
LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
// 这句是错误的，因为HashMap没有实现List()接口
LimitClass<HashMap> l3 = new LimitClass<HashMap>();
}
}
运行结果如下：
出现异常：异常为Hasamap不能·被实例化
如果我们想它不报错的话就将hash map改为导入类中的list。但仍然无法运行，只是不报错。如下
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
public class LimitClass <T extends List>{
public static void main(String[]args) {
// 可以实例化已经实现List接口的类
LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
// 这句是错误的，因为HashMap没有实现List()接口
LimitClass<List> l3 = new LimitClass<List>();
}
}2.使用类型通配符
在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时，限制这个泛型类的类型，实现或继承某个接口或类的子类。要声明这样一个对象可以使用“？”通配符来表示，同时使用extends。关键字来对泛型加以限制使用泛型类型通配符的语法，如下：
泛型类名称<？extends List> a=null;
其中，<? extends List>表示类型未知，当需要使用该泛型对象时，可以单独实例化，例如：
A <？extends List> a=null;//定了上界和下界
a=new A<ArraryList>();
a=new A<ArraryLinkList>();
像上述例子的HashMap类没有实现List接口,那编译器就会报错.除了可以实例化一个限制泛型类型的实例,还可以将该实例放置在方法的参数
public void do Something(A<? extendsList>a){}
在上述代码中，定义方式有效地限制了传入do Something()方法的参数类型。如果使用A<？>这种形式实例化泛型类对象，则默认表示可以将a指定为实例化Object及以下的子类类型，例如:
List <String>l1 = new ArraryList<String>(); //实例化一个对象
l1.add("成员")； //在集合中添加内容
List<?>l2=l1;
List<?>l3 = new LinkkedList<integer>();
System.out.println(2.get(0)); //获取集合中第一个值
在上面的例子中list类型的对象可以接受时君类型的和ArraryList集合也可以接受Integer类型的LLinkedList集合。
注意：List<?>12=11和List12=11有区别
使用通配符声明的名称实例化的对象不能对其加入新的信息，只能获取或删除。例如：
.set(0,"成员改变")； //没有使用通配符的对象调用set（）方法
//l2.set（0,"成员改变"）；//使用通配符的对象调用set（）方法，不能被调用。
//l3.set（0，1）；
l2.get（0）； //可以使用l2的获取集合中的值
l2.remove（0）；//根据键名删除集合中的值
3.继承泛型类与接口
定义为泛型的类和接口也可以被继承与实现。例如让Subclass类继承Extendclass类的泛型，代码入下：
class Extend Class <T1>{}
Class Sub Class <T1,T2,T3>extends Extend Class <T1>{}
如果在Sub Class类继承Extend Class类时保留父类的泛型类型，需要在继承时期指明。如果没有指明，直接使用extends Extends Class语句进行继承操作，则SubClass类中的 T1T2和T3都会自动变为object类型，所以在一般情况下都将父类的泛型类型保留。
定义为泛型的接口也可以被实现，例如让Sub Class类实现Some Interface接口，并继承接口的泛型。代码如下：
interface SomeInterface<T1>{}
class SubClass<T1,T2,T3>implements SomeInterface<T1>{}
13.2.5 泛型总结
总结一下泛型的使用方法。
1泛型类型参数只能是类类型，不可以是简单类型，比如A< int>这种泛型定义就是错误的。
2.泛型的类型个数可以是多个
3.可以使用extends关键字限制泛型的类型
4.可以使用通配符限制泛型的类型
