Klasa 1

[PHP] pobierz, plaintext 
class Database{
	private static $datasource='mysql:host=localhost;dbname=X';
		private static $username='X';
		private static $password='X';
		private static $db;
 
 
		private function __construct(){}
 
		public static function getDB(){
                      if(!isset(self::$db)){
                           try{
                         self::$db=new PDO(self::$datasource,self::$username,self::$password);
 
                            }
                            catch(PDOExceptin $e)
                            {
                               $error=$e->getMessage(); 
                               exit();
                            }
                      }
                        return self::$db; 
                     }
 
                    }
 
 
[PHP] pobierz, plaintext 

Klasa 2

[PHP] pobierz, plaintext 
class weryfikacja
{
 
	public function checkEmpty($var, $info)
	{
		if(strlen($var)==0)
			{
			echo $info;
			return false;
			}
		 else
			return true;
	}
}
[PHP] pobierz, plaintext 

Klasa 3

[PHP] pobierz, plaintext 
 
class Uzytkownik
	{
	public $login;
	public $haslo;
	public $haslo1;
	public $email;
 
	public function __construct()
	{
		$this->pdo = Database::getDB();
 
	}
 
	public function soilHaslo()
	{
		$this->haslo = md5($this->haslo);
		return $this->haslo;
	}
 
	public function zrobKod()
	{
		$kod = uniqid(rand());
		return $kod;
	}
	public function test()
	{
		$weryfikacja = new weryfikacja;
		$weryfikacja->checkEmpty('sdadasda','adsasdas');
	}
 
        public function addUser()
	{
 
                     // zapytanie do bazy sql 
         }
}
 
[PHP] pobierz, plaintext 

Klasa 1 jest odpowiedzialna za połączenie się z bazą danych
Klasa 2 w domyśle weryfikuje dane wprowadzone przez użytkownika,
Klasa 3 wprowadza operacje na danych, tworzy hasło, unikatowy kod do weryfikacji przez email, dodawanie użytkownika do bazy, edycje itp

Mam problem ze zrozumieniem zasięgu zmiennych, metod, obiektów itp. Wiem, co znaczy private, public, protected ale ciężko jest mi ogarnąć to w praktyce, pisze to w przedszkolu gdyż bardzo krótko programuję a jeszcze krócej w PHP, nie chce być tu karcony przez stwierdzenia typu zrób jakiś kurs albo poczytaj książkę, gdyż do takich rozwiązań już sięgałem, rozumiem iż metodą prób i błędów człowiek uczy się najwięcej ale czy ktoś mógłby mi wytłumaczyć jak działa się i jak powinno działać się....

Klasa 1 łączy z bazą, gdy w Klasie 3 chce coś dodać do bazy to w konstruktorze wywołuję połączenie $this->pdo = Database::getDB();
Podobnie chciałbym w metodzie test() użyć metody z Klasy 2, jak powinienem to zrobić ? Powyższy kod działa poprawnie, ale moje pytanie jest takie czy muszę za każdym razem w metodzie tworzyć nowy obiekt danej klasy jeżeli chcę metodę wykorzystać z innej klasy? Da się tworzyć jakoś obiekt w konstruktorze?

Zaznaczę, że połączenie z funkcją statyczną w klasie 1 w klasie 3 jest wykonane poprawnie, podczas gdy nie mam możliwości tworzenia obiektów klasy 2 w konstruktorze klasy 3

Metody statyczne właśnie po to są, by wywoływać je bez potrzeby tworzenia obiektów danej klasy.

[PHP] pobierz, plaintext 
class Weryfikacja
{
    public static function checkEmpty( $var, $info )
    {
       ...
    }
}
 
...
 
$v = "test";
if( Weryfikacja::checkEmpty( $v, "pusto tutaj" ) )
  echo "wcale nie jest pusto";
[PHP] pobierz, plaintext 

Ok przede wszystkim nie uczmy złych praktyk

