比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

Java中的泛型 — Java 编程思想

Java中的泛型 — Java 编程思想

我一直都认为泛型是程序语言设计中一个非常基础,重要的概念,Java 中的泛型到底是怎么样的,为什么会有泛型,泛型怎么发展出来的。通透理解泛型是学好基础里面中非常重要的。于是,我对《Java编程思想》这本书中泛型章节进行了研读。可惜遗憾的是,自己没有太多的经验,有些东西看了几次也是有点懵。只能以后有机会,再进行学习了。但是自己也理解了挺多的。下面就是自己对于泛型的理解与感悟。如有不对,望指出。

2|0概念

 

由来: Java 一开始设计之初是没有泛型这个特性的,直到jdk 1.5中引入了这个特性。Java 的泛型是由擦除来实现的。要知道擦除是什么?往下看。

概念:一般的类和方法,只能使用具体的类型;要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。泛型实现了参数化类型的概念,使代码应用于多个类型。泛型在编程语言中出现时,其最初的目的是希望类和方法具有广泛的表达能力。

3|0简单泛型

 

​ 有很多原因促成泛型的出现,其中最重要的一个原因就是为了创造容器类。我们暂时不指定类型,而是稍后再决定具体使用什么类型。要达到这个目的,需要使用类型参数,用尖括号括住,放在类名的后面。然后使用这个类的时候,再用实际的类型替换此类型参数。在下面例子中,T就是类型参数。代码如下:

public class Holder<T> {
private T a;

public Holder(T a) {
this.a = a;
}

public void set(T a) {
this.a = a;
}

public T get(){
return a;
}

public static void main(String[] args) {
Holder<String> h = new Holder<>();
h3.set("hello");
String a = h3.get();
}
}
class Automobile{}

​ 但是往往很多的源码中一些通用的类都是有多个泛型参数,譬如 java.util.function.BiFunction 中就有三个类型参数 T,U,R 。

4|0接口泛型

 

​ 泛型在接口上的运用是非常多的,例如迭代器(Iterable)中的 Iterator 。

public interface Itreator<T>{
// 判断是否还有元素
boolean hasNext();
// 洗一个元素
E next();
....
}

​ 这个是我们都很常用的吧,其实接口使用泛型和类使用泛型没什么区别。

5|0泛型方法

 

​ 泛型方法,在返回参数类型前面添加泛型参数列表,由<>括着
eg:

// 泛型方法 两个泛型参数,T,R 返回类型为 R
public <T, R> R test(T t, R r){
return r;
}

​ 泛型方法使得该方法独立于类而产生变化。在需要编写泛型代码的时候,基本的的指导原则是:无论何时,只要你能做到,就尽量使用泛型方法。意思是如果使用泛型方法可以代替整个类的泛型化,那就用泛型方法,因为它可以使事情更加清楚明白。另外对于static的方法而言,无法访问泛型类的类型参数,所以如果static方法需要使用泛化能力,就必须使其成为泛型方法。

6|0泛型的擦除

 

​ 在看 《Java编程思想》 中泛型章节中 ’擦除的神秘之处‘ 这一小节的时候,看的我特别的晕晕乎乎的,然后再往下面看时就越来越混了。 特别是看到’边界‘,’通配符‘ 这块了就有点懵了。首先看下什么是擦除。在泛型代码内部,无法获得有关泛型参数类型的信息。 Java 的泛型是由擦拭来实现的,这意味着当你使用泛型的时,任何具体的类型都被擦除了,你唯一知道的就是你在使用一个对象。由于 Java 一开始没有引入 泛型这个特性,在为了兼容 JDK 老版本的情况下。擦除是 Java 泛型实现的一种折中。 因此你在运行时 List<String> 和 List<Integer> 是一样的,注意是在运行时,但是在编译时,List<String> 表示这个 String 类型的 List 容器, List<Integer> 表示这个时 Integer 类型的List容器。 举个例子,例子来源于 Java编程思想

#include <iostream>
using namespace std;

temple<class T> class Manipulator{
T obj;
public
Manipulator(T x){obj = x;}
void manipylate() {obj.f();}

};
class HasF{
public:
void f(){cout<<"HasF::f()"<< endl;}
};

int main(){
HasF hf;
Manipulator<HasF> manipulator(hf);
manipulator.manipylate();
}

输出 HasF:f()

​ Manipulator 类存储了一个类型T的对象,在 manipylate 方法里,他在 obj上调用了方法 f() ; 它是怎么知道 f() 是类型参数T 中有的方法呢? 当你实例化这个模板的时,c++编译器将进行检查,如果他在 Manipulator<HasF> 被实例化的这刻,它看到HasF如果拥有这个方法 f(), 就编译通过,否则不通过。 这个代码就算不会 c++ 的人应该也看的懂吧。我们看下 Java 的版本:

public class HasF{
public void f(){
System.out.println("HasF::f()");
}
}

