泛型(Generics)
为了能够更好的学习容器，我们首先要先来学习一个概念：泛型。
泛型的本质就是“
数据类型的参数化
”
，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“
泛型
”
理解为数据类型的一个占位符(
类似：形式参数
)
，即告诉编译器，在调用泛型时必须传入实际类型
把类型当作是参数一样传递。< 数据类型 > 只能是引用类型。
泛型的好处：
代码可读性更好【不用强制转换】2程序更加安全【只要编译时期没有警告，运行时期就不会出现ClassCastException异常】
泛型主要是方便了程序员的代码编写，以及更好的安全性检测。只在编译时有效果
泛型类
定义泛型时，一般采用几个标记：E
、
T
、
K
、
V
、
N
、？。他们约定俗称的含义如下：
语法结构 ：public class 类名 < 泛型标识符号 > {}public class 类名 < 泛型标识符号 , 泛型标识符号 > {}
例子：
public class Generic<T> {
private T flag;
public void setFlag(T flag){
this.flag = flag;
}
public T getFlag(){
return this.flag;
}
}
public class Test {
public static void main(String[] args) {
//创建对象时，指定泛型具体类型。
Generic<String> generic = new Generic<>();
generic.setFlag("admin");
String flag = generic.getFlag();
System.out.println(flag);
//创建对象时，指定泛型具体类型。
Generic<Integer> generic1 = new Generic<>();
generic1.setFlag(100);
Integer flag1 = generic1.getFlag();
System.out.println(flag1);
}
}泛型接口
和泛型类的声明方式一致。
public interface IGeneric<T> {
T getName(T name);
}
//在实现接口时传递具体数据类型
public class IgenericImpl implements Igeneric<String> {
@Override
public String getName(String name) {
return name;
}
}
//在实现接口时仍然使用泛型作为数据类型
public class IGenericImpl2<T> implements IGeneric<T>{
@Override
public T getName(T name) {
return name;
}
}
public class Test {
public static void main(String[] args) {
IGeneric<String> igeneric= new IGenericImpl();
String name =igeneric.getName("秃头");
System.out.println(name);
IGeneric<String> igeneric1 = new IGenericImpl2<>();
String name1 =igeneric1.getName("秃头小子");
System.out.println(name1);
}
}泛型方法
非静态方法
非静态方法可以使用泛型类中所定义的泛型，也可以将泛型定义在方法上。
语法结构// 无返回值方法public < 泛型标识符号 > void getName ( 泛型标识符号 name ){}// 有返回值方法public < 泛型标识符号 > 泛型标识符号 getName ( 泛型标识符号 name ){}
示例：
public class MethodGeneric {
public <T> void setName(T name){
System.out.println(name);
}
public <T> T getAge(T age){
return age;
}
}
public class Test2 {
public static void main(String[] args) {
MethodGeneric methodGeneric = new MethodGeneric();
methodGeneric.setName("秃头");
Integer age =methodGeneric.getAge(123);
System.out.println(age);
}
静态方法
静态方法中使用泛型时有一种情况需要注意一下，那就是静态方法无法访问类上定义的泛型，所以必须要将泛型定义在方法上。
语法结构：// 无返回值静态方法public static < 泛型标识符号 > void setName ( 泛型标识符号 name ){}// 有返回值静态方法public static < 泛型标识符号 > 泛型表示符号 getName ( 泛型标识符号 name ){}
例子：
public class MethodGeneric {
public static <T> void setFlag(T flag){
System.out.println(flag);
}
public static <T> T getFlag(T flag){
return flag;
}
}
public class Test4 {
public static void main(String[] args) {
MethodGeneric.setFlag("秃头");
Integer flag1 =MethodGeneric.getFlag(123123);
System.out.println(flag1);
}
}泛型方法与可变参数
在泛型方法中，泛型也可以定义可变参数类型。
语法结构public < 泛型标识符号 > void showMsg ( 泛型标识符号 ... agrs ){}
例子：
public class MethodGeneric {
public <T> void method(T...args){
for(T t:args){
System.out.println(t);
}
}
}
public class Test5 {
public static void main(String[] args) {
MethodGeneric methodGeneric = new MethodGeneric();
String[] arr = new String[]{"a","b","c"};
Integer[] arr2 = new Integer[]{1,2,3};
methodGeneric.method(arr);
methodGeneric.method(arr2);
}
}泛型中的通配符
无界通配符
“?”表示类型通配符，用于代替具体的类型。它只能在
“<>”
中使用。可以解决当具体类型不确定的问题
语法结构public void showFlag ( Generic <?> generic ){}
例子：
public class Generic<T> {
private T flag;
public void setFlag(T flag){
this.flag = flag;
}
public T getFlag(){
return this.flag;
}
}
public class ShowMsg {
public void showFlag(Generic<?> generic){
System.out.println(generic.getFlag());
}
}
public class Test3 {
public static void main(String[] args) {
ShowMsg showMsg = new ShowMsg();
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
Generic<Number> generic1 = new Generic<>();
generic1.setFlag(50);
showMsg.showFlag(generic1);
Generic<String> generic2 = new Generic<>();
generic2.setFlag("秃头");
showMsg.showFlag(generic2);
}
}通配符的上下限定
对通配符的上限的限定：<
？
extends
类型
>？实际类型可以是上限限定中所约定的类型，也可以是约定类型的子类型
语法结构public void showFlag ( Generic <? extends Number > generic ){}
例子：
public class ShowMsg {
public void showFlag(Generic<? extends
Number> generic){
System.out.println(generic.getFlag());
}
}
public class Test4 {
public static void main(String[] args) {
ShowMsg showMsg = new ShowMsg();
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
Generic<Number> generic1 = new Generic<>();
generic1.setFlag(50);
showMsg.showFlag(generic1);
}
}通配符的下限限定
对通配符的下限的限定：<
？
super
类型
>
21
？实际类型可以是下限限定中所约定的类型，也可以是约定类型的父类型；
语法结构：public void showFlag ( Generic <? super Integer > generic ){}
例子：
public class ShowMsg {
public void showFlag(Generic<? superInteger> generic){
System.out.println(generic.getFlag());
}
}
public class Test6 {
public static void main(String[] args) {
ShowMsg showMsg = new ShowMsg();
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
Generic<Number> generic1 = new Generic<>();
generic1.setFlag(50);
showMsg.showFlag(generic1);
}
}泛型局限性和常见错误
泛型主要用于编译阶段，编译后生成的字节码class
文件不包含泛型中的类型信息。 类型参数在编译后会被替换成Object
，运行时虚拟机并不知道泛型。因此，使用泛型时，如下几种情况是错误的
基本类型不能用于泛型Test<int> t ; 这样写法是错误，我们可以使用对应的包装类Test<Integer> t ;2不能通过类型参数创建对象T elm = new T() ; 运行时类型参数 T 会被替换成 Object ，无法创建 T 类型的对象，容易引起误解， java 干脆禁止这种写法。
只讲干货
#有什么错误的地方大家多多担待，欢迎大家留下意见共同努力。
#需要什么技术的内容大家也可以积极留言。
#有升本的伙伴也可留言，后序也可更新升本内容C 和数据结构。
#有需要的伙伴或有什么问题直接联留下wx或联系邮箱2821835676qq.com
扫一扫
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
