Herencia

¡Al fin Herencia! Este concepto es super sencillo, prácticamente es que, si heredas una clase, vas a tener acceso a sus métodos y propiedades desde otra clase, siempre y cuando, sean public o protected (Recuerda, private no)

Este concepto une a los demás conceptos, si te quedó alguna duda de algún concepto anterior, te recomiendo volver a mirar ese capítulo, pero ahora teniendo en cuenta este concepto.

Algo que es nuevo para mi es lo de “final” lo desconocía, pero igual es sencillo, prácticamente se puede usar para evitar el polimorfismo o la herencia en caso de que sea una clase.

Herencia

La herencia nos permitirá crear nuevas clases a partir de otras. O sea, vamos reutilizar código. Quiere decir, que vamos a hacer una abstracción para generar una súper clases general que después utilicemos para crear otras clases.

• En la herencia también tendremos una jerarquía de padre e hijo.
• En OOP, la clase padre siempre la encontraremos como la ‘Súperclase’ y los hijos como ‘subclase’.

Y a través de encapsulamiento vamos a poder definir que puede heredar el hijo y que no.

El método constructor nos permite inicializar las variables del objeto.

<?php

class User {
    public $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

Y para crear una herencia utilizamos la palabra reservada extends seguido del nombre de la clases.

<?php

class Admin extends User {
    // ...
}

Para evitar que se incumpla los principios SOLID 2 y 3, podemos utilizar la palabra reservada final al principio del método. También, podemos utilizar este la palabra reservado final en una clase, pero esto significa que no puede ser heredada.

<?php

class User {
    public $name;

    final public function __construct($name) {
        $this->name = $name;
    }
}

Herencia

La versión de php 8 nos trae una manera mas amigable de poder crear clases.
Encuentra mas aquí en la documentación oficial

les comparto mi código que vimos en la clase:

<?php


 class User
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }
}

class Admin extends User
{
    public function getName()
    {
        return "Soy $this->name";
    }
}


$admin = new Admin('Italo');
echo $admin->getName();
















//EJEMPLO CON FINAL.
// <?php


// final class User
// {
//     public $name;

//     public function __construct($name)
//     {
//         $this->name = $name;
//     }

//     public function getName()
//     {
//         return $this->name;
//     }
// }

// class Admin
// {

// }


// $admin = new User('Italo');
// echo $admin->getName();

Herencia

Nos permite heredar los métodos de la clase padre o madre a las subclases hijas.

Con la palabra final no podemos sobreescribir los métodos de la clase padre o madre.

Cuando declaramos una clase con la palabra final nos indica que esa clase no se puede heredar, por lo que se presentara un error al momento de ejecutar el código. De esta forma se evitaría la herencia de la clase.

La clase abstracta no se puede instanciar, pero una final si se puede instanciar.

En conclusión una herencia es utilizar todo lo que la clase padre tiene definido, si esta clase padre tiene 5 métodos, estos los tendran las clases que se hereden a partir de allí.

<?php

    # final
    class User
    {
        public $name;

        public function __construct($name)
        {
            $this->name = $name;
        }

        final public function getName()
        {
            return "Soy $this->name";
        }
    }


    class Admin extends User
    {
    public function getName2()
        {
            return "Soy $this->name";
        }
    }

    $admin = new User('Jhon');
    echo $admin->getName();
?>

✨ La herencia hace posible reutilizar código, gracias a la característica de crear nuevas clases a partir de otras.

podria entonces decir:
.
Mi padre me encapsulo el auto de manera privada 🤣
.

<?php

class Padre
{
    private $auto;
}

class Yo extends Padre
{
    public function hacer_diligencia()
    {
        return "toca usar el bus";
    }
}

$yo = new Yo();
echo $yo->auto;
echo $yo->hacer_diligencia();

resultado:

Warning: Undefined property: Yo::$auto in F:\laragon\www\2022-Platzi\...
toca usar el bus

Detallitos como los de la keyword final son los que hacen los cursos de Italo tan buenos.

🍃 La herencia es un concepto importante de la programación orientada a objetos que permite a las clases hijas (subclases) heredar propiedades y comportamientos de sus clases padres (superclases). La subclase puede extender o modificar las características de la superclase y también puede agregar nuevas propiedades y métodos.

