《Java编程思想》学习笔记8——泛型编程高级

最新推荐文章于 2024-07-27 04:43:24 发布
最新推荐文章于 2024-07-27 04:43:24 发布
阅读量434 收藏
点赞数
分类专栏： 书籍笔记 文章标签： 编译器 泛型 编程

1.泛型边界：

Java泛型编程时，编译器忽略泛型参数的具体类型，认为使用泛型的类、方法对Object都适用，这在泛型编程中称为类型信息檫除。

例如：

[java]  view plain copy
  1. class GenericType{  
  2.     public static void main(String[] args){  
  3.         System.out.println(new ArrayList<String>().getClass());  
  4.         System.out.println(new ArrayList<Integer>().getClass());  
  5. }  
  6. }  

输出结果为：

java.util.ArrayList

java.util.ArrayList

泛型忽略了集合容器中具体的类型，这就是类型檫除。

但是如果某些泛型的类/方法只想针对某种特定类型获取相关子类应用，这时就必须使用泛型边界来为泛型参数指定限制条件。

例如：

[java]  view plain copy
  1. interface HasColor{  
  2.     java.awt.Color getColor();  
  3. }  
  4. class Colored<T extends HasColor>{  
  5.     T item;  
  6.     Colored(T item){  
  7.         this.item = item;  
  8. }  
  9. java.awt.Color color(){  
  10.     //调用HasColor接口实现类的getColor()方法  
  11.     return item.getColor();  
  12. }  
  13. }  
  14. class Dimension{  
  15.     public int x, y, z;  
  16. }  
  17. Class ColoredDimension<T extends Dimension & HasColor>{  
  18.     T item;  
  19.     ColoredDimension(T item){  
  20.         this.item = item;  
  21. }  
  22. T getItem(){  
  23.     return item;  
  24. }  
  25. java.awt.Color color(){  
  26.     //调用HasColor实现类中的getColor()方法  
  27.     return item.getColor();  
  28. }  
  29. //获取Dimension类中定义的x,y,z成员变量  
  30. int getX(){  
  31.     return item.x;  
  32. }  
  33. int getY(){  
  34.     return item.y;  
  35. }  
  36. int getZ(){  
  37.     return item.z;  
  38. }  
  39. }  
  40. interface Weight{  
  41.     int weight();  
  42. }  
  43. class Solid<T extends Dimension & HasColor & Weight>{  
  44.     T item;  
  45.     Solide(T item){  
  46.         this.item = item;  
  47. }  
  48. T getItem(){  
  49.     return item;  
  50. }  
  51. java.awt.Color color(){  
  52.     //调用HasColor实现类中的getColor()方法  
  53.     return item.getColor();  
  54. }  
  55. //获取Dimension类中定义的x,y,z成员变量  
  56. int getX(){  
  57.     return item.x;  
  58. }  
  59. int getY(){  
  60.     return item.y;  
  61. }  
  62. int getZ(){  
  63.     return item.z;  
  64. }  
  65. int weight(){  
  66.     //调用Weight接口实现类的weight()方法  
  67.     return item.weight();  
  68. }  
  69. }  
  70. class Bounded extends Dimension implements HasColor, Weight{  
  71.     public java.awt.Color getColor{  
  72.         return null;  
  73. }  
  74. public int weight(){  
  75.     return 0;  
  76. }  
  77. }  
  78. public class BasicBounds{  
  79.     public static void main(String[] args){  
  80.         Solid<Bounded> solid = new Solid<Bounded>(new Bounded());  
  81.         solid.color();  
  82.         solid.getX();  
  83.         solid.getY();  
  84.         solid.getZ();  
  85.         solid.weight();  
  86. }  
  87. }  

Java泛型编程中使用extends关键字指定泛型参数类型的上边界(后面还会讲到使用super关键字指定泛型的下边界)，即泛型只能适用于extends关键字后面类或接口的子类。

Java泛型编程的边界可以是多个，使用如<T extends A & B & C>语法来声明，其中只能有一个是类，并且只能是extends后面的第一个为类，其他的均只能为接口(和类/接口中的extends意义不同)。