Metody/własności statyczne są wygodne owszem ale przy większym projekcie i jego zarządzaniu okazują się zbyt mało "organizowalne" - zbyt prosto się do nich odwołać (są też mniej wydajne) przez co powstają złe nawyki.

Najpierw co do samego zasięgu.
- public - oznacza, że dana metoda/własność jest widoczna poza ciałem klasy - są to naogół metody i własności główne (te najważniejsze) danej klasy. Ich liczbę powinno się ograniczyć maksymalnie do liczby czynności jakie dana klasa ma realizować. W zasadzie poprzez HERMETYZACJE (zobacz sobie co to jest w OP) nie powinno się stosować publicznych własności klasy - powinny być do nich tzw. gettery i settery - po co to wszystko - poczytaj o tym - zrozumiesz ile to daje

- private - to metody i własności, które nie muszą być dostępne na zewnątrz jakiejś klasy. Są one używane wewnątrz. Nieraz tworząc jakąś klasę wykonującą dużo czynności zajmuje ona dużo kodu - aby nie umieszczać go w jednej metodzie można go funkcjonalnie rozdzielić na metody prywatne, wykorzystywane w głównych metodach publicznych klasy.

- protected - to to samo co private lecz pozwala na dziedziczenie. Możesz zrobić sobie klasę z zestawem metod chronionych (protected) i potem kolejną klasę dziedziczącą z tej właśnie. Dzięki temu możesz utworzyć kilka różnych klas dziedziczących po tej jednej, która ma metody wykrozystywane we wszystkich.

To wszystko co napisałem można zastąpić metodami i własnościami statycznymi - nawet wydaje się to łatwiejsze. Niestety tak się robić nie powinno - gubi się wówczas ładną, poukładaną i logiczną strukturę aplikacji - nie mówiąc o wydajności (odwołania statyczne są sporo wolniejsze od dynamicznych).

Masz 3 klasy.
1sza jest ok - połączenie z DB - tu nie mam zastrzeżeń.
2ga i 3cia wymaga zastanowienia. Czy jest to klasa, która będzie używana w wielu miejscach? Czy będzie miała więcej metod walidacyjnych?

Jeśli tak to zrób inaczej i nie twórz w klasie 3ciej instancji 2giej. Niech klasa 3cia dziedziczy po 2giej. Wówczas masz od razu gotową metodę, którą możesz wywołać lokalnie bez powoływania obiektu klasy drugiej.

Nie podpowiadam więcej - przemyśl to

Czytałem już wcześniej o __set i __get i na pewno będę chciał tak pisać, ale puki co jak sam widzisz mam takie "życiowe" problemy z oop że nie chcę dokładać do pieca. Wcześniej już robiłem aby klasa uzytkownik była dzieckiem weryfikacja ale nie wiem czemu nie działało mi, widocznie miałem jeszcze coś więcej pokićkane, w tym układzie jak jest teraz sprawdza się to i nie muszę tworzyć nowego obiektu klasy weryfikacja tylko odwołuje się od razu $this-> do danej metody.
Twoje pytanie odnośnie czy to coś więcej będzie robiło, to stwierdziłem że zrobię klasę weryfikacja bo przyda się przy rejestrowaniu, zmianie hasła, maila, może użyje przy dodawaniu czegoś przez użytkownika jakiś wpisów do sprawdzania, w tej klasie chciałem umieścić metody do sprawdzania danych wprowadzanych przez użytkownika. Co do klasy uzytkownik, to po prostu chciałem zrobić prostą rejestrację i tworząc klasę zacząłem zastanawiać się nad tym dlaczego nie mogę użyć danej metody (skoro jest public) i czy wszędzie muszę tworzyć obiekt.

Jeszcze jedno pytanie:
Jak powinno się pisać klasy do obsługi bazy danych, w sensie, jeżeli mam portal to są klasy odpowiedzialne za różne rzeczy, to tworzę JEDNĄ klasę która np dodaje do bazy i edytuje w niej wpisy itp?
Wiem, że można to robić na wiele sposobów ale chodzi mi o dobrą praktykę.

