✔ Probleme mit aufrufen parent methode

[hmmNaGut]

class base
{
   function base_func()
   {
     // BLALBA
     $this->base_func_settings();

   }

   function start()
   {
        $this->base_func();
   }

   function base_func_settings()
   {
     /// BLBLB
   }
}

class frombase extends base{

   function base_func_settings()
   {
   }

   function start()
   {
       // In der parent klasse sollte base_func_settings() aufgerufen werden wird aber nicht.
   }
}

Hi, wieder mal ein Problem

Ich habe eine Klassen Hirachie mit einer Basisklasse darunter wieder eine Klasse
und dann die überschriebene Klasse.

Da gibt es eine Funktion die in Base definiert wurde.

Jedoch ruft er die nächste Funktion die von der Kind Klasse überschrieben wurde nicht auf.

Ich hoffe ich konnte das Problem richtig darstellen

LG patrick

 

[Radhad]

Hmm... OOP mit PHP5 wäre etwas klarer und besser für dein vorhaben

Ein Beispiel für den Aufruf der Klasse fehlt, daher nur ein kurzeer Hinweis:

Die Klasse "frombase" überschreibt Methoden der Klasse "base". Wenn du jetzt eine Methode aufrufst, die denselben Namen hat wie in der Elternklasse "base", wird immer dir "frombase"-Methode aufgerufen. Würdest du die Methode nicht ebenso in der "frombase" Klasse schreiben, würde die "base"-Methode aufgerufen werden. ALternativ kannst du in der "frombase"-Methode mittels parent::Methodenname() eine Methode der Elternklasse "base" aufrufen.

Ich hoffe ich habe das verständlich beschrieben

 

[hmmNaGut]

Sprich ich muss die Methode von der BASIS Klasse überschreiben und
kann dann eigentlich nur mittels
Klasse::Methode() die Basisklasse aufrufen


z.B.:

class base
{
   function base_func()
   {
     // BLALBA
     $this->base_func_settings();

   }

   function start()
   {
        $this->base_func();
   }

   function base_func_settings()
   {
     /// BLBLB
   }
}

class frombase extends base{

   function base_func_settings()
   {
   }

   function base_func()
   {
      base::base_func(); // Ruft jetzt settings auf oder
      // wen base_func_settings überschrieben wurde die von frombase
      // sollte keine vorhanden sein nimmt er dei BASIS oder
   }
 
   function start()
   {
       // In der parent klasse sollte base_func_settings() aufgerufen werden wird aber nicht.
   }
}

 

[hmmNaGut]

Edit: Sorry, unabsichtllich doppelt gepostet

 

[hmmNaGut]

Frage an die Profis.
Gibt es eine Möglichkeit eine Plattform, wo sich ein
paar erfahrene Entwickler die Sources ansehen und Verbesserungsvorschläge geben

Da es ein bisschen zu gross für einen Forum Post ist.

Klappt eh. ich zeig mal einen Teil des original source.

bitte noch keine Kritiken

Danke jedenfalls.

class CController{

   protected $m_func_array;   // Funktions array
   protected $m_cntrl_array;  // Controller array
   
   public $m_view;
   
	protected function __getViewHandler(){
		return $m_view;
	}   
   
   public  function CController(){
   }
   
   public function setView(&$m_view)
   {
   	$this->m_view=$m_view;
   }
   
	protected function insertController(&$functocall, $cntrl)
	{
		$this->m_func_array[]=$functocall;
		$this->m_cntrl_array[]=$cntrl;
	} 
	
	
	public function run()  // Overwriting in Page/Modul Controller
	{
	}	
	
}

include ('includes/controller.class.php');

class CPageController extends CController
{

	
	function createNewPage($func, $name)  // Erstellt eine Neue Seite, ruft im prinzip nur $this->insertController
	{
		$this->insertController($func, $name);
	}
	
	protected function noControllerSet()
	{
		$this->index();
	}
	
	function CPageController()
	{
		CController::CController();
		
	}

	public function index()
	{
		// Model einbinden und schauen was passiert

	}
	
	public function page404($page){
		print "page404" . $page;  // Fatal Error: Page not found
	}
	 
	
	public function run() // Wertet dei Parameter aus !!
	{var_dump($this->m_func_array);
		if (!isset($_GET['page']) &&  !isset($_POST['page']))
		{
			return $this->index();
		}
		
			$i=-1;	// -1 da erste interation vor abhandlung stattfindet;
			
			foreach($this->m_cntrl_array as $cntrl)
			{

				++$i;	// Hier iterieren wir für m_func_array	
			
				if ($_GET['page']==$cntrl || $_POST['page']==$cntrl)
				{
					if (isset($_GET))
					{
							if (count($_GET)==1)
							{
								unset($_GET);
							}					
					
							if (isset($_GET))
							{$func=$this->m_func_array[$i];
								return $this->$func($_GET);	// Wenn ein oder mehr Parameter angegeben wurde $_GET übergeben an Funk.
							}
							else
							{
							$func=$this->m_func_array[$i];  // Wenn kein $_GET übergeben wurde ohne irgendetwas aufrufen
							return $this->$func();
							}

					}
					elseif (isset($_POST))
					{
							if (count($_POST)==1)
							{
								unset($_POST);
							}					
					
							if (isset($_POST))
							{$func=$this->m_func_array[$i];
								return $this->$func($_POST);	// Wenn ein oder mehr Parameter angegeben wurde $_GET übergeben an Funk.
							}
							else
							{
								$func=$this->m_func_array[$i];  // Wenn kein $_GET übergeben wurde ohne irgendetwas aufrufen
								return $this->$func();
							}

					}
				}
			}
			
			return $this->page404(); // Nicht gefunden aufrufen 
	}	
}	