使用了泛型边界之后，泛型对象就可以使用边界对象中公共的成员变量和方法。

2.泛型通配符：

泛型初始化过程中，一旦给定了参数类型之后，参数类型就会被限制，无法随着复制的类型而动态改变，如：

[java]  view plain copy
  1. class Fruit{  
  2. }  
  3. class Apple extends Fruit{  
  4. }  
  5. class Jonathan extends Apple{  
  6. }  
  7. class Orange extends Fruit{  
  8. }  
  9. 如果使用数组：  
  10. public class ConvariantArrays{  
  11.     Fruit fruit = new Apple[10];  
  12.     Fruit[0] = new Apple();  
  13.     Fruit[1] = new Jonathan();  
  14.     try{  
  15.         fruit[0] = new Fruit();  
  16. }catch(Exception e){  
  17.     System.out.println(e);  
  18. }  
  19. try{  
  20.         fruit[0] = new Orange();  
  21. }catch(Exception e){  
  22.     System.out.println(e);  
  23. }  
  24. }  

编译时没有任何错误，运行时会报如下异常：

java.lang.ArrayStoreException:Fruit

java.lang.ArrayStoreException:Orange

为了使得泛型在编译时就可以进行参数类型检查，我们推荐使用java的集合容器类，如下：

[java]  view plain copy
  1. public class NonConvariantGenerics{  
  2.     List<Fruit> flist = new ArrayList<Apple>();  
  3. }  

很不幸的是，这段代码会报编译错误：incompatible types，不兼容的参数类型，集合认为虽然Apple继承自Fruit，但是List的Fruit和List的Apple是不相同的，因为泛型参数在声明时给定之后就被限制了，无法随着具体的初始化实例而动态改变，为解决这个问题，泛型引入了通配符”?”。

对于这个问题的解决，使用通配符如下：

[java]  view plain copy
  1. public class NonConvariantGenerics{  
  2.     List<? extends Fruit> flist = new ArrayList<Apple>();  
  3. }  

泛型通配符”?”的意思是任何特定继承Fruit的类，java编译器在编译时会根据具体的类型实例化。

另外，一个比较经典泛型通配符的例子如下：

public class SampleClass < T extendsS> {…}

假如A，B，C，…Z这26个class都实现了S接口。我们使用时需要使用到这26个class类型的泛型参数。那实例化的时候怎么办呢？依次写下

SampleClass<A> a = new SampleClass();

SampleClass<B> a = new SampleClass();

…

SampleClass<Z> a = new SampleClass();

这显然很冗余，还不如使用Object而不使用泛型，使用通配符非常方便：

SampleClass<? Extends S> sc = newSampleClass();

3.泛型下边界：

在1中大概了解了泛型上边界，使用extends关键字指定泛型实例化参数只能是指定类的子类，在泛型中还可以指定参数的下边界，是一super关键字可以指定泛型实例化时的参数只能是指定类的父类。

例如：

[java]  view plain copy
  1. class Fruit{  
  2. }  
  3. class Apple extends Fruit{  
  4. }  
  5. class Jonathan extends Apple{  
  6. }  
  7. class Orange extends Fruit{  
  8. }  
  9. public superTypeWildcards{  
  10.     public static void writeTo(List<? super Apple> apples){  
  11.         apples.add(new Apple());  
  12.         apples.add(new Jonathan());  
  13. }  
  14. }  

通过? Super限制了List元素只能是Apple的父类。

泛型下边界还可以使用<?super T>，但是注意不能使用<Tsuper A>，即super之前的只能是泛型通配符，如：

[java]  view plain copy
  1. public class GenericWriting{  
  2.     static List<Apple> apples = new ArrayList<Apple>();  
  3.     static List<Fruit> fruits = new ArrayList<Fruit>();  
  4.     static <T> void writeExact(List<T> list, T item){  
  5.         list.add(item);  
  6. }  
  7. static <T> void writeWithWildcards(List<? super T> list, T item){  
  8.     list.add(item);  
  9. }  
  10. static void f1(){  
  11.     writeExact(apples, new Apple());  
  12. }  
  13. static void f2(){  
  14. writeWithWildcards(apples, new Apple());  
  15.     writeWithWildcards(fruits, new Apple());  
  16. }  
  17. public static void main(String[] args){  
  18.     f1();  
  19.     f2();  
  20. }  
  21. }  