settery i gettery to nie magiczne metody __set i __get - tu trochę mylisz pojęcia. Chodzi o zapis typu:

[PHP] pobierz, plaintext 
class Klasa {
    private $zmienna = 0;
 
    public function getZmienna() {
        return $this->zmienna;
    }
 
    public function setZmienna($zmienna) {
        $this->zmienna = $zmienna;
    }
 
}
[PHP] pobierz, plaintext 

Te metody, które wymieniłeś służą do czegoś innego - do obsługi odwołań do nieistniejących własności obiektu. Przeczytaj coś o hermetyzacji - to Ci dokładnie wytłumaczy jak i po co to stosować.

Co do układu klas to jest ok - jeśli będziesz używał tej "weryfikacji" w wielu miejscach to dziedziczenie będzie chyba najlepszym pomysłem właśnie.

Co do pytania to odpowiedź jest prosta: MODELE

Ogolnie aplikacje (kod) można podzielić na 3 oddzielne części wg architektury zwanej MVC - na początek może nie zaglębiaj się w nią bo ciężko ją na początku zrozumieć. W skrócie chodzi o to by rozdzielić zarządzanie danymi od zarządzania żądaniami (przekazywanie parametrów pod podany adres, wybór odpowiedniej strony itp.) i od warstwy prezentacji. Dzieli się to na kontroler, model i widok (Model-View-Controller). Weź sobie z tego model.

Model to klasa dotycząca (najczęściej) jakieś tabeli w bazie danych. Przykładowo masz tabele z użytkownikami (powiedzmy users). Tworzysz więc klasę modelu "users" albo "usersModel". W tej klasie implementujesz metody, które robią coś z użytkownikami - dodają, zapisują po edycji, kasują, pobierają z DB. W innej klasie (modelu) możesz obsługiwać inne tabele. Cel tutaj jest taki aby tabela miała swój odpowiednik w kodzie w formie klasy.

Robiąc później klasę rejestracji nie implementujesz w niej zapytań SQL itp. a odwołujesz się do konkretnych metod konkretnych modeli. Możesz więc zrobić metodę rejestracja, w niej walidować dane a potem przekazać je do odpowiedniej metody (np.: "dodajUzytkownika(...)") modelu "users".

Sam dostęp do bazy TY oparłeś na PDO i wzbogaciłeś to o klasę, ktora jest globalnie dostępna (poprzez odwołanie statyczne aby nie tworzyć wielu połączeń) i to tak może zostać. Tą klasę używaj w modelach.

Z modelami wiąże się pewien problem - co zrobić a raczej, do którego modelu dodać metodę zwracającą jakieś łączne dane z wielu tabel bądź pracującej na wielu tabelach naraz. To jest kwestia indywidualna. Ogólnie są dwie ścieżki:

1. Metoda zostaje wrzucona do modelu po tym co zwraca. Oznacza to, że jeśli metoda pobiera na przykład produkty klienta to wrzucasz ją do modelu produktów bo ich listę będzie zwracać.

2. Metoda zostaje wrzucona do modelu po tym co przyjmuje. To z kolei oznacza, że metoda trafi do tego modelu, którego dotyczą dane (argumenty) wejściowe tej metody. Czyli jeśli pobieramy produkty klienta to podajemy w metodzie o jakiego klienta nam chodzi - więc metoda ta powinna trafić do modelu klientów.

Oba podejścia są dobre i najczęściej występują mieszanie. Staraj się jednak trzymać jednej - osobiście polecam 2gą - jest bardziej intuicyjna. Tak to wygląda w kodzie:

[PHP] pobierz, plaintext 
$produkty = $modelProduktow->pobierzProdukty($idKlienta); // 1
 
$produkty = $modelKlienta->pobierzProdukty($idKlienta); // 2
[PHP] pobierz, plaintext 

Wybór należy do Ciebie - co dla Ciebie jest bardziej intuicyjne to wybierz

