Declare public variables in the __Construct method

Question

Note the example of the method:

<?php
#noticia_construct.class.php
class Noticia{
    public $titulo; // Acredito que não seja necessário
    public $texto; // Acredito que não seja necessário
    function __construct($valor_tit, $valor_txt){
        $this -> titulo = $valor_tit;
        $this -> texto = $valor_txt;
    }
    function exibeNoticia(){
        echo "
            <center>
                <b>". $this->titulo ."</b>
                <p>". $this->texto ."</p>
            </center>
        ";
    }
}
$noticia = new Noticia('Novo curso de PHP Avançado', 'Abordaremos: POO, XML, tex.');
$noticia -> exibeNoticia();
?>

My question is about the need to declare variables as public. They are not used anywhere in the code. In other examples of the apostille the same thing happens (about classes and inheritance). If I remove this part of the code, it keeps working.

Declaring the visibility of variables is some good practice or something like that?

This is an example of Unicamp’s advanced PHP workbook.

Answer 1

Visibility

The decision whether to leave the public variable or not is the programmer according to the need. The fact that it is not used elsewhere does not mean that it cannot be used at some point. What many programmers don’t understand is that the class should be thought to be used in various situations. If you’re going to do something simple, which isn’t going to be used in many different ways and you won’t need complex maintenance, you don’t have to create a class.

The important thing is to understand why to do things. Handbooks serve to give a basis on the technique, but they do not teach people to think about problems and how to solve them.

The most common object orientation is to leave the variables private until you have a reason to make them public. But I think it is reasonable to understand that these data may be needed somewhere in isolation, especially if the class is just that, where it would be of little use. I would probably do it that way, if I were forced to create a class (this can be useful).

Doing OOP in PHP

Another important point is about methods to access class fields. Some say they should always be used. This makes some sense, but many people repeat this without knowing why it is necessary. Want to do so, ok, everyone can do as they please, but in PHP there is no need in most cases.

PHP is a language of script, the codes have Binding at runtime, so from a technical point of view it makes no difference to access the variable or a method, unless it is known that the method will need to be used in the future. Even in these cases I have my doubts if it is so useful for applications that PHP fits well (I know that many people make use of PHP where it does not fit, but there is another problem).

In most cases it is more interesting to initialize existing members with a constructor. Not always, but need to know when to use a constructor or not, can’t just follow a rule.

No longer declaring variables

If the question was about what the bfavaretto said in comment below (the AP showed that it is not), about the variable being created automatically without being declared, it is even possible, but it is not recommended, the reason to create a class is precisely to organize the code, declare what its function, its members, power is one thing, being certain is another. Some unpredictable things can happen.

In fact this is just one of the reasons I have objections to OOP in PHP, the language was not designed for this, it lets do a lot of wrong in the name of "simplicity", OOP does not go with this. In PHP an object is just a form of array associative that allows to insert and remove members at random.

I’m surprised at Unicamp teaching PHP, I hope it’s just some sort of slot machine course.

Answer 2

Answer to the question

You are so right! If you want the variables to be really public, when using them within the class they are implicitly declared (public). This example works without errors or warnings:

<?php
  class Banana {
    public function __construct($a, $b) {
      $this->a = $a;
      $this->b = $b;
    }

    public function s() {
      echo "Digamos que {$this->a} {$this->b}.." . PHP_EOL;
    }
  }

  $a = new Banana('FORA', 'TEMER');
  $a->s();

  $a->b = "PEC 241";
  $a->s();

Note that instance variables $a and $b have not been declared and I can even update their value directly from outside the class.

Recommendations

In its code there is no need to declare the variables as public and, even, it is recommended that they be private.

In object orientation, it is not very common for you to leave public variables. Good practice is for your class to express itself through methods.

In the example you provided, it would be interesting for you to leave your variables private and create methods to access their values (called getters and setters). Follow an example:

<?php

class Noticia {

    private $titulo;
    private $texto;

    function exibeNoticia(){
        echo "
            <center>
                <b>". $this->titulo ."</b>
                <p>". $this->texto ."</p>
            </center>
        ";
    }

    public function setTitulo($titulo) {
      $this->titulo = $titulo;
    }

    public function setTexto($texto) {
      $this->texto = $texto;
    }

    public function getTitulo() {
      return $this->titulo;
    }

    public function getTexto() {
      return $this->texto;
    }
}

$noticia = new Noticia();
$noticia->setTitulo("Título da notícia");
$noticia->setTexto("Texto da notícia......");

$noticia->exibeNoticia();

This is good practice for several reasons, I will quote some of them:

1. Decouple the class constructor: you no longer need to necessarily pass the values in the class constructor by instantiating it;
2. Encapsulate the class data: recommend that you read more about the concept of encapsulation in object orientation. Basically, your class can do several things by setting one of its properties and the programmer who is using your class, you don’t have to worry about it.

Let’s assume that when setting the title, you always want to remove HTML characters. That way, your Setter from the title would look something like this:

    public function setTitulo($titulo) {
      $this->titulo = strip_tags($titulo);
    }

If this behavior was not encapsulated, you would need to do this routine whenever you were updating your class title field.