PHP Programación Orientada a obxectos

Introdución

• Na actualidade empréganse fundamentalmente dúas formas de programación:

• Programación estruturada
• Programación orientada a obxectos.

• A programación estruturada baséase na utilización de 3 estruturas básicas: Secuencial, Condicional e Repetitiva.

En base a estas 3 estruturas podemos 'programar' calquera solución informática.

É un tipo de programación 'orientada' ao procedemento. Programamos pensando nos procesos que imos que ter que aplicar aos datos dos que dispoñemos, para que en base a unha entrada produzamos unha saída.

Vexamos un exemplo.

Imaxinemos que queremos programar unha solución informática para xestionar as contas bancarias.

Partimos de que temos uns datos: un número de conta, un saldo, un titular, unha dirección.

Creamos un programa no que definimos globalmente os datos, por exemplo en forma de array, no que cada elemento do array vai ser unha conta cos datos anteriores. Podemos ler ditos datos dende unha base de datos un dun arquivo.

Isto o faríamos en primeiro lugar utilizando unha estrutura secuencial.

Creamos os procedementos necesarios para tratar ditos datos, pensando no tratamentos que imos dar a ditos datos:

Procedemento de ingresarCartos, ao que mandaríamos como parámetro un número de conta e uns cartos. Buscaríamos dito número de conta no array e aumentaríamos o seus ingresos.

Procedemento de retirarCartos, ao que mandaríamos como parámetro un número de conta e uns cartos. Buscaríamos dito número de conta no array e diminuímos o seus ingresos.

....

• A programación orientada a obxectos, denominada POO, basease no uso de clases e obxectos (instancias de clase) para dar unha solución informática a un problema.

É un tipo de programación 'orientada' ao dato. Programamos pensando na información que dispoñemos e 'modelizamos' ditos datos con clases.

Unha clase vai estar formada por 'variables' ('atributos na POO') e 'procedementos' ('métodos na POO') para tratar os datos gardados nas variables. Se temos unha fábrica de galletas, a clase Galleta sería o molde da galleta. Có molde podemos crear todas as galletas, pero o molde non é ningunha galleta en particular.

O obxecto dunha clase (denominado instancia de clase) ven ser cada un dos datos que queremos gardar na nosa solución informática. Dentro do mesmo código temos os valores que queremos gardar e os métodos que van poder tratar ditos valores. O conxunto dos valores que temos nun obxecto nun momento determinado denomínase estado do obxecto. Seguindo o exemplo da fábrica de galletas, cada obxecto (instancia de clase) ven ser unha galleta.

Na POO obtemos un código máis lexible e reutilizable.

A POO é máis achegada a nosa forma de pensar. Podemos ver calquera cousa do que nos rodea e abstraer as súas propiedades para formar na nosa cabeza a idea de clase.

Así, se vemos un coche podemos abstraer as propiedades de cor, potencia, modelo,...! Acabamos de crear unha clase !. Para esas propiedades podemos crear múltiples instancias (obxectos) que van representar coches diferentes, cada un cuns valores diferentes (estado).

Seguindo o exemplo anterior das contas bancarias...

• Creamos unha clase ContaBancaria que teña as seguintes variables (atributos ou propiedades) e procedementos (métodos):

• Atributos: Número de conta, titular, saldo,...

Métodos:

ingresarCartos

retirarCartos

Ditos métodos non necesitan levar parámetros xa que van tratar os datos que se atopan definidos na mesma clase.

É dicir, se eu creo un obxecto desta clase, por exemplo:

conta1 => NumConta: 1111, Titular: 'Angel', Saldo: 4000

Os métodos que se atopan definidos na clase poden ser utilizados polo obxecto conta1. Ditos métodos van poder acceder aos datos da clase (número de conta e saldo).

• Creamos unha clase Banco, formado por, entre outros atributos, un array de obxectos ContaBancaria. Ese array gardaría todas as contas bancarias dun banco.

• En conclusión:

• Na programación estruturado os datos e os procedementos están separados e sen relación.
• Búscase o procesamento duns datos de entrada para obter unha saída.
• A idea e buscar unha solución informática a un problema pensando no uso de procedementos e funcións como guía.

• Na POO se ten como guía aos datos.
• Primeiro defínense as clases (datos) e despois implantase os métodos (procedementos) que van facer uso destes datos.

Creando clases

• Unha clase é un molde do que despois poderemos crear obxectos.
• As variables que están definidas dentro dunha clase reciben o nome de atributos ou propiedades e as funcións que están definidas dentro dunha clase reciben o nome de métodos. Os métodos da clase son usados para manipular as súas propias propiedades.

• As clases defínense empreñando a palabra clave class seguida do nome da clase e dun bloque de código entre chaves. A sintaxe é a seguinte:

<?php
class SimpleClass
{
    // propiedade
    public string $var = 'valor por defecto';

    // métodos
    public function amosarVar() {
        echo $this->var;
    }
}
?>

• O nome da clase pode comezar por unha letra ou guión baixo seguido de letras, números e guións baixos. Non se pode utilizar ningunha palabra reservada de PHP.
• Como norma, o nome dunha clase comezará cunha letra maiúscula.

Exemplos:

class Pelota {}

class ContaBancaria {}

• Cada clase, aínda que non é obrigatorio, a definiremos nun arquivo php separado que levará o seu nome.

Así, por exemplo, a clase Alumno terá un arquivo de nome Alumno.php

Como norma, a extensión dunha clase será:

• Se seguimos as recomendacións de PHP Standards Recommendations soamente será necesario a extensión php. No exemplo anterior sería Alumno.php. Esta opción es la empleada por los Framweworks de PHP para la carga automática de clases.

Se dentro dunha páxina php necesito utilizar a clase Alumno terei que poñer:

<?php
   require_once('Alumno.php');
?>

Nota: Lembrar as formas que vimos para incluír arquivos externos.

No exemplo estamos a supoñer que o arquivo 'Alumno.php' atópase no mesmo sitio que a clase php que está a facer uso del.

• Vexamos un exemplo de clase:

Arquivo: DiscosDuros.php

<?php

class DiscosDuros {
    public string  $numSerie;
    public string $marca;
    public int $capacidade=1;   // en TB
    
    public function getCapacidadeKB(){
        return $this->capacidade*1024*1024;
    }
}

Como vemos, temos definidos tres atributos, número de serie,marca e capacidade. Por defecto, a capacidade de todos os obxectos que cremos desta clase será de 1TB.

Tamén vemos a definición dun método (getCapacidadeKB) que devolve a capacidade do disco en KB. Dentro deste método sinalar o uso da variable $this.

Nota: Veremos máis adiante o significado do modificador 'public'.

Variable $this

• En todas as linguaxe de POO sempre imos ter unha forma de referenciar a 'instancia' actual dentro do código da clase.

Que significa a 'instancia actual' ?

• Cando cremos obxectos dunha clase, cada obxecto terá os seus datos.

Así, podo crear dúas contas bancarias (dous obxectos):

conta1 => NumConta: 1111, Titular: 'Angel', Saldo: 4000

conta2 => NumConta: 2222, Titular: 'Pepe', Saldo: 2000

Agora, cada obxecto vai poder chamar aos métodos definidos na clase.

Así:

O obxecto conta1 vai poder chamar ao método conta1.devolverSaldo(), o cal, fai un return do saldo (debería devolver 4000)

O obxecto conta2 vai poder chamar ao método conta2.devolverSaldo(), o cal, fai un return do saldo (debería devolver 2000)

Como vemos cada obxecto ten uns datos diferentes pero os dous chaman o mesmo método o cal está definido da mesma forma:

<?php
class ContaBancaria {
    public float $saldo;

    public function devolverSaldo(){
        return $this->saldo;
    }
}
?>

• Coa variable $this podemos 'acceder' aos valores do obxecto que está a facer uso do método. Cando $conta1 chama a dito método, $this e $conta1; cando $conta2 chama ao método, $this é $conta2 cos seus datos específicos.

Rexistrando clases

• Para non ter que repetir un include ao principio de cada páxinas por cada unha das clases que necesitemos, podemos facer uso da autocarga de clases.

Do que se trata é de que cando fagamos uso dunha clase, a páxina PHP a inclúa automaticamente sen ter que facelo nos manualmente. Para iso podemos facer uso da...

• Antigamente se recomendaba que estas clases tivera no nome un sufixo .class da forma NomeClases.class.php.

