Checking instance values of a class in php

I suggest to study object orientation more deeply, the example below is very superficial and teaches little.

First we need to create a class with the name pais .

namespace lib

/**
 * Classe Pais
 * @package lib
 */
class Pais
{
    /**
     * @var string $iso;
     */
    private $iso;

    /**
     * @var string $nome;
     */
    private $nome;

    /**
     * Atribui um valor a propriendade $iso
     * @param string $iso
     * @return lib\Pais
     */
    public function setIso($iso)
    {
        $this->iso = $iso

        $return $this;
    }

    /**
     * Retorna o valor da propriedade $iso
     * @return string
     */
    public funcion getIso()
    {
        return $this->iso;
    }

    /**
     * Atribui um valor a propriendade $nome
     * @param string $nome
     * @return lib\Pais
     */
    public function setNome($nome)
    {
        $this->nome = $nome

        $return $this;
    }

    /**
     * Retorna o valor da propriedade $nome
     * @return string
     */
    public funcion getNome()
    {
        return $this->nome;
    }
}

We first assign a namespace to the class. Namespace allows the grouping of classes to avoid conflict between their names, acting as an encapsulator, that is, its operation is equivalent to that of directories in operating systems, where two files with the same name can not exist in a single directory, but there may be two files with the same name located in different directories.

Notice that the class has comments and some started with @ . These comments serve to standardize and generate automatic documentation for your code, using tools like phpdoc . In addition to the documentation, the comments serve to help programmers who may in the future change their code, making it easier to understand.

Notice that in the class we define the get and set methods for each property. Hence a natural question: Why create methods for accessing variables, if we can access them directly? - For security reasons.

The private variables can only be accessed from within the class, that is, they can not be accessed outside the scope of the class. For example, imagine that within the setIso method we would have a check if the code actually exists; if the property were public , we could simply set any value to the iso property without any validation.

class Pais 
{
     // Propriedade pode ser acessada fora do escopo da classe Pais
     public $iso;
}

$pais = new Pais();
$pais->iso = 'QualquerValorParaIso';

When attempting to access a private property outside the scope of the class, the following error occurs:

class Pais 
{
     // Propriedade não pode ser acessada fora do escopo da classe Pais
     private $iso;
}

$pais = new Pais();
$pais->iso = 'QualquerValorParaIso';

  

Error: Can not access private property lib \ Country :: $ iso (500 Internal Server Error)

Clarified (hopefully) some concepts, we will now create a new file where we will use the class Pais .

test.php

use lib\Pais

$paisA = new Pais();
$paisA
    ->setName('Brasil')
    ->setIso('BRA')
;

$paisB = new Pais();
$paisB
    ->setName('Portugal')
    ->setIso('PRT')
;

$paisC = new Pais();
$paisC
    ->setName('Portugal')
    ->setIso('PRT')
;

The above code generates 3 instances of class Pais , that is, 3 distinct objects independent of each other, each with its scope.

In a very simple way, we can verify that the defined values are equal between objects using the getIso method:

$isoA = $paisA->getIso(); //BRA
$isoB = $paisB->getIso(); //PRT
$isoC = $paisC->getIso(); //PRT

//output: não
echo 'Iso país A==B', $isoA==$isoB ? 'sim':'não';

//output: não
echo 'Iso país A==C', $isoA==$isoC ? 'sim':'não';

//output: sim
echo 'Iso país B==C', $isoB==$isoC ? 'sim':'não';

The above method is ineffective if there is a collection of countries, test all combinations by generating a row for every if or even we may not know how many items there are in the collection, etc ... I used the above method just to demonstrate how to create an instance of the class (which results in an object) and use its methods.

Each case is a case and should be studied in order to be implemented in the best possible way, but for the already good example.

I decided to answer because I disagree a little bit on the other answer, but I make it clear that it does not stop being right either. But the ideal would be to validate input data and have method to compare two countries.

Follow the code, I will not extend much because the code is already intuitive:

Country.php :

<?php

/**
 * Class Pais
 * @author lvcs
 */
class Pais
{
    // Atributos da classe Pais
    private $iso;

    /**
     * Pais constructor, chama o set do ISO, para iniciar a classe já com um atributo,
     * caso não seja passado um parametro no construtor ele será nulo.
     * @param $iso
     */
    public function __construct($iso = null)
    {
        $this->setIso($iso);
    }

    /**
     * Compara dois, países e retorna se são iguais ou diferentes
     * @param $pais - país para comparar
     * @return bool - diferente ou igual
     * @throws Exception - retorna erros
     */
    public function equals($pais)
    {
        try
        {
            if(is_object($pais))
                return ($this->iso === $pais->iso);
            else
            {
                $pais = new Pais($pais);
                return $this->equals($pais);
            }

        }
        catch (Exception $e)
        {
            throw  new Exception("Parametro do método deve ser um objeto país ou um iso válido");
        }

    }

    /**
     * Retorna iso atual da classe
     * @return string
     */
    public function getIso()
    {
        return $this->iso;
    }

