PHP Setters/Getters and Constructor

Question

I have been searching for this online, but I can't seem to find something that is clear enough for me to understand. I have seen "similiar" questions on here about this in Java.

class animal{
    private $name;

    // traditional setters and getters
    public function setName($name){
        $this->name = $name;
    }

    public function getName(){
        return $this->name;
    }

    // animal constructors
    function __construct(){
       // some code here
    }

    // vs

    function __construct($name){
        $this->name = $name;
        echo $this->name;
    }
}

$dog = new animal();
$dog->setName("spot");
echo $dog->getName();

// vs

$dog = new animal("spot");

1. Should I declare and access my private fields through setters and getters or through the constructor?
2. Which one is the best practice?
3. I understand the purpose of a constructor(maybe not), but what is the point of having a constructor if I can declare and access my private fields through setters and getters?

Please note...this is my first time using OOP with web development and PHP, and I'm trying to learn by getting my hands "dirty" by writing some code in order for me to understand certain things in OOP. Please keep it simple.

Answer 1

It is more a matter of semantics than best practice per say.

In your example, your buisness logic may determine that an animal always needs a name. So it makes sense to construct the object with a name. If you do not want to allow an animal's name to be changed, then you don't write a setter.

i.e.

class Animal 
{
    private $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }
}

You may have other properties that an animal doesn't have to have, like an owner that you only write a getter/setter for i.e.

class Animal
{
    private $name;
    private $owner;

    public function __construct($name)
    {    
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setOwner($owner)
    {
        $this->owner = $owner
    }
}

But if you find that you are always creating an animal with an owner at the same time you may want to put that in the contructor signature for convenience

class Animal
{
    private $name;
    private $owner;

    public function __construct($name, $owner = null)
    {    
        $this->name = $name;
        $this->owner = $owner;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setOwner(Owner $owner)
    {
        $this->owner = $owner
    }

    public function getOwner()
    {
        return $this->owner;
    }
}

If the owner is another class in your application, you can type hint that your constructor needs an owner of a specific type (class). All of this is used to make it easier for you, or another developer to understand some of the requirements/logic behind your code - as well as potentially catching a bug here or there

class Owner 
{
    private $name;

    public function __construct($name)
    {    
        $this->name = $name;
    }
}

class Animal
{
    private $name;
    private $owner;

    public function __construct($name, Owner $owner = null)
    {    
        $this->name = $name;
        $this->owner = $owner;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setOwner(Owner $owner)
    {
        $this->owner = $owner
    }

    public function getOwner()
    {
        return $this->owner;
    }
}

// Create a new owner!
$dave = new Owner('Farmer Dave');

// a standard php empty object
$otherObj = new \stdClass();

// Create a new animal
$daisy = new Animal('Daisy');

// Farmer dave owns Daisy
$daisy->setOwner($dave);

// Throws an error, because this isn't an instance of Owner
$daisy->setOwner($otherObj);

// Set up Maude, with Dave as the owner, a bit less code than before!
$maude = new Animal('Maude', $dave);

Answer 2

Should I declare and access my private fields through setters and getters or through the constructor?

In situations like this, I ask myself:

• Why should I create a method just to hold a one line function? (+Constructor)

• How painful is it going to be to refactor two, three, four, five or more getters/setters vs one constructor?(+Constructor)

• How hard is it going to be to document two, three, four, five or more getters/setters vs one constructor?(+Constructor)

• Is there going to be a default value which will be documented? (+Constructor)

• Do I like documentation and expect people to read? (+Constructor)

• Will the initial value be undefined?(+Setter)

• Is there a set of equivalent forms (shorthand, international, nicknames) which will all be acceptable as syntatically correct for required arguments? (+Setter)

• Is there a set of optional arguments with default values? (+Setter)

• Is there a common need to stringify and parse the initial value? (+Setter)

• Do I dislike documentation and expect people to experiment? (+Setter)

Which one is the best practice?

The Date object seems to be the most complex class in most languages, so its PHP implementation would be a good reference for best practices.

What is the point of having a constructor if I can declare and access my private fields through setters and getters?

A constructor is implicitly invoked upon object instantiation in order to encapsulate the default state of the resulting data structure of its type.

References

• DateTime::__construct

• date_create

• The DateTime class

• date_default_timezone_get

• date_default_timezone_set

• Changes in PHP datetime support

• PHP OOP: Accessor and Destructor Methods

• Concurrency, part 4: Comparing promises frameworks in different languages – SLaks.Blog

• CDD: Context-Driven Development