Na actualidade, se seguimos o [stándard indicado por PSR (PHP Standard Recommendations) https://www.php-fig.org/psr/] xa non é necesario.

Se seguimos o estándard de nomenclatura (PSR-4), as clases levan extensión .php sen empregar .class, da forma: NomeClase.php.

• Función sql-autoload-register.

Exemplo:

<?php
    function cargadorClases($class) {
        require $class . '.php';
    }

    spl_autoload_register('cargadorClases');

?>

Liña 6: Indicamos o nome da función que vai 'cargar' as clases cando non se atopen definidas na páxina actual.

Liñas 2-4: Definimos a función indicada no método 'spl_autoload_register'. Dita función se define cunha parámetro, que vai ser o nome da clase a cargar cando non a atope.

No interior de dita función formamos o nome do arquivo a cargar en base ao nome da clase e o incluímos cunha das formas xa vistas anteriormente.

• Podemos ter o código anterior dentro dun arquivo de include e incluílo por cada páxina que faga uso de clases.

Así:

Arquivo: incluir-clases.php:

<?php
    function cargadorClases($class) {
        require $class . '.php';
    }

    spl_autoload_register('cargadorClases');

Arquivo: DiscoDuros.php

<?php

class DiscosDuros {

    public string $numSerie;
    public string $marca;
    public string $capacidade=1;   // en TB

    public function getCapacidadeKB(): int {
        return $this->capacidade*1024*1024;
    }

}

Páxina exemplo.php.

Vai facer uso da clase DiscosDuros.

<?php
    include 'incluir-clases.php';
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Exemplos de uso de clases</title>
    </head>
    <body>
        <?php
        
            $disco1 = new DiscosDuros();  // Estamos a utilizar a clase DiscosDuros creando un obxecto de dita clase.
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());
            echo "<br />";
            $disco2 = new DiscosDuros();
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());
        ?>
    </body>
    
</html>

Creando obxectos

• Para crear un obxecto dunha clase usaremos a palabra new seguido do nome da clase. Isto devolverá un obxecto (instancia) da clase:

<?php
  $obxecto1 = new Clase();
  $obxecto2 = new Clase();
?>

Nota: Lembrar que para facer uso dunha clase teremos que tela incluída previamente.

• Vexamos un exemplo:

<?php
    function cargadorClases($class) {
        require $class . '.php';
    }

    spl_autoload_register('cargadorClases');

?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Exemplos de uso de clases</title>
    </head>
    <body>
        <?php
        
            $disco1 = new DiscosDuros();
            $disco2 = new DiscosDuros();
        ?>
    </body>
    
</html>

Nota: A partires de agora faremos un include do controlador que carga as clases cando se necesitan.

Accedendo as propiedades e métodos das clases

• Unha vez que temos un obxecto dunha clase xa podemos acceder as súas propiedades e métodos.

Para iso temos que utilizar o operador -> desta forma:

 obxecto1->propiedade;
 obxecto1->nomeMétodo();

• Vexamos un exemplo:

        <?php
            $disco1 = new DiscosDuros();
            $disco1->numSerie="1111A";
            $disco1->marca="Seagate";
            echo "<br />";
            printf("NUM.SERIE %s",$disco1->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco1->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());

            $disco2 = new DiscosDuros();
            $disco2->numSerie="2222B";
            $disco2->marca="Hitachi";
            echo "<br />";
            printf("NUM.SERIE %s",$disco2->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco2->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());
        ?>

• Esta forma de acceder tamén pode empregarse dentro da clase para acceder aos seus propio métodos e atributos, pero utilizando a palabra reservada '$this'.
• Vexamos un exemplo:

<?php

class DiscosDuros {
    public string $numSerie;
    public string $marca;
    public int $capacidade=1;   // en TB
    
    public function getCapacidadeKB(): int {
        return $this->capacidade*1024*1024;
    }
    public function getCapacidadeBytes(): int {
        return $this->getCapacidadeKB()*1024;
    }
    
    public function getMarca(): string {
        return $this->marca;
    }
}

• A este tipo de propiedades/métodos soen denominarse 'de instancia'.

Cada obxecto ten un valor gardado diferente ao dos demais.

Fai os exercicios indicados neste punto. Solamente os da sección 'Definición de clases. Creación de obxectos e acceso a variables e métodos'.

Mantemento do estado

• Para poder gardar un obxecto de forma persistente (que non se perda a información que ten e poidamos recuperala) é necesario 'transformalo' a unha cadea de texto que contén un fluxo de bytes, nun proceso que se chama serialización.

Isto é necesario xa que cando gardamos algo (nunha base de datos, ou nunha variable de sesión) é necesario que dita información pertenza a un tipo de datos, pero un obxecto está formado por propiedades con diferentes tipos de datos.

• O procedemento é moi sinxelo:

• Para convertilo empregamos a función serialice() da forma: $s = serialice($a); sendo $a un obxecto dunha clase.

Agora podemos gardar $s nunha base de datos por exemplo.

• Para volvelo a convertir a un obxecto dunha clase, empregamos a función unserialice() da forma: $a = unserialice($s); sendo $s o obxecto previamente serializado.

• No caso das variables de sesión, PHP xa serializa/deserializa un obxecto e non necesitamos empregar as funcións anteriores.

Por exemplo:

session_start();
$_SESSION['producto'] = $p;


......



$p = $_SESSION['producto'];

Herdanza

• Na POO existen tres propiedades fundamentais: Herdanda, Polimorfismo e Encapsulación.

• O concepto de herdanza é moi parecido ao que temos nos. Cando creamos unha clase que herda doutra, dita clase poderá acceder ás propiedades e métodos da clase pai.

A clase pai denomínase superclase e a clase filla subclase.

• A sintaxe é a seguinte:

 class Pai {
   public string $var1;
   public string $var2;
  
   public function imprimirVar1(): void {
     echo string $var1;
   }
 }
 class Filla extends Pai {
   public string $var3;
   public function imprimirVar3(): void {
     echo $var3;
   }
 }

• Liña 9: A clase Filla é subclase da clase Pai pola palabra clave extends.

• Se agora creamos un obxecto da clase Filla, poderemos acceder aos atributos e métodos da clase pai. Así:

  $filla1 = new Filla();

  $filla1->var1='valor';
  $filla1->imprimirVar1();
  $filla1->var3=55;
  $filla1->imprimirVar3();

Nota: Cando vexamos os modificadores de visibilidade (public, protected, privated) veremos que unha subclase herda as propiedades e métodos declarados como public ou protected).

• A herdanza permite reutilizar eficientemente o código da clase base.

• Vexamos un exemplo cos discos creados anteriormente.

• Nunha tenda adicada aos compoñentes informáticos podemos ter discos duros, pantallas, procesadores,...

Podemos crear unha clase Compoñente que teñas as propiedades comúns a todos eles (prezo, nome, num_serie,...)

• Exemplo de herdanza:

Arquivo: Componentes.php

<?php

class Componentes {
    public string $numSerie;
    public string $nome;
    public float $prezo;
    public string $marca;


    public function getNumSerie(): string {
        return $this->numSerie;
    }
    public function getNome(): string {
        return $this->nome;
    }
    public function getPrezo(): float {
        return $this->prezo;
    }
    public function getMarca(): string {
        return $this->marca;
    }

}

Arquivo: DiscosDuros.php

<?php

class DiscosDuros extends Componentes{
    public int $capacidade=1;   // en TB

    public function getCapacidadeKB(): int {
        return $this->capacidade*1024*1024;
    }
    public function getCapacidadeBytes(): int {
        return $this->getCapacidadeKB()*1024;
    }

}

Arquivo: principal.php

<?php
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);  // Non debería ser necesario xa que amosa posibles erros de configuración no php.ini ou erros antes da execución do script, pero podemos poñelo por se acaso.
error_reporting(E_ALL);

include 'incluir-clases.php';
?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">

    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Exemplos de uso de clases</title>
    </head>
    <body>
        <?php
            $disco1 = new DiscosDuros(); // Tamén ten o da clase Compoñente
            $disco1->numSerie="1111A";
            $disco1->marca="Seagate";
            $disco1->prezo=100.23;
            echo "<br />";
            printf("NUM.SERIE %s",$disco1->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco1->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());
            echo "<br />";
            printf("PREZO %s euros",number_format($disco1->getPrezo(),2));
 
            $disco2 = new DiscosDuros();
            $disco2->numSerie="2222B";
            $disco2->marca="Hitachi";
            $disco2->capacidade=5;
            $disco2->prezo=150.73;
            echo "<br />";
            printf("NUM.SERIE %s",$disco2->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco2->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());            
            echo "<br />";
            printf("PREZO %s euros", number_format($disco2->getPrezo(),2));
        ?>
    </body>
</html>

Resultado:

NUM.SERIE 1111A
MARCA 0.000000
CAPACIDADE 1048576 EN KB
PREZO 100.23 euros

NUM.SERIE 2222B
MARCA Hitachi
CAPACIDADE 5242880 EN KB
PREZO 150.73 euros

Nota: Se queres imprimir todos os datos dun obxecto podedes empregar a función var_dump(obxecto).

