Composite pattern, why is it bad if "children" know about "parent"? - php

Question

code samples: https://sourcemaking.com/design_patterns/composite/php I made something similar, except that "OnTheBookShelf" knows about $books (SeveralBooks). My "boss" say its bad that they know about each other. But why?
Allright, I edit it:
abstract class OnTheBookShelf {
public $shelf; /////////////////////////////////////////////////
abstract function getBookInfo($previousBook);
abstract function getBookCount();
abstract function setBookCount($new_count);
abstract function addBook($oneBook);
abstract function removeBook($oneBook);
}
class OneBook extends OnTheBookShelf {
private $title;
private $author;
function __construct($title, $author) {
$this->title = $title;
$this->author = $author;
}
function getBookInfo($bookToGet) {
if (1 == $bookToGet) {
return $this->title." by ".$this->author;
} else {
return FALSE;
}
}
function getBookCount() {
return 1;
}
function setBookCount($newCount) {
return FALSE;
}
function addBook($oneBook) {
return FALSE;
}
function removeBook($oneBook) {
return FALSE;
}
}
class SeveralBooks extends OnTheBookShelf {
private $oneBooks = array();
private $bookCount;
public function __construct() {
$this->setBookCount(0);
}
public function getBookCount() {
return $this->bookCount;
}
public function setBookCount($newCount) {
$this->bookCount = $newCount;
}
public function getBookInfo($bookToGet) {
if ($bookToGet <= $this->bookCount) {
return $this->oneBooks[$bookToGet]->getBookInfo(1);
} else {
return FALSE;
}
}
public function addBook($oneBook) {
$oneBook->shelf = $this; //////////////////////////////////////////////////
$this->setBookCount($this->getBookCount() + 1);
$this->oneBooks[$this->getBookCount()] = $oneBook;
return $this->getBookCount();
}
public function removeBook($oneBook) {
$counter = 0;
while (++$counter <= $this->getBookCount()) {
if ($oneBook->getBookInfo(1) ==
$this->oneBooks[$counter]->getBookInfo(1)) {
for ($x = $counter; $x < $this->getBookCount(); $x++) {
$this->oneBooks[$x] = $this->oneBooks[$x + 1];
}
$this->setBookCount($this->getBookCount() - 1);
}
}
return $this->getBookCount();
}
}
I added a bunch of //////////////// to the problematic lines. And here they say that book has reference to shelf.

Answer 1

They should know about their interfaces, so that they can be changed.
Let's say you have classes:
Bookshelf
private books: Book[]
Book
public title: String
You would then access books[i].title and display title of the a book.
Now imagine that the programmer in charge of Book decides that the title merrits its own class, so we have:
Book
public title: Title
Title
private t: String
public toString()
Now the programmer who was coding Bookshelf is required to change their code.
On the other hand if we would have:
Book
private title: String
public getTitleString()
Then we could change the implementation of the Book class, and all we would have to do is to write the getTitleString() function that would return a string representation of a title, and everything would continue to work without any additional changes to Bookshelf.

Answer 2

My "boss" say its bad that they know about each other. But why?
The problem is circular reference between Shelf and Book that is not so trivial and requires special care to work with.
For example, if you simply write $oneBook->shelf = $this; inside addBook method, then what happens if consumer calls this method for one book on two different shelves?
$book = new Book;
$shelf1 = new Shelf;
$shelf2 = new Shelf;
$shelf1->addBook($book);
$shelf2->addBook($book);
Book will be added to both shelves, but it will hold reference only to the last shelf, which leads to inconsistency and potential run-time bugs.
Of cause, circular reference can be done right, but it requires special attention and adds complexity to code.