Witam, przeczytałem zawartość działu OOP na temat klasa abstrakcyjna + interfejs. Jednak w większości nie był poruszany temat metod statycznych, a tym bardziej singletona.

Zaplanowałem sobie taki mały systemik logowań zdarzeń. Chciałem oprzeć go o klase abstrakcyjną + interfejs, a przy okazji chciałem użyć do tego celu singletona, aby późniejsze wywołanie mogło sprowadzić się do:

[PHP] pobierz, plaintext 
<?php 
dbLog::write()->error(); 
dbLog::write()->warning();
?>
[PHP] pobierz, plaintext 

Oto co próbowałem zrobić, jednak to nie działa, dostaję błąd:

[PHP] pobierz, plaintext 
interface logInterface {
	public static function write();
	public function error();
	public function warning();
	public function notice();
}
abstract class log implements logInterface{
	protected static $_instance = null;
	protected function __construct(){}
	protected function __clone(){}
 
	abstract public static function write();
 
	abstract public function error();
	abstract public function warning();
	abstract public function notice(); 	
}
class fileLog extends log implements logInterface {
	public static function write(){
		return is_null(parent::$_instance) ? parent::$_instance = new fileLog() : parent::$_instance; 
	}
	public function error(){echo 'fileLog - error';}
	public function warning(){echo 'fileLog - warning';}
	public function notice(){echo 'fileLog - notice';}
}
class dbLog extends log implements logInterface {
	public static function write(){
		return is_null(parent::$_instance) ? parent::$_instance = new dbLog() : parent::$_instance; 
	}
	public final function error(){echo 'dbLog - error';}
	public final function warning(){echo 'dbLog - warning';}
	public final function notice(){echo 'dbLog - notice';}	
}
[PHP] pobierz, plaintext 

Myślałem o przeniesieniu metody write() do klasy abstrakcyjnej log, zrobienie z niej static (czyt final static)

Ewentualnie mógłbym zrobić w każdej metodzie error, warning, notice odwoływanie się do singletona tak, żeby użycie uprościć do

[PHP] pobierz, plaintext 
<?php 
dbLog::error(); 
fileLog::notice(); 
?>
[PHP] pobierz, plaintext 

Macie jakieś pomysły jak to rozwiązać?

Po co deklarujesz w Log abstrakcyjne metody, które i tak są wymuszone przez interface?

A no właśnie, tak to jest jak się za długo siedzi nad jednym kodem i go przerabia co chwila na różne sposoby.
W pierwszej wersji miało być bez interfejsu, ale później wymyśliłem, żeby go jednak dodać.

Chciałem przenieść metodę write do klasy abstrakcyjnej. Jednak nie wiem jak ugryźć w niej poprawne tworzenie nowego obiektu dla klas potomnych. Nie wiem czy jest poprawnie (ma sens) taki sposób: (co prawda skraca zapis użycia)

[PHP] pobierz, plaintext 
<?php
interface logInterface {
	public function error($err);
	public function warning();
	public function notice();
}
abstract class log implements logInterface{
	protected function __construct(){}
	protected function __clone(){}
 
	public static function write(logInterface $log){
		return is_null($log->_instance) ? $log->_instance = new $log() : $log->_instance; 
	}
}
class fileLog extends log implements logInterface {
	protected static $_instance = null;
	protected $logi;
 
	public function __construct(){
		parent::write($this);
	}
	public function error($err){self::$_instance->logi .= "\n".$err; echo self::$_instance->logi;}
	public function warning(){echo 'fileLog - warning';}
	public function notice(){echo 'fileLog - notice';}
}
class dbLog extends log implements logInterface {
	protected static $_instance = null;
	protected $logi;
 
	public function __construct(){
		parent::write($this);
	}
	public function error($err){self::$_instance->logi .= "\n".$err; echo self::$_instance->logi;}
	public function warning(){echo 'dbLog - warning';}
	public function notice(){echo 'dbLog - notice';}	
}
 
//Użycie 
fileLog::error('1');
dbLog::error('2');
dbLog::error('3');
 
// Daje w wyniku (czyli ok):
/*
1
 
2
 
2
3
*/
 
?>
[PHP] pobierz, plaintext 

Myślałem na początku, że nie da się utworzyć wspólnej metody dla singletona w klasie abstrakcyjnej.
Zmienna $_instance przechowująca obiekt musi być przecież inna dla fileLog, a inna dla dbLog. Zatem zmienne te trzeba tworzyć dla klas dziedziczących oddzielnie, i na nich operować, bo inaczej $_instance przechowywałaby obiekt pierwszej klasy która go wywołała. Nie wiem co ja chciałem zrobić, singletona na klasę abstrakcyjną Ale jak przeniosłem te zmienne do klas dziedziczących, i odwoływałem się do nich w klasie rodzica okazało się, że się da. Tylko czy może lepiej zrobić tak jak poniżej?

