Os dejo un hilo de comentario

La línea de código include 'includes/header.php'; en PHP se utiliza para incluir el contenido de un archivo PHP dentro de otro archivo PHP. En este caso específico, se está incluyendo el archivo header.php que se encuentra en la carpeta includes.

La función include en PHP se utiliza para insertar el contenido de un archivo en otro archivo. Cuando se ejecuta esta línea de código, el intérprete de PHP buscará el archivo especificado (header.php) y lo incorporará en el lugar donde se encuentra la línea de código.

Esta técnica es comúnmente utilizada para separar el código en archivos más pequeños y reutilizables. Por ejemplo, en un proyecto de página web, el archivo header.php podría contener la estructura HTML del encabezado de la página (como la etiqueta <header>, el logo, el menú de navegación, etc.), y mediante el uso de include 'includes/header.php';, se puede agregar ese contenido en múltiples archivos PHP sin necesidad de repetir el código en cada uno.

De esta manera, el código se vuelve más modular, fácil de mantener y se evita la repetición de código. Además, si se realizan cambios en el archivo header.php, se reflejarán automáticamente en todos los archivos que lo incluyen.

Es importante asegurarse de que la ruta del archivo sea correcta y esté accesible desde el archivo en el que se realiza la inclusión.

 

 

La línea de código include 'includes/footer.php'; en PHP se utiliza para incluir el contenido de otro archivo PHP, en este caso el archivo footer.php, dentro del archivo actual.

Al igual que en el caso anterior, la función include se encarga de buscar el archivo especificado (footer.php) en la ubicación indicada (includes/) y lo incorpora en el lugar donde se encuentra la línea de código.

Usar include 'includes/footer.php'; es una práctica común para incluir el contenido del pie de página en múltiples archivos PHP. Esto ayuda a mantener una estructura de código modular y evita la repetición de código. Por ejemplo, el archivo footer.php podría contener información como derechos de autor, enlaces de navegación adicionales o código JavaScript relacionado con el pie de página.

Al igual que con cualquier inclusión de archivo, es importante asegurarse de que la ruta del archivo sea correcta y esté accesible desde el archivo en el que se realiza la inclusión.

 

Utilizando un contrunstor – datos de un formulario

<?Php

class Persona {

    private $nombre;

    private $edad;

 

    public function __construct($nombre, $edad) {

        $this->nombre = $nombre;

        $this->edad = $edad;

    }

 

    public function saludar() {

        echo "Hola, mi nombre es " . $this->nombre . " y tengo " . $this->edad . " años.";

    }

}

 

// Creación de un objeto de la clase Persona utilizando el constructor

$persona = new Persona("Juan", 30);

 

// Llamada al método saludar

$persona->saludar();

?>

 

En este código PHP, se define la clase Persona con dos atributos privados: $nombre y $edad. La clase también tiene un constructor __construct() que recibe dos parámetros ($nombre y $edad) y asigna esos valores a los atributos correspondientes de la clase.

El método público saludar() se utiliza para mostrar un mensaje de saludo que incluye el nombre y la edad de la persona.

Después de definir la clase, se crea un objeto de la clase Persona llamado $persona utilizando el constructor. Se le pasan los valores "Juan" y 30 como argumentos.

Finalmente, se llama al método saludar() del objeto $persona, que muestra el mensaje "Hola, mi nombre es Juan y tengo 30 años.".

La encapsulación se aplica al hacer los atributos $nombre y $edad privados, lo que significa que no se puede acceder a ellos directamente desde fuera de la clase. Sin embargo, se proporciona un método público (saludar()) para acceder a los valores y mostrarlos.

Esta estructura de clase con atributos privados y métodos públicos es común en la programación orientada a objetos para proteger y controlar el acceso a los datos internos de un objeto, promoviendo así la encapsulación y la modularidad del código.

 

Otro ejemplo de construct pero con string, int y bool

class Usuario {

    private $nombre;

    private $edad;

    private $activo;

 

