初识Java 18-5 泛型

news/2024/2/21 3:41:36

目录

动态类型安全

异常

混型

C++中的混型

替代方案

与接口混合

使用装饰器模式

与动态代理混合


本笔记参考自: 《On Java 中文版》


动态类型安全

        在Java 5引入泛型前,老版本的Java程序中就已经存在了List等原生集合类型。这意味着,我们可以向这些老版本的代码中传递泛型集合,这无疑是存在风险的。为此,Java 5在java.util.Collections中添加了一组实用工具checked*()

  • checkedCollection()
  • checkList()
  • checkedMap()
  • checkedSet()
  • checkedSortedMap()
  • checkedSortSet()

        这些方法的第一个参数都是被检查的集合,之后的参数会传入需要强制确保的类型。若这些方法检测到插入了不匹配的类型,就会发出异常。

    这一点和Java 5之前的原生集合不同,它们只会在我们从中取出对象时报告问题。此时,我们难以找出发生问题的代码。

        下面的例子展示了check*()的用法:

【例子:check*()的使用】

        假设我们有一个Pet类,它有两个子类CatDog。 则代码如下所示:

import reflection.pets.Cat;
import reflection.pets.Dog;
import reflection.pets.Pet;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class CheckedList {// 一个Java 5之前遗留的方法:@SuppressWarnings("unchecked")static void oldStyleMethod(List probablyDogs) {// 向probablyDogs集合中传入错误的Cat类型:probablyDogs.add(new Cat());}public static void main(String[] args) {List<Dog> dogs1 = new ArrayList<>();// 安静地放入了Cat类型:oldStyleMethod(dogs1);List<Dog> dogs2 = Collections.checkedList(new ArrayList<>(), Dog.class);try {oldStyleMethod(dogs2);} catch (Exception e) {System.out.println("发生异常:" + e);}// 使用基类集合不会存在问题:List<Pet> pets = Collections.checkedList(new ArrayList<>(), Pet.class);pets.add(new Dog());pets.add(new Cat());}
}

        程序执行的结果是:

        可以发现,oldStyleMethod(dogs1)并没有受到编译器的质疑,尽管方法内部会往dogs1集合中插入一个不匹配的Cat对象。而dogs2立刻抛出异常。

异常

        因为类型擦除,catch子句无法捕获泛型类型的异常,因为无法获知异常的确切类型。也因此,泛型类无法直接或间接地继承Throwable

        但类型参数可以用于方法声明中的throws子句。根据这个特点,我们可以编写随(受检查的)异常类型变化而变化的泛型代码:

【例子:可变化的异常】

import java.util.ArrayList;
import java.util.List;interface Processor<T, E extends Exception> {void process(List<T> resultCollector) throws E;
}class ProcessRunner<T, E extends Exception>extends ArrayList<Processor<T, E>> {List<T> processAll() throws E {List<T> resultCollector = new ArrayList<>();for (Processor<T, E> processor : this)processor.process(resultCollector);return resultCollector;}
}class Failure1 extends Exception {
}class Processor1implements Processor<String, Failure1> {static int count = 3;@Overridepublic void process(List<String> resultCollector)throws Failure1 {if (count-- > 1)resultCollector.add("哼!");elseresultCollector.add("哈!");if (count < 0)throw new Failure1();}
}class Failure2 extends Exception {
}class Processor2implements Processor<Integer, Failure2> {static int count = 2;@Overridepublic void process(List<Integer> resultCollector)throws Failure2 {if (count-- == 0)resultCollector.add(47);else {resultCollector.add(11);}if (count < 0)throw new Failure2();}
}public class ThrowGenericException {public static void main(String[] args) {ProcessRunner<String, Failure1> runner1 =new ProcessRunner<>();for (int i = 0; i < 3; i++)runner1.add(new Processor1());try {System.out.println(runner1.processAll());} catch (Failure1 e) {System.out.println(e);}ProcessRunner<Integer, Failure2> runner2 =new ProcessRunner<>();for (int i = 0; i < 3; i++)runner2.add(new Processor2());try {System.out.println(runner2.processAll());} catch (Failure2 e) {System.out.println(e);}}
}

        程序执行的结果是:

        Processor规定了会抛出异常E的方法process()process()的结果被保存在了List<T> resultCollector中(这个参数也被称为采集参数)。

    因为检查型异常的缘故,如果不使用参数化的异常,我们就无法泛化地进行如上的代码编写。

混型

        混型最基本的概念是,混合多个类的能力,生成一个可以代表混型中所有类型的类(不过,这通常是我们最后做的一件事)。

        对混型的更改会应用于所有使用了该混型的类中。可以说,混型更加接近面向切面编程。

C++中的混型

        依旧是先看看混型在C++中的表现。C++会通过多重继承实现混型,除此之外,参数化类型也是一个不错的实现手段。

【例子:在C++中使用混型】

