泛型-Java集合框架基础

1.泛型

泛型主要目的是建立具有类型安全的集合框架，如链表，散列映射等数据结构。

详细内容查看Oracle Java Technologies | Oracle

泛型类

使用"class 名称<泛型列表>"声明一个类 这种类叫泛型类

class People<E>

E指其中的泛型，并没有指定E是何种类型的数据，它可以是任意类或接口，但不能是基本数据类型

“泛型列表”给出的泛型可以作为类的成员变量的类型，方法的类型以及局部变量的类型

泛型类的类体和普通类的类体完全类似，由成员变量和方法构成。

class Cone<E>{
    double height;
    E bottom;
    public Cone(E b){
        buttom = b;
    }
}

使用泛型类声明对象

泛型类声明和创建对象时，类名后多了一对“<>”，而且要用具体的类型替换“<>”中的泛型（或使用通配“？”）

使用具体类型替换“<>”中的泛型，例如，具体类型Circle替换泛型E:

Circle circle = new Circle();
Cone<Circle> coneOne;//用具体类型Circle,不可以用泛型E:Cone<E> coneOne;
coneOne = new Cone<Circle>(circle);

使用统配“？”

泛型类声明对象时，可以使用通配符“？”来限制泛型的范围。例如：限制泛型E的范围：

Cone<? extends Geometry> coneOne;

如果Geometry是类，那么<? extends Geometry>中的“：？extends Geometry”表示任何Geometry类的子类或Geometry类本身；如果Geometry是接口，那么<? extends Geometry>中的“：？extends Geometry”表示任何实现Geometry接口的类。

j假设Geometry是接口，CIrcle是实现了Geometry接口的类，那么下列创建coneOne就是合法

Circle circle = new Circle();
coneOne = new Cone<Circle>(circle);

Cone<? super B>coneOne;

这里B必须是一个类，不可以是接口，“<? super B>”中的":?super B"表示B类的任何父类（包括B类本身）

泛型类声明对象时，也可以仅仅使用通配符“？”代表泛型E，但不限制泛型E的范围（“？”），创建对象时，必须用具体的类，

Circle circle = new Circle();
Cone<?>coneOne = new Cone<Circle>(circle);

下列定义了一个Cone<E>泛型类，一个Cone<E>的对象计算体积时，只关心它的底是否能计算面积，并不关心底的类型

Cone.java

public class Cone<E> { //泛型类
	double height; 
	E bottom; //用泛型E声明对象bottom
	
	public Cone(E b) {
		bottom = b;
	}
	
	public void setHeight(double h) {
		height = h;
	}
	
	public double computerVolume() {
		String s = bottom.toString(); //泛型变量只能调用从Object类继承的或重写的方法
		double area = Double.parseDouble(s);
		return 1.0/3.0*area*height;
	}

}

Computable.java

public interface Computable {
	public String toString();
}

Rect.java

public class Rect implements Computable {
	double sideA,sideB,area;
	Rect(double a,double b){
		sideA = a;
		sideB = b;
	}
	public String toString() {
		area = sideA + sideB;
		return ""+area;
	}
}

Circle.java

public class Circle implements Computable{
	double area,radius;
	Circle(double r){
		radius = r;
	}
	public String toString() { //重写Object类的toString()方法
		area = radius*radius*Math.PI;
		return ""+area;
		
	}
}

main.java

public class Example13_1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Circle circle = new Circle(10);
		Cone<? extends Computable>cone = new Cone <Circle>(circle); //使用限定字符“？”限定实现接口
		cone.setHeight(16);
		System.out.println(cone.computerVolume());
		
		Rect rect = new Rect(15,23);
		cone = new Cone<Rect>(rect);  //方锥对象
		cone.setHeight(98);
		System.out.println(cone.computerVolume());
		
		Cone<Rect>coneRect = new Cone<Rect>(rect);  //不使用限定符“？”
		coneRect.setHeight(198);
		System.out.println(coneRect.computerVolume());
		
		Cone<?>coneCircle = new Cone <Circle>(circle);
		coneCircle.setHeight(100);
		System.out.println(coneCircle.computerVolume());
	}
}

泛型接口

使用”interface 名称<泛型列表>“声明一个接口

interface Computer<E>

Computer是泛型接口的名称，E是其中的泛型，泛型类可以使用泛型接口

interface Computer<E,F>{
	void makeChorus(E x,F y);
}

class Chorus<E,F> implements Computer<E,F>{
	public void makeChorus(E x,F y) {
		x.toString();
		y.toString();
	}
}

class 乐器{
	public String toString() {
		System.out.println("|3 5 1-|1 3 5 - |12 35 2 - |");
		return "";
	}
}

class 歌手{
	public String toString() {
		System.out.println("阿巴阿巴阿巴阿巴阿巴。。。。");
		return "";
	}
}

public class Example13_2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Chorus<歌手,乐器>model = new Chorus<歌手,乐器>();
		歌手 pengliyuan = new 歌手();
		乐器 piano = new 乐器();
		model.makeChorus(pengliyuan, piano);
	}
}

java泛型的主要目的是建立具有类型安全的数据结构，如链表，散列表等。

在使用这些泛型类建立的数据结构时，不必进行强制类型转换，即不要求进行运行时类型检查。