Jeśli mam klasę o nazwie Polaczenie z prywatnym konstruktorem do połączenia z bazą danych, a chciałbym używać PDO (PDO umożliwia komunikację z wieloma bazami danych) to przez to, że mam prywatny konstruktor to nie mogę dziedziczyć po klasie PDO, bo inaczej dostaję błąd:
Access level to Polaczenie::__construct() must be public (as in class PDO)

A ja chcialbym moc wysylac zapytania do bazy danych przy uzyciu funkcji prepare() pochodzacej z klasy PDO w ten sposob:

[PHP] pobierz, plaintext 
$polaczenie = Polaczenie::getInstance();
$zapytanie = $polaczenie->prepare("INSERT INTO ksiazki(tytul, cena) VALUES(:tytul, :cena)");
$zapytanie->bindValue(':tytul', $_POST['tytul'], PDO::PARAM_STR);
$zapytanie->bindValue(':cena', $_POST['cena'], PDO::PARAM_STR);
$zapytanie->execute();	
[PHP] pobierz, plaintext 

Ale dostaje blad:
Call to undefined method Polaczenie::prepare()

Bo ta metoda jest w klasie PDO. Co mam zrobic ? Moglbym caly powyzszy kod wstawic do specjalnie utworzonej w tym celu metody w klasie Polaczenie i wtedy byloby ok, ale co ja mam tworzyc dla kazdego inserta oddzielna metode w klasie Polaczenie ? To jak mialbym inserty wykonywane na tabelach np. ksiazki, autorzy itd. ladowac je wszystkie do klasy Polaczenie ? Bez sensu. Co powinienem zrobic ?

Czyli, że nie ma tej funkcji

Ustaw ten konstruktor na publiczny i już.

Nie moge ustawic na publiczny w tym problem, bo chce miec singletona A obecnie mam cos takiego:

[PHP] pobierz, plaintext 
final class Polaczenie {
 
    private static $oInstance = false;
    private $pdo;
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
    private function __construct() {
        try {
            $this->pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
        }
        catch(PDOException $e) {
            echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
        }
    }
 
    public function __destruct() {
 
    }
 
 
    public static function getInstance() {
        if (self::$oInstance == false) {
            self::$oInstance = new klasaPolaczenie();
        }
        return self::$oInstance;
    }
 
}
[PHP] pobierz, plaintext 

Czy jest wiec jakies wyjscie ?

1. rejestr z połączeniem
2. instancjowanie z podaniem klasy połączenia jako argumentu konstruktora

Chociaż jeśli chodzi o połączenia do DB singleton jest dla mnie trochę mało wygodnym wyjściem, gdyż jeśli zechcesz korzystać z kilku baz naraz (może abstrakcyjne, w praktyce - przydaje się), to już masz trochę twardszy orzech do zgryzienia.

Możesz też dodać do swojej klasy potomnej metody, które wykorzystujesz w PDO o odpowiednich nazwach (np. query, prepare) i wywoływać za pomocą parent:: metody główne w klasie PDO. Np.

[PHP] pobierz, plaintext 
class Polaczenie extends PDO
{
	//...
 
	public function prepare($query)
	{
		return parent::prepare($query);
	}
}
[PHP] pobierz, plaintext 

Rozwiązanie o tyle dobre, że można dodać np. zliczanie lub cache'owanie zapytań.

Erix a mógłbyś rozwinąć myśl, bo nie bardzo rozumiem. "rejestr z połączeniem" - to w ogóle pierwszo słyszę, nie jestem w tym zaawansowany.

Void nie rozumiem - bo przecież nie mogę dziedziczyć po PDO - czy też może to rozwinięcie mysli Erixa, Erix zaproponował jakiś sposób, że będę mógł dziedziczyć po PDO (a którego ja nie zrozumiałem), a Ty kontynuujesz Jego mysl ?

Wzorzec registry.

Nie, ja przedstawiłem inną myśl Tylko masz rację, zapomniałem o tym prywatnym konstruktorze Co nie zmienia faktu, że możesz wykorzystać to, co napisałem, tylko zamiast dziedziczyć po PDO musisz wykorzystać kompozycję (czyli umieszczenie instancji klasy PDO w polu twojej klasy - to co zrobiłeś w swoim drugim poście). Wtedy byłoby tak:

[PHP] pobierz, plaintext 
class Polaczenie
{
	// Instancja klasy pdo
	private $_pdo;
	//...
 
	public function prepare($query)
	{
		return $this->_pdo->prepare($query);
	}
 
	public function query($query
	{
		return $this->_pdo->query($query);
	}
 
	// itd.
}
[PHP] pobierz, plaintext 

Albo wywal tego singletona, wtedy można zastosować dziedziczenie Poza tym, tak jak pisał erix, czasem może się przydać obsługa kilku różnych baz danych.

Serdecznie dziękuję za pomoc. Więc zgodnie z tym co napisał Erix i na podstawie klasy SingletonRegistry ze strony: http://www.phpfreaks.com/tutorial/design-p...gleton-registry zrobiłem tak:

[PHP] pobierz, plaintext 
final class Polaczenie {
 
