泛型类及其方法
- 泛型定义在类名上, ,T 可以是任意字符如A、B、C。
- 类中的方法(普通方法、静态方法、构造方法)可以使用类的泛型T。
package com.example.demo;
import lombok.Data;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/**
* @author CCL
* @createTime 2021年12月24日
*/
@Data
public class Demo1<T> {
private int age;
private T a;
public Demo1(int age, T a) {
this.age = age;
this.a = a;
}
/**
* 入参为泛型,出参为void
*/
public void call(T a) {
this.a = a;
System.out.println(a);
}
/**
* 入参为泛型,出参为特定类型
*/
public String say(T a) {
return a.toString();
}
/**
* 入参为泛型,出参为泛型,List<T>为出参类型
*/
public List<T> cry(T a) {
return Collections.singletonList(a);
}
/**
* 入参为泛型,出参为泛型
*
* @param set
* @return
*/
public List<T> cry(Set<T> set) {
return Collections.singletonList(set.iterator().next());
}
/**
* 用<>表示的方法才是泛型方法,否则只能是使用了类泛型的方法
* @param e
* @param t
* @param <E>
*/
public <E> void fun1(E e,T t){
System.out.println(e.toString());
System.out.println(t.toString());
}
}
普通类中的泛型方法
- 类可以没有泛型。
- 方法必须在公开符和返回参数之间用 标识这是一个泛型方法。
import java.util.Collections;
import java.util.List;
public class Demo2 {
//泛型作为入参
public <E> void fun1(E t){
System.out.println(t.toString());
}
//有返回值的泛型
public <E> List<E> fun2(E t){
return Collections.singletonList(t);
}
//多个泛型
public <E,T> List<E> fun2(E e,T t){
System.out.println(e);
System.out.println(t);
return Collections.singletonList(e);
}
}
泛型的范围限定
1. 用泛型限定T只能是某个类的子类
示例1:用在类上,并泛型调用方法
public class Demo3<T extends Number> {
public void demo(T t){
System.out.println(t.intValue());
}
public static void main(String[] args) {
Demo3<Long> demo3 = new Demo3<>();
Long size = 4L;
demo3.demo(size);
}
}
示例2:用在集合上,可以get,get出来的使用泛型指定的父类型来接收。但add时无论什么类型都会报错。
public class Demo4{
public static void main(String[] args) {
List<? extends Number> list= new ArrayList<>();
List<String> strList = Arrays.asList("a", "b");
List<Integer> intList = Arrays.asList(1, 2);
//Integer为Number的子类型,赋值正常
list=intList;
//String的List在编译时会报错
list=strList;
}
}
示例3:
public void play(){
//这里赋值没问题
List<? extends A> list = Arrays.asList(new A(), new B(), new C());
//取出可以
A a0 = list.get(0);
A a1 = list.get(1);
A a2 = list.get(2);
//下面所有add编译报错,因为
list.add(new A());
list.add(new B());
list.add(new C());
list.add(new Object());
}
2. 限定下限
用泛型设定?只能是指定类型及其父类。
用在集合上时,可以add指定类型及其父类,get时只能用Object接收。
class A {}
class B extends A{}
class C extends B{}
public static void main(String[] args) {
List<? super B> list = new ArrayList<>();
list.add(new A());//报错,只能add B及其父类
list.add(new B());
list.add(new C());
System.out.println(list);
//get出的类型为Object
Object object = list.get(0);
}
3.无限定通配符
无限定通配符表示不需要限定任何类型。
class PairAlg {
public boolean play(List<?> p) {
return p.get(0) == null || p.get(1) == null;
}
public static boolean hasNulls(List<?> p) {
return p.get(0) == null || p.get(1) == null;
}
}