Implementar de Clases y Polimorfismo con pHp

El polimorfismo es la capacidad de una clase abstracta o un objeto determinado para responder a un mismo método con su propio comportamiento. El polimorfismo especifica que un parámetro u objetos pasado o esperado puede adoptar múltiples formas y tener diferentes comportamiento con los mismos métodos.

Cuando realizamos programación orientada a objetos con polimorfismos debemos tener en cuenta que se puede invocar una instancia de una clase o un objetos y funcionara y se comportara igual sea cual sea la clase a la que pertenece el objeto. Si tenemos muchas clases y objetos debemos estructurar bien la jerarquías de clases y clases abstractas. Otra ventaja es poder declarar o programar métodos con el mismo nombre aunque su funcionalidad sea completamente distintas, ya que nos referimos a la instancia de la clase.

Un ejemplo supongamos una clase abstracta que representa la cantidad vehículos, que comparten como algunos datos en común el nivel de combustible, la marca y el modelo de vehículo.

Las propiedades de la clase Vehículos serán entonces combustible que contendrá la cantidad de litros que se cargan en el vehículo y marcaymodelo del vehículo.

<?php
class Vehiculo{
protected $combustible = 0; //Comienza el vehiculo vacio de combustible cero litros
protected $marcaymodelo='';
?>

A continuación definimos los métodos comunes para todos los vehículos que serán cargar combustible y mostrar cuanto queda a medida que se utiliza, además deberemos poder asignar a cada vehículo una marca y modelo y poder consultar su marca y modelo también. A continuación definimos los métodos para de la clase Vehículos.

<?   public function cargacombustible($combustible){
        $this->combustible = $combustible;
    }
       public function mostrarcombustible(){
return $this->combustible;
    }
  public function asignarvehiculo($marca,$modelo){
  $this->marcaymodelo=$marca.' '.$modelo;
  }
 
   
public function mostrarmarcaymodelo(){
  return $this->marcaymodelo;
  }
   } ?>

Luego comenzaremos a crear las clases que heredan de vehículos y tendrán sus métodos particulares por ejemplo creamos la clase Autos, tendrá la propiedad avanzar el automóvil y cada vez que avanza consumirá un litro de combustible (para que se entienda el ejercicio de manera sencilla)

class Autos extends Vehiculo{
public function avanzar(){
//cada 10 kilometros consume un litro
        $this->combustible -= 1;
    }
} //Fin Clase

Ahora implementaremos una clase general para el conductor del vehiculo, aquí tengamos en cuenta que un conductor o varios pueden conducir distintos vehiculos.
En esta clase definiremos un constructor de tipo genérico o abstracto

     function __construct($objeto_parametro){
$this->miobjeto=$objeto_parametro
}

Así podremos luego manipular cualquier objeto que se pase como parámetro del constructor, asi nuestra clase tendrá la capacidad de recibir como parámetro un objeto, esto es el polimorfismo es decir puede utilizar objetos completos por ejemplo le podemos enviar como parámetro la clase autos y utilizar todos su métodos.

Implementaremos los ejemplos en php 5 por ello es importante recordar el ámbito de un método y las variables, en la mayoría de los lenguajes es muy parecido. Para asignar o cambiar el ámbito de una variable o propiedad debemos usar la palabra reservada que corresponde cuando declaramos la variable o el método según el acceso o ámbito que queramos que tenga:

• private: indica que la variable o método sólo puede accederse por los métodos de la clase a la que pertenece el objeto y no desde ninguna otra.
• protected: indica que la variable o método es accesible por los métodos de la y también desde cualquier de sus subclase que pertenezca a esta clase.
• public: indica que las variables o métodos son accesibles desde cualquier otro método o sin importar donde este ni a quien pertenezca. Se debe tener cuidado con los atributos públicos ya que podrían modificar un valor que también utiliza otra clase u otro método.

Creamos a continuación la clase Conductor, que tendrá los siguientes métodos cargarcombustible, asignarvehiculo, ver marcaymodelo, avanzarvehiculo y consultar el combustiblerestante a medida que avanza

<? class Conductor {
     private $vehiculo;
     function __construct($objeto){
$this->vehiculo = $objeto;
    }   
    public function cargacombustible($combustible){
        $this->vehiculo->cargacombustible($combustible);
    }
public function asignarvehiculo($marca,$modelo){
        $this->vehiculo->asignarvehiculo($marca,$modelo);
    }
     public function marcaymodelo(){
       return $this->vehiculo->mostrarmarcaymodelo();
    } 
    public function avanzarvehiculo(){
$this->vehiculo->avanzar();
    }
     public function combustiblerestante(){
return $this->vehiculo->mostrarcombustible();
    }
} ?>