    public function __construct(string $nombre, int $edad, bool $activo) {

        $this->nombre = $nombre;

        $this->edad = $edad;

        $this->activo = $activo;

    }

 

    public function getInfo() {

        $estado = $this->activo ? 'activo' : 'inactivo';

        return "Nombre: {$this->nombre}, Edad: {$this->edad}, Estado: {$estado}";

    }

}

 

// Creación de un objeto de la clase Usuario utilizando el constructor

$usuario = new Usuario("Juan", 30, true);

 

// Llamada al método getInfo

echo $usuario->getInfo();

 

En este ejemplo, se define la clase Usuario con tres propiedades privadas: $nombre de tipo string, $edad de tipo int y $activo de tipo bool.

El constructor __construct recibe tres parámetros: $nombre de tipo string, $edad de tipo int y $activo de tipo bool. Se utilizan los tipos de datos especificados en la declaración del constructor para asegurar que los valores pasados cumplan con el tipo esperado.

Dentro del constructor, se asignan los valores de los parámetros a las propiedades correspondientes de la clase.

El método getInfo devuelve una cadena de texto que contiene la información del usuario, incluyendo el nombre, la edad y el estado (activo o inactivo) basado en la propiedad $activo.

Después de definir la clase, se crea un objeto de la clase Usuario llamado $usuario utilizando el constructor. Se le pasan los valores "Juan" (string), 30 (int) y true (bool) como argumentos.

Finalmente, se llama al método getInfo del objeto $usuario para obtener la información del usuario y se muestra en pantalla.

Este ejemplo ilustra cómo un constructor puede recibir diferentes tipos de datos como parámetros y utilizarlos para inicializar las propiedades de la clase.

 

Creación de métodos

class Calculadora {

    public function sumar($a, $b) {

        return $a + $b;

    }

 

    public function restar($a, $b) {

        return $a - $b;

    }

 

    public function multiplicar($a, $b) {

        return $a * $b;

    }

 

    public function dividir($a, $b) {

        if ($b != 0) {

            return $a / $b;

        } else {

            return "Error: división por cero";

        }

    }

}

 

// Creación de un objeto de la clase Calculadora

$calculadora = new Calculadora();

 

// Llamada a los métodos de la calculadora

echo "Suma: " . $calculadora->sumar(5, 3) . "<br>";

echo "Resta: " . $calculadora->restar(8, 2) . "<br>";

echo "Multiplicación: " . $calculadora->multiplicar(4, 6) . "<br>";

echo "División: " . $calculadora->dividir(10, 2) . "<br>";

echo "División: " . $calculadora->dividir(8, 0) . "<br>"; // Esto generará un error de división por cero

 

Métodos estáticos

class MathUtil {

    public static function sumar($a, $b) {

        return $a + $b;

    }

 

    public static function restar($a, $b) {

        return $a - $b;

    }

}

 

// Llamada a los métodos estáticos sin crear un objeto

echo "Suma: " . MathUtil::sumar(5, 3) . "<br>";

echo "Resta: " . MathUtil::restar(8, 2) . "<br>";

 

En este ejemplo, se crea la clase MathUtil que tiene dos métodos estáticos: sumar y restar. Estos métodos pueden ser llamados directamente desde la clase sin necesidad de crear un objeto.

Para definir un método estático, se utiliza la palabra clave static antes de la declaración del método. Dentro del método, no se puede acceder a las propiedades de instancia de la clase, ya que no hay una instancia específica asociada.

Para llamar a un método estático, se utiliza la sintaxis NombreDeClase::nombreDelMetodo(). En el ejemplo, se llama a los métodos estáticos sumar y restar utilizando MathUtil::sumar() y MathUtil::restar() respectivamente.

Los métodos estáticos son útiles cuando necesitas tener funcionalidad asociada a la clase en sí misma y no a instancias individuales de la clase. Se utilizan con frecuencia para crear utilidades, funciones auxiliares o métodos de fábrica que no dependen de un estado específico de la instancia.

 

Herencia de clases

class Animal {

    protected $nombre;

    protected $edad;

 

