泛型的知识点

泛型仅存在于编译时期，编译期间JAVA将会使用Object类型代替泛型类型，在运行时期不存在泛型；且所有泛型实例共享一个泛型类

public class Main{
	public static void main(String[] args){
		ArrayList<String> list1=new ArrayList<String>();
		ArrayList<Integer> list2=new ArrayList<Integer>();
		System.out.println(list1 instanceof ArrayList);//true
		System.out.println(list2 instanceof ArrayList);//true
		//System.out.println(list1 instanceof ArrayList<String>);//编译错误，不存在此类型
	}
}

虽然list1和list2属于不同的类型，但是JVM加载的类仅ArrayList，各泛型实例共享这个类；
泛型的4个限制：
(1)不能new T()
(2)不能创建泛型数组：new T[];
但是可以使用强制类型转换的方法，不过编译器会给出一个警告。
T[] arr=(T[])new ArrayList[10];
(3)在静态环境下不能使用泛型类型的参数
如静态方法、静态变量、静态代码块都不能用泛型类型，原因在于各泛型实例共享一个类，而静态成员时随着类的加载就存在了的。
(4)异常类不能是泛型的。

学习地址

以下是关于Java泛型的一些重要知识点：

泛型类：
使用（或任何字母，但通常使用T、E、K、V等作为约定）来声明泛型类。
在类体内部，可以使用泛型类型参数（如T）来声明属性、方法参数和返回值类型。
泛型参数在编译时会被擦除（类型擦除），因此运行时无法知道具体的泛型类型（除非通过其他方式，如使用instanceof检查对象的具体类型）。
泛型方法：
泛型方法可以在普通类或非泛型类中定义。
使用（或其他字母）在方法返回类型之前声明泛型参数。
泛型参数可以与方法参数或局部变量一起使用。
类型擦除：
在编译时，泛型信息会被擦除，替换为原始类型（如Object）。
这意味着在运行时，泛型参数的实际类型信息是未知的。
为了保持类型安全，编译器会在编译时插入类型转换和类型检查。
泛型限制：
可以使用extends关键字为泛型参数设置上界（即该参数必须是某个类的子类或实现了某个接口）。
类似地，可以使用super关键字为泛型参数设置下界（即该参数必须是某个类的超类或接口）。
静态成员与泛型：
静态成员（包括变量、方法和内部类）不能使用类的泛型参数。
这是因为静态成员是与类关联的，而不是与类的任何特定实例关联的。
如果需要在静态上下文中使用泛型，可以定义泛型静态方法或泛型内部类。
泛型通配符：
使用?表示未知的泛型类型。
? extends T表示未知的类型，但它是T或T的子类。
? super T表示未知的类型，但它是T或T的超类。
泛型与数组：
不能创建泛型数组（如new T[10]），因为类型擦除后无法确保类型安全。
但可以使用泛型集合（如ArrayList）来替代。
泛型与原始类型：
如果没有为泛型类型提供实际的类型参数，编译器会将其视为原始类型（即擦除泛型参数的类型）。
这通常是不安全的，因为它会导致类型检查失效。
泛型与类型推断：
Java编译器可以使用类型推断来自动确定泛型方法的类型参数。
这在使用泛型方法时提高了代码的可读性和简洁性。
泛型与泛型方法的区别：
泛型类是在类声明中定义的，泛型参数用于整个类的所有非静态成员。
泛型方法是在方法声明中定义的，泛型参数仅用于该方法内部。
希望这些知识点能帮助你更好地理解和使用Java泛型。

题目一

下面五条语句中，错误的有_______________________________________________。
（1）ArrayList<String> lists = new ArrayList<String>();
（2）ArrayList<Object> lists = new ArrayList<String>();
（3）ArrayList<String> lists = new ArrayList<Object>();
（4）ArrayList<String> lists = new ArrayList();
（5）ArrayList lists = new ArrayList<String>();

ArrayList<Object> lists = new ArrayList<String>(); // 编译错误

这是错误的。它尝试将lists声明为ArrayList类型，但试图用ArrayList的实例来初始化它。在Java中，泛型不是协变的，所以ArrayList不是ArrayList的子类型。

ArrayList<String> lists = new ArrayList<Object>(); // 编译错误

这同样是错误的。它尝试将lists声明为ArrayList类型，但试图用ArrayList的实例来初始化它。这会导致编译时类型不匹配错误，因为ArrayList不是ArrayList的子类型。

题二

3. 下面泛型定义中不正确的是_D_。
   A. class Test1 {}
   B. interface Test2 {}
   C. class Test3{ void test () {}}
   D. class Test4{void test () {}}

D. class Test4{void test () {}} 是不正确的。在Java中，你不能在方法内部定义泛型参数 。泛型参数应该在类、接口或方法的返回类型之前定义。正确的泛型方法定义应该是这样的：

class Test4 {  
    <T> void test() {}  
}

题三

8. 下列语句编译时不出错的是___________。 
A.	List<?> c1 = new ArrayList<String> (); c1.add (new Object ());
B.	List<?> c2 = new ArrayList<String> (); c2.add (new String ("1"));
C.	List<?> c3 = new ArrayList<String> (); c3.add ("1"); 
D. 	List<?> c4 = new ArrayList<String> (); c4.add(null);

在Java中，List<?> 是一个未知类型的列表，这被称为通配符捕获（wildcard capture）。由于它是未知的，你不能向这样的列表中添加任何元素（除了null），因为你不能保证列表的实际类型能够容纳你试图添加的元素。

现在，我们来看每一个语句：

• List<?> c1 = new ArrayList (); c1.add (new Object ());
  这个会编译失败。因为 c1 是一个未知类型的列表，你不能向其添加任何具体的对象（除了null）。

• List<?> c2 = new ArrayList (); c2.add (new String (“1”));
  这个也会编译失败。同样的原因，c2 是一个未知类型的列表，你不能向其添加 String 对象。

• List<?> c3 = new ArrayList (); c3.add (“1”);
  这个也会编译失败。c3 是一个未知类型的列表，你不能向其添加 String 对象。

• List<?> c4 = new ArrayList (); c4.add(null);
  这个不会编译失败。因为 null 可以被赋予任何类型的变量，包括未知类型的列表。

因此，只有c4的语句不会编译失败。

题四

9. 给定下列代码：

class Shape {}
class Circle extends Shape {}
class Triangle extends Shape {}
public class Test2_9 {
    public static void main (String [] args) {
        List<? extends Shape> list1 = new ArrayList< Triangle> ();
        List<? extends Shape> list2 = new ArrayList<Circle> ();

        System.out.println(list1 instanceof List< Triangle>);		①
        System.out.println(list2 instanceof List);				②
        System.out.println(list1.getClass() == list2.getClass());		③
    }
}

则关于语句①②③说法正确的是：___________。
A. ①②③输出结果为true、false、false
B. ①②③输出结果为true、true、true
C. ①编译出错，②③输出结果为false、false
D. ①编译出错，②③输出结果为true、true

选 D ，运行的时候不存在泛型，list1 list2 和 list3运行的时候都是ArrayList

题五

对于泛型类class A { … }，T在A类里可以用作不同的地方，在A类类体内，下面语句正确的有_____________________________________________________________。
A. T x;
B. T m1() {return null;}
C. static T y;
D. void m2(T i) {}
E. static T s1() {return null;}
F. static void s2(T i) {}
G. static void s3(T1 i, T1 j){}

对于泛型类 A，我们可以分析每个选项来确定哪些在类体内是正确的。

• A. T x;
  这是正确的。在泛型类的实例成员变量中，我们可以使用泛型参数 T 来声明一个变量。

• B. T m1() {return null;}
  这也是正确的。在泛型类的方法中，我们可以使用泛型参数 T 作为返回类型或参数类型。但是，这里需要注意的是，如果 T 是一个非可空类型（例如一个具体的类或接口），那么直接返回 null 可能会产生编译错误，除非 T 被声明为可以包含 null（例如 T extends SomeType | null，在Java 8及以上版本使用）。但仅从语法的角度看，这个方法是合法的。

• C. static T y;
  这是不正确的。静态成员变量不能是泛型的，因为静态成员是与类关联的，而不是与类的任何特定实例关联的，因此它们不能在声明时引用实例的类型参数。

• D. void m2(T i) {}
  这是正确的。在泛型类的方法中，我们可以使用泛型参数 T 作为参数类型。

• E. static T s1() {return null;}
  这是不正确的。与C选项类似，静态方法不能引用泛型参数，因为它们是类级别的，而不是实例级别的。

• F. static void s2(T i) {}
  这也是不正确的。静态方法不能引用泛型参数。

• G. static void s3(T1 i, T1 j){}
  这实际上是正确的，但它有点误导，因为它定义了一个新的类型参数 T1，而不是使用类的泛型参数 T。不过，从语法的角度看，这个静态方法声明是合法的，它定义了一个泛型静态方法。

总结：
正确的选项是 A, B, 和 D（如果忽略B选项的 null 返回可能导致的类型不匹配问题）。而G选项虽然技术上也是正确的，但它引入了一个新的类型参数 T1，这可能不是题目所期望的。如果考虑仅使用类声明的泛型参数 T，则G选项不应被视为正确。

题目六

List<? extends Comparable<Double>> x8 = new ArrayList<Double> ();

这个句子是没有问题的

题目七

5. 关于java泛型，下面描述正确的是___________________________。
   A. 泛型的类型参数只能是类类型（包括自定义类），不能是基本类型
   B. 泛型的类型参数可以有多个
   C. 不能对泛型的具体实例类型使用instanceof操作，如 o instanceof ArrayList，否则编译时会出错。
   D. 不能创建一个泛型的具体实例类型的数组，如 new ArrayList[10]，否则编译时会出错。

关于Java泛型的描述，正确的选项是：

A. 泛型的类型参数只能是类类型（包括自定义类），不能是基本类型
这个描述是正确的。在Java中，泛型类型参数不能是基本类型（如int, float, char等），而只能是类类型（包括自定义类、接口、数组类型或另一个泛型类型）。

B. 泛型的类型参数可以有多个
这个描述也是正确的。Java支持定义带有多个类型参数的泛型类和方法。例如：class MyClass<T, U> { … }。

C. 不能对泛型的具体实例类型使用instanceof操作，如 o instanceof ArrayList，否则编译时会出错。
这个描述不完全正确。在Java中，你不能直接使用带有泛型参数的instanceof操作，因为类型擦除导致在运行时泛型信息不可用。但是，你可以省略泛型参数，只检查原始类型，如 o instanceof ArrayList。然而，这并不会导致编译错误，只是这样的检查通常没有太多意义，因为它不会告诉你列表中元素的类型。

D. 不能创建一个泛型的具体实例类型的数组，如 new ArrayList[10]，否则编译时会出错。
这个描述是正确的。在Java中，你不能创建泛型类型的数组，因为类型擦除和数组协变性的结合会导致运行时类型安全问题。如果你尝试这样做，编译器会报错。

综上所述，正确的选项是A、B和D。