class Manipulator<T>{
private T obj;
public Manipulator(T obj){
this.obj = obj;
}

public void manipulator(){
//错误: 这个是不可以调用 f() 这个方法的。
// obj.f();
}

public static void main(String[] args){
HasF hf = new HasF();
Manipulator<HasF> manipulator = new Manipulator<>(hf);
manipulator.manipulator();
}
}

看到没有,Java 中有了擦除, Java 编译器不知道 obj 中有没有 f() 这个方法的事情。

7|0泛型的边界

 

7|1T extends Class

 

​ Java 中的泛型,在编译时,T代表一种类型,如果没有指定任何的边界,那么他就相当于 Object 。 我们可以通过 extends 关键字,给泛型指定边界。 上面代码我们为了能够调用f(), 我们可以协助泛型类,给定泛型类的边界,告诉编译器必须接受遵循这个边界的类型。这里用 extends 关键字。 将上面代码改成

public class HasF{
public void f(){
System.out.println("HasF::f()");
}
}

class Manipulator<T extends HasF>{
private T obj;
public Manipulator(T obj){
this.obj = obj;
}

public void manipulator(){
obj.f();
}

public static void main(String[] args){
HasF hf = new HasF();
Manipulator<HasF> manipulator = new Manipulator<>(hf);
manipulator.manipulator();
}
}

输出:HasF::f()

这样子在编译的时候就相当告诉编译器 Manipulator 类中 obj 的参数类型 为 HasF 或着它的子类。

7|2? extends T

 

? 是泛型表达式中的通配符。 ? extends T 表示: T 数据类型或着 T 的子类数据类型。 举个例子

class Vegetables{}
// 白菜
class Cabbage extends Vegetables{}
// 小白菜
class Pakchoi extends Cabbage{}
//大蒜
class Garlic extends Vegetables{}

public class Main{
public static void main(String[] args) {
// 这个是会报错的。
// ArrayList<Vegetables> vegetables = new ArrayList<Cabbage>();
}
}

​ 上面的中 main 方法里面是报错的因为,ArrayList<Vegetables>表示这个ArrayList容器中只能存放蔬菜,new ArrayList<Cabbage>() 表示 这个使一个只能放白菜的容器。这两个容器是不可以相等的,类型不一样。但是我们可以通过 ? extends T 来解决这个问题,代码如下:

public class Main{
public static void main(String[] args) {
ArrayList<? extends Vegetables> vegetables = new ArrayList<Cabbage>();
// 报错 不能添加白菜进去
// vegetables.add(new Cabbage());
}
}

​ 我们可以用 vegetables 表示 new ArrayList<Cabbage>(), 这是向上转型。但是,为什么 vegetables.add(new Cabbage()) ; 会报错,因为 ArrayList<? extends Vegetables>表示这个 ArrayList 容器中能够存放任何蔬菜。 但是 ArrayList 具体是什么容器,完全不知道,add 的时候,你添加什么东西进去到这个容器中都是不安全的。 这个时候,我们可以用 ? super T 来进行操作,具体往下看。

7|3? super T

 

? super T 表示: T 数据类型 或着 T的超类数据类型, super 表示超类通配符。 上面代码可以用以下表示

public class Main{
public static void main(String[] args) {
ArrayList<? super Cabbage> cabbages = new ArrayList<Vegetables>();

cabbages.add(new Cabbage());
cabbages.add(new Pakchoi());

// cabbages.add(new Vegetables());
System.out.println(cabbages);
}
}

上面ArrayList<? super Cabbage> 表示ArrayList这个容器中怎么都可以存放 Cabbage 以及Cabbage子类的数据类型。 cabbages 指向的是 蔬菜的容器类。 add 进去的是白菜以及白菜的子类型数据。这个当然是支持的。

7|4? extends T VS ? super T

 

? extends T ,? super T 一般用于方法参数列表。


public class Main{
public static void main(String[] args) {

List<Cabbage> cabbages = new ArrayList<>();
cabbages.add(new Cabbage());
cabbages.add(new Cabbage());
cabbages.add(new Cabbage());
extendsTest(cabbages);
List<? super Cabbage> list = superTest(new ArrayList<Vegetables>());
System.out.println(list);
}

public static void extendsTest(List<? extends Vegetables> list){
for (Vegetables t : list){
System.out.println(t);
}
}

public static List<? super Cabbage> superTest(List<? super Cabbage> list){
list.add(new Cabbage());
list.add(new Pakchoi());
return list;
}
}

? extends T 表示消费者 list 然后把里面的数据消费掉。
? super T 表示生产者 传入一个list 然后往里面添加数据,进行其他操作。

8|0总结

 

​ 对于 ? extends Class ,? extends T,? super T,不是很理解的,可以自己把例子写一下,然后想一想。Java 泛型的特性在很多开源的框架上是用的非常多的。这快需要深入的理解一下,我想随着敲代码的年限上,应该到了后面会有不一样得理解吧。现在通过书上能够知道,理解得就只有这么多了。

 

__EOF__

作  者:家里那只橘猫
出  处:https://www.cnblogs.com/Krloypower/p/10454507.html

未经允许不得转载:阿里云代金券 » Java中的泛型 — Java 编程思想

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS