文章目录
泛型作用: 限制加入集合中元素的类型,将类型限制为同一种类型
泛型在编译期间生效,不允许加入其他类型
一.泛型的基本应用
public class Animal{
public String name;
public String color;
public Animal(String name,String color)
{
super();
this.name = name;
this.color = color;
}
public String toString()
{
return "Animal [name=" + name + ", color=" + color + "]";
}
}
public class AnimalTest
{
public static void main(String[] args)
{
List<Animal> list = new ArrayList<>();
Animal cat = new Animal("cat","White");
Animal dog = new Animal("dog","black");
Animal rabbit = new Animal("rabbit","white");
list.add(cat);
list.add(dog);
list.add(rabbit);
for(Object o : list) { //增强for循环,遍历list,遍历出的每一个对象都用Object类型的o接收
System.out.println(o); //相当于‘Object o=每个对象’,父类引用指向子类对象(Object为如何子类的父类),实则为多态
}
}
}
Output:
Animal [name=cat, color=White]
Animal [name=dog, color=black]
Animal [name=rabbit, color=white]
但是加了泛型之后的遍历
for(Animal a : list) { //遍历list,遍历出的每一个对象都用Animal类型的a接收
System.out.println(a);
}
二.泛型的扩展
1.泛型类
定义泛型类的语法格式
类访问修饰符 class 泛型类名 <类型参数> {
类体
}
类型参数可以用任何单个大写字母表示,通常使用E来表示集合元素类型,用K与V分别表示键-值对中的键类型与值类型,用T、U、S表示任意类型
1.1 创建泛型类时,类型不确定,只有在创建对象时才确定
具体实例:
public class Animal <A> { //在此创建了<A>的泛型类
.....
}
class Test{
public static void main(String[] args){
Animal<Integer> a1 = new Animal<>(); //此时A的类型为Integer
Animal<String> a2 = new Animal<>(); //此时A的类型为String
.....
}
}
2.泛型方法
图中代码,第二个方法的参数类型为A,A即为public class GenericTest< A > 中的泛型A,由于GenericTest< Integer > gt = new GenericTest<>();中已经确定< A >的类型为Integer,所以
gt调用方法时,b方法确定为Integer。
c方法,由于方法的参数类型为B,B不是public class GenericTest< A > 中的泛型A,所以在方法体内加入< B >,否则会报错。由于B的加入,B为不确定类型,即任意类型都可。
因此,c方法帮我们解决了不同数据类型做参数的重载问题。通俗而言,如果想要传入不同类型的数据,不用写不同参数类型的方法,只需写public< B > void c(B b)即可实现。
注意:
如果在方法中加入static,则b方法报错,c方法可以。
原因是,static修饰的方法存在于对象之前,由于泛型A的类型在创建对象时确定,所以a方法报错。然而,c方法不受类型限制,因此static对此方法没有限制。
2.泛型接口
泛型接口的定义格式如下:
interface 接口名<类型参数列表>
{
...
}
在实现接口时,也应当声明与接口相同的类型参数。格式如下:
class 类名<类型参数列表> implements 接口名<类型参数列表>
{
...
}
具体实例如下:
在实现类classA中确定了泛型A为String类型。
注意: 实现类class B中的泛型是BB不是泛型A,BB类型为不确定型,因此会报错。应当改成:class B < BB>implements GenericInterface< BB>{}
三.泛型受限
1.泛型上限:? extends A :只要泛型为A或A的子类都可传入
2.泛型下限:? super A : 只要泛型为A或A的父类都可传入
public class Person{
public String name;
public int age;
public Person(String name, int age)
{
super();
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Student extends Person{
public int id;
public Student(String name, int age, int id)
{
super(name, age);
this.id = id;
}
@Override
public String toString()
{
return "Student [id=" + id + "]";
}
}
import java.util.ArrayList;
class Test{
public static void main(String[] args) {
ArrayList<Person> a1= new ArrayList<Person>();
a1.add(new Person("nana",18));
a1.add(new Person("haha",19));
show(a1);
ArrayList<Student> a2= new ArrayList<Student>();
a2.add(new Student("yiyi",20,1));
a2.add(new Student("bobo",21,2));
show(a2);
}
public static void show(ArrayList<? extends Person> ab) { //泛型上限
for(Person a : ab) {
System.out.println(a);
}
}
}
Output:
Person [name=nana, age=18]
Person [name=haha, age=19]
Student [id=1]
Student [id=2]
更多精彩尽在Blog主页