当前位置：首页 > news >正文

旅游网站建设策划方案软文撰写

news 2025/8/20 2:22:17

旅游网站建设策划方案,软文撰写,php和c 做网站的区别,望野原文及翻译赏析文章目录一、泛型介绍1. 背景2. 概念3. 好处二、泛型声明泛型类型符号泛型声明方式三、类型擦除1. 什么是类型擦除桥接方法2. 为何需要类型擦除3. 类型信息并未完全擦除四、泛型使用1. 泛型类2. 泛型接口3. 泛型方法五、泛型扩展1. 泛型的上下边界泛型的上边界泛型的下边界2. 泛…

文章目录

一、泛型介绍
- 1. 背景
- 2. 概念
- 3. 好处
二、泛型声明
- 泛型类型符号
- 泛型声明方式
三、类型擦除
- 1. 什么是类型擦除
- - 桥接方法
- 2. 为何需要类型擦除
- 3. 类型信息并未完全擦除
四、泛型使用
- 1. 泛型类
- 2. 泛型接口
- 3. 泛型方法
五、泛型扩展
- 1. 泛型的上下边界
- - 泛型的上边界
  - 泛型的下边界
- 2. 泛型中使用&(并且)操作符

一、泛型介绍

1. 背景

在JDK5之前，还没有泛型。在使用集合时，需要构建一个元素类型为Object的集合，集合能够存储任意的数据类型对象，在使用该集合的过程中，需要明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。

2. 概念

JDK5中引入Java泛型这个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。

泛型主要是方便了程序员的代码编写，以及更好的安全性检测。
泛型是一种运用于编译时期的技术，泛型的出现，实现了把运行阶段的错误提前暴露到了编译阶段。

在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

参数化类型

泛型的本质就是参数化类型。在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。

参数化类型，顾名思义就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

简单理解：泛型就是把类型当作是参数一样进行传递，数据类型只能是引用类型。

3. 好处

编译时类型安全监测
消除强制类型转换

二、泛型声明

泛型的使用需要先声明，声明通过<符号>的方式，符号可以任意，编译器通过识别尖括号和尖括号内的字母来解析泛型。

泛型的类型只能为引用类型，不能为基本类型
尖括号的位置也是固定的，只能在类名之后或方法返回值之前

泛型类型符号

一般约定的类型符号：

E：Element (表示集合元素，在集合中使用)
T：Type（表示Java类）
K：Key（表示键，比如Map中的key）
V：Value（表示值，比如Map中的key）
N：Number（表示数值类型）
?：泛型通配符（表示不确定的Java类型）

泛型声明方式

常见声明方式：

<T>：普通声明
<?>：无边界声明
<? extends 类>：上边界声明
<? super 类>：下边界声明

需要注意：通配符?不能在泛型类（接口）的声明上使用。

三、类型擦除

1. 什么是类型擦除

Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。

官方描述：
泛型被引入Java语言，以在编译时提供更严格的类型检查，并支持泛型编程。

为了实现泛型，Java编译器将类型擦除应用于：

如果类型参数是无界的，则将泛型类型中的所有类型参数替换为其边界或Object。因此，生成的字节码只包含普通类、接口和方法。
如果需要，请插入类型强制转换以保持类型安全。
生成桥接方法以保留扩展泛型类型中的多态性。

类型擦除确保了不会为参数化类型创建新类；所以泛型是没有运行时开销的。

对官方描述的理解：

泛型的使用，使得编译器在编译时进行了更严格类型检查，避免运行时引发ClassCastException异常
泛型应用于编译阶段，用泛型定义的类型参数，会在编译时会去掉，这称之为“类型擦除”。编译后生成的字节码class文件不包含泛型类型信息，运行时虚拟机并不知道泛型。
1. 编译时，泛型的类型参数会被替换为其边界或Object
2. 编译时，使用泛型的地方会插入强制类型转换
3. 在泛型父类、泛型接口的场景中，会生成桥接方法以保留泛型类型中的多态性。
  - 编译时，如果子类复写的父类中的方法使用了泛型类型，子类会自动生成一个该方法的桥接方法
  - 编译时，如果实现类实现接的接口方法使用了泛型类型，实现类会自动生成一个该方法的桥接方法

