which one to use and why ??

[PHPycho]

Hello forums!!
I am curious about some question which i am going to mention here.
we know the advantage of using getters and setters in OOP.
Let us consider the case:

<?php
class className{
	var prop1;
	var prop2;
	var prop3;

function className(){
	// Empty constructor
}

function setProp1($prop1){
	$this->prop1 = $prop1;
}
function getProp1(){
	return $this->prop1;
}
function setProp2($prop2){
	$this->prop2 = $prop2;
}
function getProp2(){
	return $this->prop2;
}	
function addProp12(){
	$value = $this->prop1 + $this->prop2;
	// Alt $value = $this->getProp1() + $this->getProp2();
	return $value;
}
}

// Using Class
$classObj = new className();
$classObj->setProp1("x");
$classObj->setProp2("y");
echo $classObj->addprop12();
?>

My Question is very simple..
once the property is set using methods, for internal use in the class file
which one to use and why ?
1> $value = $this->prop1 + $this->prop2;
2> $value = $this->getProp1() + $this->getProp2();

Thanks in advance to all of you.

[mpb001]

In your example the benefits are not really apparent due to getters and setters are usually for getting/setting information from external code though they can be used for internal ones but it is less important.

Allowing direct access to internal properties of an object means anyone who uses your class is as the mercy of you changing the objects internal structure due to the tight coupling.

Originally we write a class that has a getter and setter for a. a originally holds a simple type such as number or a string etc.
ie.

class Test
{
    var $a;
    function SetA( $a )
    {
        $this->a = $a;
    }

function GetA()
{
    return $this->a;
}
}

Now the functionality of the class grows and you want to set a to an object and call a trigger( DoSomethingWithNewA() ) due to refactoring. The class now becomes

class Test
{
    var $a;

function SetA( $a )
{
    $this->a = new Dummy($a);
    $this->DoSomethingWithNewA();
}

function GetA()
{
    return $this->a->GetValue();
}


function DoSomethingWithNewA()
{
    //refresh an setting reliant on old a etc..
}
}

Anyone who was calling your value $test->a directly is now buggered and anyone who was calling $test->GetA() isn't . Though unless you are using php5 you cannot force them not to directly access things due to lack or public, private and protected.

http://www.zend.com/php5/articles/engine2-php5-changes.php

Worth a read...

Using setters internally does allow you not to worry about any trigger code you might put in the setter etc but as the class is your code you can deal with it internally as you wish so is not such a big deal.

[laserlight]

My Question is very simple..
once the property is set using methods, for internal use in the class file
which one to use and why ?

I generally access the member variable directly to avoid the overhead of a function call. On the other hand, as mpb001 has pointed out, a getter/setter might make it a little easier to maintain changes to the class implementation.

In fact, I suggest not using getters/setters unless you have to. Rather, design your class such that the interface shows what it can and is supposed to do, rather than expose how it does it. Poor provision of a getter/setter could expose the implementation of your class, making it difficult to maintain without changing the public interface.

[alimadzi]

Also the advantages of getters and setters are more apparent in PHP 5 where you can control the visibility of methods and properties (public, protected, private). For example, you can make all your properties private and then choose to expose them to your other developers using public get and set style methods. This approach gives you more control over how your classes are used.

This also just scratches the surface as far as how PHP 5 is better from an OO perspective than PHP 4.