[PHP] pobierz, plaintext 
<?php
	class Student
	{
		private $_id;
		private $_name;
 
		public $_courses;
 
		public function __construct($id, $name)
		{
			$this -> _id = $id;
			$this -> _name = $name;
 
			$this -> courses = new CourseCollection();
			$this -> courses -> setLoadCallBack('_loadCourses', $this);
		}
 
		public function getName()
		{
			return $this -> _name;
		}
 
		public function getID()
		{
			return $this -> _name;
		}
 
		private function _loadCourses(Collection $col)
		{
			$arCourses = StudentFactory::getCoursesForStudent($this -> _id, $col);
		}
 
		public function __toString()
		{
			return $this -> _name;
		}
	}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
	require_once('class.KeyInvalidException.php');
	require_once('class.KeyInUseException.php');
 
	class Collection 
	{
		private $_members = array();
		private $_onLoad;						//funkcja zwrotna
		private $_isLoaded = false;		//flaga określająca, czy funkcja zwrota została już wysłana
 
	   public function addItem($obj, $key = null) 
		{
			$this -> _checkCallBack();
 
      	if($key) 
			{
         	if(isset($this->_members[$key])) 
            	throw new KeyInUseException("Klucz \"$key\" jest już zajęty!");
	         else 
   	         $this->_members[$key] = $obj;
      	} 
			else 
   	      $this->_members[] = $obj;
	   }
 
		public function removeItem($key) 
		{
			$this -> _checkCallBack();
 
   		if(isset($this->_members[$key])) 
      		unset($this->_members[$key]);
	   	else 
   	   	throw new KeyInvalidException("Błędny klucz \"$key\"!");
		}
 
		public function getItem($key) 
		{
			$this -> _checkCallBack();
 
   		if(isset($this->_members[$key])) 
      		return $this->_members[$key];
	   	else 
   	   	throw new KeyInvalidException("Błędny klucz \"$key\"!");   	
		}
 
		public function keys() 
		{
			$this -> _checkCallBack();
 
   		return array_keys($this->_members);
		}
 
		public function length() 
		{
			$this -> _checkCallBack();
 
   		return sizeof($this->_members);
		}
 
		public function exists($key) 
		{	
			$this -> _checkCallBack();
 
			return (isset($this->_members[$key]));
		}
 
		/*
			Ta metoda pozwala na zdefiniowanie funkcji, którą
			należy wywołać, aby wypełnić kolekcję.
			Jedynym parametrem tej funkcji powinna być
			kolekcja do wypełnienia.
		*/
		public function setLoadCallBack($functionName, $objOrClass = null)
		{
			if($objOrClass)
				$callback = array($objOrClass, $functionName);
			else
				$callback = $functionName;
 
			//sprawdzanie czy funkcja zwrotna da się wywołać
			if(!is_callable($callback, false, $callableName))
			{
				throw new Exception("Funkcja zwrotna $callableName nieprawidlowa!");
				return false;
			}
			$this -> _onLoad = $callback;
		}
 
		private function _checkCallBack()
		{
			if(isset($this -> _onLoad) && !$this -> _isLoad)
			{
				$this -> _isLoaded = true;
				call_user_func($this -> _onLoad, $this);
			}
		}
	}  
?>
[PHP] pobierz, plaintext 

Błąd zwracany przez przeglądarkę


Nie rozumiem dlaczego Collection::setCallBack() nie może wywołać Student::_loadCourses

Słowo private przy deklaracji Student::_loadCourses() coś Ci mówi? Jeśli nie, to poczytaj sobie, co ono znaczy, ponieważ to jest klucz do rozwiązania Twojego problemu.

Tak na marginesie:

[PHP] pobierz, plaintext 
			if($objOrClass)
				$callback = array($objOrClass, $functionName);
			else
				$callback = $functionName;
[PHP] pobierz, plaintext 

Usuń ten kod z cyklu "Masło maślane" - przecież to jest kombinowanie pod górę. Jak komuś będzie zależało, by wywołać metodę obiektu, to niech poda od razu prawidłową tablicę.

Dzięki za pomoc, banalny błąd nie zwróciłem na to nawet uwagi, ale co by nie było wszystko toczka w toczkę jest w książce('PHP5 Zaawansowane programowanie').

1) public $_courses; ten znak podkreślenia chyba Ci się przypadkiem wkradł - zważywszy na to, że później odwołujesz się do courses
2) Co do private - chyba każde jego użycie w Twoim-nie-Twoim kodzie jest błędne. Tego wyjątkowo restrykcyjnego modyfikatora powinno używać się tylko wtedy, gdy dana składowa/metoda obiektu jest częścią jakiegoś "pobocznego mechanizmu" używanego wewnątrz obiektu. Normalnie podstawowym modyfikatorem powinien być protected - nie ma potrzeby zamykania sobie możliwości wykorzystania danej klasy jako nadrzędnej (chodzi o dziedziczenie).