blocks|key|2713619|text|你可以通过测试你的代码来发现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2713620|2713621|致命错误:属性不能在...中声明为抽象...在第3行|blockquote|2713622|2713623|2713624|不，没有。属性不能在PHP中声明为抽象。|2713625|然而，你可以实现一个getter/setter函数抽象，这可能就是你想要的。|2713626|属性没有实现(尤其是公共属性)，它们只是存在(或不存在)：|2713627|$foo+=+new+Foo;
$foo->publicProperty+=+'Bar';|code-block|syntax|javascript|2713628|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|W|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|12|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

As you could have found out by just testing your code:

<blockquote>
 Fatal error: Properties cannot be declared abstract in ... on line 3
</blockquote>

No, there is not. Properties cannot be declared abstract in PHP.

However you can implement a getter/setter function abstract, this might be what you're looking for.

Properties aren't implemented (especially public properties), they just exist (or not):

<pre><code>$foo = new Foo;
$foo-&gt;publicProperty = 'Bar';
</code></pre>

blocks|key|589451|text|没有定义属性这回事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|589452|只能声明属性，因为它们是初始化时保留在内存中的数据的容器。|589453|另一方面，函数可以声明(类型、名称、参数)而无需定义(缺少函数体)，因此可以使其成为抽象的。|589454|"Abstract“只表示声明了但没有定义的东西，因此在使用它之前，你需要定义它，否则它就变得无用了。|589455|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

There is no such thing as defining a property.

You can only declare properties because they are containers of data reserved in memory on initialization. 

A function on the other hand can be declared (types, name, parameters) without being defined (function body missing) and thus, can be made abstract.

"Abstract" only indicates that something was declared but not defined and therefore before using it, you need to define it or it becomes useless.

blocks|key|4328963|text|不，没有办法强制使用编译器，您必须对$tablename变量使用运行时检查(例如，在构造函数中)，例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4328964|class+Foo_Abstract+{
++public+final+function+__construct(/*whatever*/)+{
++++if(!isset($this->tablename))
++++++throw+new+LogicException(get_class($this)+.+'+must+have+a+$tablename');
++}
}|code-block|syntax|javascript|4328965|要对抽象的所有派生类执行此操作，您必须将Foo_+Foo_Abstract的构造函数设为final，以防止重写。|4328966|你可以声明一个抽象的getter：|4328967|abstract+class+Foo_Abstract+{
++abstract+public+function+get_tablename();
}

class+Foo+extends+Foo_Abstract+{
++protected+$tablename+=+'tablename';
++public+function+get_tablename()+{
++++return+$this->tablename;
++}
}|4328968|entityMap^0|I|A|0|0|18|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

No, there is no way to enforce that with the compiler, you'd have to use run-time checks (say, in the constructor) for the <code>$tablename</code> variable, e.g.:

<pre><code>class Foo_Abstract {
 public final function __construct(/*whatever*/) {
 if(!isset($this-&gt;tablename))
 throw new LogicException(get_class($this) . ' must have a $tablename');
 }
}
</code></pre>

To enforce this for all derived classes of Foo_Abstract you would have to make Foo_Abstract's constructor <code>final</code>, preventing overriding.

You could declare an abstract getter instead:

<pre><code>abstract class Foo_Abstract {
 abstract public function get_tablename();
}

class Foo extends Foo_Abstract {
 protected $tablename = 'tablename';
 public function get_tablename() {
 return $this-&gt;tablename;
 }
}
</code></pre>

blocks|key|4612313|text|如上所述，没有这样的确切定义。然而，我使用这个简单的变通方法来强制子类定义“抽象”属性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4612314|abstract+class+Father+
{
++public+$name;
++abstract+protected+function+setName();+//+now+every+child+class+must+declare+this+
++++++++++++++++++++++++++++++++++++++//+function+and+thus+declare+the+property

++public+function+__construct()+
++{
++++$this->setName();
++}
}

class+Son+extends+Father
{
++protected+function+setName()
++{
++++$this->name+=+"son";
++}

++function+__construct(){
++++parent::__construct();
++}
}|code-block|syntax|javascript|4612315|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As stated above, there is no such exact definition.
I, however, use this simple workaround to force the child class to define the "abstract" property:

<pre><code>abstract class Father 
{
 public $name;
 abstract protected function setName(); // now every child class must declare this 
 // function and thus declare the property

 public function __construct() 
 {
 $this-&gt;setName();
 }
}

class Son extends Father
{
 protected function setName()
 {
 $this-&gt;name = "son";
 }

 function __construct(){
 parent::__construct();
 }
}
</code></pre>

