Java十三章：枚举类型与泛型

枚举类型

使用枚举类型设置常量

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

interface SeasonInterface{

final int spring=1;

final int summer=2;

final int autumn=3;

final int winter=4;

}

枚举类型出现后，逐渐取代了上述常量定义方式。代码如下：

public enum SeasonEnum {

spring,

summer,

autumn,

winter;

}

 

代码如下：

interface SeasonInterface{//四季接口
	final int spring=1;
	final int summer=2;
	final int autumn=3;
	final int winter=4;
 
enum SeasonEnum{//四季枚举
    spring,
    summer,
    autumn,
    winter,
}
 
public class SeasonDemo {
	public static void printSeason1(int temp){
		switch(temp){
		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("编码有误");
				break;
		}
		}
	public static void printSeason2(SeasonEnum seasonEnum) {
		switch(seasonEnum) {
		case spring:
			System.out.println("这是春季");
			break;
		case summer:
			System.out.println("这是夏季");
			break;
		case autumn:
			System.out.println("这是秋季");
			break;
		case winter:
			System.out.println("这是冬季");
			break;
			default:
				System.out.println("编码有误");
				break;
		}
	}
		public static void main(String[] args) {
			printSeason1(2);//使用接口常量做参数
			printSeason2(SeasonEnum.spring);//使用枚举类型做参数，只能用枚举中有的值
		}
		}

 运行结果如下：

深入了解枚举类型

1、values()方法

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

代码如下：

enum SeasonEnum{
   spring,
    summer,
    autumn,
    winter,
}
 
public class SeasonDemo {
	public static void main(String[] args) {
		SeasonEnum[] seasons=SeasonEnum.values();
		for(SeasonEnum temp:seasons) {
			System.out.println(temp+"是第"+(temp.ordinal()+1)+"个");
		}
	}
}

运行结果如下：

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

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

3、ordinal()方法

        枚举类型中的 ordinal() 方法用于获取某个枚举对象的位置索引值。 

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

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

代码如下：

enum SeasonEnum {//四季枚举
	spring("万物复苏"),
	summer("烈日炎炎"),
	autumn("秋高气爽"),
	winter("白雪皑皑");
 
private String introduce;//枚举的备注
 
 
private SeasonEnum(String introduce) {//构造方法
	System.out.println("This is"+" "+this.toString()+"，我来之后"+introduce);
}
public String getIntroduce() {//获取介绍值
	return introduce;
}
}
 
 
public class SeasonDemo {
	public static void main(String[] args) {
		SeasonEnum[] seasons=SeasonEnum.values();
		for(SeasonEnum temp:seasons) {
			System.out.println(temp+"是第"+(temp.ordinal()+1)+"个");
		}
	}
}

运行结果如下：

使用枚举类型的类型的优势

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

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

 泛型

定义泛型类

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

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

类名.<T> 

 

 
public class Book<T> {	//定义带泛型的Book<T>类
		private T booklnfo;	//类型形参：书籍信息
		public Book(T booklnfo) {	//参数为类型形参的构造方法
			this.booklnfo= booklnfo;	//为书籍信息赋值
		}
		public T getBooklnfo() {	//获取书籍信息的值
			return booklnfo;
		}
		public static void main(String[] args) {
			//创建参数为String类型的书名对象
			Book<String>bookName = new Book<String>("《Java从入门到精通");
			//创建参数为String类型的作者对象
			Book<String>bookAuthor = new Book<String>("明日科技");
			//创建参数为Double类型的价格对象
			Book<Double>bookPrice = new Book<Double>(69.8);
			//创建参数为Boolean类型的附赠源码
			Book<Boolean>hasSource = new Book<Boolean>(true);
			//控制台输出书名、作者、价格和是否附赠光盘
			System.out.println("书名："+bookName.getBooklnfo());
			System.out.println("作者："+bookAuthor.getBooklnfo());
			System.out.println("价格："+bookPrice.getBooklnfo());
			System.out.println("是否附赠源码？"+hasSource.getBooklnfo());
			
	}
 
}

运行结果如下：

泛型的常规用法

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

语法如下：

class MyClass<T1，T2>{  }

 

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

案例代码：

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

运行结果如下：

泛型的高级用法 

1、限制泛型可用类型

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

语法如下：

class 类名名称<T extends anyClass>

anyClas指某个接口或类，使用泛型限制后，泛型类的类型必须实现或继承anyClass 这个接口或类。无论anyClass是接口还是类，在进行泛型限制时都必须使用extends关键字。

2、使用类型通配符

在泛型机制中，提供了类型通配符，主要作用是在创建一个泛型类对象时限制这个泛型类的类型实现或继承某个接口或子类。要声明这样一个对象可以使用“？”通配符来表示，同时使用extends关键字来对泛型加以限制。

使用泛型类型通配符的语法如下：

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

 3、继承泛型类与现实泛型接口

定义泛型的类和接口可以被继承与实现。让SubClass类继承ExtendClass的泛型，代码如下：

class ExtendClass<T1>{}

class SubClass<T1,T2,T3>implements SomeInterface<T1>{}

总结

泛型的使用方法：

• 泛型的类型参数只能是类类型，不可以是简单类型，如A<int>这种泛型定义就是错误的。
• 泛型的类型个数可以是多个
• 可以使用extends关键字限制泛型的类型
• 可以使用通配符限制泛型的类型