大家好,又见面了,我是你们的朋友全栈君。
package study1118;
A T
//泛型类的定义 class 泛型名<类型> { }
//泛型类中所有类型都将会时新建泛型对象时,new的时候指定的那种类型
class A<T>{
private T key;
public void setKey(T key) {
this.key = key;
}
public T getKey(){
return this.key;
};
}
public class Test01 {
public static void main(String[] args) {
//新建一个泛型对象,指定泛型为String
A<String> a1 = new A<>();
a1.setKey("sadas");
String s = a1.getKey();
System.out.println(s);
//新建一个泛型对象,指定泛型为Integer
A<Integer> a3 = new A<>();
a3.setKey(5);
int i = a3.getKey();
System.out.println(i);
//新建一个泛型对象,若不定义泛型则默认泛型为Object
A a2=new A();
a2.setKey(new Object());
Object key = a2.getKey();
System.out.println(key);
//同样的泛型类,在new对象时候,泛型指定不同的数据类型生成的泛型对象之间不能互相赋值
//但进行赋值的类如果有泛型为Object的类则可以,涉及到自动转换类型
a1=a3;//编译报错
a3=a1;//编译报错
a3=a2;//通过
}
}
package study1118;
//泛型接口的定义
interface IB<T>{
T test(T t);
//接口中的方法默认都是抽象方法(没有方法体)
//需要在实现类中进行重写
}
//实现接口IB的抽象方法时,如果未传入实参(此处的实参是某一种泛型),默认泛型为定义接口时所指定的类型
class B1<T> implements IB<T>{
@Override
public T test(T t) {
return t;
}
}
//实现接口IB的抽象方法时,如果传入了指定泛型类型,则这个类实现接口的所有方法的参数都将指定为该泛型类型
class B2 implements IB<String>{
@Override//重写方法的快捷键ctrl+O
public String test(String s) {
return null;
}
}
public class Test02 {
public static void main(String[] args) {
//B1类和B2类用法上的区别
//新建B1类对象时候,需要指定泛型类型,若不指定会默认为Object类型,因为定义B1类时没有限制泛型,可以任意
B1 objectB1 = new B1<Integer>();
//新建B2类对象时候,不需要指定泛型类型,因为定义B2类时已经限制了泛型(此处为String)
B2 b2 = new B2();
}
}
class C1{
// 定义泛型方法(无返回值的方法)
public<T> void test(T s){
T st = s ;
}
// 定义泛型方法(有返回值,返回类型为T的方法)
public<T> T test1(T s){
return s;
}
//有可变参数的方法
public void test2(String... strs){
for (String str : strs) {
System.out.println(str);
}
}
//有可变参数的泛型方法
public<T> void test3(T... strs){
for (T str : strs) {
System.out.println(str);
}
}
}
泛型静态方法
class C2<E>{
private E e;
//在类上定义的泛型,可以在普通的方法中使用
public <T> void test(T s){
System.out.println(this.e);
}
//在类上定义的泛型,无法在静态方法中使用
public static void test1(){
// System.out.println(this.e);//编译报错——因为无法从静态上下文中引用非静态 变量 this
}
// 静态方法如果要使用泛型,应该在定义静态方法时同时指明泛型
public static<T> void test2(T t){
System.out.println(t);
}
使用泛型方法的好处——动态数据类型
public class Test02 {
public static void main(String[] args) {
C2<Object> c = new C2<>();
//泛型方法可以根据传入的参数数据类型来确定返回类型,意思就是数据类型是动态的,在调用方法时才会确定
String s=c.test("xxx");
Integer i=c.test(1);
Boolean b=c.test(true);
}
}
通配符——在不确定集合中的元素数据类型时,可以使用“?”来表示所有类型
package study1118;
import java.util.ArrayList;
import java.util.List;
class Dd{
public void meth(List<?> list){
}
//假设有一个方法meth(),需要一个list集合的参数,但是目前不确定list中存的数据到底是什么类型,所以可以用"?"表示任意泛型
public class Test03 {
public static void main(String[] args) {
Dd dd = new Dd();
//新建一个list集合,往里面丢两个字符串对象
List<String> l1 = new ArrayList<>();
l1.add("asas");
l1.add("qqqq");
dd.meth(l1);//此时meth方法就接收到了一个装有String数据类型的集合l1
//新建一个list集合,往里面丢两个数字类型的对象
List<Integer> l2 = new ArrayList<>();
l2.add(50);
l2.add(3);
dd.meth(l2);//此时meth方法就接收到了一个装有Integer数据类型的集合l2
}
}
}
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/168484.html原文链接:https://javaforall.cn