blocks|key|589486|text|根据属性的上下文，如果我想在扩展类中强制声明抽象类属性，我喜欢在抽象对象构造函数或setter/getter方法中使用带有static关键字的常量作为属性。您可以选择使用final来防止该方法在扩展类中被重写。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|589487|示例：https://3v4l.org/WH5Xl|589488|abstract+class+AbstractFoo
{
++++public+$bar;

++++final+public+function+__construct()
++++{
++++++++$this->bar+=+static::BAR;
++++}
}

class+Foo+extends+AbstractFoo
{
++++//const+BAR+=+'foobar';+//uncomment+to+prevent+exception
}|code-block|syntax|javascript|589489|$foo+=+new+Foo();+
//Fatal+Error:+Undefined+class+constant+'BAR'|589490|589491|但是，如果重新定义，扩展类将覆盖父类属性和方法。|589492|例如，如果某个属性在父类中声明为protected，并在扩展类中重新定义为public，则生成的属性为public。否则，如果该属性在父类中声明为private，则它将保持为private，并且不可用于扩展类。|589493|http://www.php.net//manual/en/language.oop5.static.php|589494|entityMap|0|LINK|mutability|MUTABLE|url|https://www.php.net/manual/en/language.oop5.final.php|1|https://3v4l.org/WH5Xl|2^0|1P|6|2D|5|2D|5|0|0|3|M|1|0|0|0|0|0|G|9|11|6|1F|6|21|7|2F|7|0|0|1I|2|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|6|7|1E|8|@]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|H|3|I|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|O|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1L|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1X|8|@]|D|@$9|1Y|A|1Z|1|20]]|E|$]]|$1|V|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12]]|13|$5|Y|Z|10|E|$11|14]]|15|$5|Y|Z|10|E|$11|U]]]]

Depending on the context of the property, if I want to force declaration of an abstract class property in an extended class, I like to use a constant with the <code>static</code> keyword for the property in the abstract object constructor or setter/getter methods. You can optionally use <a href="https://www.php.net/manual/en/language.oop5.final.php" rel="noreferrer"><code>final</code></a> to prevent the method from being overridden in extended classes.
Example: <a href="https://3v4l.org/WH5Xl" rel="noreferrer">https://3v4l.org/WH5Xl</a>
<pre class="lang-php prettyprint-override"><code>abstract class AbstractFoo
{
 public $bar;

 final public function __construct()
 {
 $this-&gt;bar = static::BAR;
 }
}

class Foo extends AbstractFoo
{
 //const BAR = 'foobar'; //uncomment to prevent exception
}
</code></pre>
<pre class="lang-php prettyprint-override"><code>$foo = new Foo(); 
//Fatal Error: Undefined class constant 'BAR'
</code></pre>
<hr />
However, the extended class overrides the parent class properties and methods if redefined. 
For example; if a property is declared as <code>protected</code> in the parent and redefined as <code>public</code> in the extended class, the resulting property is <code>public</code>. Otherwise, if the property is declared <code>private</code> in the parent it will remain <code>private</code> and not available to the extended class.
<a href="http://www.php.net//manual/en/language.oop5.static.php" rel="noreferrer">http://www.php.net//manual/en/language.oop5.static.php</a>

blocks|key|587044|text|今天我问了自己同样的问题，我想补充我的两点意见。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|587045|我们喜欢abstract属性的原因是确保子类定义它们并在子类不定义时抛出异常，在我的特定情况下，我需要一些可以与statically一起工作的东西。|offset|length|style|CODE|587046|理想情况下，我喜欢这样的东西：|587047|abstract+class+A+{
++++abstract+protected+static+$prop;
}

class+B+extends+A+{
++++protected+static+$prop+=+'B+prop';+//+$prop+defined,+B+loads+successfully
}

class+C+extends+A+{
++++//+throws+an+exception+when+loading+C+for+the+first+time+because+$prop
++++//+is+not+defined.
}|code-block|syntax|javascript|587048|我最终得到了这个实现。|587049|abstract+class+A
{
++++//+no+$prop+definition+in+A!

++++public+static+final+function+getProp()
++++{
++++++++return+static::$prop;
++++}
}

class+B+extends+A
{
++++protected+static+$prop+=+'B+prop';
}

class+C+extends+A
{
}|587050|正如您所看到的，在A中，我没有定义$prop，但我在static+getter中使用它。因此，下面的代码可以正常工作|587051|B::getProp();
//+=>+'B+prop'

$b+=+new+B();
$b->getProp();
//+=>+'B+prop'|587052|另一方面，在C中，我没有定义$prop，所以我得到了异常：|587053|C::getProp();
//+=>+Exception!

$c+=+new+C();
$c->getProp();
//+=>+Exception!|587054|我必须调用getProp()方法来获取异常，但我无法在类加载时获取它，但它非常接近所需的行为，至少在我的例子中是这样。|587055|我将getProp()定义为final是为了避免某些聪明人(6个月后我自己)想要做的事情|587056|class+D+extends+A+{
++++public+static+function+getProp()+{
++++++++//+really+smart
++++}
}

