JAVA笔记整理-泛型
一、泛型
1、泛型定义
泛型（generics）是JDK5.0以后的特性，提供了编译期间安全监测机制，它是将数据类型参数化的一种方式。 例如：在对方法进行编写参数列表时，以前我们需要知道方法的参数类型 ，现在使用泛型机制可以将方法的参数类型也作为 “未知的类型” ，在调用该方法时传递该类型。
2、泛型的使用
2.1 泛型类（generic class）
它是一种具有一个或多个类型变量的类，（一个变量可以有多种类型）
语法
public class 类<T>{
// 类里面的数据类型 和 方法返回值，以及方法的参数都可以使用T
// <>里面可以是任意大写字母
}
public class People<T> {
private T name;
private T sex;
public T getName() {
return name;
}
public People(T name,T sex){
this.name= name;
this.sex = sex;
}
public People(){
}
}
// 创建没有指定泛型的对象 ，它默认是Object类型
People obj= new People();
obj.setName("李四");
System.out.println(obj);
System.out.println(((String)obj.getName()).length());
// 创建泛型类的对象
People<String> people = new People<String>("张三","男");
System.out.println(people);
System.out.println(people.getName().length());
定义泛型的字母
T ： Type： 变量类型
K： Key ： 任意键的类型
V： Value ： 任意值的类型
E：ELement 用于定义集合的元素类型
2.2 泛型接口（generic interface）
在接口中定义泛型，使接口的方法可以使用该泛型，实现类实现该接口时需要指定接口的类型、
语法：
public interface Genarator<T> {
public T getValue();
public void setValue(T s);
}
public class StringGenarator implements Genarator<String> {
private String name;
@Override
public String getValue() {
return name;
}
@Override
public void setValue(String s) {
this.name=s;
}
public class StudentGenarator implements Genarator<Student> {
private Student stu;
@Override
public Student getValue() {
return stu;
}
@Override
public void setValue(Student s) {
this.stu = s;
}
}
泛型接口的好处：
让接口的方法的返回值或参数类型 也参数化 （泛型）
2.3 泛型方法
a、为什么会使用泛型方法
当一个类中 只有某个方法需要使用泛型，而不是类的全部方法使用泛型，这时可以将泛型定义的范围缩小，通常我们可以定义进行泛型方法。
b、定义泛型方法
语法：
public class 普通类{
public <T> T getValue(){
}
public <T> void setValue(T t){
}
}
public class Convert {
/**
* 转成字符串的方法
* @param <T> ： 任意类型
* @return
*/
public <T> String convertString(T t){
return t.toString();
}
public <K,V> V converted(K k){
return (V)k;// 强转的前提 是k -v 有关系
}
泛型的好处：
1、 可以对类的数据类型 写通用类型，提高代码的复用性 和 可扩展性
2.4 泛型通配符
在定义泛型时除了可使用大写字母表示一种泛型类以外，还可以使用通配符表示泛型类型，如下三种表示方法
:表示一种通用的泛型类，与 T t = new T() // 语法满足
? t = new ?() // 语法不满足
"< T >" 是一种确定的类型 ， 可以表示定义泛型类或泛型方法
"<?>"是一种不确定的类型， 不能定义泛型类或泛型方法， 通常用于作为方法的形参
public class Dept<T> {
// 第一个员工
private T first;
// 第二个员工
private T second;
public class Employee {
private String ename;
public String getEname() {
return ename;
}
public class Manager extends Employee {
// 通过经理对象 给经理赋值名称
public Manager(String ename){
super(ename);
}
// 使用不确定的泛型类型 <?>
/**
*
* 这里的部门的泛型可以是任意类型
*/
public void showInfo(Dept<?> dept){
System.out.println(dept.getFirst());
}
/**
* @param dept 的泛型可以是Employee 或者继承自Employee
* @param dept
*/
public void showInfo2(Dept<? extends Employee> dept){
System.out.println(dept.getFirst());
System.out.println(dept.getSecond());
}
/**
*
* @param dept 的泛型必须是 Manager 或者 Manager的父类
*/
public void showInfo3(Dept<? super Manager> dept){
System.out.println(dept.getFirst());
System.out.println(dept.getSecond());
}
public static void main(String[] args) {
TestDept obj = new TestDept();
//创建部门对象
Dept<String> dept = new Dept();
dept.setFirst("员工1");
dept.setSecond("员工2");
obj.showInfo(dept);
// 在部门中添加 员工对象
Dept<Employee> dept2 = new Dept();
dept2.setFirst(new Employee("小强"));
dept2.setSecond(new Employee("小花"));
//这里的dept2的泛型是 Employee
obj.showInfo2(dept2);
Dept<Manager> dept3 = new Dept();
dept3.setFirst(new Manager("张经理"));
dept3.setSecond(new Manager("王经理"));
//这里的dept3的泛型是 Manager
obj.showInfo2(dept3);
// 调用时 参数的泛型必须是 Manager 或Manager的父类
obj.showInfo3(dept3);
obj.showInfo3(dept2);
}
