Dopiero zacząłem przygodę z obiektowym PHP. Uczyłem się z książki 'Zaawansowane tworzenie stron www PHP5 Szybki start'.

Udało mi się wykombinować taki kod:

http://www.wklej.com.pl/show.php?what=20080812201428

Ma to służyć jako miniCMS, to są klasy do zarządzania podstronami.

Chciałbym się zapytać czy to jest wogóle obiektowo, bo mi się wydaje że to są zwykłe funkcje pogrupowane w klasy. 

Nie wiem czy rozumiem ideę obiektowego programowania.

Niestety jest to tylko kod strukturalny zamknięty w klasach i funkcjach.

No trochę lipa. Utwórz np klasę podstrona i w niej metody, źle to IMO podzieliłeś. I stwórz klasę baza a nie polacz

Zmieniłem to w jedną klasę podstrony. 

Nie widzę innej możliwości rozwiązania tego. Według mnie jest wszystko dobrze. Jedna klasa pobiera dane, druga je wyświetla. O to chyba w tym chodzi, nie?

Tak jak ktoś wyżej napisał, myślisz funkcjonalnie. Obiekt to nie zbiór funkcji. Obiekt reprezentuje jakąś konkretną "rzecz".

Pozdrawiam!

Nie, niestety nie chodzi o to. Przynajmniej nie wprost. Obiekty są po to, aby reprezentowały jakieś rzeczy. W przypadku strony www, może to być obiekt Page (zawsze używaj nazw angielskich - to bardzo ważne), który posiada właściwości i operacje. Nie jest jednak reprezentacją dokumentu HTML, tylko danych, które ta stronę tworzą (wpisy w bazie danych lub w pliku tekstowym). Poczytaj więcej, w bardziej specjalistycznych książkach

Pozdrawiam.

W sumie nie wiem czy rozpoczęcie nauki programowania obiektowego od PHP to najlepsze rozwiązanie. Ja OOP nauczyłem się na C++ i Tobie też to polecam, chociaż na początku może być trudno, ale nie ma nic za darmo Poza tym C++ to kanon, który co prawda bywa czasem trochę upierdliwy, bo wszystko musi się zgadzać i jest mniej elastyczne niż nowsze języki, ale to uczy porządnego programowania.
Bazując na swoim przykładzie, polecam naukę podstaw C++, potem wskaźników i wtedy programowanie obiektowe w C++.

Jeszcze odnośnie Twojego kodu, to zrobiłeś zbiór funkcji, jak poprzednicy pisali; klasy charakteryzują się tym, że obiekty z nich utworzone posiadają 1) zmienne i 2) metody (funkcje) i jedno i drugie jest w równym stopniu ważne, więc tworzenie klas tylko ze zmiennymi albo tylko z funkcjami niewiele nam daje, dopiero połączenie obu pozwala wykorzystać masę funkcjonalności.

Tworzysz klasę i później możesz stworzyć wiele obiektów, które są niezależne od siebie, mają inne dane (zmienne), ale korzystają z tych samych metod.

Trywialny przykład:

[PHP] pobierz, plaintext 
<?php
class Prostokat
{
	var $szerokosc;
	var $wysokosc;
 
	public function pole()
	{
		return $this->szerokosc * $this->wysokosc;
	}
}
 
$p1 = new Prostokat;
$p1->szerokosc = 20;
$p1->wysokosc = 10;
echo $p1->pole(); //200
 
$p2 = new Prostokat;
$p2->szerokosc = 65;
$p2->wysokosc = 2;
echo $p2->pole(); // 130
?>
[PHP] pobierz, plaintext 

Coś bardziej zbliżonego do Twojego kodu - obiekt 'Tabela':

[PHP] pobierz, plaintext 
<?php
class Tabela
{
	var $dane;
 
	public function __construct()
	{
		$this->dane = array();
	}
	public function addRow($text)
	{
		$this->dane[] = $text;
	}
	public function display()
	{
		echo '<table>';
		foreach($this->dane as $row)
		{
			echo '<tr><td>'.$row.'</td></tr>';
		}
		echo '</table>';
	}
}
 
$produkty = new Tabela;
$produkty->addRow('margaryna');
$produkty->addRow('masło');
$produkty->addRow('chleb');
$produkty->display();
?>
[PHP] pobierz, plaintext 

Oczywiście to też przykład trywialny, jedynie obudowanie zwykłego arraya, ale niewiele zmieniając można już poprawić trochę jakość zwyczajnej tablicy, np. walidować dane wejściowe, czyli w funkcji addRow sprawdzać czy $text jest taki jak nam odpowiada, czy nie jest za długi etc. etc.

@qBK w PHP5 nie ma var, jest private, protected, public

Pomęczyłem się pół dnia i trochę już łapię. Zrobiłem to tak aby jak najwięcej kodu móc wykorzystać w przyszłości.

Klasa:

http://www.wklej.com.pl/show.php?what=20080813115015

Wykorzystanie klasy:

http://www.wklej.com.pl/show.php?what=20080813115116

Wg tego zrobie potem zarządzanie newsami, menu itd, wszystko tą samą klasą.