D::getProp();
//+=>+no+exception...|587057|entityMap^0|0|4|8|1K|6|0|0|0|0|0|9|1|H|5|Q|6|0|0|6|1|E|5|0|0|5|9|0|2|9|E|5|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1F|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1I|8|@$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]|$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1P|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1Q|8|@$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1V|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1W|8|@$D|1X|E|1Y|F|G]]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]]|9|@]|A|$]]|$1|14|3|15|5|L|7|24|8|@]|9|@]|A|$M|N]]|$1|16|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|17|$]]

I've asked myself the same question today, and I'd like to add my two cents.

The reason we would like <code>abstract</code> properties is to make sure that subclasses define them and throw exceptions when they don't. In my specific case, I needed something that could work with <code>static</code>ally.

Ideally I would like something like this:

<pre><code>abstract class A {
 abstract protected static $prop;
}

class B extends A {
 protected static $prop = 'B prop'; // $prop defined, B loads successfully
}

class C extends A {
 // throws an exception when loading C for the first time because $prop
 // is not defined.
}
</code></pre>

I ended up with this implementation

<pre><code>abstract class A
{
 // no $prop definition in A!

 public static final function getProp()
 {
 return static::$prop;
 }
}

class B extends A
{
 protected static $prop = 'B prop';
}

class C extends A
{
}
</code></pre>

As you can see, in <code>A</code> I don't define <code>$prop</code>, but I use it in a <code>static</code> getter. Therefore, the following code works

<pre><code>B::getProp();
// =&gt; 'B prop'

$b = new B();
$b-&gt;getProp();
// =&gt; 'B prop'
</code></pre>

In <code>C</code>, on the other hand, I don't define <code>$prop</code>, so I get exceptions:

<pre><code>C::getProp();
// =&gt; Exception!

$c = new C();
$c-&gt;getProp();
// =&gt; Exception!
</code></pre>

I must call the <code>getProp()</code> method to get the exception and I can't get it on class loading, but it is quite close to the desired behavior, at least in my case.

I define <code>getProp()</code> as <code>final</code> to avoid that some smart guy (aka myself in 6 months) is tempted to do

<pre><code>class D extends A {
 public static function getProp() {
 // really smart
 }
}

D::getProp();
// =&gt; no exception...
</code></pre>

blocks|key|4612426|text|如果tablename值在对象的生命周期内永远不会改变，下面是一个简单但安全的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4612427|abstract+class+Foo_Abstract+{
++++abstract+protected+function+getTablename();

++++public+function+showTableName()
++++{
++++++++echo+'my+table+name+is+'.$this->getTablename();
++++}
}

class+Foo+extends+Foo_Abstract+{
++++//Foo+must+'implement'+getTablename()
++++protected+function+getTablename()
++++{
++++++++return+'users';
++++}
}|code-block|syntax|javascript|4612428|这里的关键是字符串值'users‘是在子类实现的getTablename()中直接指定和返回的。该函数模拟"readonly“属性。|4612429|这与之前发布的使用额外变量的解决方案非常相似。我也喜欢Marco的解决方案，尽管它可能会更复杂一些。|4612430|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

if tablename value will never change during the object's lifetime, following will be a simple yet safe implementation.

<pre><code>abstract class Foo_Abstract {
 abstract protected function getTablename();

 public function showTableName()
 {
 echo 'my table name is '.$this-&gt;getTablename();
 }
}

class Foo extends Foo_Abstract {
 //Foo must 'implement' getTablename()
 protected function getTablename()
 {
 return 'users';
 }
}
</code></pre>

the key here is that the string value 'users' is specified and returned directly in getTablename() in child class implementation. The function mimics a "readonly" property.

This is fairly similar to a solution posted earlier on which uses an additional variable. I also like Marco's solution though it can be a bit more complicated.

blocks|key|589541|text|对抽象属性的需要可以表明设计问题。虽然许多answers实现了一种Template+method+pattern，并且工作正常，但它看起来总是有些奇怪。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|589542|让我们来看一下原始示例：|589543|abstract+class+Foo_Abstract+{
++++abstract+public+$tablename;
}