    /**
     * Rebece e valida código ISO para adicionar como atributo da classe
     * @param string $iso - novo falor a setar iso
     * @throws Exception - retorna erros
     */
    public function setIso($iso)
    {
        $length = mb_strlen($iso);
        if($length === 3)
            $this->iso = mb_strtoupper($iso);
        else if($length > 3)
            throw new Exception("ISO não pode ter mais de 3 letras.");
        else
            throw new Exception("ISO não pode ter menos de 3 letras.");
    }

}

instanciando.php :

<!doctype html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<?php

    // chama a classe
    require_once 'Pais.php';

    // Diz para o PHP que estamos usando strings UTF-8 até o final do script
    mb_internal_encoding('UTF-8');

    // Diz para o PHP que nós vamos enviar uma saída UTF-8 para o navegador
    mb_http_output('UTF-8');

    /**
     * Tenta criar países, caso tenha falha nisso então pega a mensagem de erro da classe
     * Saída: nenhuma, pois todos isos são válidos
     */
    try
    {
        $pais1 = new Pais("BRA");

        $pais2 = new Pais("EUA");

        $pais3 = new Pais("ITA");

        $pais4 = new Pais("EUA");
    }
    catch (Exception $e)
    {
        echo $e->getMessage();
    }

    /**
     * Tenta criar países, caso tenha falha nisso então pega a mensagem de erro da classe
     * Saída: 'ISO não pode ter menos de 3 letras.'
     */
    try
    {
        $pais5 = new Pais("BR");

        $pais6 = new Pais("IT");
    }
    catch (Exception $e)
    {
        echo $e->getMessage();
    }

    echo '<hr/><br/>';

    try
    {
        //compara país1 com país2 e joga o resultado de equals no método manipulaResultado. Saída: 'Países são diferentes'
        manipulaResultado( $pais1->equals($pais2) );
        echo '<br/>';

        //compara país1 com país2 e joga o resultado de equals no método manipulaResultado. Saída: 'Países são diferentes'
        manipulaResultado( $pais2->equals($pais3) );
        echo '<br/>';

        //compara país1 com país2 e joga o resultado de equals no método manipulaResultado. Saída: 'Países são iguais'
        manipulaResultado( $pais2->equals($pais4) );
        echo '<br/>';

        //compara país1 com país2 e joga o resultado de equals no método manipulaResultado. Saída: 'Países são iguais'
        manipulaResultado( $pais1->equals("BRA") );
        echo '<br/>';

        //compara país1 com país2 e joga o resultado de equals no método manipulaResultado. Saída: 'Parametro do método deve ser um objeto país ou um iso válido'
        manipulaResultado( $pais1->equals("BRASIL") );
        echo '<br/>';
    }
    catch (Exception $e)
    {
        echo $e->getMessage();
    }

    echo '<hr/><br/>';





/**
     * método para comparar se o resultado do método equals é true ou false, caso seja true então 
     * imprime que países são iguais, se não imprime que são diferentes
     * @param $resultado - resultado do método equals
     */
    function manipulaResultado($resultado)
    {
        echo ($resultado) ? "Países são iguais" : "Países são diferentes";
    }

?>

</body>
</html>

Yesterday I started to do and when I read the question, I saw that he wanted everything within the class itself. Then my solution was as follows (remembering that there may be syntax errors, because my computer, for mystical reasons, is unable to install the apache server or the like).

class Pais{
private $nome;
private $iso;
private $pop;
private $lim;
private $dim


public function __construct($nome, $iso, $pop, $lim, $dim){
    $this -> nome = $nome;
    $this -> iso = $iso;
    $this -> pop = $pop;
    $this -> lim = explode(";", $lim);
    //referencia do explode php.net/pt_BR/function.explode.php
    $this -> dim = $dim;
}
public function setNome($nome){
     $this -> nome = $nome;
}
public function getNome(){
    return $this -> nome;
}
public function setISO($iso){
     $this -> iso = $iso;
}
public function getISO(){
    return $this -> iso;
}
public function setPop($pop){
     $this -> pop = $pop;
}
public function getPop(){
    return $this -> pop;
}
public function setLim($lim){
     $this -> lim = explode(";", $lim);
}
public function getLim(){
    return $this -> lim;
}
    public function setDim($dim){
     $this -> dim = $dim;
}
public function getDim(){
    return $this -> dim;
}

public function checaIgualdade($outroPais){
    if($this -> iso == $outroPais){
        echo "Mesmo País";
        unset ($outroPais);
        return 0;
    }
    if($this -> iso != $outroPais){
        echo "Paises diferentes";
        return 1;
    }
}
public function checaLimites($front){
    foreach ($this -> lim as $b => $a){
        if($a == $front){
            echo "Limítrofe.";
            $c = 1;
        }
        else{ 
        $c = 2;
        }
    }
    if($c != 1){
        echo "Não limitrofe.";
    }
}

To explain how to instantiate an object:

$brasil = new Pais("Brasil", "BRA",  200000000, "Argentina, Paraguai", 8516000);
$alemanha = new Pais("Alemanha", "ALE", 80000000, "Polonia, Dinamarca", 357168);

The function that compares works through the return of getIso:

$brasil -> checaIgualdade($alemanha -> getISO());

I think it's correct, but I can not test to be sure.