Chciałem jeszcze przenieść zapytanie do klasy jakoś, ale nie wiem zabardzo jak i czy warto.

Jak już się uczysz, to nabieraj od podstaw sensownych przyzwyczajeń - rozdzielaj kod php od html w tym przypadku, w bardziej ogólnym zainteresuj się wzorcem MVC.

Zarządzanie wszystkim tą samą klasą?
Co ma wspólnego menu z newsami? Na zdrowy "chłopski" rozum są to dwa różne obiekty, np do jednego są komentarze, do drugiego ni hu hu, jedno i drugie jest inne. Zapoznaj się z dziedziczeniem, interfejsami (możesz sobie zrobić ogólną klasę (lub interface), faktycznie, ale potem ją implementować, czy rozszerzać do swoich potrzeb nie zawierając w nich zupełnie niepotrzebnych metod czy własności).

Hah, coś mi od początku to var nie pasowało do PHP-a, ale wszystko działało więc się nie zorientowałem Przeglądałem pewnie jakiś stary kod i mi się zakorzeniło w głowie. A modyfikatorów nie używałem bo kod private var $x krzaczył mi się i nie wiedziałem o co chodzi Dzięki za zwrócenie uwagi.

edit
@marcinpruciak:
Jeśli zrobiłeś już klasę Baza, to dodaj na przykład w niej metodę 'query' albo 'execute'

[PHP] pobierz, plaintext 
<?php
class Baza
{
...
	  public function query($q)
	  {
		return mysqli_query($this->polacz, $q);
	  }
}
?>
[PHP] pobierz, plaintext 

i zamiast wywoływać
$r=mysqli_query($baza->polacz, $q);
możesz pisać
$r=$Baza->query($q)

Jest trochę krócej i później powiedzmy przechodząc z MySQL na PostgreSQL nie będziesz musiał każdego mysqli_query zamieniać na pg_query.

Nie private var $abc, a private $abc

Trochę pomyślałem, pokombinowałem i mam. Nie jest to MVC, bo gubię się przy oddzielnych trzech klasach, ale jest oddzielony widok od logiki.

[PHP] pobierz, plaintext 
<?php
class Publikuj
{
 public $pub;
 public $new_pub;
 public $id;
 
 public function pobierz_id_pub($id, $pub)
 {
     $this->id = $id;
     $this->pub = $pub;
 }
 
 public function pokaz_pub()
 {
     if($this->pub==Y) {
         echo 'id.'&pub=N&#092;">TAK';
     } else {
         echo 'id.'&pub=Y&#092;">NIE';
     }
 }
 
 public function oblicz()
 {
     if($_GET['pub']==N) {
         $this->new_pub='N';
     } else {
         $this->new_pub='Y';
     }
 }
 
 public function zastosuj()
 {
     $baza=new Baza;
     if($_GET['pub']) {
         $q=&#092;"UPDATE pages SET publikuj='$this->new_pub' WHERE id=\".$_GET['id'].\"\";
         $r=$baza->query($q);
     }
 } 
 
 public function przekierowanie()
 {
         header(&#092;"Locatio: ./pages.php\");
 }
}
?>
[PHP] pobierz, plaintext 

I użycie tej klasy w innej klasie: (muszę to jeszcze ulepszyć)

[PHP] pobierz, plaintext 
<?php
class Page
{
 public $tablica;
 public $r;
 
 public function query()
 {
     $baza= new Baza;
     $q=&#092;"SELECT * FROM `pages` ORDER BY `id`\";
     $this->r = $baza->query($q);
 }
 
 public function tworz_tabele()
 {     
     $pub= new Publikuj;
  
           while($this->tablica = mysqli_fetch_array($this->r)) {
             echo '
                     '.$this->tablica['id'].'
                     Zaznacz
                     '; $pub->pobierz_id_pub($this->tablica['id'], $this->tablica['publikuj']); $pub->pokaz_pub(); $pub->oblicz(); $pub->zastosuj(); 
                 echo '
                     '.$this->tablica['tytul'].'
                     Edytuj
                     Usun
                  ';
         }
         echo ''; 
         $pub->przekierowanie();
 }
}
?>
[PHP] pobierz, plaintext 

I co o tym myślicie? Nieźle jak na pierwszy kontakt z obiektowością?

Źle. Powinieneś mieć logikę wywołującą widok, a nie widok wywołujący logikę.

Czyli najpierw myślisz co trzeba zrobić (np. na podstawie informacji z $_GET)
Potem wykonujesz te swoje działania ($pub->oblicz(), $pub->zastosuj(), $pub->pobierz_id_pub(), a wyniki zapisuj sobie na boku w jakichś zmiennych)
Na końcu, gdy już jesteś pewien co(i czy w ogóle) chcesz wyświetlić, to wstawiasz sobie te zmienne do HTML'a

Abstrahując od twojego problemu, jeżeli chodzi o rozdzielenie logiki to poczytaj o MVC sam niedawno się z tym męczyłem i wydawało mi się to wręcz bez sensowne ale później po przemyśleniu i napisaniu pierwszego skryptu MVC zrozumiałem o co biega tak z biegu podam prosty przykład

[PHP] pobierz, plaintext 
<?php
class model
{
public function show_news($name)
{
// metoda modelu pobiera dane ze źródła danych i zwraca je do kontrolera
$news=file_get_contents("plik/".$name.".php");
return $news;
}
}
class view
{
public function show_news($news)
{
// metoda widoku formatuje dane pobrane z modelu i wyświetla w przeglądarce
echo "To jest widok newsa:<br/>zawiera html<br/>";
echo "<p>".$news."</p>"
}
}
class kontroler
{
public function __construct()
{
$model = new model;
$widok= new view;
}
public function doPage()
{
// szkielet kontrolera wywoluje odpowiedni widok z odpowiednimi danymi pobranymi z
 modelu, zarządza żądaniami użytkownika
if (isset($_GET['id']))
{
$widok->show_news($model->show_news($_GET['id']));
}
else
{
$widok->show_news($model->show_news(0));
}
}
$strona=new kontroler;
?>
<html>
<head>
......
</head>
<body>
<p>......tutaj stala czesc strony ona zawsze pozostanie taka sama </p>
<div class="tresc">
<?php
$strona->doPage();
?>
</div>
</body>
</html>
[PHP] pobierz, plaintext 

sens powyższego jest żaden, natomiast moim zdaniem dobrze obrazuje idee MVC. Zauważ że dzięki temu, jeżeli np. będziesz chciał dodać obsługę bazy mysql, to zostanie ci do zmiany tylko model, a jeżeli będziesz chciał dać możliwość obejrzenia newsa w pdf to wystarczy dopisać odpowiedni widok.

Tylko jak poradzić sobie z pętlą? Wszystkie przykłady co widziałem nie miały takiej pętli. To jedyny sposób jaki znam. 

Bo ważniejsze zmienne nie pobieram z geta tylko z tablicy. I te wszystkie funckje też muszą być w pętli. 

jeżeli masz jusz dane w tablicy to tą tablicę przekazujesz do widoku a w widoku wyciągasz wszystkie elementy tablicy i dekorujesz html później wyrzucasz do przeglądarki. Generalnie to jest tak w uproszczeniu

Kontroler - przyjmuje zapytanie i podejmuje decyzje co zrobić, jeżeli potrzebne są jakieś dane ze źródła danych (plik,baza,SOAP etc.) to prosi Model o przygotowanie takich danych.
Model - pobiera dane ze źródła danych i zwraca kontrolerowi (w postaći np. tablicy)
Kontroler dostaje dane i wywołuje odpowiedni widok
Widok - dostaje "surowe" dane i przygotowywuje je do prezentacji (np. dostał tablicę to robi na niek foreach i dla każdego wiersza dodaje tagi html) po czym wyrzuca do przeglądarki.
odnośnie twojego mini CMS (też taki pisze ) to nie potrzeba duzo roboty od frontu model ma np. 1 metode pokaz_strone($id) i wniej wczytujesz z bazy treść strony, widok też ma co najmniej jedną metodę pokaz($strona) dostaje treść strony od modelu i np. wyrzuca to pomiędzy tagami <p></p> a kontroler np. sprawdza czy w $_GET jest podane id jeżeli tak to wywołuje model z tym id a pozniej widok ze zwróconą przez model wartością, jeżeli id nie ma to wczytuje stronę domyślną.

Zedytowałem to tak:

[PHP] pobierz, plaintext 
<?php
class Page
{
 public $tablica;
 public $id;
 public $tytul;
 public $publikuj;
 public $show;
 public $r;
 
 public function query()
 {
 	$baza= new Baza;
 	$q="SELECT * FROM `pages` ORDER BY `id`";
 	$this->r = $baza->query($q);
 }
 
 public function tworz_tablice()
 {
 	$this->tablica = mysqli_fetch_assoc($this->r);
 	return $this->tablica;
 } 
 
 public function tworz_strone()
 {	 
 	$pub= new Publikuj;
 			$this->query();
 			$this->tworz_tablice();
 			$this->id = $this->tablica['id'];
 			$this->tytul = $this->tablica['tytul'];
 			$this->publikuj = $this->tablica['publikuj'];
 			$pub->pobierz_id_pub($this->id, $this->publikuj); 
 			$pub->oblicz(); 
 			$pub->zastosuj();
 			$pub->pokaz_pub();
 			$this->show = $pub->show;
 			$this->widok();
 			$pub->przekierowanie();
 }
 
 public function widok()
 { 
 	echo '<table border="1">
 			<tr>
 				<td width="5%">#</td>
 				<td width="5%">Zaznacz</td>
 				<td width="5%">Publikuj</td>
 				<td width="25%">Tytul</td>
 				<td width="15%">Edytuj</td>
 				<td width="15%">Usun</td>
 			</tr>'; 
 		 
 	while($this->tworz_tablice()) {
 		echo '<tr>
 				<td width="5%">'.$this->id.'</td>
 				<td width="5%">Zaznacz</td>
 				<td width="5%">'.$this->show.'</td>
 				<td width="25%">'.$this->tytul.'</td>
 				<td width="15%"><a href="?id='.$this->id.'">Edytuj</a></td>
 				<td width="15%">Usun</td>
 			</tr>'; 
 	}
 	echo '</table>';
 }
 }
?>
[PHP] pobierz, plaintext 

Chyba o to chodzi?

Mam tylko jeden problem. Metoda tworząca tablicę z wyników z bazy dodaje do tablicy tylko pierwszy wiersz z bazy? Nigdzie nie widzę błędu? Co jest nie tak?

Zobacz w manualu opis funkcji mysql_fetch_assoc(), zwróć uwagę na pętle while w przykładzie.

Pozdr

Udało się. Dzięki za sugestię.




Dalej ćwiczę obiektowość, stworzyłem teraz klasę dodawania i edycji stron:
http://wklej.com.pl/show.php?what=20080828234035

Jest to zgodne z obiektowością? Strona działa i ma się dobrze tutaj można zobaczyć jak:

http://195.205.202.32:6893/minicms/index.php?page=pages

Proszę o odpowiedź.

Dla każdej strony robisz osobny obiekt? Moim zdaniem bezsensu - zobacz lepiej jak wygląda kod jakiegoś fremeworka i praca z nim.
Nazwy klas po angielsku, a nazwy metod po polsku - komicznie to wygląda. Pisz TYLKO po angielsku i nie tłumacz się brakiem znajomości tego języka, bo to absolutna podstawa do nauki programowania.
Zapoznaj się z pojęciem enkapsulacji, bo $_GET wewnątrz klasy od razu włącza u każdego programisty alarm.

a co to za twór?

[PHP] pobierz, plaintext 
<?php
class EditPage extends AddPage{}
?>
[PHP] pobierz, plaintext 

Myślisz, że w programista systemu jakiegoś banku mógłby napisać:

[PHP] pobierz, plaintext 
<?php
class WyplacPieniadze extends WplacPieniadze{}
?>
[PHP] pobierz, plaintext 

?

To, co pokazujesz ma niewiele wspólnego z obiektowością - Ty jej po prostu nie rozumiesz. Kup książkę i poczytaj.
Pozdrawiam.

<P>Tylko że ja już mam książkę. "Zaawansowane tworzenie stron WWW PHP5". Jest tam ponad 100stron o obiektowości. Przeczytałem porobiłem przykłady i wydaje mi się że to co zrobiłem jest troche podobne do tego w ksiązce? </P><P>Mam kupić jeszcze jedną lepszą książkę? Jeśli tak to jaką? Najlepiej całą poświęconą obiektowiści bym chciał, ale nic nie mogłem znaleść innego niż ta co mam. </P><P>Poczytam sobie teraz o jakimś frameworku, jeśli tak radzisz.</P>

Musisz potraktować taką klasę jako obiekt a nie tylko zbiór funkcji.

jak klase można potraktować jako obiekt? Klasa i obiekt to nie to samo. Nie każdego psa traktujesz jak swojego konkretnego Reksia

Taka rada, nazwą klasy nie powinna być czasownikiem, tylko rzeczownikiem. Nazwami metod powinny być za to czasowniki. Tak więc w Twoim wypadku addPage i editPage powinny być metodami jakieś tam klasy PageManager. Więc odrazu takie klasy jak: "WyswietlPodstrony", "DodajPodstrone", "UsunPodstrone", "addPage", "editPage" są poprostu bez sensu. Kod strukturalny opakowany w klasy.

Przeglądnąłem przykłady z tej książki którą posiadasz i stwierdzam że tam nie ma kursu do nauki programowania zorientowanego na obiekty. Tam jest kurs składni oraz ogólnej wiedzy na temat obiektów. To że w tej książce nazwy klas, metod itp. są w języku polskim to wina tłumacza, nie powineneś naśladować tłumacza, który zapewne nie ma pojęcia co tłumaczy OOP nauczysz się z innych książek, np. PHP5. Zaawansowane programowanie (nie jest to doskonała książka, ale po przeczytaniu przynajmniej jej połowy powinieneś załapać o co biega)

Tak jest to łatwiej zrozumieć początkującym

A co powiecie na to? :

[PHP] pobierz, plaintext 
<?php
 
class Form
{
	public $element_text;
	public $element_textarea;
	public $element_submit;
	public $data;
 
	public function __construct()
	{
		echo '<form action="'.$_SERVER['PHP_SELF'].'" method="post">';
	}
 
	public function add_element_text($name, $size, $maxlength, $title, $value)
	{
		$this->element_text[] = array('name' =>$name, 'size' => $size, 'maxlength' => $maxlength, 'title' => $title, 'value' => $value);
	}
 
	public function add_element_textarea($name, $rows, $cols, $title, $value)
	{
		$this->element_textarea[] = array('name' =>$name, 'rows' =>$rows, 'cols' => $cols, 'title' => $title, 'value' => $value);
	}
 
	public function add_element_submit($value)
	{
		$this->element_submit[] = array('value' => $value);
	}
 