class+Foo+extends+Foo_Abstract+{
++++//Foo+must+'implement'+$property
++++public+$tablename+=+'users';+++
}|code-block|syntax|javascript|589544|将某事标记为abstract是指它是一件必须拥有的东西。嗯，一个必须具有的值(在本例中)是一个必需的依赖项，因此应该在实例化期间将其传递给构造函数|style|CODE|BOLD|589545|class+Table
{
++++private+$name;

++++public+function+__construct(string+$name)
++++{
++++++++$this->name+=+$name;
++++}

++++public+function+name():+string
++++{
++++++++return+$this->name;
++++}
}|589546|如果你真的想要一个更具体的命名类，你可以像这样继承：|589547|final+class+UsersTable+extends+Table
{
++++public+function+__construct()
++++{
++++++++parent::__construct('users');
++++}
}|589548|如果您使用DI容器，并且必须为不同的对象传递不同的表，那么这将非常有用。|589549|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Template_method_pattern^0|X|N|0|0|0|0|6|8|U|8|18|I|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1A|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1B|8|@$A|1C|B|1D|M|N]|$A|1E|B|1F|M|O]|$A|1G|B|1H|M|O]]|9|@]|C|$]]|$1|P|3|Q|5|H|7|1I|8|@]|9|@]|C|$I|J]]|$1|R|3|S|5|6|7|1J|8|@]|9|@]|C|$]]|$1|T|3|U|5|H|7|1K|8|@]|9|@]|C|$I|J]]|$1|V|3|W|5|6|7|1L|8|@]|9|@]|C|$]]|$1|X|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|Y|$Z|$5|10|11|12|C|$13|14]]]]

The need for abstract properties can indicate design problems. While many of answers implement kind of <a href="https://en.wikipedia.org/wiki/Template_method_pattern" rel="noreferrer">Template method pattern</a> and it works, it always looks kind of strange. 

Let's take a look at the original example:

<pre><code>abstract class Foo_Abstract {
 abstract public $tablename;
}

class Foo extends Foo_Abstract {
 //Foo must 'implement' $property
 public $tablename = 'users'; 
}
</code></pre>

To mark something <code>abstract</code> is to indicate it a must-have thing. Well, a must-have value (in this case) is a required dependency, so it should be passed to the constructor during instantiation:

<pre><code>class Table
{
 private $name;

 public function __construct(string $name)
 {
 $this-&gt;name = $name;
 }

 public function name(): string
 {
 return $this-&gt;name;
 }
}
</code></pre>

Then if you actually want a more concrete named class you can inherit like so:

<pre><code>final class UsersTable extends Table
{
 public function __construct()
 {
 parent::__construct('users');
 }
}
</code></pre>

This can be useful if you use DI container and have to pass different tables for different objects.

blocks|key|4612532|text|PHP7使得创建抽象的“属性”变得相当容易。如上所述，您可以通过创建抽象函数来创建它们，但是使用PHP+7可以定义该函数的返回类型，这使得在构建任何人都可以扩展的基类时变得容易得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4612533|<?php

abstract+class+FooBase+{

++abstract+public+function+FooProp():+string;
++abstract+public+function+BarProp():+BarClass;

++public+function+foo()+{
++++return+$this->FooProp();
++}

++public+function+bar()+{
++++return+$this->BarProp()->name();
++}

}

class+BarClass+{

++public+function+name()+{
++++return+'Bar!';
++}

}

class+FooClass+extends+FooBase+{

++public+function+FooProp():+string+{
++++return+'Foo!';
++}

++public+function+BarProp():+BarClass+{
++++//+This+would+not+work:
++++//+return+'not+working';
++++//+But+this+will!
++++return+new+BarClass();
++}

}

$test+=+new+FooClass();
echo+$test->foo()+.+PHP_EOL;
echo+$test->bar()+.+PHP_EOL;|code-block|syntax|javascript|4612534|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

PHP 7 makes it quite a bit easier for making abstract "properties". Just as above, you will make them by creating abstract functions, but with PHP 7 you can define the return type for that function, which makes things a lot easier when you're building a base class that anyone can extend.

<pre><code>&lt;?php

abstract class FooBase {

 abstract public function FooProp(): string;
 abstract public function BarProp(): BarClass;

 public function foo() {
 return $this-&gt;FooProp();
 }

 public function bar() {
 return $this-&gt;BarProp()-&gt;name();
 }

}

class BarClass {

 public function name() {
 return 'Bar!';
 }

}

class FooClass extends FooBase {

 public function FooProp(): string {
 return 'Foo!';
 }

 public function BarProp(): BarClass {
 // This would not work:
 // return 'not working';
 // But this will!
 return new BarClass();
 }

}

$test = new FooClass();
echo $test-&gt;foo() . PHP_EOL;
echo $test-&gt;bar() . PHP_EOL;
</code></pre>

Is there any way to define abstract class properties in PHP?

<pre><code>abstract class Foo_Abstract {
 abstract public $tablename;
}

class Foo extends Foo_Abstract {
 //Foo must 'implement' $property
 public $tablename = 'users'; 
}
</code></pre>

PHP abstract properties

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有办法在PHP中定义抽象类属性？abstract class Foo_Abstract {    abstract public $tablename;}class Foo extends Foo_Abstract {    //Foo must 'implement' $property    public $t...

问PHP抽象属性
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP抽象属性EN