POO Leccion 28 de 75 12 min de lectura

Propiedades y Metodos

Las propiedades almacenan el estado de un objeto. Los metodos definen su comportamiento. Juntos forman la esencia de la programacion orientada a objetos.

Propiedades con tipos

Las propiedades pueden tener diferentes tipos. Siempre especifica el tipo:

PHP 
<?php
declare(strict_types=1);

class Usuario
{
    public string $nombre;
    public int $edad;
    public float $saldo;
    public bool $activo;
    public array $roles = [];
    public ?string $telefono = null;  // Nullable
}
Propiedades sin inicializar

Una propiedad tipada sin valor por defecto debe asignarse antes de leerse. Si intentas leer $nombre sin haberle dado valor, PHP lanzara un error.

Metodos

Un metodo es una funcion que pertenece a una clase:

PHP 
<?php
declare(strict_types=1);

class Rectangulo
{
    public float $ancho;
    public float $alto;

    public function area(): float
    {
        return $this->ancho * $this->alto;
    }

    public function perimetro(): float
    {
        return 2 * ($this->ancho + $this->alto);
    }
}

$rect = new Rectangulo();
$rect->ancho = 10;
$rect->alto = 5;

echo $rect->area();      // 50
echo $rect->perimetro(); // 30

La palabra clave $this

$this es una referencia al objeto actual. La usamos dentro de los metodos para acceder a propiedades y otros metodos:

PHP 
<?php
declare(strict_types=1);

class Contador
{
    public int $valor = 0;

    public function incrementar(): void
    {
        $this->valor++;
    }

    public function decrementar(): void
    {
        $this->valor--;
    }

    public function reiniciar(): void
    {
        $this->valor = 0;
    }
}

$contador = new Contador();
$contador->incrementar();
$contador->incrementar();
$contador->decrementar();

echo $contador->valor; // 1

Metodos con parametros

PHP 
<?php
declare(strict_types=1);

class CuentaBancaria
{
    public float $saldo = 0;

    public function depositar(float $cantidad): void
    {
        if ($cantidad > 0) {
            $this->saldo += $cantidad;
        }
    }

    public function retirar(float $cantidad): bool
    {
        if ($cantidad > 0 && $cantidad <= $this->saldo) {
            $this->saldo -= $cantidad;
            return true;
        }
        return false;
    }
}

$cuenta = new CuentaBancaria();
$cuenta->depositar(1000);
$cuenta->retirar(250);
echo $cuenta->saldo; // 750

Encadenamiento de métodos

Si un metodo retorna $this, podemos encadenar llamadas:

PHP 
<?php
declare(strict_types=1);

class Calculadora
{
    public float $resultado = 0;

    public function valor(float $n): self
    {
        $this->resultado = $n;
        return $this;
    }

    public function sumar(float $n): self
    {
        $this->resultado += $n;
        return $this;
    }

    public function multiplicar(float $n): self
    {
        $this->resultado *= $n;
        return $this;
    }
}

$calc = new Calculadora();
$calc->valor(10)->sumar(5)->multiplicar(2);
echo $calc->resultado; // 30
El tipo self

self como tipo de retorno indica que el metodo devuelve una instancia de la misma clase. Es lo que permite el encadenamiento.

Ejercicios

Ejercicio 1: Clase Circulo

Crea una clase Circulo con propiedad radio y metodos area() y perimetro(). Usa M_PI.

Ver solucion
PHP 
<?php
declare(strict_types=1);

class Circulo
{
    public float $radio;

    public function area(): float
    {
        return M_PI * $this->radio ** 2;
    }

    public function perimetro(): float
    {
        return 2 * M_PI * $this->radio;
    }
}

$circulo = new Circulo();
$circulo->radio = 5;

echo "Area: " . $circulo->area() . "\n";           // 78.539...
echo "Perimetro: " . $circulo->perimetro() . "\n"; // 31.415...

Ejercicio 2: Clase Temporizador

Crea una clase Temporizador con propiedad segundos y metodos agregarMinutos(int $min), agregarHoras(int $h) y formatear() que retorne "HH:MM:SS".

Ver solucion
PHP 
<?php
declare(strict_types=1);

class Temporizador
{
    public int $segundos = 0;

    public function agregarMinutos(int $min): void
    {
        $this->segundos += $min * 60;
    }

    public function agregarHoras(int $h): void
    {
        $this->segundos += $h * 3600;
    }

    public function formatear(): string
    {
        $h = (int) ($this->segundos / 3600);
        $m = (int) (($this->segundos % 3600) / 60);
        $s = $this->segundos % 60;

        return sprintf('%02d:%02d:%02d', $h, $m, $s);
    }
}

$timer = new Temporizador();
$timer->agregarHoras(2);
$timer->agregarMinutos(30);
$timer->segundos += 45;

echo $timer->formatear(); // 02:30:45

Ejercicio 3: Clase StringBuilder

Crea una clase con metodos encadenables: agregar(string $texto), agregarLinea(string $texto) y obtener().

Ver solucion
PHP 
<?php
declare(strict_types=1);

class StringBuilder
{
    public string $contenido = '';

    public function agregar(string $texto): self
    {
        $this->contenido .= $texto;
        return $this;
    }

    public function agregarLinea(string $texto): self
    {
        $this->contenido .= $texto . "\n";
        return $this;
    }

    public function obtener(): string
    {
        return $this->contenido;
    }
}

$sb = new StringBuilder();
$resultado = $sb
    ->agregarLinea('Hola Mundo')
    ->agregar('PHP ')
    ->agregar('es ')
    ->agregarLinea('genial')
    ->obtener();

echo $resultado;
// Hola Mundo
// PHP es genial

¿Te está gustando el curso?

Tenemos cursos premium con proyectos reales y soporte personalizado.

Descubrir cursos premium