在用PHP构建MVC框架时，我遇到了一个可以使用Java风格泛型轻松解决的问题。一个抽象的Controller类可能看起来像这样：
abstract class Controller {
abstract public function addModel(Model $model);
可能有一种情况，类Controller的子类应该只接受Model的子类。例如，ExtendedController应该只接受addModel方法中的ReOrderableModel，因为它提供了一个reOrder（）方法，ExtendedCntroller需要访问该方法：
class ExtendedController extends Controller {
public function addModel(ReOrderableModel $model) {
在PHP中，继承的方法签名必须完全相同，因此即使类继承了超类中暗示的类类型，也不能将类型提示更改为其他类。在java中，我会简单地这样做：
abstract class Controller<T> {
abstract public addModel(T model);
class ExtendedController extends Controller<ReOrderableModel> {
public addModel(ReOrderableModel model) {
但是PHP中没有泛型支持。是否有任何解决方案仍然遵循OOP原则？
编辑我知道PHP根本不需要类型提示，但它可能是糟糕的OOP。首先，从接口（方法签名）来看，应该接受什么样的对象并不明显。因此，如果另一个开发人员想要使用该方法，那么很明显，X类型的对象是必需的，而不必查看实现（方法体），这是糟糕的封装，打破了信息隐藏原则。其次，由于没有类型安全性，该方法可以接受任何无效变量，这意味着到处都需要手动类型检查和异常抛出！
它似乎对我有效（尽管它确实抛出了一个严格警告），有以下测试用例：
class PassMeIn
{
}
class PassMeInSubClass extends PassMeIn
{
}
class ClassProcessor
{
public function processClass (PassMeIn $class)
{
var_dump (get_class ($class));
}
}
class ClassProcessorSubClass extends ClassProcessor
{
public function processClass (PassMeInSubClass $class)
{
parent::processClass ($class);
}
}
$a = new PassMeIn;
$b = new PassMeInSubClass;
$c = new ClassProcessor;
$d = new ClassProcessorSubClass;
$c -> processClass ($a);
$c -> processClass ($b);
$d -> processClass ($b);
如果你真的不想要严格的警告，你可以这样处理。
class ClassProcessor
{
public function processClass (PassMeIn $class)
{
var_dump (get_class ($class));
}
}
class ClassProcessorSubClass extends ClassProcessor
{
public function processClass (PassMeIn $class)
{
if ($class instanceof PassMeInSubClass)
{
parent::processClass ($class);
}
else
{
throw new InvalidArgumentException;
}
}
}
$a = new PassMeIn;
$b = new PassMeInSubClass;
$c = new ClassProcessor;
$d = new ClassProcessorSubClass;
$c -> processClass ($a);
$c -> processClass ($b);
$d -> processClass ($b);
$d -> processClass ($a);
不过，有一件事你应该记住，这绝对不是OOP术语中的最佳实践。如果一个超类可以接受特定类的对象作为方法参数，那么它的所有子类也应该能够接受该类的对象。阻止子类处理超类可以接受的类意味着你不能用子类代替超类，并且100%相信它在所有情况下都能工作。相关实践被称为Liskov替换原则，它指出，除其他外，方法参数的类型在子类中只能变得更弱，返回值的类型只能变得更强（输入只能变得更通用，输出只能变得更具体）。
这是一个非常令人沮丧的问题，我自己也多次遇到过，因此，如果在特定情况下忽略它是最好的做法，那么我建议你忽略它。但不要养成这样的习惯，否则你的代码将开始发展各种微妙的相互依赖关系，这将是调试的噩梦（单元测试不会抓住它们，因为单个单元将按预期运行，问题在于它们之间的交互）。如果你忽略了它，那么对代码进行注释，让其他人知道它，这是一个深思熟虑的设计选择。
Java世界发明的东西并不总是正确的。我想我在这里检测到了一个违反Liskov替换原则的行为，PHP在E_STRICT模式下抱怨它是正确的：
引用维基百科："如果S是T的一个子类型，那么程序中T类型的对象可以用S类型的对象替换，而不会改变该程序的任何期望属性。"
T是您的控制器。S是您的ExtendedController。您应该能够在控制器工作的每个地方使用ExtendedController，而不会破坏任何东西。更改addModel（）方法上的typehint会破坏一切，因为在每个传递Model类型对象的地方，如果不是意外地成为ReOrderableModel，那么typehint现在将阻止传递同一个对象。
如何逃脱？
ExtendedController可以保持typehint不变，然后检查他是否获得ReOrderableModel的实例。这避免了PHP的抱怨，但它仍然打破了Liskov替换的局面。
更好的方法是创建一个新方法addReOrderableModel()，该方法旨在将ReOrderableModel对象注入ExtendedController。该方法可以具有所需的typehint，并且可以在内部调用addModel()来将模型放置在期望的位置。
如果您需要使用ExtendedController而不是Controller作为参数，那么您就知道添加ReOrderableModel的方法是存在的，并且可以使用。您明确声明控制器不适合这种情况。每个期望传递Controller的方法都不会期望addReOrderableModel()存在，也永远不会尝试调用它。每个期望ExtendedController的方法都有权调用此方法，因为它必须存在。
class ExtendedController extends Controller
{
public function addReOrderableModel(ReOrderableModel $model)
{
return $this->addModel($model);
}
}
我的解决方法如下：
/**
* Generic list logic and an abstract type validator method.
*/
abstract class AbstractList {
protected $elements;
public function __construct() {
$this->elements = array();
}
public function add($element) {
$this->validateType($element);
$this->elements[] = $element;
}
public function get($index) {
if ($index >= sizeof($this->elements)) {
throw new OutOfBoundsException();
}
return $this->elements[$index];
}
public function size() {
return sizeof($this->elements);
}
public function remove($element) {
validateType($element);
for ($i = 0; $i < sizeof($this->elements); $i++) {
if ($this->elements[$i] == $element) {
unset($this->elements[$i]);
}
}
}
protected abstract function validateType($element);
}
/**
* Extends the abstract list with the type-specific validation
*/
class MyTypeList extends AbstractList {
protected function validateType($element) {
if (!($element instanceof MyType)) {
throw new InvalidArgumentException("Parameter must be MyType instance");
}
}
}
/**
* Just an example class as a subject to validation.
*/
class MyType {
// blahblahblah
}
function proofOfConcept(AbstractList $lst) {
$lst->add(new MyType());
$lst->add("wrong type"); // Should throw IAE
}
proofOfConcept(new MyTypeList());
尽管这与Java泛型仍然不同，但它几乎最小化了模仿行为所需的额外代码。
此外，它的代码比其他人给出的一些例子要多一些，但至少对我来说，它似乎比大多数例子都更干净（对Java同行来说更相似）。
我希望你们中的一些人会觉得它有用。
欢迎对该设计进行任何改进！
我以前也遇到过同样的问题。我用了这样的东西来解决它。
Class Myclass {
$objectParent = "MyMainParent"; //Define the interface or abstract class or the main parent class here
public function method($classObject) {
if(!$classObject instanceof $this -> objectParent) { //check
throw new Exception("Invalid Class Identified");
}
// Carry on with the function
}
}
您可以考虑切换到Hack和HHVM。它由Facebook开发，与PHP完全兼容。您可以决定使用<?php或<?hh
它支持你想要的：
http://docs.hhvm.com/manual/en/hack.generics.php
我知道这不是PHP。但它与之兼容，也显著提高了您的性能。
您可以通过将类型作为构造函数的第二个参数来进行肮脏的操作
<?php class Collection implements IteratorAggregate{
private $type;
private $container;
public function __construct(array $collection, $type='Object'){
$this->type = $type;
foreach($collection as $value){
if(!($value instanceof $this->type)){
throw new RuntimeException('bad type for your collection');
}
}
$this->container = new 'ArrayObject($collection);
}
public function getIterator(){
return $this->container->getIterator();
}
}
为了提供高水平的静态代码分析、严格的类型和可用性，我提出了这个解决方案：https://gist.github.com/rickhub/aa6cb712990041480b11d5624a60b53b
/**
* Class GenericCollection
*/
class GenericCollection implements 'IteratorAggregate, 'ArrayAccess{
/**
* @var string
*/
private $type;
/**
* @var array
*/
private $items = [];
/**
* GenericCollection constructor.
*
* @param string $type
*/
public function __construct(string $type){
$this->type = $type;
}
/**
* @param $item
*
* @return bool
*/
protected function checkType($item): bool{
$type = $this->getType();
return $item instanceof $type;
}
/**
* @return string
*/
public function getType(): string{
return $this->type;
}
/**
* @param string $type
*
* @return bool
*/
public function isType(string $type): bool{
return $this->type === $type;
}
#region IteratorAggregate
/**
* @return 'Traversable|$type
*/
public function getIterator(): 'Traversable{
return new 'ArrayIterator($this->items);
}
#endregion
#region ArrayAccess
/**
* @param mixed $offset
*
* @return bool
*/
public function offsetExists($offset){
return isset($this->items[$offset]);
}
/**
* @param mixed $offset
*
* @return mixed|null
*/
public function offsetGet($offset){
return isset($this->items[$offset]) ? $this->items[$offset] : null;
}
/**
* @param mixed $offset
* @param mixed $item
*/
public function offsetSet($offset, $item){
if(!$this->checkType($item)){
throw new 'InvalidArgumentException('invalid type');
}
$offset !== null ? $this->items[$offset] = $item : $this->items[] = $item;
}
/**
* @param mixed $offset
*/
public function offsetUnset($offset){
unset($this->items[$offset]);
}
#endregion
}
/**
* Class Item
*/
class Item{
/**
* @var int
*/
public $id = null;
/**
* @var string
*/
public $data = null;
/**
* Item constructor.
*
* @param int $id
* @param string $data
*/
public function __construct(int $id, string $data){
$this->id = $id;
$this->data = $data;
}
}
/**
* Class ItemCollection
*/
class ItemCollection extends GenericCollection{
/**
* ItemCollection constructor.
*/
public function __construct(){
parent::__construct(Item::class);
}
/**
* @return 'Traversable|Item[]
*/
public function getIterator(): 'Traversable{
return parent::getIterator();
}
}
/**
* Class ExampleService
*/
class ExampleService{
/**
* @var ItemCollection
*/
private $items = null;
/**
* SomeService constructor.
*
* @param ItemCollection $items
*/
public function __construct(ItemCollection $items){
$this->items = $items;
}
/**
* @return void
*/
public function list(){
foreach($this->items as $item){
echo $item->data;
}
}
}
/**
* Usage
*/
$collection = new ItemCollection;
$collection[] = new Item(1, 'foo');
$collection[] = new Item(2, 'bar');
$collection[] = new Item(3, 'foobar');
$collection[] = 42; // InvalidArgumentException: invalid type
$service = new ExampleService($collection);
$service->list();
即使这样的事情会让人感觉好多了：
class ExampleService{
public function __construct(Collection<Item> $items){
// ..
}
}
希望泛型能很快进入PHP。
一种替代方案是splat运算符+类型提示+私有数组的组合：
<?php
class Student {
public string $name;
public function __construct(string $name){
$this->name = $name;
}
}
class Classe {
private $students = [];
public function add(Student ...$student){
array_merge($this->students, $student);
}
public function getAll(){
return $this->students;
}
}
$c = new Classe();
$c->add(new Student('John'), new Student('Mary'), new Student('Kate'));