    private static $oInstance = false;
    private $pdo;
    private $_map; //dla wzorca registry
 
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
 
    private function __construct() {
        try {
            $this->pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
            $this->set('pdo', $this->pdo);
        }
        catch(PDOException $e) {
            echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
        }
    }
 
    public function __destruct() {
 
    }
 
 
    public static function getInstance() {
        if (self::$oInstance == false) {
            self::$oInstance = new klasaPolaczenie();
        }
        return self::$oInstance;
    }
 
 
    public function get($key)
    {
       return $this->_map[$key];
    }
 
 
    public function set($key, $object)
    {
       $this->_map[$key] = $object;
    }
 
}
[PHP] pobierz, plaintext 

Czyli dodałem:

[PHP] pobierz, plaintext 
private $_map;
 
public function get($key)
{
       return $this->_map[$key];
}
 
 
public function set($key, $object)
{
       $this->_map[$key] = $object;
}
 
//+ dla konstruktora: $this->set('pdo', $this->pdo);
[PHP] pobierz, plaintext 

A nastepnie:

[PHP] pobierz, plaintext 
$zapytanie = $polaczenie->get('pdo')->prepare("INSERT INTO ksiazki(tytul, cena) VALUES(:tytul, :cena)");
$zapytanie->bindValue(':tytul', $_POST['tytul'], PDO::PARAM_STR);
$zapytanie->bindValue(':cena', $_POST['cena'], PDO::PARAM_STR);
$zapytanie->execute();
[PHP] pobierz, plaintext 

I jest ok.

Ale jako ze teraz przeczytalem sposob Voida to skorzystam chyba z Jego sposobu Chyba, bo wszedzie pisza (w tym Wy piszecie) zeby nie korzystac z singletona to chcialbym sie zapytac co zamiast singletona gdy na jednej stronie uzywam np. 5. obiektow klas, w ktorych potrzebuje polaczenia z baza danych wiec tworze w ich konstruktorach obiekty klasy Polaczenie przez wywolanie statycznej metody getInstance():

[PHP] pobierz, plaintext 
$this->polaczenie = Polaczenie::getInstance(); 
[PHP] pobierz, plaintext 

Czy jesli usune Singletona to czy nie bede miec 5. polaczen do bazy danych zamiast 1. ?

Nie będziesz miał pięciu... Przecież skoro pobierasz uchwyt przez singleton, to zwracasz REFERENCJĘ, a nie klonujesz obiekt.

A tak w ogóle, to w Twoim przypadku może (nie próbowałem, na razie tylko klepane z palucha) byłoby najlepiej zrobić podobnie, jak singleton (ale nie tak samo ):

[PHP] pobierz, plaintext 
abstract class modelClass{
    static protected $connection = null;
 
    function __construct(){
        if(modelClass::$connection===null){
            modelClass::$connection = new PDO(...);
        }
    }
}
 
class zabawkaModel extends modelClass{
 
    function getBy($var){
        $q = parent::$connection->query('asdasd');
        // ...
    }
 
}
 
$model = new zabawkaModel();
$model->getBy('asdasdsad');
[PHP] pobierz, plaintext 

I wciąż mamy jedno połączenie, modeli tworzysz ile chcesz. :]

Erix wielkie dzieki za propozycje, niestety po zastosowaniu Twego sposobu do swojej klasy (i oczywiscie zmodyfikowaniu Twego kodu pod swoje potrzeby) dostaje blad ( ):
Call to a member function pobieranieDanych() on a non-object
u Ciebie to bylaby ta linia:

[PHP] pobierz, plaintext 
$q = parent::$connection->query('asdasd');
[PHP] pobierz, plaintext 

Jesli chodzi o singleton to wiem, ze zawsze jest jedno polaczenie, chodzilo mi o sytuacje gdybym nie zastosowal wzorca Singleton do klasy Polaczenie,
a inne klasy dziedziczylyby po klasie Polaczenie - przyklad:

[PHP] pobierz, plaintext 
class Polaczenie extends PDO{
 
    private $pdo;
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
    public function __construct() {
        try {
            $this->pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);            
        }
        catch(PDOException $e) {
            echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
        }
    }
 
    public function __destruct() {    	
    }
 
 
    public function zapytanie($z) {
    	try{
    		$wynik = $this->pdo->query($z);   		
    		$wynik_tablica = $wynik->fetchAll();
			$wynik -> closeCursor();	
			return $wynik_tablica;
    	}
		catch(PDOException $e) {
            echo '<p>blad w metodzie pobieranieDanych(): '.$e->getMessage().'</p>';
        }        
    }	
 
}
 