Un ejemplo de herencia en PHP podría ser el siguiente:

class Animal {
    protected $name;
    protected $color;

    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }

    public function eat() {
        return "El animal está comiendo";
    }

    public function sleep() {
        return "El animal está durmiendo";
    }
}

class Dog extends Animal {
    public function bark() {
        return "El perro está ladrando";
    }
}

$myDog = new Dog("Fido", "Marrón");
echo $myDog->eat(); // El animal está comiendo
echo $myDog->bark(); // El perro está ladrando

En este ejemplo, la clase Animal es la superclase y la clase Dog es la subclase. La clase Dog hereda las propiedades y métodos de la clase Animal, lo que significa que puede usar los métodos eat() y sleep(), así como las propiedades name y color. Además, la subclase Dog también tiene un nuevo método llamado bark().

Cuando creamos un nuevo objeto de la clase Dog, podemos acceder a los métodos de la superclase Animal y a los métodos de la subclase Dog. En el ejemplo, creamos un nuevo objeto Dog llamado $myDog y llamamos a los métodos eat() y bark(). Como resultado, obtenemos “El animal está comiendo” y “El perro está ladrando”.

En resumen, la herencia es un concepto clave en la programación orientada a objetos que permite a las clases hijas heredar propiedades y métodos de las clases padres, y agregar nuevas propiedades y métodos específicos.

Extender : Es básicamente heredar, utilizar eso que mi padre provee y yo como hijo pudiera sobrescribir si mi padre lo permite .

Herencia, esto es bastante sencillo.
Básicamente dice que tenemos una clase madre y de repente tenemos una clase hija… Si la clase madre tiene 5 métodos, la clase hija puede utilizar esos métodos.
En otras palabras, si la clase madre tiene 5 métodos y la clase hija tiene 4 métodos al momento de heredar tenemos entonces que la clase hija va a contar con 9 método, sus propios métodos y los métodos propios de la madre; digamos que es una herencia directa bastante sencilla que podemos entender incluso comparándolo con la vida real.
La herencia es utilizar todo lo que mi padre tenga definido.
Existen palabras clases como: extender, final que cada una tiene su objetivo.

Resumen:
Puedes extender de una clase, o implementar una interfaz.
Si extiendes puedes usar los métodos que te interese de la clase madre, si implementas es obligatorio usar todos los metodos de la interfaz.

Herencia made easy

Se describe como la abilidad de una clase padre, transmitirle a sus hijos todos sus metodos y propiedades.
Siempre y cuando estos metodos sean de tipo:

• Public
• Protected

→ Como hemos venido trabajando se logra al extender desde una clase generica a unas clases con uso mas especifico.

Cuando y para que usamos la palabra reservada final?

Tecnica de memorizacion:

→ Dame las llaves abuelo, me voy con tu carro.
→ El abuelo: Si pero no le puedes cambiar nada al carro 🪲

Básicamente, cuando se hereda se va a tener todas la propiedades y métodos del padre siempre y cuando estos no sean private

un concepto hermoso que es la herencia

Lo que aprendí en esta clase.

Cuando colocamos el

final

, evitamos que ser heredada.

Resumen

<?php

class User{
    public $name;
    public function __construct($name){
        $this->name = $name;
    }

    public function getName(){
        return $this->name;
    }
}

class Admin extends User{
    public function getName(){
        return 'Admin: '.parent::getName();
    }
}

$admin = new Admin('John');
echo $admin->getName();

Creo que este tema hubiera sido importante haberlo trabajado desde un principio ya que lo usamos en muchos ejercicios y si bien para alguien que ya había visto antes algo de POO le resulto familiar y no hubo necesidad de una previa explicación, para los que si venian de 0 en estos temas pudo ser algo confuso llegar hasta este punto.
Lo bueno que ya si uno investigo por su cuenta o se apoyo de los comentarios y llega hasta esta parte, todo queda más claro 😃
Comparto mi apunte de la clase.
.
User

<?php

// Creando la clase padre
class User{
  
  // Creando método constructor (Versiones anteriores)
  
  // public $name;
  // public function __construct($name){
  //   $this->name = $name;
  // }

  // Otra forma de crear un método constructor en (Versiones PHP8 en adelante):
  public function __construct(public $name){}