Facede os exercicios indicados neste punto. Soamente os da sección 'Herdanza'.

Construtores

• O construtor é un método 'especial' que se chama de forma automática cando creamos un obxecto dunha clase, é dicir, cando empregamos a instrución new

Utilízase sobre todo para mandar valores iniciais a un obxecto creado.

• A forma de definir un construtor é:

void __construct ([ mixed $args = "" [, $... ]] )

Nota: A diferenza de Java non podemos ter definidos varios construtores con diferentes parámetros.

• Aplicamos este concepto ao exercicio anterior:

Arquivo: Componentes.php

    <?php

    class Componentes {
        public string $numSerie;
        public string $nome;
        public float $prezo;
        public string $marca;


        function __construct(string $numSerie, string $nome, float $prezo, string $marca) {
            $this->numSerie=$numSerie;
            $this->nome=$nome;
            $this->prezo=$prezo;
            $this->marca=$marca;
        }
     .................

Arquivo: Principal.php

        <?php
            $disco1 = new DiscosDuros("1111A","Disco Duro",100.23,"Seagete"); // Tamén ten o da clase Compoñente
            $disco1->capacidade=1;
            echo "<br />";
            printf("NUM.SERIE %s",$disco1->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco1->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());
            echo "<br />";
            printf("PREZO %s euros",number_format($disco1->getPrezo(),2));
 
            echo "<br />";
            echo "<br />";
            $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi");
            $disco2->capacidade=5;
            echo "<br />";
            printf("NUM.SERIE %s",$disco2->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco2->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());            
            echo "<br />";
            printf("PREZO %s euros", number_format($disco2->getPrezo(),2));
        ?>
    </body>

Fixarse como o construtor está definido na clase Componentes, xa que é aí onde están definidos os atributos da clase.

• Como vemos, falta o atributo capacidade, pero ese atributo é específico da clase DiscoDuros. Polo tanto imos crear un construtor en dita clase, que vai ter como parámetros todos os anteriores máis o atributo 'capacidade'.

A pregunta é, se xa temos na clase superior (superclase) un construtor que asina os atributos aos valores enviados ao construtor, non hai forma de chamar a dito construtor dende a clase filla ?

A resposta é afirmativa: parent::__construct()

Apliquemos isto ao exemplo anterior:

Arquivo: DiscoDuros.php

<?php
class DiscosDuros extends Componentes{
    public int $capacidade=1;   // en TB
 
    function __construct(string $numSerie, string $nome, float $prezo, string $marca, int $capacidade) {
        parent::__construct($numSerie, $nome, $prezo, $marca);
        $this->capacidade=$capacidade;
    }
    public function getCapacidadeKB(): int {
        return $this->capacidade*1024*1024;
    }
    public function getCapacidadeBytes(): int {
        return $this->getCapacidadeKB()*1024;
    }
 
}

• Liña 5: Definimos un construtor con todos os atributos que espera a clase DiscoDuros.
• Liña 6: Chamamos ao construtor da clase pai utilizando a palabra clave 'parent::'
• Liña 7: Asinamos á variable $capacidade o valor enviado como parámetro no construtor.

Arquivo: Principal.php

        <?php
            $disco1 = new DiscosDuros("1111A","Disco Duro",100.23,"Seagete",1); // Tamén ten o da clase Compoñente
            echo "<br />";
            printf("NUM.SERIE %s",$disco1->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco1->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());
            echo "<br />";
            printf("PREZO %s euros",number_format($disco1->getPrezo(),2));
 
            echo "<br />";
            echo "<br />";
            $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);
            echo "<br />";
            printf("NUM.SERIE %s",$disco2->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco2->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());            
            echo "<br />";
            printf("PREZO %s euros", number_format($disco2->getPrezo(),2));
        ?>

Fixarse como agora no 'new' dos obxectos enviamos todos os valores, incluído a capacidade.

Como implementar varias construtores

• En Java podemos ter varios construtores á vez definidos, de tal forma que un deles diferénciase doutro polo número ou tipo de argumentos.

Isto en PHP non o podemos facer.

Para solucionalo, temos que empregar un único constructor no que imos obter o número de parámetros que enviamos e en función diso, inicializaremos as propiedades correspondentes.

As funcións que temos que empregar dentro de __construct son:

• Función func_get_args() que nos devolve nun array os parámetros enviados ao constructor.
• Función func_num_args() que nos devolve o número de parámetros do constructor.

• Unha forma sinxela de facelo sería o seguinte:

class Proba
{
 $atrib1;
 $atrib2;

 function __construct() {
      $args = func_get_args();
      $num = func_num_args();
      switch ($num) {
            case 0: // Chamamos ao constructor sen parámetros
                $this->$atrib1 = 10;
                $this->$atrib2 = 10;
                break;
            case 1:  // Chamamos ao constructor con 1 parámetro
                $this->atrib1= func_get_arg(0); // Os argumentos empezan en 0
                $this->atrib2 = 10;  // Valor por defecto
                break;
            case 2: // Chamamos ao constructor con 2 parámetros
                $this->atrib1= func_get_arg(0);
                $this->atrib2= func_get_arg(1);
        }

    }
}

Outra forma máis complexa (código obtido deste enlace) a podemos implementar có seguinte código:

    function __construct()
       {
           $a = func_get_args();
           $i = func_num_args();
           if (method_exists($this,$f='__construct'.$i)) {
               call_user_func_array(array($this,$f),$a);
           }
       }

O que vai facer este código é chamar a un procedemento de nome __constructXX sendo XX o número de argumentos.

Así se eu crea un obxecto dunha clase no que quero enviar dous argumentos poñería:

 $obx1 = new Clase($val1,$val2);

Isto chamará a o construtor por defecto o cal chamará a outro método:

 function __construct2($par1,$par2){
 }

Fixarse como o nome do método acaba en 2 que se corresponde có número de argumentos.

• Poderíamos aplicar isto ao exemplo dos DiscosDuros, de tal forma que podemos ter dous construtores, un cun os cinco parámetros e outro no que a capacidade colla un prezo por defecto.

Arquivo: DiscoDuros.php

<?php

class DiscosDuros extends Componentes{
    public int $capacidade=1;   // en TB

    
    function __construct() {
      $args = func_get_args();
      $num = func_num_args();
      switch ($num) {   //ORDEN CONSTRUCTOR SUPERIOR => $numSerie,$nome,$prezo,$marca 
            case 3: // Enviamos 3 datos: num_serie (arg(0)), nome (arg(1)) e marca (arg(2))
                parent::__construct(func_get_arg(0), func_get_arg(1), 500, func_get_arg(2));  // Enviamos un prezo por defecto en caso de non enviar o dato
                $this->capacidade = 100;    // Podemos dar un valor por defecto ao dato non enviado
                break;
            case 4:  // Enviamos 4 datos: num_serie (arg(0)), nome (arg(1)), marca (arg(2)) e capacidade (arg(3))
                parent::__construct(func_get_arg(0), func_get_arg(1), 0, func_get_arg(2));  // Neste caso enviamos 0 como prezo por defecto
                $this->capacidade = func_get_arg(3);
                break;
            case 5:  // Chamamos ao constructor con 5 parámetros: num_serie (arg(0)), nome (arg(1)), prezo (arg(2)), marca (arg(3)) e capacidade (arg(4))
                parent::__construct(func_get_arg(0), func_get_arg(1), func_get_arg(2),func_get_arg(3));
                $this->capacidade = func_get_arg(4);
                break;
        }
    }

    public function getCapacidadeKB(): int{
        return $this->capacidade*1024*1024;
    }
    public function getCapacidadeBytes(): int{
        return $this->getCapacidadeKB()*1024;
    }

}

• Agora podemos chamar aos dos construtores:

   $disco1 = new DiscosDuros("1111A","Disco Duro","Seagete",2); 
   $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);

Constructores en clases fillas

• Cando temos unha xerarquía de clases en forma de herdanza, cando unha clase filla define un constructor ten que chamar explícitamente ao constructor da clase pai coa forma: parent::__construct(parámetros).

Por exemplo:

Clase Pai:

class ArchivoBase {
    protected $handle;

    public function __construct($ruta) {
        echo "Abriendo archivo...\n";
        $this->handle = fopen($ruta, 'w');
    }

    public function escribir($texto) {
        fwrite($this->handle, $texto . "\n");
    }

}

Clase filla:

class Logger extends ArchivoBase {

    public function __construct($ruta) {
        echo "Logger iniciado\n";
        parent::__construct($ruta);
    }

    public function log($mensaje) {
        $this->escribir($mensaje);
    }
 
}

Facede os exercicios indicados neste punto. Soamente os da sección 'Constructores'.

Destructores