4.无边界的通配符：

泛型的通配符也可以不指定边界，没有边界的通配符意思是不确定参数的类型，编译时泛型檫除类型信息，认为是Object类型。如：

[java]  view plain copy
  1. public class UnboundedWildcard{  
  2.     static List list1;  
  3.     static List<?> list2;  
  4.     static List<? extends Object> list3;  
  5.     static void assign1(List list){  
  6.         list1 = list;  
  7.         list2 = list;  
  8.         //list3 = list; //有未检查转换警告  
  9. }   
  10. static void assign2(List<?> list){  
  11.         list1 = list;  
  12.         list2 = list;  
  13.     list3 = list;  
  14. }  
  15. static void assign3(List<? extends Object> list){  
  16.         list1 = list;  
  17.         list2 = list;  
  18.     list3 = list;  
  19. }  
  20. public static void main(String[] args){  
  21.     assign1(new ArrayList());  
  22. assign2(new ArrayList());  
  23. //assign3(new ArrayList()); //有未检查转换警告  
  24. assign1(new ArrayList<String>());  
  25. assign2(new ArrayList<String>());  
  26. assign3(new ArrayList<String>());   
  27. List<?> wildList = new ArrayList();  
  28. assign1(wildList);  
  29. assign2(wildList);  
  30. assign3(wildList);   
  31. }  
  32. }  

List和List<?>的区别是：List是一个原始类型的List，它可以存放任何Object类型的对象，不需要编译时类型检查。List<?>等价于List<Object>，它不是一个原始类型的List，它存放一些特定类型，只是暂时还不确定是什么类型，需要编译时类型检查。因此List的效率要比List<?>高。

5.实现泛型接口注意事项：

由于泛型在编译过程中檫除了参数类型信息，所以一个类不能实现以泛型参数区别的多个接口，如：

[java]  view plain copy
  1. interface Payable<T>{  
  2. }  
  3. class Employee implements Payable<Employee>{  
  4. }  
  5. class Hourly extends Employee implements Payable<Hourly>{  
  6. }  

类Hourly无法编译，因为由于泛型类型檫除，Payable<Employee>和Payable<Hourly>在编译时是同一个类型Payable，因此无法同时实现一个接口两次。

6.泛型方法重载注意事项：

由于泛型在编译时将参数类型檫除，因此以参数类型来进行方法重载在泛型中要特别注意，如：

[java]  view plain copy
  1. public class GenericMethod<W,T>{  
  2.     void f(List<T> v) {  
  3. }  
  4. void f(List<W> v){  
  5. }  
  6. }  

无法通过编译，因为泛型檫除类型信息，上面两个方法的参数都被看作为Object类型，使用参数类型已经无法区别上面两个方法，因此无法重载。

7.泛型中的自绑定：

通常情况下，一个类无法直接继承一个泛型参数，但是你可以通过继承一个声明泛型参数的类，这就是java泛型编程中的自绑定，如：

[java]  view plain copy
  1. class SelfBounded<T extends SelfBounded<T>>{  
  2.     T element;  
  3.     SelfBounded<T> set(T arg){  
  4.         Element = arg;  
  5.         return this;  
  6. }   
  7. T get(){  
  8.     return element;  
  9. }  
  10. }  
  11. class A extends SelfBounded<A>{  
  12. }  
  13. class B extends SelfBounded<A>{  
  14. }  
  15. class C extends SelfBounded<C>{  
  16.     C setAndGet(C arg){  
  17.         set(arg);  
  18.         return get();  
  19. }  
  20. }  
  21. public class SelfBounding{  
  22.     public static void main(String[] args){  
  23.         A a = new A();  
  24.         a.set(new A());  
  25.         a = a.set(new A()).get();  
  26.         a = a.get();  
  27.         C c = new C();  
  28.         C = c.setAndGet(new C());  
  29. }  
  30. }  

