潜在类型机制
通过泛型，我们应该可以向“将代码写得更通用一点”这一理念更进一步。特别是在编写简单的Java泛型时，泛型可以在不了解具体类型的情况下执行方法。然而，随着对Java泛型的了解逐渐深入，类型擦除无疑使泛型的作用打了折扣，并限制了“泛型”这一概念。
一些语言会提供潜在类型机制（又称结构化类型机制），它还有一个更有意思的名称：鸭子类型机制。比方说，“如果某件事物走路像鸭子，说话也像鸭子，那么就可以把它看做鸭子”。
潜在类型机制可以超越类的层次结构，调用不属于某个公共接口的方法。
支持潜在类型机制的语言
有许多语言支持潜在类型机制，例如Python、C++和Go等。
Python的潜在类型机制
class Dog:
def speak(self):
print("汪！")
def sit(self):
print("坐着")
def reproduce(self):
pass
class Robot:
def speak(self):
print("锵！")
def sit(self):
print("咔")
def oilChange(self):
pass
def perform(anything):
anything.speak()
anything.sit()
a = Dog()
b = Robot()
perform(a)
perform(b)
在perform(anything)中并不包含任何关于anything的类型信息，anything只是一个标识符。在后台，anything相当于一个被隐藏的接口，它包含了perform()要求的操作。但我们无需显式地表明它，因为它是潜在的。
———-
C++的潜在类型机制
【例子：C++中的潜在类型机制】
#include<iostream>
using namespace std;
class Dog {
public:
void speak() {
cout << "汪！" << endl;
}
void sit() {
cout << "坐着" << endl;
}
};
class Robot {
public:
void speak() {
cout << "锵！" << endl;
}
void sit() {
cout << "咔" << endl;
}
void oilChange() {}
};
template<class T> void perform(T anything) {
anything.speak();
anything.sit();
}
int main() {
Dog d;
Robot r;
perform(d);
perform(r);
}程序执行的结果相同：
若试图传入错误的类型，编译器也会报错。不同与Python，C++会在运行时抛出错误（尽管C++的错误信息出了名的冗长）。但这两门语言都保证了类型不会错用。
———-
【例子：Go中的潜在类型机制】
package main
import "fmt"
type Dog struct{}
func (this Dog) speak() {
fmt.Printf("汪！n")
}
func (this Dog) sit(){
fmt.Printf("坐着n")
}
func (this Dog) reproduce(){
}
type Robot struct{}
func (this Robot) speak() {
fmt.Printf("锵！n")
}
func (this Robot) sit(){
fmt.Printf("咔n")
}
func (this Robot) oilChange(){
}
func perform(speaker interface {speak(); sit()}){
speaker.speak()
speaker.sit()
}
func main(){
perform(Dog{})
perform(Robot{})
}程序会得到相同的结果：
Java中的直接潜在类型机制
Java的泛型加入得较晚，因此没有支持潜在类型机制。因此，若要在Java中实现上面所述的效果，通常会需要使用接口（并且使用边界）：
import reflection.pets.Dog;
class PerformingDog extends Dog implements Performs {
@Override
public void speak() {
System.out.println("汪！");
}
@Override
public void sit() {
System.out.println("坐下");
}
public void reproduce() {
}
}
class Robot implements Performs {
@Override
public void speak() {
System.out.println("锵！");
}
@Override
public void sit() {
System.out.println("咔");
}
public void oilChange() {
}
}
class Communicate {
// 通过边界，调用接口的方法：
public static <T extends Performs>
void perform(T performer) {
performer.speak();
performer.sit();
}
}
public class DogsAndRobots {
public static void main(String[] args) {
Communicate.perform(new PerformingDog());
Communicate.perform(new Robot());
}
}程序执行的结果是：
然而，仔细考虑这种做法会发现，Communicate.perform()并不需要使用到泛型，它可以直接使用Performs接口：
class Communicate {
public static void perform(Performs performer) {
performer.speak();
performer.sit();
}
}说到底，无论是PerformingDog还是Robot都已经强制实现了Performs接口。
潜在类型机制的替代方案
尽管Java并没有（直接）支持潜在类型机制，但我们依旧可以想办法创建出真正意义上的泛型代码，实现方法的跨层次应用。
反射
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
// 这个类没有实现Perform接口：
class Mime {
public void walkAgainstTheWind() {
}
public void sit() {
System.out.println("假装坐着");
}
public void pushInvisibleWalls() {
}
@Override
public String toString() {
return "哑剧";
}
}
class SmartDog {
public void speak() {
System.out.println("汪！");
}
public void sit() {
System.out.println("坐下");
}
public void reproduce() {
}
}
class CommunicateReflectively {
public static void perform(Object speaker) {
Class<?> spkr = speaker.getClass();
try {
try {
Method speak = spkr.getMethod("speak");
speak.invoke(speaker);
} catch (NoSuchMethodException e) {
System.out.println(speaker + "没法说话");
}
try {
Method sit = spkr.getMethod("sit");
sit.invoke(speaker);
} catch (NoSuchMethodException e) {
System.out.println(speaker + "无法坐下");
}
} catch (SecurityException |
IllegalAccessException |
IllegalArgumentException |
InvocationTargetException e) {
throw new RuntimeException(speaker.toString(), e);
}
}
}
public class LatentReflection {
public static void main(String[] args) {
CommunicateReflectively.perform(new SmartDog());
CommunicateReflectively.perform(new Robot());
CommunicateReflectively.perform(new Mime());
}
}程序执行的结果是：
在这里，SmartDog、Robot和Mime之间没有任何的直接联系，我们直接通过反射动态调用speak()和sit()。
将方法应用于序列中的每个元素
还可以进一步地开发反射。假设我们需要为一个序列中的每个元素应用方法，只使用接口仍是不够的，因此我们可以这样做：
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Apply {
public static <T, S extends Iterable<T>>
void apply(S seq, Method f, Object... args) {
try {
for (T t : seq)
f.invoke(t, args);
} catch (IllegalAccessException |
IllegalArgumentException |
InvocationTargetException e) {
throw new RuntimeException(e); // 可能会因为不正确的使用该方法导致异常
}
}
}apply()方法可以接受任意数量的序列元素，并将方法f()应用于所有元素。这种做法有一个好处，f.invoke()可以接受任意长度的序列，因此可以认为apply()也可以做到这点。
首先创建一个简单的继承结构，这个结构包含一个父类Shape和一个子类Square。
public class Shape {
private static long counter = 0;
private final long id = counter++;
@Override
public String toString() {
return getClass().getSimpleName() + " " + id;
}
public void rotate() {
System.out.println(this + " rotate");
}
public void resize(int newSize) {
System.out.println(this + " resize " + newSize);
}
}==子类Square：
public class Square extends Shape {}import onjava.Suppliers;
import java.util.ArrayList;
import java.util.List;
public class ApplyTest {
public static void main(String[] args)
throws Exception {
List<Shape> shapes =
Suppliers.create(ArrayList::new, Shape::new, 3);
Apply.apply(shapes,
Shape.class.getMethod("rotate"));
Apply.apply(shapes,
Shape.class.getMethod("resize", int.class), 7);
System.out.println();
List<Square> squares =
Suppliers.create(ArrayList::new, Square::new, 3);
Apply.apply(squares,
Shape.class.getMethod("rotate"));
Apply.apply(squares,
Shape.class.getMethod("resize", int.class), 7);
System.out.println();
Apply.apply(new FilledList<>(Shape::new, 3),
Shape.class.getMethod("rotate"));
Apply.apply(new FilledList<>(Square::new, 3),
Shape.class.getMethod("rotate"));
}
}程序执行的结果是：
这行代码等价于，将Shape类的构造器作为生成器，生成3个对象，并将结果放入一个ArrayList对象中。
尽管反射可以使代码看起来很优雅，但要注意，反射的运行速度通常会慢于非反射的实现。究其原因，反射在运行时处理了太多东西。尽管我们不应该只因为这个理由放弃使用反射，但这无疑是我们必须考虑的一点。
现在考虑Java 8加入的函数式方式，下面的例子通过它重写了ApplyTest：
import java.util.stream.Stream;
public class ApplyFunctional {
public static void main(String[] args) {
Stream.of(Stream.generate(Shape::new).limit(2),
Stream.generate(Square::new).limit(2))
.flatMap(c -> c) // 将所有元素扁平化，合成一条流
.peek(Shape::rotate)
.forEach(s -> s.resize(7));
System.out.println();
new FilledList<>(Shape::new, 2)
.forEach(Shape::rotate);
new FilledList<>(Square::new, 2)
.forEach(Shape::rotate);
}
}程序执行的结果是：
这么做的好处是，它更加简洁、可读性高并且不会抛出异常。因此现在可以这么说，我们只需要在某些只能使用反射来解决的场景中使用反射就好了。
Java 8的潜在类型机制（间接实现）
Java 8带来的未绑定方法引用可以在某种程度上实现潜在类型机制。
【例子：使用方法引用实现潜在类型机制】
import reflection.pets.Dog;
import java.util.function.Consumer;
class PerformingDogA extends Dog {
public void speak() {
System.out.println("汪！");
}
public void sit() {
System.out.println("坐下");
}
public void reproduce() {
}
}
class RobotA {
public void speak() {
System.out.println("锵！");
}
public void sit() {
System.out.println("咔");
}
public void oilChange() {
}
}
class CommunicateA {
public static <P> void perform(
P performer, Consumer<P> action1, Consumer<P> action2) {
action1.accept(performer);
action2.accept(performer);
}
}
public class DogsAndRobotMethodReferences {
public static void main(String[] args) {
CommunicateA.perform(new PerformingDogA(),
PerformingDogA::speak, PerformingDogA::sit);
CommunicateA.perform(new RobotA(),
RobotA::speak, RobotA::sit);
CommunicateA.perform(new Mime(),
Mime::walkAgainstTheWind, Mime::pushInvisibleWalls);
}
}程序执行结果是：
因为CommunicateA.perform()没有对P做出限制，因此它可以是任何类型。perform()只要求提供可供Consumer<P>使用的方法。因此我们可以向其中传入任何与其签名一致的方法。
但这种方式也有更好的一点，它其实不会对传入其中的方法名做出要求。在这个意义上，这种方法要更加通用。
潜在类型机制的使用例（Suppliers）
现在可以通过潜在类型机制创建Suppliers（这个类在之前的笔记中也曾出现）。这个类的方法都用于填充集合：
【例子：潜在类型机制的使用例】
import java.util.Collection;
import java.util.function.BiConsumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
public class Suppliers {
// 根据factory创建一个新的集合，并且填充它：
public static <T, C extends Collection<T>> C
create(Supplier<C> factory, Supplier<T> gen, int n) {
return Stream.generate(gen)
.limit(n)
.collect(factory, C::add, C::addAll);
}
// 填充已存在的集合coll：
public static <T, C extends Collection<T>>
C fill(C coll, Supplier<T> gen, int n) {
Stream.generate(gen)
.limit(n)
.forEach(coll::add);
return coll;
}
// 使用到未绑定方法引用adder，可以生成更加通用的方法：
public static <H, A> H fill(
H holder, BiConsumer<H, A> adder,
Supplier<A> gen, int n) {
Stream.generate(gen)
.limit(n)
.forEach(a -> adder.accept(holder, a));
return holder;
}
}在第一个fill()方法中，我们返回了coll（即传入的容器的类型信息），这样就能保证不会丢失类型信息了。
第二个fill()方法使用了未绑定的方法引用adder。通过adder.accept()，我们可以将操作a应用于对象holder。
【例子：使用Suppliers】
import onjava.Suppliers;
import java.util.ArrayList;
import java.util.List;
class Customer {
private static long counter = 1;
private final long id = counter++;
@Override
public String toString() {
return "Customer " + id;
}
}
class Teller {
private static long counter = 1;
private final long id = counter++;
@Override
public String toString() {
return "Teller " + id;
}
}
class Bank {
private List<BankTeller> tellers =
new ArrayList<>();
public void put(BankTeller bt) {
tellers.add(bt);
}
}
public class BankTeller {
public static void serve(Teller t, Customer c) {
System.out.println(t + " 服务于 " + c);
}
public static void main(String[] args) {
// 使用create()：
RandomList<Teller> tellers =
Suppliers.create(
RandomList::new, Teller::new, 4);
// 演示第一个fill()：
List<Customer> customers = Suppliers.fill(
new ArrayList<>(), Customer::new, 12);
customers.forEach(c ->
serve(tellers.select(), c));
// 演示潜在类型机制：
Bank bank = Suppliers.fill(
new Bank(), Bank::put, BankTeller::new, 3);
// 或使用第二个fill()：
List<Customer> customers2 = Suppliers.fill(
new ArrayList<>(), List::add, Customer::new, 12);
}
}程序执行的结果是：
注意第二个fill()的两个使用，我们不仅可以将有所关联的Bank类型，还可以将其用于List。
总结
尽管Java中加入的泛型存在着一些问题，但在此之前我们需要注意一点：无论一门语言多么强大，都有可能被用来编写一个无比糟糕的程序。泛型常常被用于集合之类的场景，但除此之外，泛型还能做到什么？
泛型的概念应该就像它的名字一样，追求的是一种更加“泛型（泛化）”的代码，使一种代码能够适应更多的场景。
原文地址:https://blog.csdn.net/w_pab/article/details/134693448
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.7code.cn/show_23544.html
如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！
