Quartz 4

Generic in java

12 min read

泛型

You use generic to describe something that refers or relates to a whole class of similar things. [usu ADJ n] 一般的；普通的；通用的；
Parmesan is a generic term used to describe a family of hard Italian cheeses.
帕尔玛干酪是意大利硬奶酪的通称。

泛（广泛）型（类型）

  1. 泛型又称参数化类型，是Jdk5.0出现的新特性，解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体的类型即可。
  3. Jva泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException异常。同时，代码更加简洁、健壮
  4. 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。
// 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
 
class Person<E> {
    E s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
 
    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }
 
    public E f() {//返回类型使用E
        return s;
    }
 
    public void show() {
        System.out.println(s.getClass());//显示s的运行类型
    }
}
 
public static void main(String[] args) {
		
        // 注意，特别强调： E具体的数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
        Person<String> person = new Person<String>("韩顺平教育");
        person.show(); //String
 
        /*
            你可以**这样理解**，上面的Person类
            class Person {
                String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
 
                public Person(String s) {//E也可以是参数类型
                    this.s = s;
                }
 
                public String f() {//返回类型使用E
                    return s;
                }
            }
         */
 
        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer
			/*   这样理解
            class Person {
                Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
 
                public Person(Integer s) {//E也可以是参数类型
                    this.s = s;
                }
 
                public Integer f() {//返回类型使用E
                    return s;
                }
            }
         */
}

泛型的应用

泛型的声明

interface 接口<T>{}
和
class 类 <K,V>{}

比如：List,ArrayList

  1. 其中，T,K,V不代表值，而是表示类型
  2. 任意字母都可以。常用T表示，是Type的缩写

泛型的实例化
要在类名后面指定类型参数的值（类型）。如：

List<String> strList = new ArrayList<>();
// 使用泛型方式给HashSet 放入3个学生对象
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("jack", 18));
students.add(new Student("tom", 28));
students.add(new Student("mary", 19));
 
 //遍历
for (Student student : students) {
	 System.out.println(student);
}
//使用泛型方式给HashMap 放入3个学生对象
//K -> String   V -> Student
HashMap hm = new HashMap();
hm.put("milan", new Student("milan", 38));
hm.put("smith", new Student("smith", 48));
// 遍历使用 迭代器 通过 EntrySet
Set<Map.Entry<String, Student>> entries = hm.entrySet(); // 获取 entrySet 集合
Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
while (iterator.hasNext()) {
	 Map.Entry<String, Student> next = iterator.next();
	 System.out.println(next.getKey() + "-" + next.getValue());
}

  • k-v 为了方便程序员遍历，还会创建 EntrySet 集合，该集合存放的元素 类型 是 Entry，而一个Entry 对象 就有k-v， 也就是Entry<K,V>
Link to original

实现泛型类或接口时，T,E只能是引用类型
引用类型（reference types）: Integer\Long\Double\Boolean

List<Integer>list = new ArrayList<Integer>(); // OK
// List<int>list = new ArrayList<>(); // Wrong!!

在给泛型指定具体类型后，可以传入该类型或者其子类类型

class A{}
class B extends A{}
class Pig<E>{
	E e;
	public Pig(E e) { 
		this.e = e;
	}
}
 
public class Test{
	public static void main(String[] args) {
			Pig<A> aPig = new Pig<A>(newA());
			Pig<A> aPig = new Pig<A>(newB());
	}
}

自定义泛型

class 类名 <T,R..> { //…表示可以有多个泛型
成员
}

  1. 普通成员可以使用泛型
  2. 使用泛型的数组，不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型)
  5. 如果在创建对象时，没有指定类型，默认为Object
class Tiger<T, R, M> {
	String name;
	R r;
	M m;
	T t;
	T[] ts; // 在之后实例化
	
	public Tiger(String name, R r, M m, T t) {// 构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
	// public static void f1(M m){}  因为静态是和类相关的，在类加载的时候，对象还没创建
}

interface 接口名<T,R..>{
}

  1. 接口中，静态成员也不能使用泛型（这个和泛型类规定一样）
  2. 泛型接口的类型，在继承接口或者实现接口时确定
  3. 没有指定类型，默认为Object
interface IUsb<U, R> {
    int n = 10; // 接口中的属性，只能是 final 的，而且是public static final修饰符。
    // 比如： int a = 1; 实际上是 **public static final** int a = 1; (必须初始化)
 
