Question

想象一下，两个类共享几乎相同的方法和属性，都扩展了父类，但差异很小。

class fields { 
 public function __construct() {
  global $id;
  $this->id = $id++;
 }
}

class input extends fields {
 public function __construct() {
  parent::__construct();
 }
 public function draw() {
  echo '<input>';
 }
}

class textarea extends fields {
 public function __construct() {
  parent::__construct();
 }
 public function draw() {
  echo '<textarea>';
 }
}

我认为用这种伪代码方式重写textarea类会更有效：

class textarea extends fields {
 public function __construct() {
  $this = new input(); // <<------ 
 }
 public function draw() {
  echo '<textarea>';
 }
}

基本上，我不确定如何做到这一点，以便该类的行为类似于第一个例子中的类。

本质上，我想使用OOP执行以下操作，但是能够在上面的第一个示例中使用该对象（能够调用可能重载的方法，具有不同的属性等）：

function a() {echo '123';}
function b() {a();}

我刚刚复制了整个班级并修改了几行，但我觉得这很浪费。

最终答案 感谢这些人，以下是带有示例调用的综合答案：

abstract class fields { 
 private static $masterid = 0;
 public function __construct() {
  $this->id = self::$masterid++;
 }
}

class input extends fields {
 public $data;
 public function __construct($new = '') {
  parent::__construct();
  if ($new) $this->data = $new;
  else $this->data = 'Hello';
 }
 public function draw() {
  echo '<input>'.$this->export().'</input>';
 }
 public function export() {
  return 'ID '.$this->id.' = '.$this->data;
 }
}

class textarea extends input {
 public function __construct($new = '') {
  parent::__construct($new);
 }
 public function draw() {
  echo '<textarea>'.$this->export().'</textarea>';
 }
}

$a = new textarea();
$a->draw();
$a = new textarea('World');
$a->draw();
$a = new input('!');
$a->draw();

//Outputs:
// <textarea>ID 0 = Hello</textarea>
// <textarea>ID 1 = World</textarea>
// <input>ID 2 = !</input>

Answer 1

将fields类设为抽象类，就像Darren建议的那样，使'draw'方法成为fields类的函数。

现在有了诀窍，你希望输入类扩展字段，但是覆盖draw方法。这将允许您自定义该方法的功能，您仍然可以从其中调用父变体。

最后，由于textarea类与输入类有许多相似之处，因此make textarea会扩展输入。从而继承了字段和输入的属性和方法。

Answer 2

让“fields”类具有draw方法：

public function draw($msg) {
    echo $msg;
}

然后在textarea或输入类中放置：

parent::draw("<input>");

这减少了你拥有的方法的数量，并且可以为这两种类型的字段调用一种方法。

同样在“字段”类中，将ID代码更改为：

public $id
public function __construct($id) {
    $this->id = $id;
}

然后在子类中：

parent::__construct(1); //Or whatever ID you want

你拥有它的方式，ID每次设置时都是相同的值，这将导致每个子类的字段具有相同的id。这样每个子类都有一个单独的ID。

另外因为我很好，所有这些都放在一起：

public class field {
    $id;
    public __construct($id) {
        $this->id = $id;
    }

    public function draw($msg) {
        echo $msg;
    }
}

public class input extends field {
    public __construct() {
        parent::__construct(1);
        parent::draw("<input>");
    }
}

public class textarea extends field {
    public __construct() {
        parent::__construct(2);
        parent::draw("<textarea>");
    }
}

这就是我如何将你所说的放在一起。我可能错了你要求的东西。你能说出我主要是Java程序员吗？

Answer 3

目前还不清楚你想做什么。对于您给出的示例，我认为结构没问题，但您应该进行一些更改，尤其是构造函数。我认为构造函数应该是抽象的，使用抽象方法draw（）。

abstract class fields { 

   // Use a static member to keep track of id's instead of making it global
   private static $id = 0;

   // Use an instance variable to keep track of a particular instance's id
   private $myId;

   public function __construct() {
      // Increment the static ID & assign it to the instance id.
      $this->myId = self::$id++;
   }

   // Provide a public getter, so that the ID can't be changed
   // externally to this class
   public function getId() {
       return $this->myId;
   }

   public abstract draw(); // Make sure all sub classes implement a draw() method.

}

class input extends fields {
   // Don't need to call the parent constructor if you're not adding anything
   // else. It will be called automatically.

   public function draw() {
      echo '<input>';
   }
}

class textarea extends fields {
   public function draw() {
      echo '<textarea>';
   }
}

包装/重用/克隆PHP对象（代码优化）

3 个答案: