Polimorfismo

Polimorfismo

La palabra Polimorfismo puede que cause miedo al escucharla por primera vez, a mi me pasó, pero realmente no es nada del otro mundo, simplemente es darle a una clase diferentes comportamientos, prácticamente lo que hacemos al heredar la clase Base en la clase Admin o User es sobreescribir su constructor para que se comporte de una manera distinta, pero que el resto de la clase Base siga igual, prácticamente, si yo heredo una clase, puedo cambiar el comportamiento de sus métodos sobreescribiéndolos, y si alguien hereda mi clase, se comportará de la nueva forma en la que yo la definí, pero si alguien hereda la clase padre, se comportará de la forma que tiene por defecto, de esa forma no tenemos que cambiar el código base y podemos conseguir que una clase se comporte de maneras diferentes dependiendo de la situación.

Polimorfismo

El polimorfismo solamente significa varias formas. Esto quiere decir que si un mismo elemento si se comporta de diferentes maneras y otorga diferentes resultados quiere decir que aplica el término de polimorfismo.

<?php

abstract class Base {
    protected $name;

    private function getClassName() {
        return get_called_class();
    }

    public function login() {
        return "<p>Mi nombre es $this->name desde la clase {$this->getClassName()} <br><p>";
    }
}

class Admin extends Base {
    public function __construct($name) {
        $this->name = $name;
    }
}

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

class Guest extends Base {
    protected $name = 'invitado';
}

$guest = new Guest();
echo $guest->login();

$admin = new Admin('Helena');
echo $admin->login();

$user = new User('John Moore');
echo $user->login();

Para abrir el servidor de php utilizamos el comando

php -S localhost:8000

Y también podemos ejecutar el archivo utilizando el comando:

php *archivo*.php

Recuerden:
Poli => Muchos
Morfismo => Formas
Es contruir metodos con el mismo nombre pro con diferentes comportamientos

Recomiendo mucho el curso de POO de ann

Para jugadores de League of legends, les traigo un ejemplo, para que entiendan mas facil, espero que les funcione.

<?php

class Personaje{
    //Atributos - mi personaje tiene una vida y un dano de ataque
    public $vida;
    public $damage;

    //Metodos - al Atacar arrojara este mensaje por defecto.
    public function Atacar(){
        return 'Acabas de atacar';
    }
}

//Estoy creando la clase garen, donde heredara todos, los atributos y metodos de la clase Personaje.
class Garen extends Personaje{

    public function __construct($vida,$damage){
        $this->vida = $vida;
        $this->damage = $damage;
    }
    //Polimorfismo, estamos sobre escribiendo la funcion de atacar segun la necesidad que tiene este personaje.
    //Cuando garen ataca arroja un mensaje especial para el (Garen)
    public function Atacar(){
        return 'Garen acaba de pegar y te quito: '.$this->damage;
    }
}

//Instancio mi objeto, le envio la vida y el dano que tendra.
$garen = new Garen(100, 20);
echo $garen->Atacar();

🔮 El polimorfismo nos permite otorgar diferentes comportamientos a un método, conservando el mismo identificador.

Estás en el top 3 de profesores de Platzi. Muy conciso en las explicaciones, con ejemplos clarísimos y súper pragmático. Gracias.

Este es mi aporte use namespace porque al parecer estaba confundiendo las clases de otras carpetas y con namespace especificas que esos archivos solo van a pertenecer dentro de ese grupo en este caso es Polimorfismo

Index.php

User.php

Admin.php

Guest.php

Base.php

php -S localhost:8000 es un buen dato para probar rapidamente los cambios en php

PARA MI no tiene sentido usar en el ejemplo una clase abstracta ya que en la practica no lo es. Es hasta un distractor. Pero si Italo lo hizo así alguna buena razón debe tener.

Mi código que hicimos en la clase:
index.php

<?php
abstract class Polimorfismo
{
    protected $name;

    private function getClassName ()
    {
        return get_called_class();
    }

    public function login()
    {
        return "Mi nombre es $this->name desde la clase {$this->getClassName()}";
    }

}

class Admin extends Base 
{
    public function __contruct($name)
    {
        $this->name = $name;
    }
}


class User extends Base 
{
    public function __contruct($name)
    {
        $this->name = $name;
    }
}

class Guess extends Base 
{
    protected $name = 'Invitado';
}

$guest = new Guest();
echo $guest->login();
//Mi nombre es Invitado de la clase guest.


$user = new User('Iridian');
echo $user->login();
//Mi nombre es Iridian de la clase user.


$admin = new Admin('Guadalupe');
echo $admin->login();
//Mi nombre es Guadalupe de la clase Admin.



?>

Desde mi punto de vista con todo respeto, el profesor escribe muy rápido y si estamos en este modulo es porque somos aprendices y no dominamos el tema, por lo tanto considero que se requiere mayor explicación en cada paso del proceso.

Polimorfismo–representación gráfica

Si alguien utiliza Visual Studio Code pueden utilizar una extension que se llama PHP Server.
Después de instalar dan clic derecho en el área de trabajo y dan PHP server project. Adjunto una imagen para que sea mas detallada. Para que puedan ejecutar otro programa tienen que detener el servidor con Stop Server.

php constructor:

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

Ahora entiendo muchas cosas, por esa razón en los frameworks existe un archivo Base en el cual se basa,genial clase

El polimorfismo me ayudo muchisimo para desarrollar la logica de programacion

Mi código de la clase:

<?php 



abstract class Base {

    protected $name; 

    private function getClassName(){
        return get_called_class(); 
    }

    public function login(){
        return "Mi nombre es $this->name desde la clase {$this->getClassName()}"; 
    }

}


class Admin extends Base {
    
    public function __construct($name)
    {
        $this->name = $name; 
    }

}

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

class Guest extends Base{
    
    protected $name = "Invitado"; 
    
}


$guest = new Guest();
echo $guest->login(); 

$user = new User("Juan");
echo $user->login(); 

$admin = new Admin("SuperJuan");
echo $admin->login(); 

El polimorfismo aplica cuando un mismo elemento tiene diferentes comportamientos.

🍃 El polimorfismo es uno de los conceptos fundamentales de la programación orientada a objetos (POO). Se refiere a la capacidad de los objetos de diferentes clases de responder a un mismo mensaje o método de forma diferente.

En otras palabras, cuando un objeto de una clase es tratado como si fuera un objeto de otra clase, y responde al mismo mensaje de forma diferente, estamos hablando de polimorfismo.

El polimorfismo se logra a través del uso de herencia y de la sobrescritura de métodos. Por ejemplo, si tenemos una clase Animal que tiene un método llamado “hacerSonido”, y creamos dos clases que heredan de ella, como Perro y Gato, podemos sobrescribir el método “hacerSonido” en cada una de estas clases para que realice un sonido diferente.

De esta manera, si tenemos un arreglo de objetos que contienen tanto perros como gatos, y llamamos al método “hacerSonido” de cada uno de estos objetos, cada uno de ellos responderá al mismo mensaje de forma diferente, ya que cada clase ha sobrescrito el método “hacerSonido” de forma diferente.

El polimorfismo nos permite escribir código más genérico y reutilizable, ya que podemos tratar a objetos de diferentes clases de forma similar, sin importar sus diferencias específicas. Además, el polimorfismo nos ayuda a hacer que nuestro código sea más flexible, ya que nos permite agregar nuevas clases de objetos sin tener que modificar el código existente.

En resumen, el polimorfismo es la capacidad de los objetos de diferentes clases de responder a un mismo mensaje de forma diferente, lo que nos permite escribir código más genérico, reutilizable y flexible.

En este código se muestra un ejemplo de polimorfismo en PHP mediante el uso de clases abstractas y la herencia. Veamos el código línea por línea:

<?php

// Creamos la clase abstracta Base, que tiene un método protegido $name y un método privado getClassName
abstract class Base {
    protected $name;
    private function getClassName() {
        return get_called_class();
    }
    public function login() {
        return "Mi nombre es $this->name desde la clase {$this->getClassName()}";
    }
}

Aquí se crea la clase abstracta Base, que tiene un atributo protegido $name, que será utilizado por las clases hijas, un método privado getClassName, que devuelve el nombre de la clase y un método público login, que devuelve una cadena de texto con el nombre del objeto y la clase a la que pertenece.

// Creamos la clase Admin, que hereda de Base y tiene un constructor que recibe un nombre
class Admin extends Base {
    public function __construct($name) {
        $this->name = $name;
    }
}

// Creamos la clase User, que hereda de Base y tiene un constructor que recibe un nombre
class User extends Base {
    public function __construct($name) {
        $this->name = $name;
    }
}

// Creamos la clase Guest, que hereda de Base y tiene un valor predeterminado para el atributo $name
class Guest extends Base {
    protected $name = "invitado";
}

Aquí se crean tres clases hijas de Base: Admin, User y Guest. Las dos primeras tienen un constructor que recibe un nombre y asigna el valor a $name, mientras que la tercera tiene un valor predeterminado para $name.

// Creamos un objeto de la clase Guest y llamamos al método login
$guest = new Guest();
echo $guest->login();

// Creamos un objeto de la clase User y llamamos al método login
$user = new User("usuario");
echo $user->login();

