【java高级程序设计】泛型（中）||边界||自食用

！extends  ------- 就用继承关键词声明类型边界

泛型边界：泛型参数指定范围（就...你总不能乱传吧，还是得有个度来着...）

代码：（只能生产车的制车厂）  BenzCar类：（extends Car）

类似于BMWCar

package fanxing;  
 


public class BenzCar extends Car{
	public BenzCar() {
		System.out.println("开始生产奔驰汽车");
	}

}

核心：

public class BenzCar extends Car{
    public BenzCar() {
        System.out.println("开始生产奔驰汽车");
    }

}

CarFactory类：

package fanxing;  
 


public class CarFactory {
	public T create(Class clazz) throws Exception {
		System.out.println("制车厂：装载发动机、座椅、轮子");
		return clazz.newInstance();
	}
}

测试类：

package fanxing;



public class GenericTest {
	public static void main(String[] args) throws Exception {
		CarFactory benz = new CarFactory();
		CarFactory bmw = new CarFactory();
		
		System.out.println("======开始生产奔驰汽车======");
		benz.create(BenzCar.class);
		System.out.println("======开始生产宝马汽车======");
		bmw.create(BMWCar.class);
	}
}

结果：

======开始生产奔驰汽车======
制车厂：装载发动机、座椅、轮子
开始生产奔驰汽车
======开始生产宝马汽车======
制车厂：装载发动机、座椅、轮子
开始生产宝马汽车

二、 含边界的泛型方法

 

代码：

package fanxing;  
 


public class Sortor {
	publicV getMax(V v, V s){
		//return math.max(v,s); //报错返回类型
		if(v>s) return v;
		else return s;
	}

}

三、 多边界

！extends Obj1 & Obj2  ------- 就用继承关键词+&声明多类型边界 代码：

package fanxing;  
 


public class Factory {
	public T create(Class t) throws Exception{
		return t.newInstance();
	}
}

public class Parrot implements Speakable,Flyable{

	@Override
	public String speak() {
		return "我是一只鹦鹉";
	}

}

package fanxing;

public class GenericTest {
	public static void main(String[] args) throws Exception {
		Factory factory = new Factory(); 
		Parrot parrot = factory.create(Parrot.class);
		System.out.println(parrot.speak());
	}
}

结果： 

我是一只鹦鹉

四、 通配符与边界

！   ?  extends/super  Obj  ------- 就用?+ 继承关键词声明边界

 

代码：

package fanXin2;  
 


public class Animal {
}

public class Bird extends Animal{
}

public class Fish extends Animal{
}

package fanXin2;  
 


public class Zoo {
	private T t;
	public Zoo(T t) {
		this.t = t;
	}
	public T pop() {
		return this.t;
	}

}

方式一：用extends（限制子类——

package fanXin2;  
 


public class GenericTest {
	public static void main(String[] args) {
		Zoo zoo = new Zoo (new Bird()); 
		          //初始设置为Bird，后续可更改，但必须继承Animal类
		System.out.println(zoo.pop().getClass().toString());
		zoo = new Zoo(new Fish()); //修改为Fish
		System.out.println(zoo.pop().getClass().toString());

	}
}

核心：

先创建Zoo类实例为< ? extends Animals>，可后续修改其泛型类型，但必须继承Animal类。

初始化为Bird类。

后续可修改为Fish类。

结果：

class fanXin2.Bird
class fanXin2.Fish

方式二： 用super （限制父类—— 

package fanXin2;  
 


public class GenericTest {
	public static void main(String[] args) {
		Zoo zoo = new Zoo (new Bird()); 
		          //初始设置为Bird，后续可更改，但必须继承Animal类
		System.out.println(zoo.pop().getClass().toString());
		
		zoo = new Zoo(new Animal());
		System.out.println(zoo.pop().getClass().toString());
		//zoo = new Zoo(new Fish()); //不合法，Fish不是Bird的父类或本类

	}
}

结果：

class fanXin2.Bird
class fanXin2.Animal