public class Test {public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();ArrayList<Integer> list2 = new ArrayList<>();System.out.println(list1.getClass() == list2.getClass());}
}

打印结果为true，因为list1和list2的Class对象是同一个Class。

特别注意：对于编译后生成的字节码class文件不包含泛型类型信息这句话，网上普遍都说这个说法，但都没去仔细解释，理解的时候可能会有不解，因为你发现现实中的class文件中时是包含了泛型类型信息的。下文会解释这个问题。

桥接方法

桥接方法是JDK1.5引入泛型后，为使java泛型方法生成的字节码与JDK1.5版本之前的字节码兼容由编译器自动生成的。

子类继承父类（实现接口）实现泛型方法的情况，父类经过编译后方法的泛型类型入参和返回值类型都为Object（或上边界类型），而子类的实现方法的入参和返回值类型为具体的泛型类型（如String），此时子类并没有重写父类的方法了（返回值和形参与父类完全相同才是重写方法），所以需要编译器生成一个桥接方法达到重写父类方法的目的。

因此当子类继承父类（实现接口）实现泛型方法的时候，编译器会为子类自动生成桥接方法。

举例说明：

public interface TestInterface<T> {T get();void set(T t);
}class Test3 implements TestInterface<Integer> {@Overridepublic Integer get() {return null;}@Overridepublic void set(Integer s) {}
}
class MainClass {public static void main(String[] args) {Method[] methods = Test3.class.getDeclaredMethods();for (Method method : methods) {System.out.println((method.isBridge() ? "桥接方法：" : "普通方法：") + method.toGenericString());}}
}

打印结果：

桥接方法：public java.lang.Object com.joker.test.generic.Test3.get()
普通方法：public java.lang.Integer com.joker.test.generic.Test3.get()
桥接方法：public void com.joker.test.generic.Test3.set(java.lang.Object)
普通方法：public void com.joker.test.generic.Test3.set(java.lang.Integer)

以set方法作分析：

编译时，经过类型擦除后，TestInterface接的set方法变成了void set(Object t)
而实现类Test3原本的实现方法是void set(Integer s)，明显已经不再是实现方法了
为了解决这个问题，Java编译器通过桥接的生成了一个**void set(Object t)**方法，保证了实现方法

2. 为何需要类型擦除

为什么Java不像C#一样实现真正的泛型呢？而要用类型擦除的方式实现了个伪泛型。

其实JDK1.5引入的泛型采用类型擦除式实现的根本原因是兼容性上的取舍，而不是因为实现不了真正意义上的泛型。

为了确保JDK1.5之前的和JDK1.5能使用同一个类加载器，所以Java通过类型擦除的方式实现的泛型支持。经过编译阶段的泛型类型擦除后，与JDK1.5之前是基本没有变动。

3. 类型信息并未完全擦除

下面举例说明：

定义一个Demo泛型类和一个Test测试类。

public class Demo<T> {private T id;public T getId() {return id;}
}

public class Test {public static void main(String[] args) {Demo<Integer> demo = new Demo<>();Integer id = demo.getId();}
}

1. 查看IDEA编译后的class文件
Demo.calss

public class Demo<T> {private T id;public Demo() {}public T getId() {return this.id;}
}

Test.class

public class Test {public Test() {}public static void main(String[] args) {Demo<Integer> demo = new Demo();Integer id = (Integer)demo.getId();}
}

从class文件可见：

使用泛型的地方进行了强制类型转换
但泛型的类型参数并未替换为Object

原因：在编译过程中，泛型信息是被擦除了，但是声明侧的泛型信息会被class文件以Signature的形式保留在Class文件的Constant pool中。

2. 使用javap命令反编译Demo.class文件和Test.class文件
javap -v Demo.class