  // Creando método para imprimir 'name'
  public function getName(){
    return $this->name;
  }

  /*
    Una clase, propiedad, constante o método pueden tener un encapsulamiento del tipo 'final'
    Esto lo que hace es que dicho elemento no pueda ser modificado o sobreescrito en alguna clase que herede de esta...
  */
  final public function getName2(){
    return $this->name;
  }

}

?>

.
Admin

<?php

// Incluyendo archivo 'User'
include_once('User.php');

// Creando clase que hereda de la clase 'user'
class Admin extends User{

  // Como esta clase hereda de la clase 'User' puede acceder a sus propiedades, constantes y métodos siempre y cuando el alcance lo permita
  // Adicionalmente se puede sobrecargar algún método, es decir, se puede crear un método que exista en el padre para que tenga otro comportamiento siempre y cuando su método de acceso no sea 'final'
  
  public function getName(){ // Aplicando polimorfismo
    return "El nombre es: {$this->name}";
  }

  public function getName2(){ // Esto no es posible ya que el método 'getName2' tiene un encapsulamiento del tipo 'final' en la clase padre
    return "Esta clase fue modificada en la clase 'Admin'";
  }

}

// Creando una instancía de la clase 'Admin'
$admin1 = new Admin("Joel");
echo $admin1->getName(); // El nombre es: Joel

// Si no se hubiera aplicado 'Polimorfismo' al método getName desde la clase 'Admin', el resultado seria:
// echo $admin1->getName(); // Joel

echo $admin1->getName2(); // Fatal error: Cannot override final method User::getName2()


?>

https://www.php.net/manual/es/language.oop5.inheritance.php
La herencia es un principio de programación bien establecido y PHP hace uso de él en su modelado de objetos. Este principio afectará la manera en que muchas clases y objetos se relacionan unas con otras.

Por ejemplo, cuando se extiende una clase, la subclase hereda todos los métodos públicos y protegidos de la clase padre. A menos que una clase sobrescriba esos métodos, mantendrán su funcionalidad original.

La herencia permite heredar métodos y atributos de una clase en específico. Esto significa que podemos usarlos aunque no estén declarados en la clase hija.
La herencia se puede permitir con la palabra reservada extends
La herencia se puede **evitar ** con la palabra reservada final
La Herencia se relaciona con el Polimorfismo en que es el medio por el cuál podemos utilizar una misma funcionalidad para diversos comportamientos y características

12. Herencia

Usamos extends para heredar en una clase, y anteponemos final si queremos que no se modifique un método o variable.

Si anteponemos final al nombre de una clase, esta no podrá ser heredada mediante extends.

<?php

class User
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

/**
 * Al agregar "final" antes del nombre de la clase,
 * hago que el método no pueda ser redefinido
 * También se le puede colocar a variables o clases
 * Pero si se le coloca a una clase, esta
 * NO podrá ser heredada
*/

    final public function getName()
    {
        return $this->name;
    }
}

class Admin extends User
{
    // code
}

$admin = new Admin('Aldo');
echo $admin->getName();

Intentando agregar variables a Admin sin agregárselas a User me encontré con un problema ya que cuando utilizaba el constructor, este sobreescribía la variable que traía de la clase User. Al buscar acerca de cómo se hacía eso, encontré lo siguiente:

class Admin extends User
{
    public function __construct($name, $access_number)
    {
        parent::__construct($name); //constructor heredado de User
        $this->access_number = (int) $access_number;
        
    }
    public function getAccessNumber()
    {
        return "Mi número de acceso es: $this->access_number ";
    }
}

Esto permite agregar variables sin perder las heredadas, no se si esto es una práctica recomendable o se realice de otra manera.

Las clases abstract no se pueden instanciar(ósea crear un objeto con la palabra new), pero las clases final si.

La herencia es utilizar los métodos y propiedades del padre, y como hijo podemos sobrescribirlo si el padre lo permite, en este caso seria, si los métodos no indican el modificador de acceso final.

Excelente explicación, me queda claro el significado de herencia sin problema.
Gracias profesor

Excelente

• La diferencia de una clase final y una clase abstracta es que la final si se puede instanciar, la abstarcta no. * 😃