枚举类型与泛类

13.1 枚举

13.1.1 使用枚举类型设置常量

使用枚举类型设置常量

       设置常量时，我们通常放置在接口中，这样在程序中就可以直接使用。该常量不能被修改，因为在接口中定义常量时，改常量的修饰符为final与static。例题：

package 十三;

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);
    }
}

 

3.1.2 深入了解枚举类型 

1、values()方法

        枚举类型实例，该方法将枚举中所有的枚举值以数组的形式返回。

package 十三;

public class ShowEnum {
	public static void main(String[]args){
        SeasonEnum es[] = SeasonEnum.values();
        for(int i = 0;i < es.length;i++){
            System.out.println("枚举常量：" + es[i]);
        }
    }
}

 

 

2、valuesOf()方法与compareTo()方法

        枚举类型中的静态方法 valuesOf() 可以将普通字符串转换为枚举类型，而 comparedTo() 方法用于比较两个枚举类型对象定义时的顺序。例题：

package 十三;

public class EnumMethodTest {
    public static void main(String[] args) {
        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() 方法用于获取某个枚举对象的位置索引值。 

4、枚举类型中的构造方法

        在枚举类型中，可以添加构造方法，但是规定这个构造方法必须被 private 修饰符所修饰。

使用枚举类型的类型

         枚举类型声明提供了一种对用户友好的变量定义方法，枚举了某种数据类型所有可能出现的值。总结枚举类型，它具有以下特点：

• 类型安全。
• 紧凑有效的数据定义。
• 可以和程序其他部分完美交互。
• 运行效率高。

13.2 泛型

13.2.2  定义泛型类

Object 类为最上层的父类，很多程序员为了使程序更为通用，程序设计时通常使传入的值与返回的值都以 Object 类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来地类型，否则在运行时将会发生 ClassCastException 异常。

为了提前预防这种问题，java提供了泛型机制。其语法如下：

类名<T>

其中，T 是泛型的名称，代表某一种类型。

package 十三;
public class 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
		Book<String> bookName = new Book<String>("java从入门到精通");
		Book<String> bookAuthor = new Book<String>("明日科技");
		Book<Double> bookPrice = new Book<Double>(69.8);
		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());
	}
}

13.2.3 泛型的常规用法

1.定义泛型类时声明多个类型

class MyClass<T1,T2>{}

其中，T1和T2 为可能被定义的类型。

这样，在实例化指定类型的对象时就可以指定多个类型。例如：

MyClass<Boolean,Float> m = new MyClass <Boolean,Float>();

2.定义泛型类时声明数组类型

例题13.7 定义泛型数组

package 十三;

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) {
        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]);
        }
    }
}

13.2.4 泛型的高级用法 

1.限制泛型可用类型

默认可以使用任何类型来实例化一个泛型类对象，但 java 中也对泛型类实例化的类型作了限制。

class 类名称<T extends anyClass>

例题13.9

package 十三;

import java.util.LinkedList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class LimitClass<T extends List> {
	public static void main(String[] args) {
		//可以实例化已经实现的接口的类
		LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
		LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
		//这句是错误的，因为 HashMap 类没有实现接口 List()接口
		LimitClass<HashMap> l3 = new LimitClass<HashMap>();
	}
}

2.使用类型通配符

在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时限制这个泛型类的类型实现或继承某个接口或类的子类。

泛型类名称<? extends List> a=null;

其中，<? extends List> 表示类型未知，当需要使用该泛型对象时，可以单独实例化。例如：

A<? entends List> a=null;
a = new A<ArrayList>();
a = new A<LinkedList>();