#include<string>
#include<ctime>
#include<iostream>using namespace std;template<class T> class TimeStamped : public T {long timeStamp;
public:TimeStamped() {timeStamp = time(0);}long getStamp() {return timeStamp;}
};template<class T> class SerialNumbered : public T {long serialNumber;static long counter;
public:SerialNumbered() {serialNumber = counter++;}long getSerialNumber() {return serialNumber;}
};// 定义静态存储,并进行初始化
template<class T> long SerialNumbered<T>::counter = 1;class Basic {string value;
public:void set(string val) {value = val;}string get() {return value;}
};int main() {// 使用混型:TimeStamped<SerialNumbered<Basic>> mixin1, mixin2;mixin1.set("test 1");mixin2.set("test 2");cout << mixin1.get() << ": " << mixin1.getStamp() <<" " << mixin1.getSerialNumber() << endl;cout << mixin2.get() << ": " << mixin2.getStamp() <<" " << mixin2.getSerialNumber() << endl;
}

        程序执行的结果是:

        mixin1mixin2具有所有混入类型的方法,这就相当于将已有的类映射到新的子类上一样。

        不幸的是,由于类型擦除会丢弃基类的类型,因此在Java中,泛型类无法直接继承自泛型参数


替代方案

        为了在Java中使用混型,下面将会给出一些替代的方案。

与接口混合

        一种常见的方式是通过接口来实现泛型的效果:

【例子:使用接口实现混型的效果】

import java.util.Date;interface TimeStamped {long getStamp();
}class TimeStampedImp implements TimeStamped {private final long timeStamp;TimeStampedImp() {timeStamp = new Date().getTime();}@Overridepublic long getStamp() {return timeStamp;}
}interface SerialNumbered {long getSerialNumber();
}class SerialNumberedImp implements SerialNumbered {private static long counter = 1;private final long serialNumber = counter++;@Overridepublic long getSerialNumber() {return serialNumber;}
}interface Basic {void set(String val);String get();
}class BasicImp implements Basic {private String value;@Overridepublic void set(String val) {value = val;}@Overridepublic String get() {return value;}
}// 混合多个类的能力
class Mixin extends BasicImpimplements TimeStamped, SerialNumbered {private TimeStamped timeStamp =new TimeStampedImp();private SerialNumbered serialNumber =new SerialNumberedImp();@Overridepublic long getStamp() {return timeStamp.getStamp();}@Overridepublic long getSerialNumber() {return serialNumber.getSerialNumber();}
}public class Mixins {public static void main(String[] args) {Mixin mixin1 = new Mixin(),mixin2 = new Mixin();mixin1.set("Test 1");mixin2.set("Test 2");System.out.println(mixin1.get() + ": " +mixin1.getStamp() + " " +mixin1.getSerialNumber());System.out.println(mixin2.get() + ": " +mixin2.getStamp() + " " +mixin2.getSerialNumber());}
}

        程序执行的结果是:

        在这里,Mixin类使用的是委托模式,这种模式要求每个被混入其中的类在Mixin中都有一个字段,Mixin负责把对应的任务委托给字段所代表的类。

        然而,这种做法在面对复杂的混型时会导致代码量的急剧增加。

----------

使用装饰器模式

||| 装饰器模式:用其他的类装饰一个可包装的类,分层叠加功能。

        可以发现,装饰器模式和混型的概念有相似之处。装饰器通过组合和规范的结构(这个结构就是可装饰物和装饰器的层次结构)进行实现,而混型的实现基于继承。

    装饰器是透明的,可以通过一个公共的信息集向其传递信息。

(可以将混型看做一种不要求装饰器继承结构的泛型装饰器机制)

【例子:使用装饰器重写上一个例子】

