58

我注意到你不能在 PHP 中使用抽象常量。

有没有一种方法可以强制子类定义一个常量（我需要在其中一个抽象类内部方法中使用它）？

4

7 回答 7

76

这可能有点“黑客”，但只需很少的努力就可以完成这项工作，但如果未在子类中声明常量，则会出现不同的错误消息。

自引用常量声明在语法上是正确的并且解析没有问题，如果该声明在运行时实际执行，则只会抛出错误，因此必须在子类中覆盖抽象类中的自引用声明，否则将出现致命错误: Cannot declare self-referencing constant.

在这个例子中，抽象的父类Foo强制它的所有子类声明变量NAME。此代码运行良好，输出Donald. 但是，如果子类Fooling没有声明变量，就会触发致命错误。

<?php

abstract class Foo {

    // Self-referential 'abstract' declaration
    const NAME = self::NAME;

}

class Fooling extends Foo {

    // Overrides definition from parent class
    // Without this declaration, an error will be triggered
    const NAME = 'Donald';

}

$fooling = new Fooling();

echo $fooling::NAME;
于 2017-03-31T07:26:59.733 回答
32

Aconstant是一个constant；据我所知，PHP中没有abstract或没有private常量，但您可以解决以下问题：

示例抽象类 

abstract class Hello {
    const CONSTANT_1 = 'abstract'; // Make Abstract
    const CONSTANT_2 = 'abstract'; // Make Abstract
    const CONSTANT_3 = 'Hello World'; // Normal Constant
    function __construct() {
        Enforcer::__add(__CLASS__, get_called_class());
    }
}

这会运行良好 

class Foo extends Hello {
    const CONSTANT_1 = 'HELLO_A';
    const CONSTANT_2 = 'HELLO_B';
}
new Foo();

酒吧会返回错误

class Bar extends Hello {
    const CONSTANT_1 = 'BAR_A';
}
new Bar();

Songo 会返回错误

class Songo extends Hello {

}
new Songo();

执行者类

class Enforcer {
    public static function __add($class, $c) {
        $reflection = new ReflectionClass($class);
        $constantsForced = $reflection->getConstants();
        foreach ($constantsForced as $constant => $value) {
            if (constant("$c::$constant") == "abstract") {
                throw new Exception("Undefined $constant in " . (string) $c);
            }
        }
    }
}
于 2012-04-29T00:06:57.203 回答
19

不幸的是，不是……一个常数正是它在锡上所说的，常数。一旦定义了就不能重新定义，这样就不可能通过PHP的抽象继承或者接口来要求它的定义。

但是...您可以检查该常量是否在父类的构造函数中定义。如果没有，则抛出异常。

abstract class A
{
    public function __construct()
    {
        if (!defined('static::BLAH'))
        {
            throw new Exception('Constant BLAH is not defined on subclass ' . get_class($this));
        }
    }
}

class B extends A
{
    const BLAH = 'here';
}

$b = new B();

从您的初始描述来看，这是我能想到的最佳方式。

于 2012-04-29T00:24:27.803 回答
15

不，但您可以尝试其他方法，例如抽象方法：

abstract class Fruit
{
    abstract function getName();
    abstract function getColor();

    public function printInfo()
    {
        echo "The {$this->getName()} is {$this->getColor()}";
    }
}

class Apple extends Fruit
{
    function getName() { return 'apple'; }
    function getColor() { return 'red'; }

    //other apple methods
}

class Banana extends Fruit
{
    function getName() { return 'banana'; }
    function getColor() { return 'yellow'; }

    //other banana methods
}

或静态成员：

abstract class Fruit
{
    protected static $name;
    protected static $color;

    public function printInfo()
    {
        echo "The {static::$name} is {static::$color}";
    }
}

class Apple extends Fruit
{
    protected static $name = 'apple';
    protected static $color = 'red';

    //other apple methods
}

class Banana extends Fruit
{
    protected static $name = 'banana';
    protected static $color = 'yellow';

    //other banana methods
}

来源

于 2012-04-29T00:18:22.380 回答
2

在 php 7.2 中测试，但应该从 5.3 开始，您可以利用后期静态绑定来存档此行为。它将引发与异常相同的致命错误，因为在大多数情况下，您不想在运行时处理致命错误。如果您愿意，您可以轻松实现自定义错误处理程序。

所以以下对我有用：

<?php

abstract class Foo {

    public function __construct() {
        echo static::BAR;
    }

}


class Bar extends Foo {
    const BAR = "foo bar";
}

$bar = new Bar();    //foo bar

如果删除，const您将获得：

Fatal error: Uncaught Error: Undefined class constant 'BAR' in ...
于 2019-02-20T19:07:22.917 回答
2

也许我遗漏了一些东西，但使用后期静态绑定对我有用。这对你的问题有用吗？

abstract class A{
    const NAME=null;

    static function f(){
        return static::NAME;
    }
}

class B extends A{
    const NAME='B';    
}

B::f();
于 2021-10-24T03:11:02.340 回答
-1

PHP 接口支持常量。这并不理想，因为您必须记住在每个子类上实现接口，因此它部分地违背了目的。

于 2020-04-14T05:00:29.930 回答