Witam. Wprawiam się dopiero w OOP. W ramach ćwiczeń postanowiłem stworzyć klasę do tworzenia formularzy. Po pewnym czasie zorientowałem się ze klasa jest na tyle uniwersalna, że można nia tworzyć całe dokumenty.
W założeniach ma działać analogicznie jak JS metody CreateElement() itp.

Podstawą jest klasa htmlElement - opisuje pojedynczy element drzewa będący na końcu gałęzi (liść) - to znaczy taki który nie posiada dzieci
Drugą klasą jest klasa node - opisuje ona węzeł drzewa, może posiadać dzieci którymi mogą być zarówno inne klasy node jak i htmlElement. node dziedziczy z htmlElement.
Klasom zaimplementowałem konstruktory oraz metody genHtml() służące generowaniu kodu.
Oprócz tego stworzyłem 3 dodatkowe klasy których jedynym zadaniem jest uproszcone generowanie instancji klas htmlElement i node są to:inputSubmit, textarea, inputText.

Moje pytania:
czy to jest właściwe podejście do OOP?
czy popełniłem jakieś błędy? jakie?

Konstruktory klas mają możliwość podania jednego lub dwóch argumentów. W tym celu do każdego konstruktora musiałem dodać:

[PHP] pobierz, plaintext 
<?php
if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
?>
[PHP] pobierz, plaintext 

Czy da się to uprościć?

Nie jestem pewien czy przypisywanie w konstruktorze $this->attribs=$arg_list[1]; (tabeli z argumentu funkcji do wnętrza klasy jest prawidłowe) Co prawda działa, ale....

Chcę zaznaczyć że są to moje pierwsze kroki w OOP i przedstawiam jedynie szkielet klasy którą mam zamiar rozbudować. Będę wdzięczny za wszelkie opinie.

Teraz kod:

[PHP] pobierz, plaintext 
<?php
class htmlElement {
	public $tag;
	public $innerHtml;
	public $attribs;
 
	function __construct($tag) {
		$this->tag=$tag;
		if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
	}
 
	function makeOpenTag() {
		$r='<'.$this->tag;
		if (count($this->attribs)) foreach ($this->attribs as $key=>$val) $r.=' '.$key.'="'.$val.'"';
		return $r.'>';
	}
 
	function makeCloseTag() {
		return '</'.$this->tag.'>';
	}
 
	function genHtml(){
		return $this->makeOpenTag().$this->innerHtml;
	}
}
 
class inputText extends htmlElement {
	function __construct($name) {
		if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
		$this->tag='input';
		$this->attribs['type']='text';
		$this->attribs['name']=$name;
	}
}
 
class inputSubmit extends htmlElement {
	function __construct($name) {
		if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
		$this->attribs['type']='submit';
		$this->attribs['name']=$name;
	}
}
 
class textarea extends node {
	function __construct($name) {
		if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
		$this->tag='input';
		$this->tag='textarea';
		$this->attribs['name']=$name;
	}
}
 
class node extends htmlElement {
	public $parent;
	public $childs;
 
	function __construct($tag){
		$this->tag=$tag;
 
		if (func_num_args()==2) {
			$arg_list = func_get_args();
			$this->attribs=$arg_list[1];
		}
	}
 
	function add($element){
		$this->childs[]=$element;
	}
 
	function genHtml(){
		$html=$this->makeOpenTag();
		if (count($this->childs)) foreach ($this->childs as $formEl) $html.=$formEl->genHtml();
		$html.=$this->makeCloseTag();
		return $html;
	}
}
 
$root=new node('div');
$root->add(new htmlElement('input', Array( 'type'=>'text', 'name'=>'t1')));
$root->add(new textarea('ta1'));
$root->add(new htmlElement('input', Array( 'type'=>'button', 'name'=>'t2')));
$root->add(new inputText('t3'));
 
$n_node=new node('div');
$n_node->add(new htmlElement('input',Array( 'type'=>'button', 'name'=>'end', 'value' =>'Zakończ')));
$root->add($n_node);
 
echo $root->genHtml();
?>
[PHP] pobierz, plaintext 

Hm... http://pl.php.net/manual/en/ref.dom.php

I znów wyważane otwartych drzwi i wynajdywanie koła na nowo.
A słyszałeś o XMLWriter lub czym innym co tworzy XMLe?

Co do formularzy, to raczej powinno się ułatwiać a nie utrudniać, no i rozdzielić kod html od PHP.
Więc jak masz element do formularza to każdy musi mieć jakąś nazwę, więc logiczne aby było "coś" między np. inputText a htmlElement, taki ogólny element który ma metodę steName($strName), powinna też być prosta możliwość dodawania jakiejś walidacji np. addValidator( Validator $validator ), aby móc używać jakiś standardowych elementów, a tworzenie było łatwiejsze.

Co do kodu, to na pewno powinieneś się zaprzyjaźnić z parent::__construct() i pochodnymi, jak i widocznością metod czyli np. protected function makeOpenTag().
No i możesz używać (a raczej powinieneś) public function __construct( $strTagType, $arrAttribute = array() )... widzę tu braki pewnych bardziej podstawowych rzeczy. (no i na boga używaj zawsze {} nie ważne że nie wymagane, bo potem czytać kod bez nich i bez wcięć to masakra).

Dobra to trochę ode mnie, bo nie analizuję tego głębiej.

@mike
Wolę operacje na węzłach niż, pisanie prawie jakby xml tylko trochę inaczej. (chyba za dużo zabawy drzewem html w JS )

Choć mi bardziej jednak chodziło o http://pl.php.net/manual/en/ref.domxml.php niż to poprzednie... (szczerze to nie używałem, wystarczało mi SimpleXML)

To zależy od tego czego potrzebujesz. Każda biblioteka ma "zady" i "walety"
Do dużych XMLi zastosowanie czegoś budowanego na węzłach to pomyłka.

@mike
Jak to mówią, nie zawsze robi się to co się lubi.
Bo to że takie coś jak odwzorowanie drzewa XML do czysto obiektowej postaci jest kosztowne, każdy chyba wie.