Podemos ver como en cada función de la clase Autos vamos instanciando los métodos comunes de Super clase Vehiculos para así poder asignarle las propiedades o métodos que sean particulares y no comunes a todos los vehiculos.

Veamos a continuación como utilizar estas clases y el polimorfismo propiamente dicho.

<? //Creamos una variable que instancia a Conductor y le pasamos como parámetro la clase Autos
$ferrari = new Conductor (new Autos);
//Asignamos el vehiculo y la marca
echo $ferrari->asignarvehiculo('Ferrari ','550 MARANELLO ').'<br>';
//Mostramos el vehiculo asignado
echo $ferrari->marcaymodelo().'<br>';
//Cargamos combustible en el vehiculo indicando la cantidad en litros
echo 'Carga combustible '.$ferrari->cargacombustible(50).'<br>';
//Mostrmos la cantidad de combustible actual
echo 'Combustible actual '.$ferrari->combustiblerestante().' litros<br><br>';
echo 'Avanza vehiculo<br>';
$ferrari->avanzarVehiculo();
echo $ferrari->marcaymodelo().' le quedan '.$ferrari->combustiblerestante().' litros de combustible<br><br>';

//Creamos otra instancia con otro vehículo podemos por ejemplo crear una variable que sea la marca y patente
$hondaHB0071 = new Conductor (new Autos);
echo $hondaHB0071->asignarvehiculo('Honda ','ACCORD').'<br>';
echo $hondaHB0071->marcaymodelo().'<br>';
echo 'Carga combustible '.$hondaHB0071->cargacombustible(50).'<br>';
echo 'Combustible actual '.$hondaHB0071->combustiblerestante().' litros<br><br>';
echo 'Avanza vehiculo Honda<br>';
$hondaHB0071->avanzarVehiculo();
echo $hondaHB0071->marcaymodelo().' le quedan '.$hondaHB0071->combustiblerestante().' litros de combustible<br><br>'; ?>

Veamos a continuación las verdaderas ventajas del polimorfismo y la herencia de clases, vamos añadir la clase para

//Motos
class Motos extends Vehiculo{
  public function avanzar(){
  //cada 10 kilometros consume un litro
        $this->combustible -= 1;
    }
}


$moto = new Conductor (new Motos);
echo $moto->asignarvehiculo('Yamaha ','YBR 125').'<br>';
echo $moto->marcaymodelo().'<br>';
echo 'Carga combustible '.$moto->cargacombustible(10).'<br>';

echo 'Combustible actual '.$moto->combustiblerestante().' litros<br><br>';

echo 'Avanza vehiculo moto<br>';
$moto->avanzarVehiculo();
echo $moto->marcaymodelo().' le quedan '.$moto->combustiblerestante().' litros de combustible<br><br>';  ?>

Aquí podemos observar como pudimos implementar una extensión de la misma clase a través de polimorfismo reutilizando la clase padre Vehiculos y los métodos y propiedades que tiene en común un automóvil y una motocicleta aunque se comportan de forma diferente en este caso podemos ver que la capacidad de combustible es distinta.

Podríamos incorporar los cálculos necesarios para hacer el consumo de combustible más real según el vehículo.
La ventaja de utilizar polimorfismo es que podemos crear métodos parecidos pero con parámetros distintos por ejemplo.

Implementación de interfaces con pHp

Las interfaces son declaraciones que definen qué métodos pueden ser implementados por una clase, ocultando cómo estos métodos son utilizados o gestionados. Los métodos que se declaran en una interfaz deben ser públicos, para poder ser accedidos por las clases que implementamos. Permiten un encapsulamiento de las clases y polimorfismos.
Para implementar una interfaz con php, se utiliza el la palabra reservada implements. Si tenemos varios métodos declarados en una interfaz estos deben ser implementados en una clase. Las clases pueden implementar mas de una interfaz para poder acceder a distintos métodos por lo que podemos tener distintas funcionalidades en distintas clases.

Vemos un ejemplo de interfaces

<?php
interface  avanzar {
    public function acelerar();
}
interface detener {
    public function frenar();
}
class vehiculo implements avanzar, detener
{
    public function acelerar()  {
//codigo para acelerar el vehiculo
}
    public function detener()  {
//codigo para detener el vehiculo
}
}
?>