Object Oriented Programming Problem - php

Question

I'm designing a little CMS using PHP whilst putting OOP into practice. I've hit a problem though.
I have a page class, whos constructor accepts a UID and a slug. This is then used to set the properties (unless the page don't exist in which case it would fail). Anyway, I wanted to implement a function to create a page, and I thought ... what's the best way to do this without overloading the constructor. What would the correct way, or more conventional method, of doing this be?
My code is below:
<?php
class Page {
private $dbc;
private $title;
private $description;
private $image;
private $tags;
private $owner;
private $timestamp;
private $views;
public function __construct($uid, $slug) {
}
public function getTitle() {
return $this->title;
}
public function getDescription() {
if($this->description != NULL) {
return $this->description;
} else {
return false;
}
}
public function getImage() {
if($this->image != NULL) {
return $this->image;
} else {
return false;
}
}
public function getTags() {
if($this->tags != NULL) {
return $this->tags;
} else {
return false;
}
}
public function getOwner() {
return $this->owner;
}
public function getTimestamp() {
return $this->timestamp;
}
public function getViews() {
return $this->views;
}
public function createPage() {
// Stuck?
}
}

Answer 1

PHP Doesn't support overloading. I would probably go for something like:
$oPage = new Page();
$oPage->setTitle($sSomeTitle);
$oPage->setcontent($sSomeContent);
$oPage->save();
Or you could create an extra object - that is responsible for handling this.
$oPage = new Page();
$oPage->setTitle($sSomeTitle);
$oPage->setcontent($sSomeContent);
PageManager::create($oPage);
The advantage of this - is that your page class remains a pure data container, where all logic for loading/saving is done within an separate class.

Answer 2

I put those arguments in a constructor without which an object cannot exist. Other (optional) attributes of an object can be set by calling its setters.
For example, in your case a page seems to always have a UID, without which your system cannot recognize it, so it should be an argument to the constructor and I would build it such that the callee of the constructor shall not be able to call an empty constructor, because it won't mean anything for the page class.
A page can have no content and not even any title, but it has no meaning for the system without a UID or for example a URI. So my callee's code would look as follows:
$page = new Page($uid);
$page->setTitle($sSomeTitle);
$page->setcontent($sSomeContent);
$page->render();
However, my discussion mainly pertains to modelling your class. I personally think that the second solution in Wesley's answer is better.

Answer 3

You can make static method, that returns Page object
public static function CreatePageWithExtraAttribute($uid, $slug, $extra) {
$page = new Page($uid,$slug);
//your code here
return $page;
}
Or make a static method that querys database for example
public static function CreatePage($extra) {
list($uid,$slug) = SomeDatabaseManager::GetUidSlug();
$page = new Page($uid,$slug);
//your code here
return $page;
}
Then use it
$page=Page::CreatePageWithExtraAttribute($title)