class mypagecontroller extends CPageController
{

	function mypagecontroller(){
		CPageController::CPageController();
		$this->createNewPage('news', 'news');  // Newspage
		$this->createNewPage('templatetest', 'templatetest');
		
		// Set View
		$this->m_view = new CView;
	}

	public function Artikel(){
		
		$cArt = new CArticleController;
		$cArt->setView($this->m_view);
		$cArt->run();
		
		$this->m_view->render();		
	}
	
	public function news(){
		print "Newsseite Controller einbinden!";
	}	
	public function run(){
		CPageController::run();
	}
	
	public function templatetest()
	{
	}
	
}

]

 

[hmmNaGut]

Die Mehtode run() ist zu langsam da ich zuviele Abfragen bezüglich $_GET und $_POST habe.

ich werde die foreach schleife mit $_REQUEST machen da ich ja eh schon
weiss das page per get und post übergeben wurde.

 

[Radhad]

Also als erstes würde ich dir raten, erstelle pro Klasse eine Datei, das wird dann schonmal auf anhieb übersichtlicher. Das zweite wäre, ausgeschriebene und aussagekräftige Methoden und Variablennamen zu verwenden. Und das 3. wäre, statt pro Seite eine Methode zu schreiben lieber eine Methode zu schreiben, die die Seiten / Controller entsprechend lädt, sonst hast du ein ziemlich starres Konstrukt.

Ansonsten kenne ich keine Plattform, wo komplette Projekte gegengeprüft werden.

 

[hmmNaGut]

Danke für deine Tipps

Im normalfall speichere ich ja auch die Klassen in extra Dateien
dient nur damit ich überprüfen kann, ob alles Funktioniert wie ich es mir vorstelle
um gleich eventuelle Änderungen im Code der Basis Klasse oder Child Klasse zu machen.

Den 2. Kritikpunkt hoffe ich meinst du wegen ausgeschrieben.
oder habe ich die Namen so schlecht gewählt

Zum 3. Punkt wegen den Starren Konstrukt

Wäre das so in etwa denkbar

Dies wäre für den Aufruf der Pages zuständig und übergibt die Parameter an Page page wiederum an die Controller der Artikel usw.

    class CSystem{
       public $objects_array;             // Array aus Objecte
       public $page_controller_array;  // Enthält die PageModule
       public $m_viewinstanz;           // Instanz der View Klasse

         public function getObjectbyName($obj_name); // Liefert Object Namen zurück
        public function registerObject($name, $obj);
        public function setPageController('Name', $pagecntrl);
        public function getCurrentPage();
        public function getPageCntrlbyName($name);

        protected function __getRequest();  // Wertet die HTTP angabe aus
  
       

        public function runApp() // Führt die Application aus. und bekommt von __getRequest die $_GET[], $_POST übergeben.
       // runApp ruft auch die CPageController auf


    }

 

[Radhad]

Ja, sieht schon besser aus. Um noch etwas flexibler zu bleiben würde ist eine Klasse für die Requests implementieren, so kannst du sie später noch einfach ausbauen falls du mehr Funktionen benötigst.

Zu 2.: das schreib ich immer so hin wenn Namen nicht ausgeschrieben werden Würde auch bei Klassen empfehlen, das "m_" als Prefix wegzulassen, da du diese ja immer mit $this bzw. self:: oder parent:: aufrufst und dadurch schon klar ist, zu welchem Kontext sie gehören. Viele nutzen bei private oder protected Variablen den "_" als Prefix, um das schneller erkennen zu können. Sähe beispielweise so aus:

class Foo
{
    private $_bar;

    protected $_foobar;

    public $foobarbar;

...
}

Auf jeden Fall ist es sehr wichtig, dass du eine Definition findest, wo du auch nach 6 Monaten noch genau erkennen kannst, was die Struktur bedeutet, in welchem Kontext welche Variable steht und wie die Abhängigkeiten von den diversen Klassen ist.

 

[hmmNaGut]

Danke dir schon mal sehr.
Werde mir deine Ratschläge zu Herzen nehmen.

Aber ich bleibe trotzdem COOL ;-)

Sollte ich das Projekt fertigstellen so werde ich es dir zum rewriten geben