// Creamos un objeto de la clase Admin y llamamos al método login
$admin = new Admin("Administrador");
echo $admin->login();

Finalmente, se crean objetos de las tres clases hijas y se llama al método login para cada uno de ellos. Como todas las clases hijas implementan el método login de la clase Base, podemos llamar a este método de forma genérica y obtener el resultado esperado para cada una de las clases hijas.

En resumen, este código muestra cómo se puede implementar el polimorfismo en PHP mediante el uso de clases abstractas y la herencia, lo que nos permite tratar a objetos de diferentes clases de forma similar, sin importar sus diferencias específicas.

Cuando una o más clases usan la misma interfaz, se refiere a “polimorfismo”.

El polimorfismo es esa característica de programación orientada a objetos que se presenta con mucha complejidad en el internet .
Polimorfismo simplemente significa varias formas, y, eso quiere decir que, un mismo elemento si se comporta de diferentes maneras y otorga diferentes resultados entonces aplica el término de polimorfismo, es muy sencillo porque podemos emplearlo en casi cualquier área.
Si es de varias cosas, si se comporta de diferentes maneras un único elemento entonces es polimorfismo.
si notamos que un elemento goza de la virtud de cambiar y de comportarse de diferentes maneras entonces es polimorfismo.
Como podemos ver el polimorfimo aplica cuando un mismo elemento tiene diferentes comportamientos.

Resumen de la clase

<?php
abstract class Base{
    protected $name;
    private function getClassName(){
        return get_called_class();
    }
    public function login(){
        return "Mi nombres es $this->name desde la clase {$this->getClassName()}";
    }

}

class Admin extends Base{

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

class User extends Base{

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

class Guest extends Base{

    protected $name = 'Invitado';                

}

$guest = new Guest();
echo $guest->login();

$user = new User('Usuario');
echo $user->login();

$admin = new Admin('Linda');
echo $admin->login();


?>

Woooow 😮
Me ha encantado esta clase, no recordaba el polimorfismo y ahora ya todo va quedando mucho más claro!
Les comparto mi apunte junto al resultado que va devolviendo cada cosa por si le sirve a alguien de apoyo.
En este caso fui creando los archivos separados como lo vimos en la clase de modularización.
.
Base

<?php

// Creando la clase abstracta 'Base'
abstract class Base{

  // Creando propiedad
  protected $name;

  // Creando métodos de la clase
  private function getClassName(){
    return get_called_class(); // retornara el nombre de la clase en la cual fue invocado dicho método
  }

  public function login(){
    return "Mi nombre es $this->name desde la clase {$this->getClassName()}";
  }

}

?>

.
Admin

<?php

include_once('Base.php');

// Creando clase 'Admin' que hereda de la clase 'Base'
class Admin extends Base1{
  
  // Creando método constructor para que al inicializarse un objeto de dicha clase, se tenga que pasar cierta información
  public function __construct($name){
    $this->name = $name;
  }

}

// Creando una instancia de la clase 'Admin'
$admin1 = new Admin("Administrador");
echo $admin1->login(); // Mi nombre es Administrador desde la clase Admin


?>

.
User

<?php

// Incluyendo el archivo 'Base';
include_once("Base.php");

// Creando clase 'User' que hereda de la clase 'Base'
class User extends Base1{
  
  // Creando método constructor para que al inicializarse un objeto de dicha clase, se tenga que pasar cierta información
  public function __construct($name){
    $this->name = $name;
  }

}

// Creando una instancia de la clase 'User'
$user1 = new User("Joel"); // Mi nombre es Joel desde la clase User
echo $user1->login();


?>

.
Guest

<?php

// Incluyendo el archivo 'Base';
include_once("Base.php");

// Creando clase 'Guest' que hereda de la clase 'Base'
class Guest extends Base1{
  
  // Definiendo de forma estatica la variable $name que se usa en la clase heredada 'Base'
  protected $name = "Invitado";

}

// Creando una instancia de la clase 'Guest'
$guest1 = new Guest();
echo $guest1->login(); // Mi nombre es Invitado desde la clase Guest

?>

Pueden utilizar la extensión RunCode de Visual Studio Code para ejectuar directamente las pruebas de PHP en la consola, sin necesidad de abrir un navegador ni subir un servidor

Si no les funcionó levantando el server: php -S localhost:8000 .\abstract\Base.php

Crear servidor local en PHP

Me encanta esto del polimorfismo

10. Polimorfismo

Como anotación muy interesante, se puede crear un servidor local desde una ubicación escribiendo en terminal (teniendo PHP instalado):

php -S localhost:8000

El polimorfismo aplica cuando un mismo elemento tiene distintos comportamientos, comparto el código de la clase:

<?php

abstract class Base
{
    protected $name;