    public function __construct($nombre, $edad) {

        $this->nombre = $nombre;

        $this->edad = $edad;

    }

 

    public function comer() {

        echo "El animal está comiendo.";

    }

 

    public function dormir() {

        echo "El animal está durmiendo.";

    }

}

 

class Perro extends Animal {

    private $raza;

 

    public function __construct($nombre, $edad, $raza) {

        parent::__construct($nombre, $edad);

        $this->raza = $raza;

    }

 

    public function ladrar() {

        echo "El perro está ladrando.";

    }

}

 

// Creación de un objeto de la clase Perro

$perro = new Perro("Max", 5, "Labrador");

 

// Acceso a los métodos de la clase Animal (heredados)

$perro->comer();   // Método de la clase Animal

$perro->dormir();  // Método de la clase Animal

 

// Acceso a los métodos de la clase Perro

$perro->ladrar();  // Método específico de la clase Perro

 

En este ejemplo, se define la clase base Animal, que tiene dos propiedades protegidas: $nombre y $edad. También tiene dos métodos públicos: comer() y dormir().

Luego, se define la clase Perro, que extiende la clase Animal utilizando la palabra clave extends. La clase Perro agrega una propiedad privada $raza y un método público ladrar().

Dentro del constructor de la clase Perro, se utiliza parent::__construct() para llamar al constructor de la clase Animal y pasar los valores correspondientes.

Cuando se crea un objeto de la clase Perro, se heredan automáticamente las propiedades y métodos de la clase Animal. Esto significa que el objeto $perro puede acceder a los métodos comer() y dormir() definidos en la clase Animal, así como al método ladrar() específico de la clase Perro.

La herencia de clases permite compartir código y comportamiento común entre diferentes clases, evitando la duplicación de código y promoviendo la reutilización. Además, las clases derivadas pueden extender y personalizar el comportamiento de la clase base, añadiendo propiedades y métodos adicionales según sea necesario.

 

 

Clases abstractas

abstract class Figura {

    protected $color;

 

    public function __construct($color) {

        $this->color = $color;

    }

 

    abstract public function calcularArea();

}

 

class Circulo extends Figura {

    private $radio;

 

    public function __construct($color, $radio) {

        parent::__construct($color);

        $this->radio = $radio;

    }

 

    public function calcularArea() {

        return pi() * pow($this->radio, 2);

    }

}

 

class Rectangulo extends Figura {

    private $base;

    private $altura;

 

    public function __construct($color, $base, $altura) {

        parent::__construct($color);

        $this->base = $base;

        $this->altura = $altura;

    }

 

    public function calcularArea() {

        return $this->base * $this->altura;

    }

}

 

// Creación de objetos de las clases concretas

$circulo = new Circulo("Rojo", 5);

$rectangulo = new Rectangulo("Azul", 4, 6);

 

// Llamada a los métodos específicos de cada clase

echo "Área del círculo: " . $circulo->calcularArea() . "<br>";

echo "Área del rectángulo: " . $rectangulo->calcularArea();

 

En este ejemplo, se define la clase abstracta Figura con una propiedad protegida $color y un método abstracto calcularArea(). El método abstracto no tiene implementación en la clase abstracta, sino que se implementa en las clases concretas que heredan de ella.

La clase Figura es una abstracción general que representa una figura geométrica genérica. No se pueden crear objetos directamente de una clase abstracta, por lo que no se puede hacer $figura = new Figura().

Luego, se definen dos clases concretas Circulo y Rectangulo que heredan de la clase abstracta Figura. Estas clases implementan el método calcularArea() de acuerdo con las fórmulas específicas de cada figura geométrica.

Se crean objetos de las clases Circulo y Rectangulo y se llama al método calcularArea() para calcular el área de cada figura. Los resultados se muestran en pantalla.

La clase abstracta Figura proporciona una estructura común y un contrato para las clases derivadas, asegurando que todas las clases que heredan de ella implementen el método calcularArea(). La utilización de una clase abstracta permite definir comportamiento común y forzar la implementación de métodos específicos en las clases hijas.