第十三章---枚举类型与泛型

一，枚举类型

1.使用枚举类型设置常量

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

public interface Constants (
public static final int Constants A = 1;
public static final int Constanta_B =12;
}

枚举类型出现后，逐渐取代了上述最定义方式。使用枚举类型定义常量的通法加下;

public enum Constants{
Constants_A,
Constants_B，}

 例13.1]分别创建四季的接常量和枚举，比较两者的使用场

2，深入了解枚举类型

1.values()方法

枚举类型实例包含一个values（）方法，该方法将枚举中所有的枚举值以数组的形式返回。

[例13.2]打印四季枚举中的所有枚举值

2.valueOf()方法与compareTo()方法

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

[例13.3]使用字符串创建一个季节的枚举值，并判断季节的位置

3.ordinal()方法

校举英型中的ordinal0方法用于获取某个枚举对象的位置索引值。

[例13.4]输出每一个季节的索引位置

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

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

(例13.5]为四季枚举创建构造方法，记录每一个季节的特征

3，使用枚举类型的优势

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

1.类型安全

2.紧凑有效的数据定义

3.可以和程序其他部分完美交互

4.运行效率高。

二，泛型

1，回顾向上向下转型

 1.例子

2，定义泛型类

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

2.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
		Book<String> bookName = new Book<String>("java从入门到精通");//创建参数为String类型的书名对象
		Book<String> bookAuther = new Book<String>("明日科技");//创建参数为String类型的作者对象
		Book<Double> bookPrice = new Book<Double>(69.8);//创建参数为Double类型的价格对象
		Book<Boolean> HasSourse = new Book<Boolean>(true);//创建参数为Boolean类型的附赠源代码
		//控制台输出书名，作者，价格和是否附赠光盘
		System.out.println("书名："+bookName.getbookInfo());
		System.out.println("作者："+bookAuther.getbookInfo());
		System.out.println("价格："+bookPrice.getbookInfo());
		System.out.println("是否附赠源代码："+HasSourse.getbookInfo());
		
	}
 
}

 

3，泛型的常规用法

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

        在定义泛型类时，可以声明多个类型。语法如下:

class MyClass<T1,T2>{}

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

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

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

         [例13.7]定义泛型数组

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 自动生成的方法存根
		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常用的被泛型化的集合类

[例13.8]使用泛型约束集合的元素类型

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
 
public class AnyClass {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义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));
		}
	}
 
}

 

4，泛型的高级用法

1.限制泛型可用类型

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

class 类名称<Textends anyClass>

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

[例13.9]限制泛型的类型必须为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<HashMap> l3 = new LimitClass<HashMap>();
	}
 
}

2使用类型通配符

泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时限制这个泛型类的类或承某个接口或类的子类。要声明这样一个对象可以使用“?”通配符来表示，同时使用 extends穿来对泛型加以限制。使用泛型类型通配符的语法如下:

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

<extendsList>表示类型未知，当需要使用该泛型对象时，可以单独实例化。例如:

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

可以实例化一个限制泛型类型的实例，还可以将该实例放置在方法的参数中。例如:

Public void doSomethina(A<? extends List> a){}

:3，继承泛型类与实现泛型接口

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

class ExtendClass<T1>{}
class SubClass<T1,T2,T3> extends ExtendClass<T1>{}

定义为泛型的接口也可以被实现。例如，让SubClass 类实现 SomeInterface 接口，并继承接口的发型，代码如下:

interface Somelnterface<T1>{}
class SubClass<T1,T2,T3> implements Somelnterface<T1>(}

5，泛型总结

1.泛型的类型参数只能是类类型，不可以是简单类型，如 A<in>这种泛型定义就是错误的

2.泛型的类型个数可以是多个。

3.可以使用 extends 关键字限制泛型的类型

4.可以使用通配符限制泛型的类型。