import java.util.Date;class Basic {private String value;public void set(String val) {val = value;}public String get() {return value;}
}class Decorator extends Basic {protected Basic basic;Decorator(Basic basic) {this.basic = basic;}@Overridepublic void set(String val) {basic.set(val);}@Overridepublic String get() {return basic.get();}
}class TimeStamped extends Decorator {private final long timeStamp;TimeStamped(Basic basic) {super(basic);timeStamp = new Date().getTime();}public long getStamp() {return timeStamp;}
}class SerialNumbered extends Decorator {private static long counter = 1;private final long serialNumber = counter++;SerialNumbered(Basic basic) {super(basic);}public long getSerialNumber() {return serialNumber;}
}public class Decoration {public static void main(String[] args) {TimeStamped t1 = new TimeStamped(new Basic());TimeStamped t2 = new TimeStamped(new SerialNumbered(new Basic()));// 该方法不可用:// t2.getSerialNumber();t2.getStamp();SerialNumbered s1 = new SerialNumbered(new Basic());SerialNumbered s2 = new SerialNumbered(new TimeStamped(new Basic()));// 同样不可用:// s2.getStamp();s2.getSerialNumber();}
}

        通过这种方式创建的类也会包含所有所需的方法,但是使用装饰器产生的对象类型是其层次结构上的最后一层包装。换言之,因为只有最后一层是实际的类型,因此只有最后一层的方法是可见的

----------

与动态代理混合

        通过动态代理(可见笔记17-3),可以创建一种更捷径混型的机制。使用了动态代理,获得的结果类的动态类型将会是混合后的合并类型。

        需要注意的是,在动态代理中每个被混入的类都必须是某个接口的实现

【例子:使用混合代理实现混型】

import onjava.Tuple2;import static onjava.Tuple.*;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;class MixinProxy implements InvocationHandler {Map<String, Object> delegateByMethod;@SuppressWarnings("unchecked")MixinProxy(Tuple2<Object, Class<?>>... pairs) {delegateByMethod = new HashMap<>();for (Tuple2<Object, Class<?>> pair : pairs) {for (Method method : pair.b2.getMethods()) {String methodName = method.getName();// containKey()来自Map类:如果包含key值,则返回trueif (!delegateByMethod.containsKey(methodName))delegateByMethod.put(methodName, pair.a2);}}}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {String methodName = method.getName();Object delegate = delegateByMethod.get(methodName);return method.invoke(delegate, args);}@SuppressWarnings("unchecked")public static Object newInstance(Tuple2... pairs) {Class[] interfaces = new Class[pairs.length];for (int i = 0; i < pairs.length; i++) {interfaces[i] = (Class) pairs[i].b2;}ClassLoader cl =pairs[0].a2.getClass().getClassLoader();return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(pairs));}
}public class DynamicProxyMixin {public static void main(String[] args) {// BasicImp来自于Mixins.java的那个例子:@SuppressWarnings("unchecked")Object mixin = MixinProxy.newInstance(tuple(new BasicImp(), Basic.class),tuple(new TimeStampedImp(), TimeStamped.class),tuple(new SerialNumberedImp(),SerialNumbered.class));Basic b = (Basic) mixin;TimeStamped t = (TimeStamped) mixin;SerialNumbered s = (SerialNumbered) mixin;b.set("Hello");System.out.println(b.get());System.out.println(t.getStamp());System.out.println(s.getSerialNumber());}
}

        程序执行的结果是:

        然而,这种实现只对动态类型有效,而不会包括静态类型。除此之外,如main()中所展示的:

在使用方法之前,我们还需要强制向下转型,这也会带来多余的麻烦。

    为了支持Java的混型,业界开发了不止一个用于支持泛型的附加语言。


https://www.xjx100.cn/news/3118863.html

相关文章

网络数据通信—ProtoBuf实现序列化和反序列化

目录 前言 1.环境搭建 2. centos下编写的注意事项 3.约定双端交互接口 4.约定双端交互req/resp 5. 客户端代码实现 6.服务端代码实现 前言 Protobuf还常用于通讯协议、服务端数据交换场景。那么在这个示例中&#xff0c;我们将实现一个网络版本的通讯录&#xff0c;模拟…

JoySSL证书从申请到安装

为了保护网站和用户数据的安全&#xff0c;使用SSL证书是至关重要的一步。JoySSL是一种可靠的SSL证书提供商&#xff0c;它提供了简单易用的证书申请和安装流程。本文将详细介绍如何从申请到安装JoySSL证书的步骤。 一、申请JoySSL证书 1&#xff0c;访问JoySSL官方网站&#…

C++设计模式——Bridge模式(上)

一、什么是桥接模式 桥接模式&#xff08;Bridge Pattern&#xff09;是一种结构型设计模式&#xff0c;它将抽象部分和实现部分解耦&#xff0c;使得它们可以独立地变化。该模式使用了组合关系来替代继承&#xff0c;从而达到降低系统复杂度的目的。C作为一门面向对象的编程语…

鸿蒙(HarmonyOS)应用开发——基础组件

组件 组件化是一种将复杂的前端应用程序分解成小的、独立的部分的方法。这些部分被称为组件&#xff0c;它们可以重复使用&#xff0c;可以与其他组件组合使用以创建更复杂的组件&#xff0c;并且它们有自己的生命周期和状态。 组件化的目的是提高开发效率和代码重用率&#…

iOS NSDate的常用API

目录 一、创建日期 1.获取当前时间 2.当前时间指定秒数之后/前的时间 3.指定日期之后/后的时间 4.2001年之后/前指定秒数的时间 5.1970年之后/后指定秒数的时间 二、初始化日期 1.init 2.时间间指定秒数的时间 3.指定时间指定秒数之前/后的时间 4.2001年指定秒数之后…

面试篇之微服务(一)

目录 概览 1.什么是微服务&#xff1f; 2.微服务带来了哪些挑战&#xff1f; 3.现在有哪些流行的微服务解决方案&#xff1f; 这三种方案有什么区别吗&#xff1f; 4.说下微服务有哪些组件&#xff1f; 注册中心 5.注册中心是用来干什么的&#xff1f; 6.SpringCloud可…

管理Android12系统的WLAN热点

大家好!我是编码小哥,欢迎关注,持续分享更多实用的编程经验和开发技巧,共同进步。 要创建一个APK管理Android 12系统的WLAN热点,你需要遵循以下步骤: 1. 获取必要的权限和API访问权限。在AndroidManifest.xml文件中添加以下权限: ```xml <uses-permission android:…

WPF制作雷达扫描效果

前言 要实现该功能,我们就不得不先了解一下WPF里面的RenderTransform RenderTransform(渲染变换) <Border Height="100" Width="100" Background="Red"