1.何为泛型
2.使用泛型的简单演示
3.泛型类
4.泛型方法
5.泛型接口
6.泛型的类型通配符
6.1设定通配符的上限
1.何为泛型
泛型就是指定一个容器里的元素是固定的一个类型。
如 : List<String> list 表示 list 中的元素全都要为String类型。
使用泛型后,编译器在编译时,就可以对集合中存储的对象的类型进行检查,一旦发现类型不匹配,就编译失败。这个技术就是泛型。
好处:
1.将程序运行时期的问题转移到了编译时期,可以更好的 让程序员发现问题并解决问题。
2.避免了向下转型的麻烦
总结:
泛型就是应用在编译时期的一项安全机制。
泛型的擦除:
编译器通过泛型对元素类型的检查后,只要检查通过,就会生成class文件,但在class文件中,就将泛型的标识去掉了。
泛型的表现:
泛型的应用在集合框架中用得很多。什么时候要写泛型呢?1.只要看到类或者接口在描述时右边有尖括号< >,就需要泛型。
其实是集合容器在不明确操作元素的类型的情况下,向外提供了一个参数< >,使用容器时,只要将具体类型传递给该参数即可。
说白了泛型就是传递类型参数。跟函数传参是一样的, 只不过函数是往小括号传参,泛型是往尖括号。
#注意:泛型只能装对象。
2.使用泛型的简单演示
示例一:
public class Main {
public static void main(String args[])
{
List<Integer> list = new ArrayList<Integer>(); //用泛型指定 list 操作的元素类型为整型,由于泛型只能装对象,所以用Integer。Integer 是 int 的对象表示
list.add(1);
list.add(2);
list.add(3);
for(Iterator<Integer> it = list.iterator();it.hasNext();)
{
System.out.println(it.next());
}
}
}
示例二:自定义类的泛型使用
/*Person类文件*/
public class Person implements Comparable<Person> {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
@Override
public int compareTo(Person o) {
int temp = this.age - o.age;
return temp==0?this.name.compareTo(o.name):temp; //先通过年龄比较,若年龄相同,再通过名字比较。
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
/*Main主文件*/
import java.util.*;
public class Main {
public static void main(String args[])
{
Set<Person> set = new TreeSet<Person>();
set.add(new Person("xiaoming",28));
set.add(new Person("xiaohong",22));
set.add(new Person("zhangsan",31));
for(Person person:set)
{
System.out.println(person);
}
}
}
3.泛型类
使用泛型类可以对类传入任意类型的参数,而并非只能传入局限的一种类型。
class Apple<E>
{
E info;
public Apple(E info)
{
this.info = info;
}
public E getInfo()
{
return info;
}
}
public class Main {
public static void main(String[] args)
{
Apple<String> app1 = new Apple<>("ABCD");
System.out.println(app1.getInfo());
Apple<Double> app2 = new Apple<>(3.14);
System.out.println(app2.getInfo());
}
}
打印结果:
ABCD
3.14
4.泛型方法
泛型方法:该方法中可以传入任意类型的变量。
class Demo<E>
{
E info;
public void print1(E e)
{
System.out.println(e);
}
public <Q>void print2(Q q) //泛型方法
{
System.out.println(q);
}
}
public class Main {
public static void main(String[] args)
{
Demo<String> d1 = new Demo<>(); //创建Demo实例时,已经把泛型确定为String
d1.print1("abc");
d1.print1(123); //错误,因为创建Demo实例时,已经把泛型确定为String,所以print1()只能处理String
d1.print2("abc");
d1.print2(123); //正确,因为print2中又使用了泛型,print2是泛型方法
}
}
5.泛型接口
interface Inter<T> //泛型接口
{
public void fun(T t);
}
class Cla1 implements Inter<String> //一般类实现泛型接口
{
public void fun(String t)
{
;
}
}
class Cla2<W> implements Inter<W> //泛型类实现泛型接口,W的类型由泛型类Cla2决定。
{
public void fun(W w)
{
;
}
}
6.泛型的类型通配符
先看一段用于遍历 List 容器的代码:
public void test(List c)
{
for(int i=0;i<c.size();i++)
{
System.out.println(c.get(i));
}
}
这段代码是典型的遍历 List 元素的代码,运行起来是没问题。问题是 List 是一个有泛型声明的接口,而上述代码使用List接口时没有传入类型参数,这将引起一个警告Warnning。如何解决这个警告?就是当传入 List c 作为参数时,给出 List 的类型,但又不知道List 会是什么类型,那可以用<?>代替,如:
public void test(List<?> c)
{
for(int i=0;i<c.size();i++)
{
System.out.println(c.get(i));
}
}
其中,?就是通配符
6.1设定通配符的上限
当通配符为 List<? extends xx> 表示?表示的类型 一定是 xx类或者是xx类的子类。
import java.util.*;
//顾客类
class Customer
{
public void BuyFruits(List<? extends Fruit> fruits) //表示通配符的类型参数一定要是 Fruits类的子类 或是 Fruits类本身
{
System.out.println("BUY"+fruits);
}
}
//抽象水果类
abstract class Fruit
{
abstract public void Buy(Customer c);
}
//苹果类
class Apple extends Fruit
{
public String name;
public Apple(String name) {
super();
this.name = name;
}
public void Buy(Customer c)
{
System.out.println("Buy Apple");
}
@Override
public String toString() {
return "Apple"+this.name;
}
}
//蕉类
class Banana extends Fruit
{
public String name;
public Banana(String name) {
super();
this.name = name;
}
public void Buy(Customer c)
{
System.out.println("Buy Banana");
}
@Override
public String toString() {
return "Banana"+this.name;
}
}
public class Main
{
public static void main(String[] args)
{
Customer c = new Customer();
List<Apple> AppleList = new ArrayList<>();
List<Banana> BananaList = new ArrayList<>();
Apple a1 = new Apple("红富士");
Apple a2 = new Apple("青苹果");
Banana b1 = new Banana("香蕉");
Banana b2 = new Banana("大蕉");
AppleList.add(a1);
AppleList.add(a2);
BananaList.add(b1);
BananaList.add(b2);
//主要体现是Customer类的BuyFruits方法可以传入不同的类型参数
c.BuyFruits(AppleList);
c.BuyFruits(BananaList);
}
}
打印结果:
BUY[Apple红富士, Apple青苹果]
BUY[Banana香蕉, Banana大蕉]