Hallo!

Ich bin noch nicht wirklich fit in OOP, deshalb diese Frage. Ich habe eine Klasse A und eine Klasse B.

Die Klasse B erbt von der Klasse A.

Wie kann ich verhindern, dass die Klasse B den Konstruktor der Klasse A verwendet?
also

PHP-Code:

class A {
  public function __construct($param, $param2) {

  }
}

class B extends A{
  public function __construct() {
   // Ich will verhindern, dass dieser Aufruf funktioniert.
    parent::construct('afa','asfa');
  }
} 


final geht nicht, weil die Klasse B sonst überhaupt keinen Konstruktor habe dürfte.
private und protected gehen auch nicht, weil der Konstruktor der Klasse A sonst keine Parameter haben dürfte.

Wie kann ich das machen?

[Ben]

Zitat von Fat Tony

private und protected gehen auch nicht, weil der Konstruktor der Klasse A sonst keine Parameter haben dürfte.

Parameter darf er haben, er könnte nur nicht von außerhalb der Klasse aufgerufen werden.

Wo genau liegt denn der Sinn in dem, was du da machen willst?

Es heißt übrigens

PHP-Code:

parent::__construct(); 


Kleiner Umweg:

PHP-Code:

<?php

    class A {
      public function __construct($param, $param2) {
          echo __CLASS__;
      }
    }
    
    class B extends A{
      public function __construct() {
        if(false) {
            parent::__construct('afa','asfa');
        }
        else {
            echo __CLASS__;
        }
      }
    } 
    
    
    $obj = new B();
    
?>

Für mich erschließt sich wie gesagt der Grund nicht so wirklich.


EDIT:
Mein Beispiel ist totaler Quatsch. lol ... dann könntest du den Superkonstruktor auch gar nicht aufrufen .. ohweia .. erstmal richtig wach werden.

Im Konstruktor der ersten Klasse (zB A) werden bestimme Dinge erledigt, die nur einmal erledigt werden dürfen.

Wenn jetzt eine zweite Klasse den Konstruktor der ersten Klasse erneut aufruft wäre es möglich das gesamte System bezüglich Rechte zu hintergehen.

MfG Fat Tony

[Lars]

PHP-Code:

public function __construct()
{
    static $done;
    
    if ( $done )
    {
        return;
    }
    
    tuwas();
    
    $done = true;
} 


Genau das habe ich gesucht!

[Lars]

Mein Listing ist nicht ganz richtig. Eigentlich muss es so aussehen:

PHP-Code:

class Test
{
    private static $done;
    
    public function __construct()
    {
        if ( self::$done )
        {
            return;
        }
        
        tuwas();
        
        self::$done = true;
        
        return;
    }
} 


[Ben]

Ich wollte gerade sagen. Du solltest die statische Variable schon klassenweit verfügbar machen und somit dann natürlich auch in den erbenden Klassen.

Aber feine Lösung. *Thumbs Up*

[Lars]

Danke, Chef

[dejan_spasic]

Der Code oben ist etwas unstabiel, wie ich finde.

PHP-Code:

class Test
{
    private static $done = false;
    protected $object = null;
    
    public function __construct()
    {
        if ( self::$done )
        {
            return;
        }
        
        $this->object = new stdClass();
        
        self::$done = true;
        
        return;
    }
    
    public function getObject() {
        return $this->object;
    }
}

$foo = new Test();
$bar = new Test();

var_dump($foo->getObject());
var_dump($bar->getObject()); 


Wäre hier nicht ein Singelton Pattern angebrachter?

PHP-Code:

class Test
{
    private static $instance = null;
    protected $object = null;

    private function __construct()
    {        
        $this->object = new stdClass();
    }
    
    public function getObject() {
        return $this->object;
    }
    
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$foo = Test::getInstance();
$bar = Test::getInstance();

var_dump($foo->getObject());
var_dump($bar->getObject()); 


[Lars]

Sollte auch nur das Prinzip, das ich zu vermitteln versuchte, näherbringen