public class GenericList
{
public static void main(String[] args)
{
// 创建一个只想保存字符串的List集合
List strList = new ArrayList(); // ①
strList.add(“疯狂Java讲义”);
strList.add(“疯狂Android讲义”);
// 下面代码将引起编译错误
// strList.add(5); // ②
strList.forEach(str -> System.out.println(str.length())); // ③
}
}
======================================================================
泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参(或叫泛型)将在声明变量、创建对象、调用方法时动态地指定(即传入实际的类型参数，也可称为类型实参 ) 。
下面是 Java 5 改写后 List 接口、 Iterator 接口、 Map 的代码片段 。
// 定义接口时指定了 一个泛型形参，该形参名为 E
public interface List{
// 在该接口里. E 可作为类型使用
// 下面方法可以使用 E 作为参数类型
void add (E x);
Iterator iterator(); //①
// 定义接口时指定了一个泛型形参 ，该形参名为 E
}
public interface Iterator{
//在该接口里 E 完全可以作为类型使用
E next() ;
boolean hasNext() ;
// 定义该接口时指定了两个泛型形参，其形参名为 K 、 v
}
public interface Map<K , V>{
// 在该接口里 K 、 V 完全可以作为类型使用
Set keySet() //②
V put(K key, V value)
}
尖括号中的内容一一就是泛型的实质:允许在定义接口、类时声明泛型形参，泛型形参在整个接口、类体内可当成类型使用，几乎所有可使用普通类型的地方都可以使用这种泛型形参 。
可以为任何类、接口增加泛型声明(并不是只有集合类才可以使用泛型声明 ，虽然集合类是泛型的重要使用场所) 。 下面自定义一个 Apple 类，这个 Apple 类就可以包含一个泛型声明 。
Apple.java
// 定义Apple类时使用了泛型声明
public class Apple
{
// 使用T类型定义实例变量
private T info;
public Apple(){}
// 下面方法中使用T类型来定义构造器
public Apple(T info)
{
this.info = info;
}
public void setInfo(T info)
{
this.info = info;
}
public T getInfo()
{
return this.info;
}
public static void main(String[] args)
{
// 由于传给T形参的是String，所以构造器参数只能是String
Apple a1 = new Apple<>(“苹果”);
System.out.println(a1.getInfo());
// 由于传给T形参的是Double，所以构造器参数只能是Double或double
Apple a2 = new Apple<>(5.67);
System.out.println(a2.getInfo());
}
}
=======================================================================
当使用一个泛型类时 (包括声明变量和创建对象两种情况) ， 都应该为这个泛型类传入一个类型实参。如果没有传入类型实际参数 ， 编译器就会提出泛型警告 。 假设现在需要定义一个方法 ， 该方法里有一个集合形参，集合形参的元素类型是不确定的， 那应该怎样定义呢?
为了表示各种泛型 List 的父类，可以使用类型通配符，类型通配符是一个问号 ( ?) ，将一个问号作为类型实参传给 List 集合 ， 写作: List<?> (意思是元素类型未知的 List ) 。 这个问号(?)被称为通配符，它的元素类型可以匹配任何类型 。
public void test(List<?> c){
for (int i = 0 ; i < c . size() ; i++ ){
System . out .println (c.get(i) );
}
}
在使用任何类型的 List 来调用它，程序依然可以访问集合 c 中的元素，其类型是 Object，这永远是安全的，因为不管 List 的真实类型是什么，它包含的都是Object 。
但这种带通配符的 List 仅表示它是各种泛型 List 的父类，并不能把元素加入到其中 。 例如，如下代码将会引起编译错误 ：
List<?> c = new ArrayLi st ();
//下丽程序引起编译错误
c . add(new Object()) ;
因为程序无法确定 c 集合中元素的类型，所以不能向其中添加对象 。 根据前面的 List接口定义的代码可以发现 : add()方法有类型参数 E 作为集合的元素类型，所以传给 add 的参数必须是 E 类的对象或者其子类的对象 。 但因为在该例中不知道 E 是什么类型，所以程序无法将任何对象"丢进"该集合 。 唯一的例外是 nulL ——它是所有引用类型的实例 。
另 一方面 ， 程序可以调用 get()方法来返回 List<?>集合指定索引处的元素，其返回值是一个未知类型，但可以肯定的是，它总是一个 Object 。 因此，把 get()的返回值赋值给一个 Object 类型的变量，或者放在任何希望是 Object 类型的地方都可以 。
当直接使用 List<?>这种形式时，即表明这个 List 集合可以是任何泛型 List 的父类 。 但还有一种特殊的情形，程序不希望这个 List<?>是任何泛型 List 的父类，只希望它代表某一类泛型 List 的父类。
一个简单的绘图程序，下面先定义三个形状类 :
Shape.java
// 定义一个抽象类Shape
public abstract class Shape
{
public abstract void draw(Canvas c);
}
Circle.java
// 定义Shape的子类Circle
public class Circle extends Shape
{
// 实现画图方法，以打印字符串来模拟画图方法实现
public void draw(Canvas c)
{
System.out.println(“在画布” + c + “上画一个圆”);
}
}
Rectangle.java
// 定义Shape的子类Rectangle
public class Rectangle extends Shape
{
// 实现画图方法，以打印字符串来模拟画图方法实现
public void draw(Canvas c)
{
System.out.println(“把一个矩形画在画布” + c + “上”);
}
}
上面定义了 三个形状类，其中 Shape 是一个抽象父类 ， 该抽象父类有两个子类 : Circle 和 Rectangle 。接下来定义一个 Canvas 类 ， 该画布类可以画数量不等的形状 (Shape 子类的对象) 。
Canvas.java
public class Canvas
{
// // 同时在画布上绘制多个形状
// public void drawAll(List shapes)
// {
// for (Shape s : shapes)
// {
// s.draw(this);
// }
// }
// 同时在画布上绘制多个形状，使用被限制的泛型通配符
public void drawAll(List<? extends Shape> shapes)
{
for (Shape s : shapes)
{
s.draw(this);
}
}
public static void main(String[] args)
{
List
Canvas c = new Canvas();
// 由于List
// 所以下面代码引发编译错误
c.drawAll(circleList);
}
}
程序中使用了被限制的泛型通配符。
被限制的泛型通配符表示如下 :
//它表示泛型形参必须是 Shape 子类的 List
List<? extends Shape>
List<? extends Shape>是受限制通配符的例子，此处的问号 (?) 代表一个未知的类型，就像前面看到的通配符一样 。 但是此处的这个未知类型一定是 Shape 的子类型(也可以是 Shape 本身)，因此可以把 Shape 称为这个通配符的上限 (upper bound) 。
类似地，由于程序无法确定这个受限制的通配符的具体类型，所以不能把 Shape 对象或其子类的对象加入这个泛型集合中 。 例如，下面代码就是错误的:
public void addRectangle(List<? extends Shape> shapes){
//下面代码引起编译错误
shapes .add(O , new Rectangle());
}
简而言之，这种指定通配符上限的集合，只能从集合中取元素(取出的元素总是上限的类型) ，不能向集合中添加元素(因为编译器没法确定集合元素实际是哪种子类型) 。
除可以指定通配符的上限之外， Java 也允许指定通配符的下限，通配符的下限用<? super 类型>的方式来指定，通配符下限的作用与通配符上限的作用恰好相反 。
指定通配符的下限就是为了支持类型型变 。 比如 Foo 是 Bar 的子类，当程序需要一个 A<? super Bar>变量时，程序可以将 A 、 A赋值给 A<? super Bar>类型的变量，这种型变方式被称为逆变。
对于逆变的泛型集合来说，编译器只知道集合元素是下限的父类型，但具体是哪种父类型则不确定。
因此，这种逆变的泛型集合能向其中添加元素(因为实际赋值的集合元素总是逆变声明的父类) ，从集合中取元素时只能被当成 Object 类型处理(编译器无法确定取出的到底是哪个父类的对象)。
假设实现一个工具方法:实现将 src 集合中的元素复制到 dest 集合的功能，因为 dest 集合可以保存 src 集合中的所有元素，所以 dest 集合元素的类型应该是 src 集合元素类型的父类。
对于上面的 copy()方法，可以这样理解两个集合参数之间的依赖关系;不管 src 集合元素的类型是什么，只要 dest 集合元素的类型与前者相同或者是前者的父类即可，此时通配符的下限就有了用武之地 。
下面程序采用通配符下限的方式来实现该 copy()方法 ：
MyUtils.java
public class MyUtils
{
// 下面dest集合元素类型必须与src集合元素类型相同，或是其父类
public static T copy(List<? super T> dest
, List src)
{
T last = null;
for (T ele : src)
{
last = ele;
// 逆变的泛型集合添加元素是安全的
dest.add(ele);
}
return last;
}
public static void main(String[] args)
{
List ln = new ArrayList<>();
List li = new ArrayList<>();
li.add(5);
// 此处可准确的知道最后一个被复制的元素是Integer类型
// 与src集合元素的类型相同
Integer last = copy(ln , li); // ①
System.out.println(ln);
}
}
使用这种语句，就可以保证程序的①处调用后推断出最后一个被复制的元素类型是 Integer，而不是笼统的 Number 类型 。
实际上， Java 集合框架中的 TreeSet有一个构造器也用到了这种设定通配符下限的语法，如下所示 ：
//下面的 E 是定义 TreeSet 类时的泛型形参
TreeSet(Comparator<? super E> c)
通过这种带下限的通配符的语法 ，可以在创建 TreeSet 对象时灵活地选择合适的 Comparator 。 假定需要创建一个 TreeSet集合，并传入一个可以比较 String 大小 的 Comparator ， 这个 Comparator既可以是 Comparator，也可以是 Comparator一一只要尖括号里传入的类型是 String 的父类型(或它本身) 即可。
TreeSetTest.java
public class TreeSetTest
{
public static void main(String[] args)
{
// Comparator的实际类型是TreeSet的元素类型的父类，满足要求
TreeSet ts1 = new TreeSet<>(
new Comparator()
{
public int compare(Object fst, Object snd)
{
-
return hashCode() > snd.hashCode() ? 1
- hashCode() < snd.hashCode() ? -1 : 0;
}
});
ts1.add(“hello”);
ts1.add(“wa”);
// Comparator的实际类型是TreeSet元素的类型，满足要求
TreeSet ts2 = new TreeSet<>(
new Comparator()
{
public int compare(String first, String second)
{
-
return first.length() > second.length() ? -1
- first.length() < second.length() ? 1 : 0;
}
});
ts2.add(“hello”);
ts2.add(“wa”);
System.out.println(ts1);
System.out.println(ts2);
}
}
J ava 泛型不仅允许在使用通配符形参 时设定上限，而且可以在定义泛型形参 时设定 上限 ，用于表示传给该泛型形参的实际类型要么是该上限类型 ，要么是该上限类型的子类。
下面程序示范了这种用法 :
Apple.java
public class Apple
{
T col;
public static void main(String[] args)
{
Apple ai = new Apple<>();
Apple ad = new Apple<>();
// 下面代码将引起编译异常，下面代码试图把String类型传给T形参
// 但String不是Number的子类型，所以引发编译错误
// Apple as = new Apple<>(); // ①
}
}
上面程序定义了 一个 Apple 泛型类 ， 该 Apple 类的泛型形参的上限是 Number 类，这表明使用 Apple类时为 T 形参传入的实际类型参数只能是 Number 或 Number 类的子类 。 上面程序在①处将引起编译错误 : 类型 T 的上限是 Number 类型，而此处传入的实际类型是 String 类型 ，既不是 Number 类型，也不
是 Number 类型的子类型，所以将会导致编译错误 。
在一种更极端的情况下，程序需要为泛型形参设定多个上限 (至多有一个父类上限，可以有多个接口上限)，表明该泛型形参必须是其父类的子类(是父类本身也行)，并且实现多个上限接口。
如下代码所示 :
// 表明 T 类型必须是 Number 类或其子类，并必须实现 java.io.Seria1izab1e 接口
pub1ic c1ass Apple<T extends Number & java. i o . Serializab1e>{
……
}
======================================================================
假设需要实现这样一个方法一一该方法负责将一个 Object 数组的所有元素添加到一个 Collection 集合中 。
考虑采用如下代码来实现该方法：
static void fromArrayToCollection(Object[) a , Collection c){
for (Object 0 : a){
c . add (o);
}
}
上面定义的方法没有任何问题，关键在于方法中的 c 形参，它的数据类型是 Collection。 Collection不是 Collection的子类型一一所以这个方法的功能非常有限，它只能将 Object[]数组的元素复制到元素为 Object ( Object 的子类不行)的 Collection 集合中。
下面代码将引起编译错误 ：
String[] strArr = {“a” , "b " };
List strList = new ArrayList<>() ;
/ / Collection对象不能当成 Collection使用，下面代码出现编译错误
fromArrayToCollection(strArr , strList);
为了解决这个问题，可以使用 Java 5 提供的泛型方法 (Generic Method)。所谓泛型方法，就是在声明方法时定义→个或多个泛型形参。
泛型方法的语法格式如下:
修饰符 <T , S> 返回值类型方法名(形参列表){
//方法体 … .
}
采用支持泛型的方法，就可以将上面的fromArrayToCollection 方法改为如下形式:
static void fromArrayToCollection (T[] a , Collection c){
for (T 0 : a){
c.add(o) ;
}
}
下面程序示范了完整的用法 :
GenericMethodTest.java
public class GenericMethodTest
{
// 声明一个泛型方法，该泛型方法中带一个T泛型形参，
static void fromArrayToCollection(T[] a, Collection c)
{
for (T o : a)
{
c.add(o);
}
}
public static void main(String[] args)
{
Object[] oa = new Object[100];
Collection co = new ArrayList<>();
// 下面代码中T代表Object类型
fromArrayToCollection(oa, co);
String[] sa = new String[100];
Collection cs = new ArrayList<>();
// 下面代码中T代表String类型
fromArrayToCollection(sa, cs);
// 下面代码中T代表Object类型
fromArrayToCollection(sa, co);
Integer[] ia = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection cn = new ArrayList<>();
// 下面代码中T代表Number类型
fromArrayToCollection(ia, cn);
// 下面代码中T代表Number类型
fromArrayToCollection(fa, cn);
// 下面代码中T代表Number类型
fromArrayToCollection(na, cn);
// 下面代码中T代表Object类型
fromArrayToCollection(na, co);
// 下面代码中T代表String类型，但na是一个Number数组，
// 因为Number既不是String类型，
// 也不是它的子类，所以出现编译错误
// fromArrayToCollection(na, cs);
}
}
大多数时候都可以使用泛型方法来代替类型通配符 。
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
fromArrayToCollection(na, cn);
// 下面代码中T代表Object类型
fromArrayToCollection(na, co);
// 下面代码中T代表String类型，但na是一个Number数组，
// 因为Number既不是String类型，
// 也不是它的子类，所以出现编译错误
// fromArrayToCollection(na, cs);
}
}
大多数时候都可以使用泛型方法来代替类型通配符 。
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-VtLlv01Q-1714798646305)]
[外链图片转存中…(img-AF7rf4kx-1714798646306)]
[外链图片转存中…(img-cFaJ69iP-1714798646306)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
1266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