• Ao igual que os construtores tamén dispoñemos dun método 'especial' denominado destrutor o cal se chama cando se deixa de ter referencias a un obxecto.

Cando remata o script todas as referencias pérdense e polo tanto se chamará ao método __destruct.

Non temos control sobre 'cando' se vai chamar a dito método.

Normalmente o empregaremos nos exemplos para levar constancia de 'cantos' obxectos creamos dunha clase por darlle unha funcionalidade nos nosos exemplos, pero sen ten un control de cando se chama non o empregaremos nunha situación real.

Normalmente se emprega para liberar recursos ou facer algún tipo de log para cando se destrúa un obxecto.

Vexamos un exemplo:

Arquivo: Componentes.php

    <?php

    class Componentes {
        static int $numComponentes = 0;
        
        public string $numSerie;
        public string $nome;
        public float $prezo;
        public string $marca;


        function __construct(string $numSerie, string $nome, float $prezo, string $marca) {
            $this->numSerie=$numSerie;
            $this->nome=$nome;
            $this->prezo=$prezo;
            $this->marca=$marca;
        }
    
        public function getNumSerie(): string{
            return $this->numSerie;
        }
        public function getNome(): string{
            return $this->nome;
        }
        public function getPrezo(): float{
            return $this->prezo;
        }
        public function getMarca(): string{
            return $this->marca;
        }
        function __destruct(){
            echo "<br />Acabouse";
        }

    }

        <?php
            $disco1 = new DiscosDuros("1111A","Disco Duro","Seagete",2); // Tamén ten o da clase Compoñente
            echo "<br />";
            printf("NUM.SERIE %s",$disco1->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco1->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco1->getCapacidadeKB());
            echo "<br />";
            printf("PREZO %s euros",number_format($disco1->getPrezo(),2));

            echo "<br />";
            $disco1=null;
            echo "<br />";
            echo "Segundo disco";
            echo "<br />";
            $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);
            echo "<br />";
            printf("NUM.SERIE %s",$disco2->numSerie);
            echo "<br />";
            printf("MARCA %s",$disco2->marca);
            echo "<br />";
            printf("CAPACIDADE %s EN KB",$disco2->getCapacidadeKB());            
            echo "<br />";
            printf("PREZO %s euros", number_format($disco2->getPrezo(),2));
        ?>

Dará como resultado:

NUM.SERIE 1111A
MARCA Seagete
CAPACIDADE 2097152 EN KB
PREZO 100.00 euros
Acabouse
Segundo disco

NUM.SERIE 2222B
MARCA Hitachi
CAPACIDADE 6291456 EN KB
PREZO 150.73 euros Acabouse

Destructores en clases fillas

• Ao igual que no caso dos constructores, se temos unha xerarquía de clases relacionadas pola herdanza, se sobreescribimos un __destruct dunha filla, esta debe chamar explicitamente ao __destruct da clase pai para que se execute.

Por exemplo:

Clase Pai:

class ArchivoBase {
    protected $handle;

    public function __construct($ruta) {
        echo "Abriendo archivo...\n";
        $this->handle = fopen($ruta, 'w');
    }

    public function escribir($texto) {
        fwrite($this->handle, $texto . "\n");
    }

    public function __destruct() {
        echo "Cerrando archivo...\n";
        fclose($this->handle);
    }

}

Clase filla:

class Logger extends ArchivoBase {

    public function __construct($ruta) {
        echo "Logger iniciado\n";
        parent::__construct($ruta);
    }

    public function log($mensaje) {
        $this->escribir($mensaje);
    }

    public function __destruct() {
        echo "Logger destruido\n";
        parent::__destruct(); 
    }
}

Polimorfismo e Sobrecarga

Polimorfismo

• Outra das propiedades da POO é o Polimorfismo.

Normalmente o polimorfismo dáse en clases que manteñan unha relación de herdanza, aínda que tamén se pode dar en outro tipo de relacións (por exemplo utilizando interfaces).

Basicamente, é a capacidade que teñen as clase de definir métodos có mesmo nome e o mesmo número (e tipo en outras linguaxes) de argumentos.

Cando un obxecto chame a dito método ou use unha propiedade, saberá que método/propiedade utilizar en base a súa pertenza a un tipo de clase determinado.

• Vexamos un exemplo aplicado ao caso dos DiscosDuros.

Imaxinemos que creamos un método de nome 'comprobarDatos' que o que fai é que no caso dos DiscosDuros, mira que a capacidade teña un valor positivo e no caso dos Compoñenetes, o prezo teña un valor positivo. Devolverá 1 ou 0 dependendo do valor.

Se eu creo un obxecto da clase DiscosDuros e chamo a dito método, chamará ao definido na clase DiscosDuros por pertencer a ela. Dende a clase DiscosDuros vou poder chamar ao método da clase superior utilizando a expresión parent::.

Arquivo: DiscosDuros.php

<?php

class DiscosDuros extends Componentes{

    .........
    public function comprobarDatos(): bool {
        if (parent::comprobarDatos()==0) return false;
        if ($this->capacidade < 0) {
            echo "<br />Capacidade negativa !!!<br />";
            return false;
        } else {
            return true;
        }
    }
}

Arquivo: Componentes.php

<?php
    class Componentes {
        ...................
        public function comprobarDatos(): bool {
            if ($this->prezo<0) {
                echo "<br />Prezo negativo!!!<br />";
                return false;
            }
            else {
                return true;
            }
        }

    }

Arquivo: principal.php

<?php
            $disco1 = new DiscosDuros();
            $disco1->prezo=-100;
            $disco1->capacidade=10;
            printf("O Prezo é negativo. Datos correctos?:%b",$disco1->comprobarDatos());
            $disco1->prezo=100;
            $disco1->capacidade=-10;
            printf("Capacidade negativa. Datos correctos?:%b",$disco1->comprobarDatos());
?>

Saída:

Prezo negativo!!!
O Prezo é negativo. Datos correctos?:0
Capacidade negativa !!!
Capacidade negativa. Datos correctos?:0

Sobrecarga

• Dicimos que un método está sobrecargado se está definido dúas ou máis veces nunha clase e se diferenza un doutro polo número (e tipo en outras linguaxes) de argumentos.

En PHP non podemos ter sobrecarga de métodos xa que non deixa ter definidos varios métodos có mesmo nome.

Un 'apaño' que podemos facer é o seguinte (parecido ao que fixemos cos construtores):

<?php
class Proba {
    function __call($method_name, $arguments) {
           $i = count($arguments);
           if (method_exists($this,$f=$method_name.$i)) {
               call_user_func_array(array($this,$f),$arguments);
           }
    }
    private function metodo1($a){
        echo "<br />Chamada a 'metodo' cun argumento";
    }
    private function  metodo2($a,$b){
        echo "<br />Chamada a 'metodo' con dous argumentos";;
    }
}

<?php

  $p1 = new Proba();

  $p1->metodo(1);
  $p1->metodo(1,'Proba');
?>

Dará como resultado:

Chamada a 'metodo' cun argumento
Chamada a 'metodo' con dous argumentos

• No exemplo estamos a utilizar a función __call.

Esta é unha función especial que se chama cando un obxecto chama a unha función que non estea definida. Recibe como datos o nome da función e os parámetros enviados na súa chamada.

Nota: Fixarse que as funcións están declaradas como 'private' para que dende a páxina que faga uso da clase non aparezan os métodos (en forma de axuda) no IDE de PHP cando tecleamos o nome do obxecto. Veremos a continuación a encapsulación.

Atributos e Métodos de clase

• Un método/atributo de clase pode ser chamado/usado sen necesidade de instanciar un obxecto.

Chámase directamente dende o nome da clase.

O concepto de clase o podemos asociar ao de variables globais nun programa tradicional.

Se as variables dos obxectos son variables (atributos) 'locais' a cada un, é dicir, cada obxecto ten un valor propia para cada atributo da clase, nas variables de clase (estáticas) todos os obxectos teñen o mesmo valor, xa que fisicamente están apuntando á mesma dirección de memoria.

Se un obxecto cambia o valor dun atributo de clase, se cambia para todos os obxectos.

• Para declarar unha variable ou método de clase, debemos antepoñer a palabra reservada static.

Para acceder a unha variable dende fora da clase debemos de poñer: Clase::$variableClase, sendo Clase o nome da clase.

Vexamos un exemplo:

class Clase {
  static $variableStatic = 10;
}

  
  echo Clase::$variableStatic;

• Ao igual que os atributos, podemos crear métodos de clase.

Para acceder dende un método (de clase ou static) a un atributo static temos que facer uso da palabra clave: self:: cando estamos dentro da clase

Vexamos un exemplo:

class Clase {
  static int $variableStatic = 10;