Classfile /D:/work/my/springboot/target/classes/com/joker/test/generic/Demo.classLast modified 2023-2-14; size 610 bytesMD5 checksum 4851ec541c05f1d29bee93edb79085f0Compiled from "Demo.java"
public class com.joker.test.generic.Demo<T extends java.lang.Object> extends java.lang.Objectminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #4.#24         // java/lang/Object."<init>":()V#2 = Fieldref           #3.#25         // com/joker/test/generic/Demo.id:Ljava/lang/Object;#3 = Class              #26            // com/joker/test/generic/Demo#4 = Class              #27            // java/lang/Object#5 = Utf8               id#6 = Utf8               Ljava/lang/Object;#7 = Utf8               Signature#8 = Utf8               TT;#9 = Utf8               <init>#10 = Utf8               ()V#11 = Utf8               Code#12 = Utf8               LineNumberTable#13 = Utf8               LocalVariableTable#14 = Utf8               this#15 = Utf8               Lcom/joker/test/generic/Demo;#16 = Utf8               LocalVariableTypeTable#17 = Utf8               Lcom/joker/test/generic/Demo<TT;>;#18 = Utf8               getId#19 = Utf8               ()Ljava/lang/Object;#20 = Utf8               ()TT;#21 = Utf8               <T:Ljava/lang/Object;>Ljava/lang/Object;#22 = Utf8               SourceFile#23 = Utf8               Demo.java#24 = NameAndType        #9:#10         // "<init>":()V#25 = NameAndType        #5:#6          // id:Ljava/lang/Object;#26 = Utf8               com/joker/test/generic/Demo#27 = Utf8               java/lang/Object
{public com.joker.test.generic.Demo();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: returnLineNumberTable:line 7: 0LocalVariableTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/joker/test/generic/Demo;LocalVariableTypeTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/joker/test/generic/Demo<TT;>;public T getId();descriptor: ()Ljava/lang/Object;flags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: getfield      #2                  // Field id:Ljava/lang/Object;4: areturnLineNumberTable:line 13: 0LocalVariableTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/joker/test/generic/Demo;LocalVariableTypeTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/joker/test/generic/Demo<TT;>;Signature: #20                          // ()TT;
}
Signature: #21                          // <T:Ljava/lang/Object;>Ljava/lang/Object;
SourceFile: "Demo.java"

javap -v Test.class

Classfile /D:/work/my/springboot/target/classes/com/joker/test/generic/Test.classLast modified 2023-2-14; size 739 bytesMD5 checksum a82bd374c2bff99147acd130f3819415Compiled from "Test.java"
public class com.joker.test.generic.Testminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #7.#28         // java/lang/Object."<init>":()V#2 = Class              #29            // com/joker/test/generic/Demo#3 = Methodref          #2.#28         // com/joker/test/generic/Demo."<init>":()V#4 = Methodref          #2.#30         // com/joker/test/generic/Demo.getId:()Ljava/lang/Object;#5 = Class              #31            // java/lang/Integer#6 = Class              #32            // com/joker/test/generic/Test#7 = Class              #33            // java/lang/Object#8 = Utf8               <init>#9 = Utf8               ()V#10 = Utf8               Code#11 = Utf8               LineNumberTable#12 = Utf8               LocalVariableTable#13 = Utf8               this#14 = Utf8               Lcom/joker/test/generic/Test;#15 = Utf8               main#16 = Utf8               ([Ljava/lang/String;)V#17 = Utf8               args#18 = Utf8               [Ljava/lang/String;#19 = Utf8               demo#20 = Utf8               Lcom/joker/test/generic/Demo;#21 = Utf8               id#22 = Utf8               Ljava/lang/Integer;#23 = Utf8               LocalVariableTypeTable#24 = Utf8               Lcom/joker/test/generic/Demo<Ljava/lang/Integer;>;#25 = Utf8               MethodParameters#26 = Utf8               SourceFile#27 = Utf8               Test.java#28 = NameAndType        #8:#9          // "<init>":()V#29 = Utf8               com/joker/test/generic/Demo#30 = NameAndType        #34:#35        // getId:()Ljava/lang/Object;#31 = Utf8               java/lang/Integer#32 = Utf8               com/joker/test/generic/Test#33 = Utf8               java/lang/Object#34 = Utf8               getId#35 = Utf8               ()Ljava/lang/Object;
{public com.joker.test.generic.Test();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: returnLineNumberTable:line 6: 0LocalVariableTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/joker/test/generic/Test;public static void main(java.lang.String[]);descriptor: ([Ljava/lang/String;)Vflags: ACC_PUBLIC, ACC_STATICCode:stack=2, locals=3, args_size=10: new           #2                  // class com/joker/test/generic/Demo3: dup4: invokespecial #3                  // Method com/joker/test/generic/Demo."<init>":()V7: astore_18: aload_19: invokevirtual #4                  // Method com/joker/test/generic/Demo.getId:()Ljava/lang/Object;12: checkcast     #5                  // class java/lang/Integer15: astore_216: returnLineNumberTable:line 9: 0line 10: 8line 11: 16LocalVariableTable:Start  Length  Slot  Name   Signature0      17     0  args   [Ljava/lang/String;8       9     1  demo   Lcom/joker/test/generic/Demo;16       1     2    id   Ljava/lang/Integer;LocalVariableTypeTable:Start  Length  Slot  Name   Signature8       9     1  demo   Lcom/joker/test/generic/Demo<Ljava/lang/Integer;>;MethodParameters:Name                           Flagsargs
}
SourceFile: "Test.java"

由反编译的文件可知：

声明侧的泛型被记录在Class文件的Constant pool中以Signature的形式保存

对于Java中泛型类型的获取可参考：Java中如何获取泛型类型信息

四、泛型使用

1. 泛型类

泛型类型用于类的定义中，被称为泛型类。用户在使用该类的时候，才把类型明确下来。

在类上定义的泛型，在实例方法中可以直接使用，不需要定义，但不能在静态方法中使用。

原因：Java中泛型只是一个占位符，必须在传递类型后才能使用。类实例化时才能正真的的传递类型参数，由于静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数静态的方法就已经加载完成了。

语法：

public class 类名<泛型表示符号> {
}

示例：

public class Test<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}
}

