[RESOLVED] A few class questions..

[nrg_alpha]

ok.. so I'm am learning classes.. and I have some simple (and perhaps negligable questions)

here is a small simple example snippet:

class person{
   public $name;
   public $age;
   public $weight;

   public function __construct(){
      $this->age = 0;
      $this->weight = 0;
   }
}

My first question is with regards to constructs.. I read that if you have a construct in your class, an object cannot be instantiated until the construct executes.. In this case, there is no parameters to pass along into the construct.

so when I create Bob I don't see a difference between,

$bob = new person;
-and-
$bob = new person();

I suppose in this case, it doesn't really matter since the __construct() doesn't pass in any parameters? From good coding practices, which version of creating object 'bob' is better?

Finally, when it comes to setting up default properties within a class.. I realise I can go a few ways.. so in the above class example, I want the default name property to be unknown.. does it matter whether I do this:

class person{
   public $name;
   public $age;
   public $weight;

   public function __construct(){
      $this->name = 'UNKNOWN';
      $this->age = 0;
      $this->weight = 0;
   }
}

or this?

class person{
   public $name = 'UNKNOWN';
   public $age;
   public $weight;

   public function __construct(){
      $this->age = 0;
      $this->weight = 0;
   }
}

Your wisdom and insight is appreciated 🙂

Cheers,

NRG

[NogDog]

1. Functionally, there is no difference, but I prefer to use the empty parens just for consistency in the way the code looks, and it makes it more obviously that I explicitly meant to call it with no parameters.

2. Again, functionally it does not matter, but I would opt for putting it in the variable declaration as I feel that makes it more apparent that it starts with a default value.

But both of these are basically personal preferences, and if some certified "experts" disagree with me, I won't be horribly surprised (nor is it likely that they'll change the way I do things unless they can provide a really convincing reason.).

[nrg_alpha]

Thanks for your response, Nog..
After reading your answer to number 1, I think I can agree with this.. so I'll make a habit of including the construct parentheses.

I was admittedly thrown off by your answer 2 (although I have no real reason to... strange isn't it?). I was starting to wonder if it's best set it in the construct.. (but again, I'm not knowledgable enough to know if there actually is a difference).. all I know is that both versions worked when tested.

Thanks Nog.. should someone join in and demonstrate an actual difference (read consequences of going one way or the other), I guess there's no harm one way or the other.

Cheers,

NRG

[Weedpacket]

There are a couple of small functional differences between initialising instance variables statically (i.e., when the variable is declared in the class) and initialising them in the constructor...

The more complicated one first 🙂. When initialised statically, they are also initialised for subclasses; when initialised in the constructor, the subclass will have to call the parent's constructor (which has to be stated explicitly in the subclass's constructor or it won't happen). I think the following code is sufficiently bare-bones to not have any distractions:

class Foo1
{
	public $foo='foo';
	public function __construct(){}
}


class Bar1 extends Foo1
{
	public function __construct(){}
}

class Foo2
{
	public $foo;
	public function __construct()
	{
		$this->foo='foo';
	}
}

class Bar2 extends Foo2
{
	public function __construct(){}
}

$t1 = new Bar1;
$t2 = new Bar2;

echo "\$t1->foo=".$t1->foo,"\n\$t2->foo=".",$t2->foo;

$t2->foo won't have a value because its constructor (Bar2::construct) doesn't call Foo2::construct, so the assignment to $foo doesn't happen.

The other functional difference is more straightforward: Values that can be legitimately assigned in static initialisers are limited to literals, global constants, class constants, and literal arrays of things that can be legitimately assigned in static initialisers. In particular, anything that involves evaluating an operation or function call is not allowed. Initialisers in constructors don't have this limitation.

[nrg_alpha]

Thanks for the input Weedpacket..

I think I understand.. so if do things via NogDog's method, even if I forget to call the parent's constructor in a child class, the properties that I want initialized with default values will do just that regardless.

If I rely on a parent constructor to initialise a property's defaut value, I risk not getting that property / default if I dont call parent::__construct().

Very smooooth 🙂

OK.. that settles it for me!

Thanks for the input guys.. very much appreciated!
I'll flag this as resolved even though it wasn't a matter of something being broken or not, but rather a technique that should be employed.

Cheers,

NRG

[Drakla]

Your moving in the right direction quite quickly - take a look at this page on design patterns on the Zend site as it's a really good introduction to not just creating classes, but using them well.

http://devzone.zend.com/node/view/id/3

[nrg_alpha]

Drakla;10880617 wrote:

Your moving in the right direction quite quickly - take a look at this page on design patterns on the Zend site as it's a really good introduction to not just creating classes, but using them well.

http://devzone.zend.com/node/view/id/3

Hi Drakla

lol what a coincidence.. I am viewing this Zend article for classes:
http://devzone.zend.com/node/view/id/638

But I was not aware of the link you provided. Bookmarked! So much content to chew on (hopefully I don't choke lol).

Thanks again.. I'll definately read it 🙂

Cheers,

NRG