Dobry człowieku, Ty to masz do mnie cierpliwość (nie to żebym się żalił)

Z tego co napisałeś zrozumiałem tyle:

[PHP] pobierz, plaintext 
 
 
class users extends weryfikacja
{
 
	private $login;
	private $haslo;
	private $email;
 
	public function __construct($varlogin, $varhaslo, $varemail)
	{
 
		$this->pdo = Database::getDB();
		$this->login = $varlogin;
		$this->haslo = $varhaslo;
		$this->email = $varemail;
	}
 
 
	public function addUser()
	{
 
		$data_rejestracji = time();
		if($this->checkMail($this->email,'') && $this->checkEmpty($this->login,'') && 
		$this->checkEmpty($this->haslo,'') && $this->checkLogin($this->login,''))
		{
		$stmt = $this->pdo -> prepare('INSERT INTO `users` (`login`,`haslo`,`mail`,`kod`,`data_rejestracji`)      VALUES(
                        :login,
						:haslo,
						:mail,
						:kod,
						:data_rejestracji)');
		$stmt -> bindValue(':login', $this->login, PDO::PARAM_STR);
		$stmt -> bindValue(':haslo', $this->haslo, PDO::PARAM_STR);
		$stmt -> bindValue(':mail', $this->email, PDO::PARAM_STR);
		$stmt -> bindValue(':kod', $this->zrobKod(), PDO::PARAM_STR);
		$stmt -> bindValue(':data_rejestracji', $data_rejestracji, PDO::PARAM_STR);
		$stmt -> execute();
 
 
		}
		else
			echo "Wprowadzone dane nie są poprawne";
	}
	public function changePass($new_pass)
       {
                  // i inne funkcje związane tylko z tabelą w bazie users
       }
 
 
}
 
[PHP] pobierz, plaintext 

Czy można robić to jako w konstruktorze? Wymusza to podawanie 3 wartości przy tworzeniu nowego obiektu. Czy lepiej napisać specjalną metodę na settowanie, która będzie wywoływana w addUser ?

Może być tak (prawie) - co prawda myślałem nad tym by model nie walidował danych ale może w sumie. Ja to ogólnie widzę bardziej tak:

[PHP] pobierz, plaintext 
class users extends weryfikacja
{
 	public function __construct()
	{
 		$this->pdo = Database::getDB(); // rozumiem że $this->pdo jest dziedziczone po "weryfikacja"
										// jeśli tak - to może od razu tam w konstuktorze dać $this->pdo = (...) 
										// wtedy tu konstruktor byłby niepotrzebny ;)
	} 
 
	public function addUser($login,$haslo,$email) // tutaj do konkretnej metody podawaj argumenty - bo konstruktor to kiepski pomysł :)
	{
 
		$data_rejestracji = time();
		if($this->checkMail($this->email,'') && $this->checkEmpty($this->login,'') && 
		$this->checkEmpty($this->haslo,'') && $this->checkLogin($this->login,''))
		{
		$stmt = $this->pdo -> prepare('INSERT INTO `users` (`login`,`haslo`,`mail`,`kod`,`data_rejestracji`)      VALUES(
                        :login,
						:haslo,
						:mail,
						:kod,
						:data_rejestracji)');
		$stmt -> bindValue(':login', $login, PDO::PARAM_STR);
		$stmt -> bindValue(':haslo', $haslo, PDO::PARAM_STR);
		$stmt -> bindValue(':mail', $email, PDO::PARAM_STR);
		$stmt -> bindValue(':kod', $this->zrobKod(), PDO::PARAM_STR); 
		$stmt -> bindValue(':data_rejestracji', $data_rejestracji, PDO::PARAM_STR);
		$stmt -> execute();
 
		}
		else
			echo "Wprowadzone dane nie są poprawne";
	}
	public function changePass($new_pass)
       {
                  // i inne funkcje związane tylko z tabelą w bazie users
       }
}
[PHP] pobierz, plaintext 