    private function getClassName()
    {
        return get_called_class();
    }

    public function login()
    {
        return "Mi nombre es $this->name desde la clase {$this->getClassName()}<br>";
    }
}

class Admin extends Base
{
    public function __construct($name)
    {
        $this->name = $name;
    }
}

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

class Guest extends Base
{
    protected $name = 'Invitado';
}

$guest = new Guest();
echo $guest->login();

$user = new User('Profesor');
echo $user->login();

$admin = new Admin('Carlos');
echo $admin->login();

Jajaja, no tenía idea que con PHP, podía levantar un server local. Súper.

Como levantar un servidor php desde la carpeta local

Epa, vamos mejorando, una técnica que estoy usando para interiorizar mejor estos conceptos es hacer los ejercicios desde cero tratando de no mirar la clase y luego explicarme con mis propias palabras lo que se hizo y el porque, ya que uno se va llenando de cosas más si asume varias horas de clase seguidas jejeje.

A mi me enseñaron que Polimorfismo es sobrescribir lo que hace un método u.u Por ejemplo sobrescribir lo que haga get_called_class();

Les dejo con un ejemplo que hice con los diferentes roles de personajes del juego Valorant (shooter tactico… y encima tactico pa)

<code> 
<?php

abstract class Valorant
{
    protected $agent;

    private function getClassAgent()
    {
        return get_called_class();
    }

    public function selectAgent(){
        return "\nUsted escogio el agente $this->agent - CLASE DE AGENTE:{$this->getClassAgent()}";
    }
}

class Duelist extends Valorant
{
    public function __constuct($agent)
    {
        $this->agent=$agent;
    }
}

class Sentinel extends Valorant
{
    public function __construct($agent)
    {
        $this->agent=$agent;
    }
}

class Controller extends Valorant
{
    public function __construct($agent)
    {
        $this->agent=$agent;
    }
}

class Initiator extends Valorant
{
    public function __construct($agent)
    {
        $this->agent=$agent;
    }
}

$sova= new Initiator("Sova");
echo $sova->selectAgent();

$cypher= new Sentinel("Cypher");
echo $cypher->selectAgent();

$viper= new Controller("Viper");
echo $viper->selectAgent();

/* Usted escogio el agente Sova - CLASE DE AGENTE:Initiator
Usted escogio el agente Cypher - CLASE DE AGENTE:Sentinel
Usted escogio el agente Viper - CLASE DE AGENTE:Controller */

En el caso que presentó el profesor, entiendo que no hacía falta que la clase Base sea abstracta, ya que los métodos no lo eran.

Les dejo este artículo acerca de las diferencias entre interface y clase abstracta: https://codeinphp.github.io/post/abstract-class-vs-interface/

los elementos complejos se refiere a las funciones?? como las diferencia?

Excelente!

Las clases abstractas no se pueden instanciar directamente, solo se pueden instanciar las clases hijas (mientras estas no sean abstractas). Una clase abstracta no necesariamente tiene que tener métodos abstractos, depende del caso, y si la clase tiene metedos abstractos sus clases hijas tienen la necesidad de implementar sus metodos si o si.

POLIMORFISMO: un mismo molde que puede generar diferentes objetos con similares caracteristicas, básicamente es utilizar todo el potencial de tu molde.

muy bien explicado por el profesor, muy bien entendible los significados con sus ejemplos.

Polimorfismo

Es la característica en POO que se presenta con mucha complejidad en Internet.

Básicamente significa varias formas, lo cual nos quiere decir que un mismo elemento si se comporta de varias maneras y otorga diferentes resultados aplica el término de polimorfismo. Se puede implementar en cualquier área.

Un ejemplo sería cuando tenemos en el sistema un módulo de comentarios y se guarda en la tabla de la base de datos, pero esta tabla tambien almacena diferentes tipos de comentarios, nos lleva a decir que es una tabla poliformica porque esta guardando comentarios de diferentes tipos, sea de productos, generales, precios demás.

<?php

    abstract class Base
    {

        protected $name;

        private function getClassName()
        {
            return get_called_class();
        }

        public function login()
        {
            return "Mi nombre es $this->name desde la clase {$this->getClassName()}";
        }

       
    }

    class Admin extends Base
    {
        public function __construct($name)
        {
            $this->name = $name;
        }
    }

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

    class Guest extends Base
    {
        protected $name = 'Invitado';
    }

    $guest = new Guest();
    echo $guest->login() . "\n";

    $user = new User('Jhon');
    echo $user->login() ."\n";

    $admin = new Admin('Fabio');
    echo $admin->login();
?>

Nota: La “\n” se utiliza como salto de línea en la consola.