如果使用时没指定具体的泛型类型，则泛型类型为Object。

    public static void main(String[] args) {Test<String> test1 = new Test<>();String data1 = test1.getData();Test test2 = new Test();Object data2 = test2.getData();}

2. 泛型接口

泛型接口和泛型类的声明方式一致。泛型接口的具体类型需要在实现类中进行声明。
语法：
public interface 接口名<泛型标识符号> {
}
示例：

public interface TestInterface<T> {public T get();public void set(T t);
}

public class Test2 implements TestInterface<String> {@Overridepublic String get() {return null;}@Overridepublic void set(String s) {}
}

如果实现类未指定具体的泛型类型，则泛型类型为Object。

public class Test2 implements TestInterface{@Overridepublic Object get() {return null;}@Overridepublic void set(Object s) {}
}

3. 泛型方法

泛型类型声明在方法上，叫做泛型方法。

需要注意：只是在方法中使用类定义的泛型，该方法不是泛型方法。
语法：

public <泛型表示符号> void 方法名(泛型表示符号 参数名){
}public <泛型表示符号> 泛型表示符号 方法名(泛型表示符号 参数名){
}等......

示例：

public class Test {public static <T> void aaa(T t) {}public <T> void bbb(T t) {}
}

五、泛型扩展

1. 泛型的上下边界

泛型的上边界

泛型类型必须为指定类型的子类型。

格式：<? extends 类>

示例：

public class Test {public void aaa(List<? extends Number> t) {Number number = t.get(0);}public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);Test test = new Test();test.aaa(list);}
}

泛型的下边界

泛型类型必须为指定类型的父类型。
格式：<? super 类>

示例：

public class Test {public void aaa(List<? super Number> t) {Object object = t.get(0);}public static void main(String[] args) {ArrayList<Object> list = new ArrayList<>();list.add(1);Test test = new Test();test.aaa(list);}
}

2. 泛型中使用&(并且)操作符

当需要多重约束的时候，可以使用&操作符
&操作符只能放在泛型的声明上（泛型类、泛型接口、方法方法的声明上）
&操作符后面只能是接口，不能是具体的类型，即使是Object也不行
&操作符不能用于super上，因为java有规定

使用方式：

    // 泛型类上申明，约束泛型类变量class WildcardTypeT<T extends Comparable<T> & List<T> & Serializable> {}// 方法上申明public <R extends Enum<R> & Serializable> List<R> parse2Enums(){}