普通类的多态
public class FruitApp {
public static void main(String[] args) {
Fruit f =new Apple(); //声明时使用多态
test01(new Apple()); //方法里形参使用多态
}
public static void test01(Fruit fruit){ //形参使用多态
}
public static Fruit test02(){
return new Apple(); //返回值使用多态
}
}
对泛型，是没有多态的
/*定义泛型类*/
public class A<T> {
}
public class App {
public static void main(String[] args) {
//A<Fruit> a=new A<Apple>()；泛型没有多态
A<Fruit> a=new A<Fruit>();
//test01(new A<Apple>());//形参使用多态错误
}
public static void test01(A<Fruit> a){
}
public static A<Fruit> test02(){
//return new A<Apple>; //返回值使用多态错误
}
}
利用通配符，可以实现上面想实现的功能
public class Student<T> {
T score;
public static void main(String[] args) {
Student<?> stu=new Student<String>(); //声明时使用通配符相当于泛型了,同下面的一样都是在声明时
test01(new Student<Integer>());
test02(new Student<Apple>());
//test03(new Student<Apple>()); 错误，泛型没有多态
}
public static void test01(Student<?> a){ //test01就可以传入任意指定类型的类了
}
/*此处的test02 则可以传入Fruit的子类，实现了多态*/
public static void test02(Student<?extends Fruit> a){
}
/*该方法已经声明了泛型的具体属性，在上面调用的时候是没办法多态的*/
public static void test03(Student<Fruit> a){
}
}
泛型的嵌套
public class AhAhut<T> {
T stu;
public static void main(String[] args) {
//泛型的嵌套,下面定义的意思是，AhAhut里面的stu定义为了Student类，而因为
//Student类也有一个泛型需要具体指定，所以就有了嵌套
AhAhut<Student<String>> room=new AhAhut<Student<String>>();
//要取出的话，需要从外到内拆分，先取出Student，再取score
room.stu=new Student<String>();//上面已经指定了Student的具体类型
Student<String> stu=room.stu;
String score=stu.score;
System.out.println(score);
}
}
输出结果为:null
没有泛型数组，用通配符可以去替代
public static void main(String[] args) {
Integer[] arr=new Integer[10]; //普通数组
//没有泛型数组
//Student<String>[] arr2=new Student<String>[10];
Student<?>[] arr2=new Student<?>[10];//可以用问号来创建
//第一个Student的泛型指定为String
Student<String> stu=new Student<>();
stu.score="A";
arr2[1]=stu;
System.out.println(arr2[1].score);
//第一个Student的泛型指定为Integer
Student<Integer> stu2=new Student<>();
stu2.score=20;
arr2[2]=stu2;
System.out.println(arr2[2].score);
}
}
用容器去完成
public class Array {
public static void main(String[] args) {
//具体指定MyArrayList为String
MyArrayList<String> strlist=new MyArrayList<String>();
strlist.add(0, "abc");
String elem=strlist.get(0);
System.out.println(elem);
}
}
/*可以定义一个容器来实现泛型数组的功能*/
class MyArrayList<E>{
//E[] cap=new E[];不能创建泛型数组，
//只能用Object来存，取的时候再转回去
Object[] cap=new Object[10];
public void add(int idx,E e){
cap[idx]=e; //Object数组可以接收任意类型，所以E类型能进来
}
@SuppressWarnings("unchecked")
public E[] getAll(){
return (E[]) cap; //返回时再转回去
}
@SuppressWarnings("unchecked")
public E get(int idx){
return (E)cap[idx]; //返回时再转回去
}
}
