[ABSTRACT][INTERFACE][STATIC][SINGLETON] Klasa abstrakcyjna, interfejs metody statyczne Opcje

[vokiel]

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:

Kod

Fatal error: Can't inherit abstract function logInterface::write() (previously declared abstract in log) in C:\xampp\htdocs\test.php on line 10

[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ć?

[vokiel]

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ą (IMG:style_emoticons/default/sciana.gif) 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