泛型（15）：潜在类型机制

约定不等于承诺〃 2023-07-18 12:37 1阅读 0赞

在本章的开头介绍过这样的思想，即要编写能够尽可能广泛地应用的代码。为了实现这一点，我们需要各种途径来放松对我们的代码将要作用的类型所做的限制，同时不失去静态类型检查的好处。然后，我们就可以编写出无需修改就可以应用于更多情况的代码，即更加“泛化”的代码。

java泛型看起来是向这一方向迈进了一步。当你在编写或使用只是持有对象的泛型时，这些代码将可以工作于任何类型（除了基本类型，尽管正如你所见到的，自动包装机制可以克服这一点）。或者，换个角度讲，“持有器”泛型能够声明：“我不关心你是什么类型”。如果代码不关心它将要作用的类型，那么这种代码就可以真正地应用于任何地方，并因此而相当“泛化”。

还是正如你所见到的，当要在泛型类型上执行操作（即调用Object方法之前的操作）时，就会产生问题，因为擦除要求指定可能会用到的泛型类型的边界，以安全地调用代码中的泛型对象上的具体方法。这是对“泛化”概念的一种明显的限制，因为必须限制你的泛型类型，使他们继承自特定的类，或者实现特定的接口。在某些情况下，你最终可能会使用普通类或普通接口，因为限定边界的泛型可能会和指定类或接口没有任何区别。

某些编程语言提供的一种解决方案称为潜在类型机制或结构化类型机制，而更古怪的术语称为鸭子类型机制，即“如果它走起来像鸭子，并且叫起来也像鸭子，那么你就可以将它当作鸭子对待。”鸭子类型机制变成了一种相当流行的术语，可能是因为它不像其他的术语那样承载着历史的包袱。

泛型代码典型地将在泛型类型上调用少量的方法，而具有潜在类型机制的语言只要求实现某个方法子集，而不是某个特定类或接口，从而放松了这种限制（并且可以生产更加泛化的代码）。正由于此，潜在类型机制使得你可以横跨类继承结构，调用不属于某个公共接口的方法。因此，实际上一段代码可以声明：“我不关心你是什么类型，只要你可以speak()和sit()即可。”由于不要求具体类型，因此代码就可以更加泛化。

潜在类型机制是一种代码组织和复用机制。有了它编写出的代码相对于没有它编写出的代码，能够更容易地复用。代码组织和复用是所有计算机编程的基本手段：编写一次，多次使用，并在一个位置保存代码。因为我并未被要求去命名我的代码要操作于其上的确切接口，所以有了潜在类型机制，我就可以编写更少的代码，并更容易的将其应用于多个地方。

下面是用C++来实现上面的描述：

class Dog{
    	public:
    		void speak(){}
    		void sit(){}
    		void reproduce(){}
    };
    
    class Robot{
    	public:
    		void speak(){}
    		void sit(){}
    		void oilChange(){}
    };
    
    template<class T> void perform(T anything){
    	anything.speak();
    	anything.sit();
    }
    
    int main(){
    	Dog d;
    	Robot r;
    	perform(d);
    	perform(r);
    }

在C++中，Dog和Robot没有任何共同的东西，只是碰巧有两个方法具有相同的签名。从类型的观点看，它们是完全不同的类型。但是，perform()不关心其参数的具体类型，并且潜在类型机制允许它接受这两种类型的对象。

因为泛型是在这场竞赛的后期才添加到java中的，因此没有任何机会可以去实现任何类型的潜在类型机制，因此java没有对这种特性的支持。所以，初看起来，java的泛型机制比支持潜在类型机制的语言更“缺乏泛化性”。例如，如果我们试图用java实现上面的示例，那么就会被强制要求使用一个类或接口，并子啊边界表达式中指定它：

public interface Performs {
    	void speak();
    
    	void sit();
    }

import typeinfo.pets.Dog;
    
    class PerformingDog extends Dog implements Performs {
    
    	@Override
    	public void speak() {
    		System.out.println("Woof!");
    	}
    
    	@Override
    	public void sit() {
    		System.out.println("Sitting");
    	}
    
    	public void reproduce() {
    	}
    }
    
    class Robot implements Performs {
    
    	@Override
    	public void speak() {
    		System.out.println("Click!");
    	}
    
    	@Override
    	public void sit() {
    		System.out.println("Clank!");
    	}
    
    	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) {
    		PerformingDog d = new PerformingDog();
    		Robot r = new Robot();
    		Communicate.perform(d);
    		Communicate.perform(r);
    	}
    }

但是要注意，perform()不需要使用泛型来工作，它可以被简单的指定为接受一个Performs对象：

class CommunicateSimply {
    	static void perform(Performs performer) {
    		performer.speak();
    		performer.sit();
    	}
    }
    
    public class SimpleDogsAndRobots {
    	public static void main(String[] args) {
    		CommunicateSimply.perform(new PerformingDog());
    		CommunicateSimply.perform(new Robot());
    	}
    }

在本例中，泛型不是必需的，因为这些类已经被强制要求实现Performs接口。

**如果本文对您有很大的帮助，还请点赞关注一下。**