CLASE 4.

INCLUDES Y CLASES
4.1 Return type declaration

<?php declare(strict_types = 1);//Forzar a que se respete el tipo de

dato de los parmetros y el valor devuelto por la funcin

/**
* Return type declaration
*
* Podemos indicar el tipo de dato que retorna una funcin
*/

//$numero = 7; //esta variable no es accesible desde la funcin suma

function suma(int $x, int $y) : int

{
//global $numero; //"global" permite usar $numero dentro de la
funcin

return $x + $y;
}

var_dump(suma(2,6));

4.2 include (11:14)

<?php

/**
* include
*
* Incluye y evala el archivo especificado.
*
* Cuando se incluye un archivo, el cdigo que contiene
* hereda el mbito de las variables de la lnea en la
* que ocurre la inclusin.
*/
include 'suma.php';
//include 'suma.php';

$resultado = suma(2,5);
var_dump($resultado);

4.3 include_once (15:30)

<?php
/**
* El codigo se incluye solo una vez
*/

include_once 'suma.php';
include_once 'suma.php'; //no da error ya que el codigo no se vuelve a
incluir

$resultado = suma(2,8);
var_dump($resultado);
4.4 require (17:28)

Similar a include solo que en caso de no encontrar el archivo arroja un error fatal y detiene por
completo el script que se est ejecutando. Con include si no encuentra el archivo arroja una
advertencia y el script se sigue ejecutando.

<?php

require 'suma.php';
//require 'suma.php';
$resultado = suma(5,8);
var_dump($resultado);

4.5 require_once (20:03)

No arroja error si se incluye dos veces porque el archivo ya fue incluido una vez.

<?php

require_once 'suma.php';
require 'suma.php';

$resultado = suma(1,8);
var_dump($resultado);

4.6 Clase Producto (23:55)

Es recomendable que el nombre del archivo tenga el mismo nombre de la clase que va a
contener el archivo.

<?php

/**
* Las clases son para POO lo que para los arquitectos son los planos.
*/
// Define la clase Producto
class Producto {

// Declaracin de propiedades
var $nombre;
var $talla;
var $precio = 12;

function __construct($nombre, $talla)

{
//echo "He sido construido.\n";
$this->nombre = $nombre;
$this->talla = $talla;
}

function resumen()
{
echo $this->nombre . PHP_EOL;
echo $this->talla . PHP_EOL;
echo $this->precio . PHP_EOL;
}
}
4.7 Instancias (27:05)

<?php

require_once 'Producto.php';

// Crea una nueva instancia de Producto

$producto = new Producto;

// Setea las propiedades

$producto->nombre = 'Camiseta de CSS';
$producto->talla = 'L';
//$producto->precio = 12;

// Acceder a las propiedades

// echo $producto->nombre . PHP_EOL;
// echo $producto->talla . PHP_EOL;
// echo $producto->precio . PHP_EOL;

// Crea otra instancia de Producto

$producto2 = new Producto;

$producto2->nombre = 'Camiseta de JS';

$producto2->talla = 'S';
$producto2->precio = 11;

echo "Otro producto: {$producto2->nombre}.\n";

// echo "El precio de {$producto->nombre} es {$producto->precio}.\n";
// echo "El precio de {$producto2->nombre} es {$producto2-
>precio}.\n";

$producto->resumen();
$producto2->resumen();

4.8 Valores por defecto (33:09)

Se especifican en las propiedades dentro de la clase y significa que si esos valores no se setean
tendrn un valor por defecto.

Por ejemplo en la clase Producto

var $precio = 12;

4.9 Los mtodos (36:52)

Son funciones dentro de la clase.

Dentro de la clase Producto

function resumen()
{
echo $producto ->nombre . PHP_EOL;
echo $producto ->talla . PHP_EOL;
echo $this->precio . PHP_EOL;
}
4.10 $this (37:33)

Se usa para acceder a las propiedades de la propia instancia.

function resumen()
{
echo $this->nombre . PHP_EOL;
echo $this->talla . PHP_EOL;
echo $this->precio . PHP_EOL;
}

4.11 Constructor (40:04)

Funcin que se ejecuta cuando apenas se crea la instancia. El nombre de la funcin es

construct() con dos guiones bajos al principio.

<?php

require_once 'Producto.php';

$producto1 = new Producto('Camiseta de HTML', 'L');

$producto2 = new Producto('Camiseta de JS', 'S');
$producto3 = new Producto('Camiseta de CSS', 'M');
$producto4 = new Producto('Camiseta de PHP', 'L');
echo $producto1->nombre . PHP_EOL;
echo $producto2->nombre . PHP_EOL;
echo $producto3->nombre . PHP_EOL;
echo $producto4->nombre . PHP_EOL;

4.12 Clases Fabrica (1:06:00)

<?php

class Fabrica {

public function fabricarMesa($p_color, $p_patas)

{
return new Class($p_color, $p_patas) {
private $color;
private $patas;

public function __construct($p_color, $p_patas)

{
$this->color = $p_color;
$this->patas = $p_patas;
}

public function getColor()

{
return $this->color;
}

public function getPatas()

{
return $this->patas;
}
};
}
}

4.13 Clases annimas (58:55, 1:06:13)

Cuando no hay un constructor definido se puede crear la clase sin usar los parntesis.

$fabrica = new Fabrica;

<?php

require_once 'Fabrica.php';

$fabrica = new Fabrica();

$mesa1 = $fabrica->fabricarMesa('Marrn', 4);

$mesa2 = $fabrica->fabricarMesa('Negro', 8);

echo 'La mesa 1 es de color ' . $mesa1->getColor() .

' y tiene ' . $mesa1->getPatas() . ' patas.' . PHP_EOL;

echo 'La mesa 2 es de color ' . $mesa2->getColor() .

' y tiene ' . $mesa2->getPatas() . ' patas.' . PHP_EOL;