我正在构建一个具有重用和简单性的ORM库;一切都很顺利，除了我被一个愚蠢的继承限制所困扰。请考虑以下代码：
class BaseModel {
/*
* Return an instance of a Model from the database.
*/
static public function get (/* varargs */) {
// 1. Notice we want an instance of User
$class = get_class(parent); // value: bool(false)
$class = get_class(self); // value: bool(false)
$class = get_class(); // value: string(9) "BaseModel"
$class = __CLASS__; // value: string(9) "BaseModel"
// 2. Query the database with id
$row = get_row_from_db_as_array(func_get_args());
// 3. Return the filled instance
$obj = new $class();
$obj->data = $row;
return $obj;
}
}
class User extends BaseModel {
protected $table = 'users';
protected $fields = array('id', 'name');
protected $primary_keys = array('id');
}
class Section extends BaseModel {
// [...]
}
$my_user = User::get(3);
$my_user->name = 'Jean';
$other_user = User::get(24);
$other_user->name = 'Paul';
$my_user->save();
$other_user->save();
$my_section = Section::get('apropos');
$my_section->delete();
显然，这不是我期望的行为（虽然实际行为也有意义）。所以我的问题是，如果你们知道在父类中获得子类名称的意思。 / p>
答案 0 :(得分：167)
如果您能够想到在静态上下文之外执行此操作的方法，则无需等待PHP 5.3。在php 5.2.9中，在父类的非静态方法中，您可以执行以下操作：
get_class($this);
它将以字符串形式返回子类的名称。
即
class Parent() {
function __construct() {
echo 'Parent class: ' . get_class() . "\n" . 'Child class: ' . get_class($this);
}
}
class Child() {
function __construct() {
parent::construct();
}
}
$x = new Child();
这将输出：
Parent class: Parent
Child class: Child
答案 1 :(得分：85)
简而言之。这是不可能的。在php4中你可以实现一个可怕的黑客（检查debug_backtrace()），但该方法在PHP5中不起作用。引用：
编辑：PHP 5.3中的后期静态绑定示例（在评论中提到）。请注意，它目前的实施存在潜在问题（src）。
class Base {
public static function whoAmI() {
return get_called_class();
}
}
class User extends Base {}
print Base::whoAmI(); // prints "Base"
print User::whoAmI(); // prints "User"
答案 2 :(得分：12)
我知道这个问题真的很旧，但是对于那些寻找比在包含类名的每个类中定义属性更实用的解决方案的人来说：
您可以使用static关键字。
如this contributor note in the php documentation
中所述可以在超类中使用
static关键字来访问从中调用方法的子类。
示例：
class Base
{
public static function init() // Initializes a new instance of the static class
{
return new static();
}
public static function getClass() // Get static class
{
return static::class;
}
public function getStaticClass() // Non-static function to get static class
{
return static::class;
}
}
class Child extends Base
{
}
$child = Child::init(); // Initializes a new instance of the Child class
// Output:
var_dump($child); // object(Child)#1 (0) {}
echo $child->getStaticClass(); // Child
echo Child::getClass(); // Child
答案 3 :(得分：6)
我知道它的旧帖子，但想分享我找到的解决方案。
经过PHP 7+的测试
使用功能get_class() link
<?php
abstract class bar {
public function __construct()
{
var_dump(get_class($this));
var_dump(get_class());
}
}
class foo extends bar {
}
new foo;
?>
上面的示例将输出：
string(3) "foo"
string(3) "bar"
答案 4 :(得分：5)
如果你不想使用get_called_class（），你可以使用后期静态绑定的其他技巧（PHP 5.3+）。但在这种情况下，你需要在每个模型中都有getClass（）方法。这对IMO来说不是什么大不了的事。
<?php
class Base
{
public static function find($id)
{
$table = static::$_table;
$class = static::getClass();
// $data = find_row_data_somehow($table, $id);
$data = array('table' => $table, 'id' => $id);
return new $class($data);
}
public function __construct($data)
{
echo get_class($this) . ': ' . print_r($data, true) . PHP_EOL;
}
}
class User extends Base
{
protected static $_table = 'users';
public static function getClass()
{
return __CLASS__;
}
}
class Image extends Base
{
protected static $_table = 'images';
public static function getClass()
{
return __CLASS__;
}
}
$user = User::find(1); // User: Array ([table] => users [id] => 1)
$image = Image::find(5); // Image: Array ([table] => images [id] => 5)
答案 5 :(得分：2)
看起来您可能正在尝试将单例模式用作工厂模式。我建议您评估您的设计决策。如果单例确实合适，我还建议仅使用静态方法，其中继承不。
class BaseModel
{
public function get () {
echo get_class($this);
}
public static function instance () {
static $Instance;
if ($Instance === null) {
$Instance = new self;
}
return $Instance;
}
}
class User
extends BaseModel
{
public static function instance () {
static $Instance;
if ($Instance === null) {
$Instance = new self;
}
return $Instance;
}
}
class SpecialUser
extends User
{
public static function instance () {
static $Instance;
if ($Instance === null) {
$Instance = new self;
}
return $Instance;
}
}
BaseModel::instance()->get(); // value: BaseModel
User::instance()->get(); // value: User
SpecialUser::instance()->get(); // value: SpecialUser
答案 6 :(得分：2)
也许这实际上并没有回答这个问题，但你可以在get（）中添加一个参数来指定类型。然后你可以打电话
BaseModel::get('User', 1);
而不是调用User :: get（）。您可以在BaseModel :: get（）中添加逻辑，以检查子类中是否存在get方法，如果您想允许子类覆盖它，则调用它。
否则，我能想到的唯一方法就是向每个子类添加东西，这是愚蠢的：
class BaseModel {
public static function get() {
$args = func_get_args();
$className = array_shift($args);
//do stuff
echo $className;
print_r($args);
}
}
class User extends BaseModel {
public static function get() {
$params = func_get_args();
array_unshift($params, __CLASS__);
return call_user_func_array( array(get_parent_class(__CLASS__), 'get'), $params);
}
}
User::get(1);
如果您再将子类化为User，这可能会中断，但我认为在这种情况下您可以将get_parent_class(__CLASS__)替换为'BaseModel'
答案 7 :(得分：0)
问题不是语言限制，而是你的设计。别介意你上课;静态方法相信程序而不是面向对象的设计。您还以某种形式使用全局状态。 （get_row_from_db_as_array()如何知道在哪里找到数据库？）最后单元测试看起来很难。
尝试这些方法。
$db = new DatabaseConnection('dsn to database...');
$userTable = new UserTable($db);
$user = $userTable->get(24);
答案 8 :(得分：0)
普雷斯顿回答的两个变种：
1）
class Base
{
public static function find($id)
{
$table = static::$_table;
$class = static::$_class;
$data = array('table' => $table, 'id' => $id);
return new $class($data);
}
}
class User extends Base
{
public static $_class = 'User';
}
2）
class Base
{
public static function _find($class, $id)
{
$table = static::$_table;
$data = array('table' => $table, 'id' => $id);
return new $class($data);
}
}
class User extends Base
{
public static function find($id)
{
return self::_find(get_class($this), $id);
}
}
注意：用_开始一个属性名称是一个惯例，基本上意味着“我知道我公开了这个，但它确实应该受到保护，但我不能这样做并实现我的目标”