  static function metodoStatic(): void {
     echo self::$variableStatic;
  }
  function metodo(): void {
     echo self::$variableStatic;
  }

}

  Clase::metodoStatic(); // Chama ao método de clase
  $ob1 = new Clase();
  $obj1->metodo();  // Chama ao método e este accede á variable de clase.

Fixarse como para chamar a un método de clase usamos a forma: Clase::métodoClase()

• Vexamos agora un exemplo de aplicación no exemplo dos DiscosDuros.

Podemos crear unha variable de clase que garde o número de discos duros/compoñentes creados.

Cada vez que eu creo un compoñente aumentarei o número e se o destrúo (non teño ningunha referencia) diminúo o contador. Farei o mesmo para a clase DiscosDuros e ademais crearei un método de clase que me amose o número total (de todos os compoñentes) e o número de discos duros.

• Solución:

Arquivo: Componentes.php

    <?php

    class Componentes {
        static int $numComponentes = 0;
        
        public string $numSerie;
        public string $nome;
        public float $prezo;
        public string $marca;


        function __construct(string $numSerie,string $nome,float $prezo,string $marca) {
            $this->numSerie=$numSerie;
            $this->nome=$nome;
            $this->prezo=$prezo;
            $this->marca=$marca;
            
            self::$numComponentes+=1;
        }
        static function imprimirTotal(): void{
        
            printf("Número de compoñentes:%d<br />",self::$numComponentes);
        }

    
        public function getNumSerie(): string{
            return $this->numSerie;
        }
        public function getNome(): string{
            return $this->nome;
        }
        public function getPrezo(): float{
            return $this->prezo;
        }
        public function getMarca(): string{
            return $this->marca;
        }
        function __destruct(){
            self::$numComponentes-=1;
        }

    }

Arquivo: DiscosDuros.php

<?php

class DiscosDuros extends Componentes{
    public int $capacidade=1;   // en TB
    public static int $numDiscosDuros=0;


    
    function __construct() {
      self::$numDiscosDuros+=1;
      $args = func_get_args();
      $num = func_num_args();
      switch ($num) {   //ORDEN CONSTRUCTOR SUPERIOR => $numSerie,$nome,$prezo,$marca 
            case 3: // Enviamos 3 datos: num_serie (arg(0)), nome (arg(1)) e marca (arg(2))
                parent::__construct(func_get_arg(0), func_get_arg(1), 500, func_get_arg(2));  // Enviamos un prezo por defecto en caso de non enviar o dato
                $this->capacidade = 100;    // Podemos dar un valor por defecto ao dato non enviado
                break;
            case 4:  // Enviamos 4 datos: num_serie (arg(0)), nome (arg(1)), marca (arg(2)) e capacidade (arg(3))
                parent::__construct(func_get_arg(0), func_get_arg(1), 0, func_get_arg(2));  // Neste caso enviamos 0 como prezo por defecto
                $this->capacidade = func_get_arg(3);
                break;
            case 5:  // Chamamos ao constructor cun parámetro
                parent::__construct(func_get_arg(0), func_get_arg(1), func_get_arg(2),func_get_arg(3));
                $this->capacidade = func_get_arg(4);
                break;
        }
    }

    static function imprimirTotal(): void{
        Componentes::imprimirTotal();
        printf("Número de compoñentes:%s<br />",self::$numComponentes);
        printf("Número de discos:%s<br />",self::$numDiscosDuros);
        
    }

    public function comprobarDatos(): bool{
        if (!parent::comprobarDatos()) return false;
        if ($this->capacidade < 0) {
            echo "<br />Capacidade negativa !!!<br />";
            return false;
        } else {
            return true;
        }
    }

    public function getCapacidadeKB(): float{
        return $this->capacidade*1024*1024;
    }
    public function getCapacidadeBytes(): float{
        return $this->getCapacidadeKB()*1024;
    }

    function __destruct(){
        parent::__destruct();
        self::$numDiscosDuros-=1;
    }
    
}

Arquivo: principal.php:

        <?php
        
        
            echo "<br />";
            echo "Primeiro disco";
            echo "<br />";
            $disco10 = new DiscosDuros("1111A","Disco Duro","Seagete",2); // Tamén ten o da clase Compoñente
            echo DiscosDuros::imprimirTotal();
            
            $disco10=null;
            echo "<br />";
            echo "Primeiro disco borrado";
            echo "<br />";
            echo DiscosDuros::imprimirTotal();
            $disco12 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);
            $disco13 = new DiscosDuros("3333B","Disco Duro",150.73,"Hitachi",6);
            $disco14 = new DiscosDuros("4444B","Disco Duro",150.73,"Hitachi",6);
            echo "<br />";
            echo "Tres novos discos";
            echo "<br />";
            echo DiscosDuros::imprimirTotal();
        ?>

Facede os exercicios indicados neste punto. Soamente os da sección 'Atributos e métodos de clase'.

Constantes

• Un pouco relacionado co punto anterior, temos as constantes.

Son valores fixos establecidos na definición da clase, que non se poden modificar en tempo de execución.

• Para declarar unha constante no interior dunha clase usamos a palabra reservada const antes do nome da constante que non debe levar o caracter $.

Como norma, o nome de constante debe estar en en maiúsculas para diferenciar facilmente unha constante dunha variable.

class Clase {

   const NUM_MAXIMO=1000;  // A partires de php 7.1 se pode poñer public ou private
}

• Por defecto a constante é pública se non poñemos modificador ningún (como calquera variable). Podemos establecer os modificadores de protected e private.

• Para acceder á constante podemos facelo como se fora un atributo estático (polo tanto, na memoria está a ocupar unha posición que é compartida por todos os obxectos, como sucede nas variables de clase). Podemos acceder directamente utilizando o nome da clase ou a través dun obxecto da forma:

 $a = new Clase();

 echo $a::NUM_MAXIMO;
 echo Clase::NUM_MAXIMO;

Constantes predefinidas en PHP

• Tedes neste enlace algunhas constantes que vos poden servir na programación PHP.

• De todas elas, vos pode axudar na programación en PHP (sobre todo en aloxamentos compartidos de Internet):

• __FILE__: Ruta completa e nome do arquivo. Usado dentro dun INCLUDE devolverá o nome do ficheiro do INCLUDE.
• __DIR__: Directorio do ficheiro. Usado dentro dun INCLUDE, devolverá o directorio do arquivo incluído.

Por que ?