	public function show()
	{
		foreach ($this->element_text as $text)
		{
			echo $text['title'].'<input type="text" name="'.$text['name'].'" size="'.$text['size'].'" maxlength="'.$text['maxlength'].'"value="'.$text['value'].'"><br />';
		}
 
		foreach($this->element_textarea as $area)
		{
			echo $area['title'].'<textarea name="'.$area['name'].'" rows="'.$area['rows'].'" cols="'.$area['cols'].'">'.$area['value'].'</textarea><br />';
		}
 
		foreach($this->element_submit as $submit)
		{
			echo '<input type="submit" value="'.$submit['value'].'" name="submit" /></form>';
		}		
	}
 
	public function validate()
	{	 
	foreach ($this->element_submit as $submit) {
		if($_POST['submit']==$submit['value']) {
			foreach($this->element_text as $text) {
				if($_POST[$text['name']]) {
					$this->data[] = array($text['name'] => $_POST[$text['name']]);
				} else {
				echo 'Pole '.$text['title'].' zostało puste.<br />';
				}
			}
			foreach ($this->element_textarea as $area) {
				if($_POST[$area['name']]) {
					$this->data[] = array($area['name'] => $_POST[$area['name']]);
				} else {
				echo 'Pole '.$area['title'].' zostało puste.<br />';
				}
			}
		}
	}
	}
 
}
 
 
$form = new Form;
$form->add_element_text('title', '30', '50', 'Tytuł: ', '');
$form->add_element_text('subtitle', '30', '50', 'Podytuł: ', '');
$form->add_element_textarea('content', '30', '50', 'Treść: ', '');
$form->add_element_submit('Zapisz');
$form->show();
$form->validate();
echo $form->data[0]['title'];
echo $form->data[1]['subtitle'];
echo $form->data[2]['content'];
?>
[PHP] pobierz, plaintext 

Klasa tworząca formularz dodawania strony, będę ją mógł użyć potem do edycji strony, dodania newsa, edycji newsa, tak jak klasy QuickForm w Pear. Jeśli o to w tym chodzi znaczy że łapie to powoli. 

jesli chodzi o samo pojecie obiektowosci to juz lepiej. tutaj jaknajbardziej dobrze zrealizowales grupowanie w klase - kazdy obiekt reprezentuje formularz, czyli jakas rzecz i jego metody umozliwiaja ci jego kontrole.

problem jest tylko z realizacja. __construct() nie powinna wypisywac poczatku formularza. powinno sie to stac dopiero na poczatku metody show().

takze jak na poczatek to to wlasnie moze byc dobry zalazek .

Czemu sądzisz że to dopiero zalążek, myślałem że to już gotowa klasa. Ale cieszę się że załapałem o co chodzi, mam nadzieję że pójdzie teraz z górki.
Faktycznie masz rację z tym konstruktorem, nie wiem dlaczego tak go zrobiłem, już go poprawiam.

Tylko troche mi na końcu nie wyszło tak jak bym chciał, zrobiła się dwuwymiarowa tablica, ale chyba prościej się nie da z tego wyjść. 

Można jeszcze dorobić kilka metod, na przykład lepszą walidację, ale narazie nie jest mi to potrzebne. 

Każdy formularz na stronie może być obiektem, ale każde pole w nim również może być obiektem. Przecież operacje na elementach formularza nie ograniczają się do wyswietlenia <input type="xxx" name="xxx" value="xxx" />. Podobnie wyświetlanie - nie ma jednego schematu. Dlaczego najpierw mają być inputy, następnie textarea, a na końcu input submit? Semantyka generowanego XHTML też leży. Nie ma możliwości tworzenia labeli, fieldsetów itp.

No tak, wiem o tym, ale ja robiłem klasę przygotowaną do swoich potrzeb i na mojej stronie akurat będzie pasował taki schemat.

Teraz muszę zrobić coś żeby dodać to do bazy.

Kurcze właśnie zobaczyłęm na Helion.pl w zapowiedziach książkę 'PHP programowanie zorientowane obiektowo', nie piszą kiedy będzie, a taka by mi się teraz przydała. To ogólnie polecacie tą: 'PHP5 Zaawansowane programowanie'?

powiem tak - do PHP nie warto inwestowac w ksiazki za duzo, bo niestety czesto sie tutaj wszystko zmienia i ksiazka szybko sie dezaktualizuje. kup jedna tylko po to, zeby zalapac sam poczatek, rozkminic jak to ugryzc, ale mowisz, ze juz to masz za soba. teraz juz ksiazki nie beda ci raczej przydatne, bo ich autorzy czesto sa rozbierzni w zeznaniach - w PHP jest wyjatkowo wiele roznych drog. lepiej po prostu teraz zglebiaj wiedze z jakichs branzowych serwisow/czasopism/czegos co jest bardziej aktualne. ksiazki mozna czytac o C, Javie, ale PHP za szybko ewoluuje. bo jak teraz zaczniej sobie zasmiecac glowe kolejnymi wersjami "wizji obiektowego PHP" to zaraz znowu wejda przestrzenie nazw, zupelnie nowe konstrukcje, a ty utkwisz w tym, co sobie wymyslil jeden autor.

natomiast co do samej klasy - owszem, jesli robisz na wlasny uzytek tylko i wylacznie to nie ma po co dorabiac wodotryskow, jesli ma to tylko spowolnic i powiekszyc system, a ty z tego nigdy nie skorzystasz. ale tak jak zaznaczyl Crozin (i to, na co ja wskazalem poprzednio) - ta klasa sama w sobie i tak wymaga raczej dopracowania. obiekt formularza potraktuj jako kontener na inne obiekty - pola. dopiero pola maja wartosci. mozesz tutaj bardzo ladnie przecwiczyc rozne elementy programowania obiektowego w PHP - interfejsy, klasy abstrakcyjne... nie chce za duzo pisac, ani narzucac ci swojej wersji, ale ja realizuje takie mniej wiecej drzewo:

co do tytułu "PHP5: Zaawansowane programowanie" to ja mam pozytywne odczucia. Książka jest dobrze napisana, przykłady są przejrzyste. Jednak dla dobrego zrozumienia czasami trzeba przeczytać coś parę razy - w sumie jak ze wszystkim co do nauki.

Apropo twojego ostatniego przykładu z formularzem. To nie podoba mi się to stwierdzenie:


Skoro to jest miniCMS to może jeszcze go kiedyś wykorzystasz, może wtedy będzie ci potrzebny lable albo coś czego tu nie ma i będzie zonk. Lepiej by było - moim zdaniem - gdybyś zrobił klasę ogólną Form, która, np. tworzy nagłówek, zamyka formularz i klasy które dziedziczą. Tak jak koledzy powiedzieli, każdy input, każdy textarea może być obiektem. Każdy z tych elementów może mieć osobną klasę dla siebie dzięki której będziesz nimi sterował i każda z tych klas może dziedziczyć po klasie Form. To daje ci elastyczność i wygodę pracy teraz i w przyszłości.
Wspominam o tych modyfikacjach między innymi dlatego, że to zasadniczo część filozofii programowania obiektowego. Dzięki temu kod jest łątwy do zrozumienia, łatwy do obsługi i modyfikacji

Input dziedziczący po Form? Jakoś mi się to nie widzi. Ja pomiędzy Inputem, a Formem nie widzę żadnego związku - jedyne co je łączy to to, że Inputy znajdują się wewnątrz Form. Zarówno Input jak i Form mogą co najwyżej dziedziczyć po HTMLElement, ponieważ oba są elementami HTMLa. Tutaj może pomocne okazać się JS oraz DOM. Zobacz jak tam to jest rozwiązane. W JS możesz zrobić coś takiegoTeraz możemy to przełożyć na PHP:

[PHP] pobierz, plaintext 
<?php
 
$fieldset = new Fieldset;
$input = new Input;
 
$fieldset->appendChild($input);
 
//możesz też wykonać inne operacje na tych obiektach
$input->setType('file');
 
?>
[PHP] pobierz, plaintext 

Teraz, jak to będzie wyglądało od strony klasy (a nie obiektu):

[PHP] pobierz, plaintext 
<?php
 
class HTML_Elelement{
	protected
		$childNodes = array();
 