泛型的自绑定约束目的是用于强制继承关系，即使用泛型参数的类的基类是相同的，强制所有人使用相同的方式使用参数基类。

Java基础--16--继承-extends
武天旭的博客
09-16 750
1、基本概念 定义： 1、子类继承父类的特征和行为，使得子类对象具有父类的实例域和方法； 2、子类从父类继承方法，使得子类具有父类相同的行为。 作用： 继承可以节省代码量以及方便代码维护，将多段代码中相同的部分提取出来组成一个父类 Java不支持多继承，但支持多重继承： 名称 描述 是否支持 单继承 B类继承A类 支持 多重继承 C类继承B类，B类继承A类 支持 继承同一个类 C类和B类都继承A类 支持 多继承 C类同时继承A类和B类 不支持 继承的特性： 1、子类拥有父类非
Java中，一个接口可以extends多个接口
云聪的技术错题集
03-29 1万+
Java中，一个类不能继承多个类，但是一个接口可能继承多个接口。下面是Java代码示例： package interfaceextends; public interface LaughBehavior { public void laugh(); } package interfaceextends; public interface SpeakBehavior { public
java 限定extends 多个对像
最新发布
weixin_35687240的博客
07-27 54
解决方案相关学习资料：https://edu.51cto.com/video/2306.htmlJava中的多重继承问题与解决方案 Java是一种面向对象的编程语言，它支持继承机制，允许一个类继承另一个类的属性和方法。然而，Java不支持多重继承，即一个类不能同时继承多个类。这是因为多重继承可能导致一些问题，比如菱形继承...
java：不支持一个类extends多个类
qq_45476544的博客
03-13 566
虽然看似C可以重写方法，但如果B的参数列表和A的参数列表不同？加大了类在设计和开发上的复杂性，可能造成继承层次膨胀。菱形继承（钻石继承）会导致底层子类在调用方法时存在二义性。2.可以将A类对象、B类对象作为成员属性给到C。一、多继承的潜在问题——菱形继承。1.可以实现多接口达到类似效果。
Java编程思想笔记(全)
06-14
### Java编程思想笔记知识点概述 #### 第 1 章 对象导论 在这一章节中，主要介绍...以上内容概括了《Java编程思想笔记》中的核心知识点，涵盖了Java语言的基础到高级特性，适合初学者和有一定经验的开发者参考学习。
Java编程笔记13：泛型
梦幻天空
03-07 657
Java编程笔记13：泛型 图源：PHP中文网 容器中的泛型 泛型存在的理由之一是解决容器可以持有不同类型的数据的问题。 假设有一个最简单的容器： package ch13.container; import util.Fmt; class SimpleContainer { private Object content; public SimpleContainer(Object content) { this.content = content; }
Java JDK 6学习笔记——ppt简体版
06-11
Java JDK 6学习笔记是为Java初学者量身定制的一份宝贵资料，它涵盖了Java编程的基础概念、语法以及核心特性。这份PPT简体版旨在帮助读者快速掌握Java开发的基本技能，逐步成为一名合格的Java程序员。 Java JDK...
夯实JAVA基本之一——泛型详解(2)：高级进阶
热门推荐
启舰
11-17 2万+
前言：被温水煮惯了，梦想的东西总是不敢于尝试，失败了又怎样，最多从头来过。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— ...
Java编程笔记14：泛型（续）
梦幻天空
03-14 342
Java编程笔记14：泛型（续） 图源：PHP中文网 问题 在前文已经说过，Java因为历史原因，实现的泛型机制是不完整的，因此存在一些问题（限制），下面来详细讨论这些问题以及解决方案。 无法使用基本类型 Java的泛型存在很多限制，无法使用基本类型就是其中之一，幸运的是因为包装类的存在，在大多数情况下“自动解包”和“自动打包”都可以帮我们解决将基础类型应用到泛型的相关问题。 package ch14.base_type; import java.util.ArrayList; import java.
extends多个接口
TuxedoLinux的博客
07-03 2431
Java中，一个接口可以extends多个接口 Java中，一个类不能继承多个类，但是一个接口可能继承多个接口。下面是Java代码示例：[java] view plain copy package interfaceextends;    public interface LaughBehavior { ...
Java中的多继承（它来了它来了）
肖肖的博客
11-11 1569
相信大家看到这时，已经了解了类的继承。不太懂就点一下我吧！放心这个是安全的，只是解释了一下类的继承不太懂的码友可以点一下，希望能帮到你。（以下内容是我对接口的总结，谢谢你耐心的看完。） 大家都知道类的继承只能是单继承，一个子类只能继承一个父类。你也许会问怎么不可以多继承，那下面咱们进入主题： 多继承 在Java中想要实现多继承，可以选择接口，接口是Java中用于多继承的一种机制。下面是接口的定义格式： interface 接口名称 // 定义抽象类 { final 数据类型 成员名称 = 常量 ； // 数
java实现多继承
m0_57454517的博客
07-27 1万+
java实现多继承 1，多层继承 就是多个单继承积累，最下层在子类能具有上层类在特征，但这种方法重复高，一般不去用 2、内部类 一个类要继承多个类，在这个类的内部写多个内部类，然后让这些内部类都继承不同的类。 class dota { private String str = "let's play some dota"; public void play() { System.out.println(str); System.out.println("好
Java程序定义一个泛型类，使用extend 关键字限制泛型类为List接口，并分别创建两个泛型对象。
程序研博客
09-22 741
package javase17; import java.awt.*; import java.util.*; import java.util.List; public class javase17_2<T extends List> { //定义一个泛型类，使用extend 关键字限制泛型类为List接口 public static void main(String[] args) { //创建两个泛型对象 javase17_2&lt.
JavaSE第11篇：面向对象之接口、多态
【01编程】的博客
07-25 180
核心概述：本篇我们将学习面向对象中的接口和多态，接口类似我们之前学习继承时的父类或抽象类，接口与众不同的时，接口中跟多的定义事物的功能（方法），子类或实现类可以实现或重写接口中的方法。而接口或继承，则是多态的前提。合理地利用多态可以提高我们程序的可扩展性和灵活性。 第一章：接口 1.1-接口概述（了解） 什么是接口 Java中的接口是一系列方法的声明，是一些方法特征的集合。 一个接口只有方法的特征（只有声明）没有方法的实现（没有方法体），因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同
04_Java泛型 有界类型参数 多重边界，泛型extends，泛型 &
思念十年后
03-24 868
Java泛型有界类型参数Java泛型多重边界 有界类型参数 有些场景需要限制 允许传递给类型参数的类型。 声明一个有界类型参数，列出类型参数名称，后跟extends关键字，后跟其边界上限。 //限制类型参数天加上界 public class GenericTypeExtends { public static void main(String[] args) { printNum(100); printNum(1000L); printNum(1.0
Java基础 | 06.继承extends
xyx-Eshang的博客
03-31 3513
文章目录1.何为继承？2.继承的规则2.1.类的单继承和多级继承2.2.接口间的多继承3.重写（覆写、覆盖）4.构造方法的继承规则5.继承的应用场景6.多态 1.何为继承？ 作用是降低代码的冗余度，提高编程效率 子类继承父类的成员（变量、方法和构造方法），同时子类还可以拓展、重写变量和方法 注意：仅继承public和protected 2.继承的规则 2.1.类的单继承和多级继承 对于Java的类，一个子类只能继承自一个父类 但可以多级继承 // 允许多级继承 public class A {...
JAVA继承 extends ---初步详解
ABC1_456的博客
07-28 2447
extends 的意思是“扩展”。子类是父类的扩展，继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
类扩展 java,类扩展多个类Java？
weixin_30110807的博客
02-12 196
I know that a class can implement more than one interface, but is it possible to extend more than one class? For example I want my class to extend both TransformGroup and a class I created. Is this po...
Java编程思想入门与高级技巧解析
《Java编程思想读书笔记》是一本面向Java初学者和高级编程人员的实用指南，它深入探讨了Java编程的关键概念与特性，特别是针对那些希望提升编程技能或深化理解Java语言的读者。本书主要涵盖了以下几个重要的知识点：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值