Se estades nun aloxamento compartido cun CMS (como o Wordpress que utilizamos na práctica e queredes facer un include dun arquivo php, dando a ruta absoluta do voso aloxamento, teredes que averiguar dita ruta. Unha das formas é facendo un echo dunha das constantes anteriores dende un Post ou páxina do CMS.

Encapsulación

• Outra das propiedades da POO é a Encapsulación.

Mediante dita propiedade 'obrigamos' a que o uso dos datos e métodos se fagan de acordo ao implementado polo programador.

Ocúltanse (a o que vai facer uso da clase) aqueles métodos e propiedades que non vai ter que utilizar e evítase que os datos poidan ter valores non válidos.

En definitiva, a encapsulación é un mecanismo no que organizamos os datos e métodos de tal forma que evitamos o acceso a os datos de calquera outra forma diferente á especificada. A encapsulación garante a integridade dos datos que contén un obxecto.

• A encapsulación impleméntase cunha destas tres palabras clave:

• Público(public): é o modificador por defecto, co cal se non poñemos nada enténdese que o modificador é public. Calquera pode acceder ás propiedades e métodos declarados como public.
• Privado(private): o acceso as propiedades e métodos declarados como private están restrinxidos a clase na que foron creados.
• Protexido(protected): unicamente poden acceder a estas propiedades e métodos a propia clase e as súas clases derivadas, é dicir, clases que sexan 'fillas' da clase onde o atributo/método estea declarado como protected.

Estes modificadores van poder ser aplicados tanto a propiedades como a métodos.

Vexamos un exemplo aplicado ao caso dos DiscosDuros...

Supoñamos que cando creo un DiscoDuro e doulle un prezo, quero que en función da capacidade aplique un desconto ou outro. Isto o fai un método que non quero que sexa 'visible' fora do código da clase.

Polo tanto terei que declaralo como 'private'. Como o desconto o vou poder aplicar a todos os compoñentes, o vou definir na clase Componentes, e o vou facer 'protected' para que o poida referenciar a subclase 'DiscosDuros' pero que non poida acceder directamente dende fora da clase Componentes.

Arquivo: Componentes.java

<?php

class Componentes {
    static int $numComponentes = 0;

    public string $numSerie;
    public string $nome;
    public float $prezo;
    public string $marca;

    protected float $desconto=0;

    function __construct(string $numSerie, string $nome, float $prezo, string $marca) {
        $this->numSerie=$numSerie;
        $this->nome=$nome;
        $this->prezo=$prezo;
        $this->marca=$marca;

        self::$numComponentes+=1;
    }

    public function getDesconto(): float{
        return $this->desconto;
    }

    ......................

Arquivo: DiscosDuros.php

<?php

class DiscosDuros extends Componentes{
    public int $capacidade=1;   // en TB

    function __construct(string $numSerie, string $nome, float $prezo, string $marca, int $capacidade) {
        parent::__construct($numSerie, $nome, $prezo, $marca);
        $this->capacidade=$capacidade;
        
        if($capacidade>5){
            $this->desconto=10; // Faremos un desconto dun 10%
        } else {
            $this->desconto=3;  // Faremos un desconto dun 3%
        }
    }
    ................

Arquivo: principal.php

        <?php
  
           $disco1 = new DiscosDuros("1111A","Disco Duro",100.23,"Seagete",1); // Tamén ten o da clase Compoñente
            echo "<br />";
            printf("DISCO 1 DESCONTO %.2f%%",$disco1->getDesconto());
 
            echo "<br />";
            echo "<br />";
            $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);
            printf("DISCO 2 DESCONTO %.2f%%",$disco2->getDesconto());
        ?>

Dará como resultado:

DISCO 1 DESCONTO 3%

DISCO 2 DESCONTO 10%

• Fixarse como a única forma de acceder a unha variable 'private' dende o exterior de dita clase, é a través dun método (no exemplo 'getDesconto')

Protexendo os atributos

• Normalmente, na POO imos querer que as propiedades dunha clase non poidan ser accedidas directamente, xa que imos querer ter un 'control' sobre os valores asinados.

A forma de realizar este control é que a asignación de valores se faga a través dun método, no que comprobamos o valor a asignar. Isto xa o podemos facer no construtor, pero se queremos modificar os valores durante a execución do programa, teremos que facer que os atributos sexan privados e crear os métodos para asinar os valores.

• Nota: Noutras linguaxes coñecense como métodos get (obter o valor dun atributo) e métodos set(darlle un valor a un atributo).

Inicialmente poderíamos facer algo parecido a isto (aplicado ao exemplo dos DiscosDuros e Componentes)

Arquivo: DiscosDuros.php

<?php

class DiscosDuros extends Componentes{
    private int $capacidade=1;   // en TB

    function __construct(string $numSerie, string $nome, float $prezo, string $marca, int $capacidade) {
        parent::__construct($numSerie, $nome, $prezo, $marca);
        $this->capacidade=$capacidade;
        
        if($capacidade>5){
            $this->desconto=10; // Faremos un desconto dun 10%
        } else {
            $this->desconto=3;  // Faremos un desconto dun 3%
        }
        
    }
    public function setCapacidade(int $novoValor): bool {. // Se non necesito informar podo poñer void e non facer o return
        if ($novoValor<0) { // Non deixamos unha capacidade negativa
            return false;
        }
        else {
            $this->capacidade=$novoValor;
            return true;
        }
    }
    public function getCapacidade(): int{
        return $this->capacidade;
    }

• Liña 4: Declaramos a capacidade como privada.
• Liñas 17-25: Definimos un método cambiarCapacidade que vai comprobar se a capacidade é negativa. Se o é, retorna 0. En caso contrario, cambia a capacidade e retorno 1
• Liñas 26-28: Definimos un método para que devolva a capacidade.

Arquivo: principal.php

        <?php
  
           $disco1 = new DiscosDuros("1111A","Disco Duro",100.23,"Seagete",1); // Tamén ten o da clase Compoñente
            echo "<br />";
            if ($disco1->setCapacidade(4)){
                echo "Capacidade cambiada <br />";
                printf("Nova capacidade Disco 1:%d",$disco1->getCapacidade());
            }
            else {
                echo "A capacidade do DISCO 1 non pode ser negativa";
            }
            
            echo "<br />";
            echo "<br />";
            $disco2 = new DiscosDuros("2222B","Disco Duro",150.73,"Hitachi",6);
            if ($disco1->setCapacidade(-2)){
                echo "Capacidade cambiada <br />";
                printf("Nova capacidade Disco 2:%d",$disco1->getCapacidade());
            }
            else {
                echo "A capacidade do DISCO 2 non pode ser negativa";
            }

Da como resultado:

Capacidade cambiada
Nova capacidade Disco 1:4

A capacidade do DISCO 2 non pode ser negativa

• PHP é un pouco 'especial' e atopamos diferentes artigos no que non se recomenda o uso de métodos get e set para cada propiedade por motivos de optimización de código.

Eu penso que vai depender da aplicación e de como ides necesitar modificar os valores das propiedades dunha clase.

Se por exemplo, non ides modificar os valores e soamente ides darlles uns valores iniciais (irían no construtor, onde podedes validalos) non necesitaríamos crear un método 'set' para darlle un valor a unha propiedade e como no código non teríamos asignacións, poderíamos non ter un método 'get'.

Se a nosa clase vai ser utilizada en outros proxectos e o uso indebido das propiedades pode dar lugar a problemas, deberíamos ter un método 'set' por cada propiedades para controlar que os valores son os correctos.

Métodos máxicos

• PHP incorpora dous métodos 'especiais' chamados máxicos que son chamados automaticamente (parecido ao que fixemos coa función __call) cando accedemos a unha propiedade dunha clase calquera:

• Método __get: Se chama automaticamente cando intentamos acceder a unha propiedade calquera dunha clase. Leva como parámetro o nome do atributo do que queremos obter o valor.

Por exemplo:

class Clase{

 private $propiedade;

 public function __get($atributo) {  
      return $this->$atributo;  // Hai que poñer $atributo para que o substitúa polo seu valor, se non estariamos a intentar devolver un atributo de nome $atributo...
 }  
}

  $obj = new Clase();
  echo $obj->propiedade;

• Método __set: Set chámase automaticamente cando intentamos dar un valor a unha propiedade dunha clase. Ten como parámetros de entrada o nome do atributo e o valor que se lle quere dar.

Por exemplo:

class Clase{

 private $propiedade1;
 private $propiedade2;

 public function __set($atributo,$valor) {  
      $this->$atributo=$valor;
   }  
 } 
}

  $obj = new Clase();
  $obj->propiedade1=10;
  $obj->propiedade2=10;

• Relacionado cos dous métodos anteriores temos a función property_exists. A necesitamos utilizar para comprobar se o atributo que estamos intentar modificar ou obter o seu valor existe.

Teremos que facer uso da constante __CLASS__, que devolve o nome da clase 'actual'.

No caso de __get:

class Clase{

 private $propiedade;

 public function __get($atributo) {  
      if (property_exists(__CLASS__, $atributo)) { 
        return $this->$atributo;
      }  
      return NULL;
 } 
}

  $obj = new Clase();
  echo $obj->propiedade;

No caso de __set:

class Clase{

 private $propiedade1;
 private $propiedade2;

 public function __set($atributo,$valor) {  
      if (property_exists(__CLASS__, $atributo)) { 
         $this->$atributo=$valor;
      }
      else {
          echo "Non existe o atributo $atributo";
      }
   }  
 } 
}

  $obj = new Clase();
  $obj->propiedade1=10;
  $obj->propiedade2=10;

• O tratamento que queirades darlle cando o atributo non exista vai depender do programador. Poderíamos retornar un 0/1 como fixamos antes cos métodos que asignaban un valor a unha propiedade private.

No exemplo aparecería un echo.

Facer os exercicios indicados neste punto.

Funcións relacionadas coas clases e métodos

• PHP dispón de funcións que nos van permitir saber o nome da clase a que pertence un obxecto, preguntar por se unha clase está definida, saber se un método existe nunha clase,...

• Todas estas funcións as tedes descritas neste enlace.

Imaxe obtida do enlace anterior

• Outra función relacionada coas clases e que poderemos necesitar dela é a función instanceof.

A súa función é comprobar se unha variable é dunha clase determinada.

Un código de exemplo sería o seguinte:

 $p = new Clase();

 if ($p instanceof Clase){
   echo "O obxecto \$p é da clase Clase";
 }

Operacións con obxectos

Referencias

• Unha referencia en PHP vai permitir que varias variables 'apunten' fisicamente á mesma dirección de memoria, permitindo que se unha delas modifica o valor o resto das variables que fan referencia tamén verán modificado o seu valor.

Para facer unha referencia a outra variable simplemente teremos que igualalas (a partires da versión PHP5):

 $ob1 = new Clase();
 $ob1->propiedade = 5;

 $ob2 = $ob1;
 $ob2->propiedade = 10;  // Agora $ob1-> propiedade vai ter de valor 10

Nota: Lembrar que no caso doutro tipo de datos crearíase unha copia nova (non sería unha referencia).

Clonar obxectos

• Clonar un obxecto é facer unha copia exacta do mesmo, pero fisicamente estarán ocupando posicións de memoria diferentes, polo que non teremos unha referencia como no caso anterior.

 $ob1 = new Clase();
 $ob1->propiedade = 5;

 $ob2 = clone($ob1);
 $ob2->propiedade = 10;  // $ob1-> propiedade mantén o seu valor a 5

Comparar obxectos

• Temos dous operadores para comparar dous obxectos:

• O operador de comparación simple (==): dará como resultado verdadeiro se os obxectos que se comparan son instancias da mesma clase e os seus atributos teñen os mesmos valores.
• O operador de identidade (===): dará como resultado verdadeiro se as variables comparadas son referencias á mesma instancia.

 $ob1 = new Clase();
 $ob1->propiedade = 5;

 $ob2 = $ob1;
 $ob3 = clone($ob1);

 // $ob1==$ob2 => Dará como resultado true xa que teñen os mesmos valores.
 // $ob1===$ob2 => Dará como resultado true xa que unha é unha referencia á outra

 // $ob1==$ob3 => Dará como resultado true xa que teñen os mesmos valores.
 // $ob1===$ob3 => Dará como resultado false xa que unha non é referencia da outra

Métodos máxicos

• Existen unha serie de método máxicos que se poden aplicar sobre as clases.

Algún deles xa os vimos anteriormente, na encapsulación.

• Comentar o método __toString: Este método devolverá un string cando se usa o obxecto coma se fose unha cadea de texto, por exemplo dentro dun echo ou dun print. Debe devolver unha cadea de texto.

  class Clase {
    $propiedade='valor';

    public function __toString(){
       return 'Isto aparece nun echo:' . $this->propiedade;
    }
  }

 $ob1 = new Clase();

 echo $ob1;

O resultado será:

Isto aparece nun echo:valor

• Este método o usaremos cando vexamos o acceso a base de datos.

Dunha consulta a unha base de datos obteremos un array de obxectos dunha clase. Normalmente teremos que visualizar o contido dese array.

 echo "<ol>";
 foreach ($arrayObxecto as $obxecto) {
   printf("<li>%s</li>",$obxecto);
 }
 echo "</ol>";

O resultado será unha lista sen ordenar no que se visualizará o indicado no método __toString da clase á que pertence $obxecto.

Facer os exercicios indicados neste punto.

Clases abstractas

• A partires de PHP5 introducíronse na linguaxe as clases e os métodos abstractos.

Para que unha clase sexa abstracta debe levar a palabra clave abstract.

abstract class Clase {

}

• As clases abstractas teñen estas características:

• Non se poden crear obxectos a partir delas, isto é: unha clase abtracta non pode ser instanciada.
• Unha clase abstracta pode incorporar métodos abstractos, que son aqueles dos que so existe a súa declaración, deixando a implementación para as clases fillas ou derivadas.
• Unha clase abstracta pode incorporar métodos non abstractos.

• Para que se utilizan ?

Normalmente ides necesitar crealas cando queirades ter unha clase que sexa 'base' doutras e 'obrigar' a implementar certos métodos.

Por exemplo, imaxinade que estades a facer unha aplicación no que queredes modelizar as figuras xeométricas.

Así, tedes a figura Cadrado, Circulo, coas súas propiedades.

Eu como deseñador quere que todas esas clases implementen o procedemento debuxar (que é diferentes para cada unha delas).

Faría isto:

abstract class FiguraXeometrica {

   abstract public function debuxar();
 
}

Agora, calquera clase que derive de FiguraXeometrica terá que implementar a método debuxar obrigatoriamente.

• Nota:Unha clase abstracta pode ter propiedades e métodos con código que serán herdadas polas subclases.

Facer os exercicios indicados neste punto.

Interfaces

• As interfaces son un tipo especial de clases que se caracterizan en que soamente levan as definicións de métodos, pero sen ningunha implementación.

Cando outra clase queira facer uso da interface terá que obrigatoriamente implementar o código dos métodos que están definidos na interface.

As interfaces, ao igual que as clases abstractas non poden ser instanciadas.

As interfaces, ao igual que as clases abstractcas poden empregar a herdanza con outras interfaces

• O concepto é parecido ao das clases abstractas, pero ten dúas diferenzas importantes:

• Para utilizar unha interface non teño que herdar de dita clase, se non que simplemente incorpora a interface (con todos os seus métodos) á miña clase.

Unha clase vai poder utilizar unha ou varias interfaces. Se empregásemos as clases abstractas soamente podemos herdar dunha.

• Unha interface non pode ter código nos métodos que deben ser públicos e soamente permite definir constantes, non se poden empregar atributos. É obrigatorio poñer código aos métodos nas clases que implementen a interface.

Como se declara ? Utilizando a palabra clave interface:

interface ClaseInterface {
  public function metodo1(): int;   // É un exemplo de tipo de dato devolto. Se queremos que poida devolver calquera tipo, non poñer nada
  public function metodo2(): string;
}

Como vemos os métodos non levan código.

Para utilizar dita interface, deberemos utilizar a palabra clave implements:

class Clase implements ClaseInterface {

  public function metodo1(): int {
    ....
  }
  public function metodo2(): string {
    ....
  }

}

Podemos combinar varias interfaces da forma:

class Clase implements ClaseInterface1,ClaseInterface2 {

  public function metodo1(): int {
    ....
  }
  public function metodo2(): string {
    ....
  }
  public function metodo3(): string {
    ....
  }

}

As interfaces tamén se poden utilizar con clases fillas:

class Clase extends ClasePai implements ClaseInterface1,ClaseInterface2 {

  public function metodo1(): int {
    ....
  }
  public function metodo2(): string {
    ....
  }
  public function metodo3(): string {
    ....
  }

}

• As interfaces van permitir definir métodos cun nome específico e cun número de parámetros determinado.

Así, se por exemplo, teño unha tenda no que teñamos diferentes tipos de produtos formando listas. Cada lista estará formada por un tipo de produto determinado, e eu quero que aquelas que o necesiten, poidan buscar un produto da súa lista. A implementación da busca será diferente por cada tipo de produto. Podo crear unha interface, de tal forma que para buscar sempre vou mandar un único parámetro como dato a utilizar na busca. Calquera clase que necesite buscar terá que incorporar a miña interface e terá que implementar o código específico, pero obrigatoriamente terá que levar o nome do procedemento indicando por min e o parámetro indicado por min na interface:

interface Busca {

  public function buscaProduto(int $valor): string ;

}

Namespaces

• Información obtida da web php.net.

• Os espazos de nomes proporcionan unha maneira de agrupar clases, interfaces, funcións e constantes relacionadas.

Tamén vai servir para solucionar o problema de que utilicemos clases ou código de terceiros (desenvolvido por outras persoas) no que pode darse o caso de que se chamen igual varias clases, constantes, funcións,..., polo que teríamos un erro ao intentar utilizalas.

• Tamén van poder utilizarse para abreviar nomes extra-largos que poidamos ter nos nomes de clases, mellorando a lexibilidade do código fonte.

• Calquera código PHP pode estar dentro dun namespace (espazo de nome) pero soamente vense afectado o seguinte tipo de código: clases (incluíndo abstractas e traits), interfaces, funcións e constantes.

Declaración

• Os espazos de nomes decláranse utilizando a palabra reservada namespace.

Un ficheiro que conteña un espazo de nomes debe declaralo ao comezo do mesmo, antes que calquera outro código ou espazo en branco, cunha excepción: a palabra reservada declare.

<?php
namespace MiProyecto;

const CONSTANTE_1 = 1;
class Clase { /* ... */ }
function funcion_1() { /* ... */ }

Nota: Nos exemplos estamos a utilizar clases, pero lembrar, como está indicado ao principio, que poderíamos ter funcións, constantes...

• Pódese definir o mesmo espazo de nomes en varios ficheiros, permitindo a separación do contido dun espazo de nomes a través do sistema de ficheiros.

Por exemplo:

Arquivo físico: Arquivo1.php

<?php
namespace MiProyecto;

const CONSTANTE_1 = 1;
class Clase1 { /* ... */ }
function funcion_1() { /* ... */ }

Arquivo físico: Arquivo2.php

<?php
namespace MiProyecto;

const CONSTANTE_2 = 1;
class Clase2 { /* ... */ }
function funcion_2() { /* ... */ }

• Un espazo de nome o podemos identificar cun cartafol nun sistema de arquivos. En diferentes cartafoles podemos ter o mesmo nome de arquivo. Para referenciar a un arquivo teremos que antepoñer o nome do cartafol (ruta relativa/absoluta) ao nome do arquivo.

• Aínda que non é obrigatorio, crearemos un cartafol por cada un dos namespaces.

Por exemplo, se teño unha clase MiClase dentro do namespace 'experimento', creamores un cartafol de nome experimento e dentro del poñeremos a clase miclase.php.

Uso

• Para referenciar a unha clase que se atopa definida nun espazo de nome de nome 'Espazo' teremos que poñer:

obj = new Espazo\Clase();

Sendo Clase unha clase definida no espazo de nomes 'Espazo' da forma:

<?php
namespace Espazo;
class Clase {
  ...............
}

Imaxinemos que no caso da clase Componentes, o noso sitio tamén xestiona compoñentes dos coches. Tamén teremos definida unha clase Componentes no que gardaremos:

Arquivo: Coches/Componentes.php

<?php
namespace ClasesCoches;

class Componentes {
    
    public float $prezo;
    public string $modelo;
    public int $ano_comercializacion;
    
}

Fixarse que, como estamos a dar un nome ao arquivo físico igual ao nome da clase, non van poder estar fisicamente no mesmo cartafol, por iso creamos un cartafol de nome /Coches/ onde estarán todas as clases que teñan que ver cos compoñentes dos coches.

Arquivo: Informatica/Componentes.php

<?php
namespace ClasesInformatica;
class Componentes {
  public string $numSerie;
  public string $nome;
  public float $prezo;
  public string $marca;
}

O mesmo facemos coas clases que teñan que ver con compoñentes informáticos, e creamos un cartafol de nome /Informatica/ onde gardaremos as clases dos compoñentes informáticos.

• Como vemos, creamos un espazo de nome 'ClasesInformatica' e outro 'ClasesCoches'.

• Para poder utilizar ditas clases, teremos que referencialas polo seu espazo de nome, xa que a clase Componentes podería facer referencia tanto a clase gardada no espazo de nomes ClasesInformatica ou a clase gardada no espazo de nome ClasesCoches:

Arquivo: Principal.php

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<?php

  require ('Coches/Componentes.php');
  require ('Informatica/Componentes.php');
  
?>
<html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
    <head>
        <meta charset="utf-8" />
        <title>Exemplos de códigos php</title>
    </head>
    <body>

    <?php   
        $objCoche1 = new ClasesCoches\Componentes();
        $objInfor1 = new ClasesInformatica\Componentes();
    ?>
    </body>    
</html>

• Liñas 5-6: Incluímos os arquivos físicos onde están definidas as clases.
• Liñas 17-18: Creamos un obxecto de cada clase. Fixarse como están referenciadas as clases de cada espazo de nome.

• Nota: Normalmente o que se fai cando se van empregar clases que están noutro espazo de nome é empregar use despois do require, da forma: use name_space\nome_clase;

Sub-espazos

• Ao concepto aprendido no punto anterior podemos sumarlle o concepto de sub-espazo, que é cando temos unha clase que está definida non espazo de nomes dentro doutro espazo de nomes. Sería como un cartafol dentro dun cartafol no sistema de arquivos.

<?php
namespace MiñasClases\OutrasClases;
class Clase {

}

<?php
  $obj1 = new Miñasclases\OutrasClases\Clase();

No exemplo dos compoñentes, poderíamos ter un espazo para as clases que teñan relación cos Computadores, outro espazo para os Móbiles,... Fixarse que fisicamente poden estar no mesmo cartafol (/Informatica/) mentres non teñan nomes iguais.

• Aínda que non é obrigatorio, crearemos un cartafol por cada un dos namespaces e subespazos.

Por exemplo, se teño unha clase MiClase dentro do namespace 'experimento', creamores un cartafol de nome experimento e dentro del poñeremos a clase miclase.php.

Alias

• Se creamos unha estrutura de espazos de nomes moi grande, pode darse o caso de que para referenciar a unha clase teñamos que poñer algo parecido a isto:

<?php
  $obj1 = new Miñasclases\OutrasClases\Outras\MaisClases\Clase();

Para evitalos podemos facer uso dos alias. Un alias é un nome que fai referencia a un conxunto de espazos de nomes.

Así,

<?php
namespace Espazo\SubEspazo1\SubEspazo2\SubEspazo3;
class Clase {

}

Agora, para referenciar a clase creo un alias do seu espazo de nome:

<?php
   require ('Clase.php');

   use Espazo\SubEspazo1\SubEspazo2\SubEspazo3 as EspazoSub;

   $ob1 = new EspazoSub\Clase(); 
?>

• Liña 4: Creamos un alias de nome 'EspazoSub' que é equivalente a poñer Espazo\SubEspazo1\SubEspazo2\SubEspazo3.
• Liña 5: Facemos referencia á clase Clase por medio do alias.

Nota: Se non poñemos o 'as EspazoSub' collerá como alias a última parte do use. No exemplo sería SubEspazo3.

Referenciando outros namespaces

Imaxinemos que temos a Clase1 dentro do espazo Espazo1 e a clase Clase2 dentro do espazo Espazo2,

• Se temos varios espazos diferentes y queremos referenciar a clases definidas noutros espazos teríamos que:

• Ter un require/include da clase que imos a empregar. Lembrar que isto é o lugar físico onde se atopa o arquivo PHP.
• Facer o use da forma: use Espazo\Clase;

No exemplo anterior, se Clase1 emprega a Clase2 tería:

<?php

   namespace Espazo1;

   require ('Clase2.php');
   use Espazo2\Clase2;

   class Clase1 {
        ...........
        $clase2 = new Clase2();
   }

?>

IMPORTANTE: Cando dentro dun namespaces facemos unha referencia a unha clase e queremos acceder a unha clase global da linguaxe (por exemplo, as clases mysqli para traballar contra bases de datos) non as va a atopar, xa que ao definir un namespace vai buscar as clases que se atopan dentro do mesmo.

No exemplo anterior:

<?php

   namespace Espazo1;

   require ('Clase2.php');
   use Espazo2\Clase2;

   class Clase1 {
        ...........
        $clase2 = new Clase2();
        $conexion = new mysqli("host", "usuario", "contraseña", "base_de_datos");   // NON A VAI ATOPAR
   }

?>

Para solucionalo temos dúas opcións:

• Empregar o operador de resolución de ámbito global: Isto é, poñer \ antes do clase a empregar. Por exemplo: $conexion = new \mysqli("host", "usuario", "contraseña", "base_de_datos");
• Declarar use ao principio do arquivo:

::<?php

   namespace Espazo1;
   use mysqli;

   require ('Clase2.php');
   use Espazo2\Clase2;

   class Clase1 {
        ...........
        $clase2 = new Clase2();
        $conexion = new mysqli("host", "usuario", "contraseña", "base_de_datos");   // AGORA SI A VAI ATOPAR
   }

?>

Facer os exercicios indicados neste punto

Documentación

• Para documentar código PHP existe un estándard parecido a Java (javadoc) coñecido como PHPDOC.

Proporciona unha forma coherente de documentar clases, métodos, propiedades, constantes e máis en PHP.

• Características Principais de PHPDoc:

• Comentarios de Documentación: Utiliza comentarios de varias liñas comezando con /** e terminando con */ para documentar elementos do código.
• Etiquetas: PHPDoc utiliza etiquetas especiais que comezan con @, como @param, @return, @throws, @var, etc., para proporcionar información específica.
• Descricións: Permite engadir descricións lexibles para clases, métodos, parámetros e valores de retorno.
• Compatibilidade con Ferramentas: Moitas ferramentas e IDEs como PhpStorm, Visual Studio Code e outros, recoñecen e utilizan os comentarios de PHPDoc para proporcionar intellisense, comprobación de tipos e outras funcionalidades.

• Exemplo de Uso de PHPDoc:

<?php

/**
 * Clase para representar un Libro.
 *
 * @package MiProyecto\Modelo
 */
class Libro {

    /**
     * Título do libro.
     *
     * @var string
     */
    protected string $titulo;

    /**
     * Asigna o título do libro.
     *
     * @param string $titulo Título do libro.
     * @return void
     */
    public function setTitulo(string $titulo): void {
        $this->titulo = $titulo;
    }

    /**
     * Obten o título do libro.
     *
     * @return string Título do libro.
     */
    public function getTitulo(): string {
        return $this->titulo;
    }
}

• Neste exemplo, cada elemento importante da clase Libro está documentado usando comentarios de PHPDoc.
• Beneficios de Usar PHPDoc:

• Mellora a Lexibilidade: Fai que o código sexa máis fácil de entender para outros desenvolvedores.
• Soporte para Xeración de Documentación Automática: Ferramentas como phpDocumentor poden xerar documentación do código automaticamente baseándose nestes comentarios.
• Axuda no Desenvolvemento: IDEs modernos utilizan PHPDoc para proporcionar autocompletado, verificación de tipos e axuda contextual.

• PHPDoc é esencial para manter un código PHP grande e complexo ben documentado, lexible e fácil de manter.

-- Ángel D. Fernández González -- (2025).