[PHP] pobierz, plaintext 
<?php
interface logInterface {
	public static function write();
	public function error();
	public function warning();
	public function notice();
}
abstract class log implements logInterface{
	protected function __construct(){}
	protected function __clone(){}
}
class fileLog extends log implements logInterface {
	protected static $_instance = null;
	protected $logi;
 
	public static function write(){
		return is_null(self::$_instance) ? self::$_instance = new fileLog() : self::$_instance; 
	}
	public function error(){self::write()->logi .= "\nfileLog - error"; echo self::write()->logi;}
	public function warning(){echo 'fileLog - warning';}
	public function notice(){echo 'fileLog - notice';}
}
class dbLog extends log implements logInterface {
	protected static $_instance = null;
	protected $logi;
 
	public static function write(){
		return is_null(self::$_instance) ? self::$_instance = new dbLog() : self::$_instance; 
	}
	public function error(){self::write()->logi .= "\ndbLog - error"; echo self::write()->logi;}
	public function warning(){echo 'dbLog - warning';}
	public function notice(){echo 'dbLog - notice';}	
}
?>
[PHP] pobierz, plaintext 

Możesz jeszcze powiedzieć czy dbLog i fileLog używane są zamiennie (tj. programista decyduje się na używanie jednego albo drugiego) czy równolegle (tj. używane jest w jednym skrypcie zarówno jedno jak i drugie)? Wydaje mi się, że to pierwsze, ale jakbyś mógł wyjaśnić wszystko.

Swoją drogą... na Twoim miejscu zastanowiłbym się czy nie lepsze byłoby dobieranie się do obiektu Log przy pomocy np. kontekstu niż robić z niego singletona.

Nie ma też sensu robić trzech osobnych metod do zapisywania. Wystarczy jedna, z dodatkowym parameterm określającym "poziom":

[PHP] pobierz, plaintext 
$log; //instancja naszego loggera
 
$log->log('my event', Log::NOTICE);
$log->log('my event', Log::WARNING);
//itp
[PHP] pobierz, plaintext 

Co do szkieletu klas...

[PHP] pobierz, plaintext 
interface Logger{
  public function log($msg, $level);
}
 
abstract class Log implements Logger{
  const NOTICE = 0;
  const WARNING = 1;
  const ERROR = 2;
  const SOMETHING = 4; 
 
  protected $logs = array();
}
 
class DatabaseLog{
  public function log($msg, $level){
    //...
  }
}
 
class FileLog{
  private $fileHandle;
 
  public function __construct(){
    $this->fileHandle = fopen('./my/log/file');
  }
 
  public function log($msg, $level){
    //...
  }
}
[PHP] pobierz, plaintext 

@Crozin dzięki wielkie za zainteresowanie.

Chcę zrobić dość uniwersalny system logów, będzie wykorzystywany moduł plikowy, jak id db, dlatego chciałem mieć to razem, z możliwością łatwego przełączania. Na razie bardziej zamiennie, ale z czasem może mi się coś odmienić. Poza tym zawsze przyda się mała wprawka bardziej obiektowego php

Zrobiłem 3 metody zapisywania, aby później skrócić użycie. Co prawda zastanawiałem się też nad jedną metodą z flagami - w poprzedniej klasie logów tak miałem, jednak czasem zdarzało mi się niechcący wybrać nie tą flagę (wtedy jeszcze miałem 2 binarnie: 0 i 1). Później w podglądzie logów miałem nieodpowiednie kolorowanie.

Teraz chcę po prostu sprawdzić inny sposób, zobaczyć jak to się będzie sprawdzało. Ta wersja wydaje się być wygodniejsza, szybciej i jaśniej jest napisać

[PHP] pobierz, plaintext 
log::error('widaomo, że błąd');
// niż
log->log("to jest błąd",log::ERROR);
[PHP] pobierz, plaintext 

Rozbudowy, czy dodatkowego rozszerzania tych klas, za bardzo nie widzę. Nawet jeśli, to zawsze można zedytować jedną klasę abstrakcyją i powinno bez problemu działać. Zdaję sobie sprawę, że jest to trochę przerost formy nad treścią, ale nie raz się robi coś nieekonomicznego dla wygody:)

Przewiduję, że te 3 metody będą odwoływały się do wspólnej jednej prywatnej, z tą tylko różnicą, że będą ustawiać inną flagę. Czyli zamiast trzech flag i jednej metody, są trzy metody (może 4) i nie ma flag

Mam nadzieję, że będzie się później tego wygodniej używało A jeśli nie, to skorzystam z Twojego schematu

Pozdrawiam, i dziękuję za pomoc

Pamiętaj, że zawsze możesz ustawić domyślny poziom (ten najczęściej stosowany) dzięki czemu zapis skróci się do

[PHP] pobierz, plaintext 
$log->log('my log');
[PHP] pobierz, plaintext 

Dodatkowo nie kieruj się jedynie długością zapisu. Z reguły jego czytelność oraz logiczność są dużo ważniejsze.