	public function appendChild(HTML_Element $element){
		$this->childNodes[] = $element;
	}
}
 
class Fieldset extends HTML_Element{	
	public function appendChild(HTML_Element $element){
		if($element->getTag == 'form'){ //przyklad rozbudowy metody
			throw new Exception('Element <form> nie moze zawierac w sobie innych formylarz');
		}
 
		parent::appendChild($element);
	}
}
 
class Input extends HTML_Element{
	public function appendChild(HTML_Element $element){
		throw new Exception('Element <input> nie moze zawierac w sobie innych elementów.');
		//oczywiscie element Input moglby dziedziczyc z HTML_Element_XXX (nie moge nazwy wymyslec )
		//ktory by odpowiadal za elementy typu <imput />, <img />, <hr /> (te, które nie mogą posiadać w sobie innych elementów)
	}
}
 
?>
[PHP] pobierz, plaintext 

Generalnie, jeżeli uczysz się OOP napisanie właśnie zestawu klas do obsługi drzewa DOM może okazać się bardzo dobrym pomysłem. Poznasz zasady dziedziczenia, hermetyzacji, dowiesz się co to są/kiedy używać interfejsów, klas/metod abstrakcyjnych i innych zagadnień związanych z OOP.

@Crozin - może faktycznie mnie poniosło z tym dziedziczeniem Ale chciałem głównie pokazać koledze to, że w prosty sposób można stworzyć ładny duży formularz, bez nadmiernego wysiłku. Chodziło mi o stworzenie wielu obiektów (form, input, lable, textarea) które ułatwią pracę w przyszłości, a napewno nie utrudnią pracy na chwilę obecną. Co jest zgodne z filozofią OOP

Kod po poprawkach, zrobiłem jedną klasę z danymi, inne po niej dziedziczą. Wszystko zrobiłem w static, nie wiem czy to dobrze

[PHP] pobierz, plaintext 
<?php
 
class HTML_Element
{
    protected static $element_input;
 protected static $element_textarea;
 protected static $element_submit='Zapisz';
         
 public function show_start()
 {
     echo '<form method="post" action="'.$_SERVER['PHP_SELF'].'">'; 
 }
 