Tak jak Ci napisałem najlepiej nic nie kombinować i podać dane metodzie których potrzebuje

I już więcej nie męczę, dla upewnienia.

[PHP] pobierz, plaintext 
class Model 
{
	public function __construct()
	{
		$this->pdo = Database::getDB();
	}
}
 
 
 
class Users extends Model 
{
 
	public function addUser($login, $haslo, $email)
	{
		$weryfikacja = new Weryfikacja;
		$data_rejestracji = time();
		if
		($weryfikacja->checkMail($email,'') && $weryfikacja->checkEmpty($login,'') && 
		$weryfikacja->checkEmpty($haslo,'') && $weryfikacja->checkLogin($login,''))
		{
		$stmt = $this->pdo -> prepare('INSERT INTO `users` (`login`,`haslo`,`mail`,`kod`,`data_rejestracji`)      VALUES(
                        :login,
						:haslo,
						:mail,
						:kod,
						:data_rejestracji)');
		$stmt -> bindValue(':login', $login, PDO::PARAM_STR);
		$stmt -> bindValue(':haslo', $haslo, PDO::PARAM_STR);
		$stmt -> bindValue(':mail', $email, PDO::PARAM_STR);
		$stmt -> bindValue(':kod', $weryfikacja->zrobKod(), PDO::PARAM_STR);
		$stmt -> bindValue(':data_rejestracji', $data_rejestracji, PDO::PARAM_STR);
		$stmt -> execute();
 
 
		}
		else
			echo "Wprowadzone dane nie są poprawne";
	}
 
 
}
 
[PHP] pobierz, plaintext 

Wygląda ok, co prawda w PDO jeszcze inaczej można przekazywać wartości, ale nie o tym.

Staraj się nie mieszać angielskiego z polskim.

$weryfikacja = new Weryfikacja;
$data_rejestracji = time();

tu masz w pełni po polsku, a tutaj już:
$weryfikacja->checkMail(...)

pomieszane trochę, co nie wygląda na dobre.

A powiem Ci że w momencie w którym wklejałem to sam o tym pomyślałem, lepiej trzymać się jednej koncepcji, fakt!

Dla uproszczenia kod:

[PHP] pobierz, plaintext 
                $stmt -> bindValue(':login', $login, PDO::PARAM_STR);
		$stmt -> bindValue(':haslo', $haslo, PDO::PARAM_STR);
		$stmt -> bindValue(':mail', $email, PDO::PARAM_STR);
		$stmt -> bindValue(':kod', $weryfikacja->zrobKod(), PDO::PARAM_STR);
		$stmt -> bindValue(':data_rejestracji', $data_rejestracji, PDO::PARAM_STR);
		$stmt -> execute();
[PHP] pobierz, plaintext 

Można zamienić na:

[PHP] pobierz, plaintext 
$stmt->execute(array(
    'login' => $login,
    'haslo' => $haslo,
    // itd...
));
[PHP] pobierz, plaintext 

1. Dwukropek przy bindowaniu jest niepotrzebny
2. ::bindValue domyślnie ma 3 argument jako PDO::PARAM_STR
3. można użyć skróconej formy poprzez podanie tablicy parametrów do execute

Twoja metoda aczkolwiek jest o wiele dokładniejsza - więc może tak zostać jak najbardziej - wiedz jednak, że da się inaczej

Dobrze wiedzieć, warto ogólnie rozumieć co się wykorzystuje i co jest domyślnie aby unikać błędów i niepotrzebnego kodu, jednak zostanę przy tym jak mam, na pewno będzie to rozsądniejsze dla początkującego jak będę używał pełnych rozwiązań, wtedy widzę co gdzie i dlaczego mogę zmienić, aczkolwiek dziękuję po raz kolejny za pomoc

Ps. dziś rozmawiam z kolegą i mówię mu, że znalazł się pomocny użytkownik na forum i ruszyłem trochę, więc szykuje się flaszka kurierem