------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
泛型
格式：
<>
尖括号，是把参数类型作为参数传递给集合。
数据结构类名<引用数据类型> 数据结构对象名 = new 数据结构类名<存储的对象类型>
使用迭代器时：
Iterator<引用数据类型>
如：
ArrayList<String> al = new ArrayList<String>;
Iterator<String> it = al.iterator();
继承Comparator接口，使用比较器时：
public StringLengthComparator implements Comparator<String > ...
继承Comparable接口
泛型的好处：
1. 解决了类型的安全问题，将运行时的错误转到编译时就可以查看出来。
2. 避免了编译时，强转类型而带来的安全问题。
何时使用泛型？：
当API的集合框架中，出现了<>的标志时，则需要使用泛型。
package com.lxh.collection;
import java.util.*;
public class GenericDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new StringLengthComparator());
ts.add("sdfsd");
ts.add("b");
ts.add("fasefwefas");
ts.add("adfsa");
ts.add("ddfsa");
// 编译时就判断了类型安全的问题。
//ts.add(2);
// 迭代器也需要声明泛型
Iterator it = ts.iterator();
while(it.hasNext()) {
String str = it.next();
System.out.println(str);
}
}
}
// 迭代器声明泛型
class StringLengthComparator implements Comparator {
/**
* 比较器是String类型的，也就是实际声明了，所以其必须实现的抽象方法compare()的参数列表，
* 则必须为String，这就是继承中多态的体现。
* */
public int compare(String s1, String s2) {
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
return s1.compareTo(s2);
return num;
}
}
泛型类：
何时使用反省类：
当定义的类，自己要操作的引用数据类型（基本数据类型不可以）不确定的时候，使用泛型类。
表示泛型的标志可以自定义，并非一定是E或者T。
package com.lxh.collection;
public class CreateGenericDemo {
public static void main(String[] args) {
Utils util = new Utils();
util.setObject(new Student());
util.getObject();
/*
* 非泛型类的方式
Tools t = new Tools();
t.setObject(new Student());
t.getObject();
*/
}
}
/**
* 泛型类
* */
class Utils {
private T t;
public void setObject(T aa) {
this.t = t;
}
public T getObject() {
return this.t;
}
}
/**
* 非泛型类型
* */
class Tools {
private Object obj;
public void setObject(Object obj) {
this.obj = obj;
}
public Object getObject() {
return this.obj;
}
}
class Student {
public String name = "df";
}
class Teacher {
}
l 泛型方法
当泛型定义在类上的时候，其下的方法都会被泛型所使用的引用类型所限制。当想让同一个类的不同方法可以操作不同的引用类型时，则不要在类上定义泛型，而只是在方法上定义泛型。
格式：
public <T> void methodName() ...
package com.lxh.collection;
public class GenericMethod {
public static void main(String[] args) {
GenericMethodDemo m = new GenericMethodDemo();
m.print("abc");
m.show(123);
}
}
class GenericMethodDemo {
public void print(T t) {
System.out.println("print:" + t);
}
public void show(T t) {
System.out.println("show:" + t);
}
}
使泛型类的方法不适用泛型类的引用类型:
解决方案：
对泛型方法定义自己的泛型。类似于就近原则。
静态方法的泛型：
static修饰符修饰的方法，在类对象没有创建之前，即类被虚拟机加载的时候就存储在内存当中了。所以，需要将静态方法定义上泛型。
package com.lxh.collection;
package com.lxh.collection;
public class GenericMethod {
public static void main(String[] args) {
GenericMethodDemo2 m = new GenericMethodDemo2();
m.print("abc");
m.show(123);
GenericMethodDemo2.method(12431321);
}
}
class GenericMethodDemo2 {
public void print(T t) {
System.out.println("print:" + t);
}
/**
* 泛型类中，定义泛型方法
* */
publicvoid show(Q t) {
System.out.println("show:" + 5424);
}
/**
* 泛型类中，定义静态泛型方法
* */
public static void method(T t) {
System.out.println("show:" + t);
}
}
泛型接口：
实现了泛型接口的类仍旧可以定义成为一个泛型类型的。
package com.lxh.collection;
public class GenericInterface {
public static void main(String[] args) {
Demo d = new Demo();
d.print("ac");
Demo2 d2 = new Demo2();
d2.print(456486);
}
}
class Demo2 implements Inter {
public void print(T t) {
System.out.println(t);
}
}
class Demo implements Inter {
public void print(String str) {
System.out.println(str);
}
}
interface Inter {
public void print(T t);
}