------------------------------
class Ksiazki extends Polaczenie
{
	private $polaczenie;
 
	public function __construct()
	{
		$this->polaczenie = new Polaczenie();
	}	
 
	public function __destruct()
	{		
	}	
 
	public function pobierzKsiazki()
	{
		return $this->polaczenie->zapytanie("SELECT * FROM ksiazki");
	}
}
 
--------------------------------------------------------------
 
class Autorzy extends Polaczenie
{
	private $polaczenie;
 
	public function __construct()
	{
		$this->polaczenie = new Polaczenie();
	}	
 
	public function __destruct()
	{		
	}	
 
	public function pobierzAutorow()
	{
		return $this->polaczenie->zapytanie("SELECT * FROM autorzy");
	}
}
 
-------------------------
 
$ksiazki = new Ksiazki();
$rezultat1 = $ksiazki->pobierzKsiazki();
 
 
$autorzy = new Autorzy();
$rezultat2 = $autorzy->pobierzAutorow();
 
[PHP] pobierz, plaintext 

To wtedy utworzenie dwoch obiektow oznaczaloby pewnie dwa polaczenia do bazy danych zamiast jednego jak w przypadku zastosowania wzorca singleton do klasy Polaczenie.





Najlepszym wyjsciem jest chyba tworzenie obiektu klasy Polaczenie i przekazywanie go do konstruktorow pozostalych klas:

[PHP] pobierz, plaintext 
class Polaczenie extends PDO{
 
    private $pdo;
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
    public function __construct() {
        try {
            $this->pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);            
        }
        catch(PDOException $e) {
            echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
        }
    }
 
    public function __destruct() {    	
    }
 
 
    public function pobieranieDanych($z) {
    	try{
    		$wynik = $this->pdo->query($z);   		
    		$wynik_tablica = $wynik->fetchAll();
			$wynik -> closeCursor();	
			return $wynik_tablica;
    	}
		catch(PDOException $e) {
            echo '<p>blad w metodzie pobieranieDanych(): '.$e->getMessage().'</p>';
        }        
    }	
 
}
 
----------------------------------------------
 
class Ksiazki
{
	private $polaczenie;
 
	public function __construct($db)
	{
		$this->polaczenie = $db;
	}	
 
	public function __destruct()
	{		
	}	
 
	public function pobierzKsiazki()
	{
		return $this->polaczenie->pobieranieDanych("SELECT * FROM ksiazki");
	}
}
 
-----------------------------------------------------------------
 
$polaczenie = new klasaPolaczenie();
 
$ksiazki = new klasaKsiazki($polaczenie);
$rezultat_1 = $ksiazki->pobierzKsiazki();
 
$ksiazki2 = new klasaKsiazki($polaczenie);
$rezultat_2 = $ksiazki->pobierzKsiazki();
[PHP] pobierz, plaintext 

Pokaż, jak dokładnie wywoływałeś mój schemat; kod, daj var_dump na zmiennej połączenia i upewnij się, że wywołujesz konstruktor rodzica, bo mam obawy, że jednak tego nie robisz.

No fakt - miałeś rację - zapomniałem, że w php konstruktor klasy nadrzednej trzeba samemu wywolac. Ale to i tak niewiele daje, bo musze pisac w klasie Ksiazki w kazdej metodzie zawierajacej zapytanie caly kod wlacznie z fetchowaniem i zamykaniem kursora oraz blokiem try/catch:

[PHP] pobierz, plaintext 
abstract class Polaczenie extends PDO{
 
    static protected $pdo = null;
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
    public function __construct() {
		if(self::$pdo===null){		
			try {
				self::$pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
				self::$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);            
			}
			catch(PDOException $e) {
				echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
			}
		}
    }
 
 
    public function __destruct() {    	
    }
 
 
    public function pobieranieDanych($z) {
    	try{
    		$wynik = self::$pdo->query($z);  		
    		$wynik_tablica = $wynik->fetchAll();
			$wynik -> closeCursor();			
			return $wynik_tablica;
    	}
		catch(PDOException $e) {
            echo '<p>blad w metodzie pobieranieDanych(): '.$e->getMessage().'</p>';
        }        
    }
 
}
 
-------------------------------------------------
 
class Ksiazki extends Polaczenie
{
 
 
	public function __construct()
	{
		parent::__construct();
	}	
 
	public function __destruct()
	{		
	}	
 
	public function pobierzKsiazki()
	{
		try
		{		
			$wynik = parent::$pdo->query("SELECT * FROM ksiazki");
			$wynik_tablica = $wynik->fetchAll();
			$wynik -> closeCursor();			
			return $wynik_tablica;
		}
		catch(PDOException $e) 
		{
            echo '<p>blad w zapytaniu: '.$e->getMessage().'</p>';
        }  
	}
}
--------------------------------------------------------
$ksiazki = new Ksiazki();
$rezultat = $ksiazki->pobierzKsiazki();	
[PHP] pobierz, plaintext 

Moze wiec wrocic do tego sposobu z przekazywaniem do konstruktora klasy Ksiazki obiektu klasy Polaczenie - jak nizej ?

[PHP] pobierz, plaintext 
class Polaczenie extends PDO{
 
    private $pdo;
 
    private $dsn = 'mysql:host=localhost;dbname=koszyk';
    private $uzytkownik = 'root';
    private $haslo = '';
 
 
    public function __construct() {
        try {
            $this->pdo = new PDO($this->dsn, $this->uzytkownik, $this->haslo, array(PDO::MYSQL_ATTR_INIT_COMMAND=>"SET NAMES utf8"));
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);            
        }
        catch(PDOException $e) {
            echo '<p>Polaczenie nie moglo zostac utworzone: '.$e->getMessage().'</p>';
        }
    }
 
    public function __destruct() {    	
    }
 
 
    public function pobieranieDanych($z) {
    	try{
    		$wynik = $this->pdo->query($z);   		
    		$wynik_tablica = $wynik->fetchAll();
			$wynik -> closeCursor();	
			return $wynik_tablica;
    	}
		catch(PDOException $e) {
            echo '<p>blad w metodzie pobieranieDanych(): '.$e->getMessage().'</p>';
        }        
    }	
 
}
 
----------------------------------------------
 
class Ksiazki
{
	private $polaczenie;
 
	public function __construct($db)
	{
		$this->polaczenie = $db;
	}	
 
	public function __destruct()
	{		
	}	
 
	public function pobierzKsiazki()
	{
		return $this->polaczenie->pobieranieDanych("SELECT * FROM ksiazki");
	}
}
 
-----------------------------------------------------------------
 
$polaczenie = new klasaPolaczenie();
 
$ksiazki = new klasaKsiazki($polaczenie);
$rezultat = $ksiazki->pobierzKsiazki();
[PHP] pobierz, plaintext 

Masz złe podejście do programowanie obiektowego. Poczytaj trochę o ogólnych zasadach OOP, dziedziczeniu itp. W typowo modelowych klasach jakimi są Książki i Autorzy dziedziczysz po abstrakcyjnej klasie Polaczenie. Jaki to ma sens? Dziedziczenie wykorzystuje się do poszerzania możliwości klas w jakiś logiczny sposób ze sobą powiązanych - piszesz klasę ogólną, posiadającą jakieś podstawowe właściwości i metody charakterystyczne dla pewnego zbioru obiektów i dzięki klasom potomnym specjalizujesz ją (rozszerzasz jej działanie). Np. masz klasę Pojazd, która jest klasą abstrakcyjną - nie istnieje coś takiego jak "pojazd", nazywamy tak różne środki transportu służące do przemieszczania się, ale sam "pojazd" nie istnieje. Dopiero konkretne typy pojazdów (a raczej wypadałoby powiedzieć że to "Pojazd" jest typem dla konkretnych obiektów) można stworzyć i wykorzystywać. Klasy Samochód, Motocykl, Rower dziedziczą więc po klasie Pojazd - są pewną wyspecjalizowaną formą tej klasy (a przy tym są z nią logicznie powiązane).

Wracając do twojego przykładu - Połączenie nie jest w żaden sposób typem dla obiektu Książka, ani Autor. Klasy te mogą posiadać informację o połączeniu z bazą, ale na pewno nie w wyniku dziedziczenia. Możesz więc przekazywać uchwyt połączenia z bazą w argumencie konstruktora klasy Książka i przechowywać go w prywatnym polu tej klasy. Możesz też wykorzystać tzw. rejestr (wzorzec registry), czyli taki globalny pojemnik na różne obiekty (oparty na singletonie), do którego wrzucasz sobie obiekt połączenia i uzyskujesz do niego dostęp w dowolnym momencie programu. Niektórzy nie lubią takiego rozwiązania, ze względu właśnie na tą "globalność", ale czasami może być wygodne. Poza tym możesz spróbować dowiedzieć się trochę i zaimplementować wzorzec context

"Możesz więc przekazywać uchwyt połączenia z bazą w argumencie konstruktora klasy Książka i przechowywać go w prywatnym polu tej klasy." - no wlasnie tak sadzilem, ze to byloby najwygodniejsze i najlepsze rozwiazanie jak w moim poprzednim poscie (jego druga czesc) Dziekuje

Dzieki za uwage odnosnie dziedziczenia w tym wypadku, aczkolwiek w zyciu to chyba roznie z tym bywa - np. wczoraj natknalem sie na cos takiego:
http://webinside.pl/artykul-369-zachowanie...ebie-klasy.html