    //U name; 不能这样使用
 
    //普通方法中，可以使用接口泛型
    R get(U u);
 
    void hi(R r);
 
    void run(R r1, R r2, U u1, U u2);
 
    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
 
    default R method(U u) {
        return null;
    }
}

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。特别说明：Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

修饰符<T,R..> 返回类型 方法名（参数列表）{
}

泛型方法，可以定义在普通类中，也可以定义在泛型类中

class Fish<T, R> {//泛型类
 
    public void run() {//普通方法
    }
 
    public<U,M> void eat(U u, M m) {//泛型方法
    }
 
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
 
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}
class Main{
	public static void main(String[] args){
			new Fish<String, ArrayList>.hello(new ArrayList(), 11.2f);
	}
 
}

泛型没有继承性

// List<Object> list = new ArrayList<String>();

<?>:支持任意泛型类型
<?extends A>:支特A类以及A类的子类，规定了泛型的上限
<?super A:>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

class AA{
}
class BB extends AA{
}
class CC extends BB {
}
public class Main{
	public static void main(String[] args){
		 List<Object> list1 = new ArrayList<>();
		 List<String> list2 = new ArrayList<>();
		 List<AA> list3 = newArrayList<>();
		 List<BB> list4 = newArrayList<>();
		 List<CC> list5 = newArrayList<>();
 
      // 如果是 List c ，可以接受任意的泛型类型
		 printCollection1(list1);
		 printCollection1(list2);
		 printCollection1(list3);
		 printCollection1(list4);
		 printCollection1(list5);
		 
		 //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
		 // printCollection2(list1);//×
		 // printCollection2(list2);//×
		 printCollection2(list3);//√
		 printCollection2(list4);//√
		 printCollection2(list5);//√
		 
		 //List<? super AA> c: 支持 AA 类以及AA类的父类，不限于直接父类
		 printCollection3(list1);//√
		 //printCollection3(list2);//×
		 printCollection3(list3);//√
		 //printCollection3(list4);//×
		 //printCollection3(list5);//×
	
	}
	 // ? extends AA 表示 上限，可以接受 AA或者AA子类
	public static void printCollection2(List<? extends AA> c) {
		 for (Object object : c) {
			 System.out.println(object);
			}
	 }
	  //说明: List<?> 表示 任意的泛型类型都可以接受
	public static void printCollection1(List<?> c) {
		 for (Object object : c) { // 通配符，取出时，就是Object
			 System.out.println(object);
		 }
	 }
	 // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
	public static void printCollection3(List<? super AA> c) {
		for (Object object : c) {
			System.out.println(object);
		 }
	}
}

类型擦除机制

Java 的类型擦除

Java 的泛型是“伪泛型”。为了兼容旧版本的 JDK（Java 5 之前没有泛型），Java 采用了类型擦除机制。

  • 编译时：编译器会帮你做类型检查。
  • 编译后：所有的泛型信息都会被擦除，替换为它们的上界（如果没有指定上界，则替换为 Object）。
    List<String>，编译成字节码后，在运行时它仅仅是一个 List。JVM 并不知道里面装的是 String 还是 Integer

Kotlin 运行在 JVM 上，因此它必须遵守 JVM 的底层规则。这意味着 Kotlin 的泛型在运行时同样会被擦除。

// 你写的代码
val list: List<String> = listOf("A")
 
// 运行时实际的样子（和 Java 一样被擦除了）
val list: List = listOf("A")

既然类型被擦除了，怎么才能在运行时获取 T 的具体类型呢？
Java 的做法通常是笨拙地手动传递 Class<T>

public class LogFactory {
    // 泛型方法，显式接收 Class<T> 参数
    public static <T> Logger getLogger(Class<T> clazz) {
        return LoggerFactory.getLogger(clazz);
    }
}
@Service
public class UserService {
 
    // 调用时显式传入当前类的 Class 对象
    private static final Logger log = LogFactory.getLogger(UserService.class);
 
    public void createUser(String username) {
        log.info("正在创建用户: {}", username);
        // 业务逻辑...
    }
}

Graph View