 public function show_end()
 {
     echo '</form>';
 }
} 
 
class Input extends HTML_Element
{ 
 public function add_element_input($type, $name, $size, $maxlength, $title, $value='')
 {
      parent$element_input[]=array('type' => $type, 'name' =>$name, 'size' => $size, 'maxlength' => $maxlength, 'title' => $title, 'value' => $value);
 }
 
 public function show()
 { 
     foreach (parent$element_input as $text)
     { 
         echo $text['title'].'<input type="'.$text['type'].'" name="'.$text['name'].'" size="'.$text['size'].'" maxlength="'.$text['maxlength'].'"value="'.$text['value']; if($_POST['submit'] == parent$element_submit) { echo $_POST[$text['name']];} echo'"><br />'; 
     }
 }
}
 
class Textarea extends HTML_Element
{
 public function add_element_textarea($name, $rows, $cols, $title, $value='')
 {
     parent$element_textarea[] = array('name' =>$name, 'rows' => $rows, 'cols' => $cols, 'title' => $title, 'value' => $value);
 }
 
 public function show()
 { 
     foreach (self$element_textarea as $text)
     {     
         echo $text['title'].'<textarea name="'.$text['name'].'" rows="'.$text['rows'].'" cols="'.$text['cols'].'">'.$text['value'];  if($_POST['submit'] == parent$element_submit) { echo $_POST[$text['name']];} echo '</textarea><br />'; 
     }
 }
}
 
class Submit extends HTML_Element
{
 public function add_element_submit($value)
 {
     parent$element_submit = $value;
 }
 
 public function show()
 {
     echo '<input type="submit" value="'.parent$element_submit.'" name="submit" />'; 
 }
}
 
class Validate extends HTML_Element
{
 protected static $errors=array();
 protected static $data=array();
 
 public function validate()
 { 
     if($_POST['submit'] == parent$element_submit) {
         foreach (parent$element_input as $text) {
             if(empty($_POST[$text['name']])) {
                 self$errors[]=$text['title'];
             } else {
                 self$data[$text['name']] = $_POST[$text['name']];
             } 
         }     
 
         foreach (parent$element_textarea as $text) { 
             if(empty($_POST[$text['name']])) {
                 self$errors[]=$text['title'];
             } else {
                 self$data[$text['name']] = $_POST[$text['name']];
             }
         } 
     }
 }
  
 public function show_error()
 { 
     foreach(self$errors as $error) {
         echo 'Uzupełnij pol: '.$error.'.<br />';
         print_r($validate->data);   
     }
 }
 
 public function return_data()
 {
     return self$data;
 }
}
 
$html = new HTML_Element;
$html->show_start();
$input = new Input;
$input->add_element_input('text', 'title', '30', '50', 'Podtytu: ', '');
$input->add_element_input('text', 'subtitle', '30', '50', 'Podtytu: ', '');
$input->add_element_input('text', 'titje', '30', '50', 'tytu: ', '');
$input->add_element_input('text', 'subtjle', '30', '50', 'Podtytu: ', '');
$input->show();
$text = new Textarea;
$text->add_element_textarea('content', '10', '50', 'Treś: ', '');
$text->show();
$submit = new submit;
$submit->add_element_submit('Zapisz');
$submit->show();
$html->show_end();
$validate =new Validate;
$validate->validate();
$validate->show_error();
$data = $validate->return_data();
echo '<pre>'; print_r($data); echo '</pre>';
 
?>
[PHP] pobierz, plaintext 

1) HTML_Element powinno być klasą abstrakcyjną i już NAPEWNO nie powinno mieć nic wspólnego z formularzem. Jak zapewne zauważyłeś HTML_Element powinien być klasą rodzicem dla wszystkich innych elementów, np.: input, form, p, span, a, kbd - i całej masy innych
2) Żadna z powyższych klas nie powinna nic wyświetlać. Co najwyżej metoda show() mogłaby to robić.

[PHP] pobierz, plaintext 
<?
 
$form = new FormElement('myAction', 'myMethod');
$form->append(new TextInputElement('myName', 'myValue'));
$form->append(new TextareaElement('myName', 'myValue'));
$form->append(new SelectElement('myName', array(
  'option1' => 'value1',
  'option2' => 'value2',
  'option3' => 'value3',
  'option4' => 'value4'
), 2));
$htmlForm = $form->toString();
 
echo $htmlForm;
?>
[PHP] pobierz, plaintext 

Powyższe to tylko przykład.

1) Każdy element powinien dziediczyć po HTMLElement, która to dla każdego elementu udostępnia metody typu: setId(), setClass() itp. itd.
2) Elementy, które mogą zawierać w sobie inne elementy (np. <form> może zawierać inne elementy <input>) powinny mieć metodę append(), która wyglądała by mniej-więcej tak:

[PHP] pobierz, plaintext 
<?
 
class DivEelement{
  private $childNodes = array();
 
  public function append(HTMLElement $node){
    $this->childNodes[] = $node;
  }
}
?>
[PHP] pobierz, plaintext 

3) Każdy element powinien posiadać methodę toString() która działałaby na takiej zasadzie:

[PHP] pobierz, plaintext 
<?php
public function toString(){
  /*createAttributes() powinno robić coś takiego: masz sobie jakas tam tablice
id => mojeID
class => mojaKlasa
action => mojPlik
method => get
  a ona robi z tego: id="mojeID" class="mojaKlasa" action="mojPlik" method="get"*/
  $attributes = $this->createAttributes();
 
  $return = '<form' . $attributes . '>';
  foreach($this->childNodes as $node){
    $return .= $node->toString();
  }
  $return .= '</form>';
}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
abstract class HTML_Element
{
    
} 
class FormElement extends HTML_Element
{
 protected $method;
 protected $action;
 protected $class;
 protected $childNodes = array();
  
 public function __construct($method, $action, $class) 
 { 
     $this->method = $method;
     $this->action = $action;
     $this->class = $class; 
 }
 
 public function append(HTML_Element $node)
 {
     $this->childNodes[] = $node;
 }
 
 public function createAttributes()
 {
     return array('id' => $this->id, 'class' => $this->class, 'action' => $this->action, 'method' => $this->method);
 }
 
 public function toString()
 {
     $attributes = $this->createAttributes();
 
     $return = '<form' . $attributes . '>';
     foreach($this->childNodes as $node) {
         $return .= $node->toString();
     }
     $return .= '</form>';
     return $return;
 }
}
 
class TextInputElement extends HTML_Element
{ 
 public function __construct($type, $name, $size, $maxlength, $title, $value='', $class)
 {
      $this->type = $type; 
      $this->name = $name;
      $this->size = $size;
      $this->maxlength = $maxlength;
      $this->title = $title;
      $this->value = $value;
      $this->class = $class;
 }
 public function toString()
 {
     return $this->title.' <input type="'.$this->type.'" name="'.$this->name.'" size="'.$this->size.'" maxlendth="'.$this->maxlendth.'" title="'.$this->title.'" value="'.$this->value.'" class="'.$this->class.'">';
 }
}
 
class TextareaElement extends HTML_Element
{
 public function __construct($name, $rows, $cols, $title, $value='', $class)
 {
     $this->name = $name;
     $this->rows = $rows;
     $this->cols = $cols;
     $this->title = $title;
     $this->value = $value;
     $this->class = $class;
 }
 
 public function toString()
 {     
     return $this->title.'<textarea name="'.$this->name.'" rows="'.$this->rows.'" cols="'.$this->cols.'" class="'.$this->class.'">'.$this->value.'</textarea>'; 
 }
}
 
class SubmitElement extends HTML_Element
{
 public function __construct($value, $class)
 {
     $this->value = $value;
     $this->class = $class;
 }
 
 public function toString()
 {
     return '<input type="submit" value="'.$this->value.'" name="submit" class="'.$this->class.'" />'; 
 }
}
 
?>
[PHP] pobierz, plaintext 

Zrobiłem tym sposobem, co pokazałeś, ale mam problem, bo nie wiem jak dodać do tego klasę validate w sposób żeby był zgodny z tym co już mam. 

W jakim sensie sam sie ucze ale ja bym to dal do interfejsu bo kazda klasa moze implementowac funkcje validate() dla jej danych lub do klasy abtrs. HTML_Element ale nie chce powiedziec czegos glupiego moze zle sie zrozumialem

Ja mam parę uwag:

W konstruktorach masz stanowczo zbyt dużo.
Form obejdzie się i bez klasy i action - innymi słowy w konstruktorze powinno być tylko i wyłącznie method, bo bez tego obiekt jest bezużyteczny.
Z inputem podobnie. W konstruktorach masz moim zdaniem za dużo zbędnych danych, bez których obiekt poradzi sobie bez żadnego problemu. Konstruktor jest nie po to, żeby upychać wsjo jak leci.

Klasę abstrakcyjną w takiej formie można sobie spokojnie darować.
Aktualnie jest tak, że każdy element dziedziczy po niczym (się zrymowało, hehe). Nie wiem, mistrzem OOP nie jestem i raczej w najbliższej przyszłości nie będę, ale jakoś mi się to nie widzi.

W klasie abstrakcyjnej (tudzież w interfejsie - zależy od kilku rzeczy ) mógłbyś zadeklarować na przykład metodę abstrakcyjną toString() którą masz w każdym elemencie. Ale jest to metoda publiczna - innymi słowy jakoś bardziej widzę tutaj interfejs niż klasę abstrakcyjną na razie.
Interfejs dlatego, że w aktualnym stanie te klasy nie mają nic wspólnego - jedynie metodę toString, która dodatkowo w każdej jest inaczej interpretowana. A to już domena interfejsu - są sobie klasy, mają jakieś metody o takich samych nazwach, ale inaczej się je implementuje.

Dla przykładu:
Masz kota i sweter z szorstkiej włóczki. Kot drapie i sweter drapie, prócz tego nie mają cech wspólnych - możesz dla nich obu zrobić interface z metodą drapie() (nie po angielsku, bo podejrzewam, że drapanie przez szorstki sweter nie będzie tak samo jak drapanie przez kota, poza tym to tylko przykład), ale nie ma sensu robić klasy abstrakcyjnej, w której będzie jedynie niezaimplementowana metoda. Przynajmniej moim zdaniem.
No chyba, że ta wspólna metoda jest prywatna lub chroniona, ale to inna bajka