Should I use a setter within a class to set a property?

Question

I want to set a property value within my class. I can do it without a setter and a getter but I want to know the "correct" way to approach this. This is for a login script so the property and the setter are both private.

Should I just set the property directly or use a setter and a getter?

Answer 1

This is a matter of opinion. Traditional object oriented programming principles say Yes, but it's really up to you.

Note that you will have to use a setter method if you set your property to private. Setters should always be public, so that other classes and methods can operate on the property. If you don't have any reason to access the property from outside your class though, then don't create a setter, because it really won't matter; you'll always have access to private member variables / properties from within the class.

Answer 2

This is probably mainly a matter of personnal preference...

If you have to set the private property from a method of the class, I would say that you can access that property directly.

A reason to use an setter/getter, in that kind of situation, would be if you want to ensure that some condition or calculation is made on the data each time the property is set.

As a sidenote : of course, if your want to access your private property from outside the class, you'll have to use to public setter/getter -- but it doesn't seem to be what you are trying to do here.

Answer 3

Don't forget that you can use the "magic" __get / __set methods without having to create getters and setters for everything.

magic functions

edit: If the member variables are private or protected you will have to use a getter and setter. If they are public, it's a matter of style - though you should be consistent with the rest of your class.

Answer 4

Setter/Getters allow derived classes to modify/limit/enhance state and behavior of an object more easily. But you can over-do setters/getters and then they become a bit annoying. (Especially in languages that do not hide them).

class Foo {
  protected $x;
  public function __construct($x) {
    $this->setX($x);
  }

  public function setX($x) {
    $this->x = $x;
  }

  public function something($y) {
    // not using a getter here, it's only an example
    echo $this->x * $y;
  }
}

class DoubleFoo extends Foo {
  public function setX($x) {
    parent::setX($x*2);
  }
}

$df = new DoubleFoo(1);
$df->something(5);