Los creadores de esta herramienta crearon suficientes funciones para cubrir todas las necesidades de un sistema, phpDataMapper es reciente y todavía esta en desarrollo, pero va por buen camino.

Pueden visitar su pagina y guía oficial phpDataMapper.

Consultas Personalizadas

$lista_registros=$persona->select()->from('persona')->where(array('id' => '3'));

Podriamos hacerlo así:

$lista_registros=$persona->query('SELECT * FROM persona WHERE id=3');

Más sencillo:

$lista_registros = $persona->all(array('id' => 3));

Seleccionamos la persona con el id 3.

Relaciones

En caso de que una tabla tenga relacion con otra por una clave foranea podemos hacer algo muy sencillo:

En caso de que persona tenga relación con publicación:

Ejemplo:

Archivo: Persona.php

<?php

class Persona extends phpDataMapper_Base {//inicio de la clase de mapeo

    // definir la fuente de  datos (tabla para el adaptador)
    protected $_datasource = "persona";

    // definir los atributos como propiedades de la clase con visibilidad publica
    public $id = array ('type' => 'int', 'primary' => true, 'serial' => true );
    public $nombre = array ('type' => 'string', 'required' => true );
    public $email = array ('type' => 'string', 'required' => true );
    public $web = array ('type' => 'string' );

    public $publicaciones = array(
        'type' => 'relation',
        'relation' => 'HasMany',
        'mapper' => 'Publicacion',
        'where' => array('personaid' => 'entity.id')
        );
   
}//fin de la clase de mapeo

?>

No es necesario modificar la tabla persona en la base de datos, $publicaciones hará las veces de una función.

El 'mapper' como sabemos, será la clase mapeo la cual vamos a usar para ese atributo en este caso Publicacion de tipo 'relation' donde personaid de la publicación sea igual al id de la persona: 'where' => array('personaid' => 'entity.id')

Archivo: Publicacion.php

Para crear este mapeo debemos crear en la base de datos: tabla publicacion, atributos: id int, nombre varchar, personaid int.

<?php

class Publicacion extends phpDataMapper_Base {//inicio del mapeo

    protected $_datasource = "publicacion";

    // definir los atributos como propiedades de la clase con visibilidad publica
    public $id = array ('type' => 'int', 'primary' => true, 'serial' => true );
    public $nombre = array ('type' => 'string', 'required' => true );
    public $personaid = array('type' => 'int', 'key' => true, 'required' => true);

}//fin del mapeo

?>

Para definir una clave foranea: array('type' => 'int', 'key' => true, 'required' => true);

Archivo: index.php

<?php

include 'Conexion.php';
include 'Persona.php';
include 'Publicacion.php';

$persona = new Persona(Conexion::getConexion());

$lista_registros = $persona->all();

foreach ( $lista_registros as $registro ) {

    echo 'Id: '.$registro->id.'<br/>';
    echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
    echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
    echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
    echo '<br/>';

    //Para mostrar todas las publicaciones
    foreach($registro->publicaciones as $publicacion) {

        echo "<p> ID: ".$publicacion->id.' Nombre: '. $publicacion->nombre. "</p>";

    }

}

?>

Ejemplo de una salida:

Id: 2
  Nombre: Alguien
  Email: alguien@alguienweb.com
  Web: www.alguienweb.com

ID: 3 Nombre: primera publicacion

ID: 4 Nombre: segunda publicacion

El alcance de este patrón de diseño se nota en las relaciones de las tablas, en el ejemplo anterior pudimos mostrar rápidamente los registros de publicaciones asociados a persona.

Otros frameworks también usan el Mapeo, yo recomiendo esta herramienta, ya que no se necesita depender de un frameworks para usarla, simplemente lo copiamos y empezamos a usarlo con nuestra aplicación, sin necesidad de modificar mucho nuestro código.

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $registro = $persona->get(1);

    $registro->nombre='Webmaster';
    
    $persona->save($registro);    
   
        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';      

?>

Primero obtenemos el registro que deseamos actualizar:

$registro = $persona->get(1);

Luego cambiamos los datos:

$registro->nombre='Webmaster';

Y guardamos:

$persona->save($registro);

Salida:

Id: 1
  Nombre: Webmaster
  Email: null@documentoweb.com
  Web:  www.documentoweb.com

Eliminación

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $persona->delete(array('id' => 1));//Eliminacion

    $lista_registros = $persona->all();
    
    foreach ( $lista_registros as $registro ) {

        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';

    }
    

?>

Para eliminar un registro usamos la función delete(condición):

$persona->delete(array('id' => 1));

Donde la condición es un arreglo en el cual se expresan los valores que debe tener el registro para ser eliminado, en este caso el registro con el id 1.

Salida:

Id: 2
  Nombre: Alguien
  Email: alguien@alguienweb.com
  Web:  www.alguienweb.com

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $registro = $persona->get(1);

    $registro->nombre='Webmaster';
    
    $persona->save($registro);    
   
        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';      

?>

Primero obtenemos el registro que deseamos actualizar:

$registro = $persona->get(1);

Luego cambiamos los datos:

$registro->nombre='Webmaster';

Y guardamos:

$persona->save($registro);

Salida:

Id: 1
  Nombre: Webmaster
  Email: null@documentoweb.com
  Web:  www.documentoweb.com

Eliminación

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $persona->delete(array('id' => 1));//Eliminacion

    $lista_registros = $persona->all();
    
    foreach ( $lista_registros as $registro ) {

        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';

    }
    

?>

Para eliminar un registro usamos la función delete(condición):

$persona->delete(array('id' => 1));

Donde la condición es un arreglo en el cual se expresan los valores que debe tener el registro para ser eliminado, en este caso el registro con el id 1.

Salida:

Id: 2
  Nombre: Alguien
  Email: alguien@alguienweb.com
  Web:  www.alguienweb.com

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $lista_registros = $persona->all();

    foreach ( $lista_registros as $registro ) {

        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';

    }

?>

Para cargar todos los registros usamos la función all(), luego recorremos el arreglo con un foreach.

Salida:

Id: 1
  Nombre: Null
  Email: null@documentoweb.com
  Web:  www.documentoweb.com

Id: 2
  Nombre: Alguien
  Email:  alguien@alguienweb.com
  Web: www.alguienweb.com

Obtener un registro

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    $registro = $persona->get(1);

    
        echo 'Id: '.$registro->id.'<br/>';
        echo '&nbsp;&nbsp;Nombre: '.$registro->nombre.'<br/>';
        echo '&nbsp;&nbsp;Email: '.$registro->email.'<br/>';
        echo '&nbsp;&nbsp;Web: '.$registro->web.'<br/>';
        echo '<br/>';
    

?>

Para obtener un registro especifico usamos la función get($id), le pasamos por parámetros el id de el registro deseado.

Salida:

Id: 1
  Nombre: Null
  Email: null@documentoweb.com
  Web:  www.documentoweb.com

Nuevo Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Null";
    $nuevo_registro->email = "null@documentoweb.com";
    $nuevo_registro->web = "www.documentoweb.com";
    
    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Alguien";
    $nuevo_registro->email = "alguien@alguienweb.com";
    $nuevo_registro->web = "www.alguienweb.com";

    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

?>

Creamos 2 registros, usamos la función get() para obtener un nuevo id, el lo hace automáticamente por ser incrementable:

$nuevo_registro = $persona->get ();

Luego completamos los otros datos:

$nuevo_registro->nombre = "Null";
$nuevo_registro->email = "null@documentoweb.com";
$nuevo_registro->web = "www.documentoweb.com";

Para finalizar usamos la función save($nuevo_registro), para guardar en la base de datos el registro y sus datos:

$persona->save($nuevo_registro);

Salida:

Registro Guardado 
Registro Guardado

Nuevo Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Null";
    $nuevo_registro->email = "null@documentoweb.com";
    $nuevo_registro->web = "www.documentoweb.com";
    
    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Alguien";
    $nuevo_registro->email = "alguien@alguienweb.com";
    $nuevo_registro->web = "www.alguienweb.com";

    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

?>

Creamos 2 registros, usamos la función get() para obtener un nuevo id, el lo hace automáticamente por ser incrementable:

$nuevo_registro = $persona->get ();

Luego completamos los otros datos:

$nuevo_registro->nombre = "Null";
$nuevo_registro->email = "null@documentoweb.com";
$nuevo_registro->web = "www.documentoweb.com";

Para finalizar usamos la función save($nuevo_registro), para guardar en la base de datos el registro y sus datos:

$persona->save($nuevo_registro);

Salida:

Registro Guardado 
Registro Guardado

Nuevo Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Null";
    $nuevo_registro->email = "null@documentoweb.com";
    $nuevo_registro->web = "www.documentoweb.com";
    
    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Alguien";
    $nuevo_registro->email = "alguien@alguienweb.com";
    $nuevo_registro->web = "www.alguienweb.com";

    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

?>

Creamos 2 registros, usamos la función get() para obtener un nuevo id, el lo hace automáticamente por ser incrementable:

$nuevo_registro = $persona->get ();

Luego completamos los otros datos:

$nuevo_registro->nombre = "Null";
$nuevo_registro->email = "null@documentoweb.com";
$nuevo_registro->web = "www.documentoweb.com";

Para finalizar usamos la función save($nuevo_registro), para guardar en la base de datos el registro y sus datos:

$persona->save($nuevo_registro);

Salida:

Registro Guardado 
Registro Guardado

Nuevo Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Null";
    $nuevo_registro->email = "null@documentoweb.com";
    $nuevo_registro->web = "www.documentoweb.com";
    
    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Alguien";
    $nuevo_registro->email = "alguien@alguienweb.com";
    $nuevo_registro->web = "www.alguienweb.com";

    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

?>

Creamos 2 registros, usamos la función get() para obtener un nuevo id, el lo hace automáticamente por ser incrementable:

$nuevo_registro = $persona->get ();

Luego completamos los otros datos:

$nuevo_registro->nombre = "Null";
$nuevo_registro->email = "null@documentoweb.com";
$nuevo_registro->web = "www.documentoweb.com";

Para finalizar usamos la función save($nuevo_registro), para guardar en la base de datos el registro y sus datos:

$persona->save($nuevo_registro);

Salida:

Registro Guardado 
Registro Guardado

Nuevo Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Null";
    $nuevo_registro->email = "null@documentoweb.com";
    $nuevo_registro->web = "www.documentoweb.com";
    
    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

    //Nuevo Registro

    $nuevo_registro = $persona->get ();
    $nuevo_registro->nombre = "Alguien";
    $nuevo_registro->email = "alguien@alguienweb.com";
    $nuevo_registro->web = "www.alguienweb.com";

    $persona->save($nuevo_registro);

    echo 'Registro Guardado <br/>';

?>

Creamos 2 registros, usamos la función get() para obtener un nuevo id, el lo hace automáticamente por ser incrementable:

$nuevo_registro = $persona->get ();

Luego completamos los otros datos:

$nuevo_registro->nombre = "Null";
$nuevo_registro->email = "null@documentoweb.com";
$nuevo_registro->web = "www.documentoweb.com";

Para finalizar usamos la función save($nuevo_registro), para guardar en la base de datos el registro y sus datos:

$persona->save($nuevo_registro);

Salida:

Registro Guardado 
Registro Guardado

Archivo: Conexion.php

<?php

//Archivos necesarios
require 'phpDataMapper/Base.php';
require 'phpDataMapper/Adapter/Mysql.php';

class Conexion {//Inicio de la clase

    public function getConexion() {
        try {
            //parametros: ip, base de datos, usuario, pass
            $conexion = new phpDataMapper_Adapter_Mysql ( 'localhost', 'prueba', 'root', '' );
        } catch ( Exception $e ) {
            echo $e->getMessage ();
            exit ();
        }
        return $conexion;
    }

}//Fin de la clase

?>

El primer archivo requerido es el Base.php este es para las tablas, el mapeo.

El segundo es la interfaz de conexión para MySql.

El bloque try-catch es una estructura que se usa cuando es necesario capturar excepciones (errores).

try {
//Sentencias a ejecutar
} catch ( Exception $e ) {
//Sentancias a ejecutar en caso de una excepcion
}

En este caso la excepción seria que no se pudo hacer la conexión con MySql.

Mapeo

Archivo: Persona.php

<?php

class Persona extends phpDataMapper_Base {//inicio de la clase de mapeo

    // definir la fuente de datos (tabla)
    protected $_datasource = "persona";

    // definir los atributos como propiedades de la clase con visibilidad publica
    public $id = array ('type' => 'int', 'primary' => true, 'serial' => true );
    public $nombre = array ('type' => 'string', 'required' => true );
    public $email = array ('type' => 'string', 'required' => true );
    public $web = array ('type' => 'string' );
   
}//fin de la clase de mapeo

?>

Estructura:

• La Clase lleva el nombre de la tabla que va a representar (mapear).
• La variable $_datasource es el nombre de la tabla.
• Todos los atributos deben ser representados.
• Los id (claves primarias), deben ser autoincrementables en la base de datos, su representación estándar es: array ('type' => 'int', 'primary' => true, 'serial' => true );
• Los atributos requeridos (not null) poseen el estatus 'required' => true
• Los demás atributos solo llevan el tipo.
• Cada tabla debe ser representada por su modelo.
• El modelo hereda de phpDataMapper_Base.
• La idea simplemente es llevar la tabla a código PHP.

Uso

Archivo: index.php

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $persona = new Persona(Conexion::getConexion());
    
?>

Al instanciar el modelo pasamos por parametro la conexión.

La sentencia Conexion::getConexion() significa una auto-instanciación de Conexion(), (no se necesita el new), y llamado de la función getConexion() inmediatamente.

También podría ser:

<?php

    include 'Conexion.php';
    include 'Persona.php';

    $conexion = new Conexion();
    $persona = new Persona($conexion->getConexion());

?>

Para aplicar este patrón usaremos phpDataMapper, una herramienta creada bajo el ORM , nos facilitará en gran manera el manejo de nuestra base de datos.

Es una herramienta de gran utilidad para cuando se necesite crear una aplicación rápidamente, además suma robustez a nuestra aplicación, ayuda mantener un código elegante y entendible.

Links Relacionados

• Mapeo objeto-relacional
• phpDataMapper Home
• OOP
• Descarga: phpDataMapper

Uso

Para poder implementar la herramienta necesitamos descargarla, descomprimirla y pegarla en el directorio raíz de nuestra aplicación.

Importante:

• Esta herramienta necesita que los id de cada entidad sean autoincrementables, por ello se necesita MySql como administrador de base de datos (Hasta ahora esa es la interfaz de conexión que usa phpDataMapper).

Antes de Empezar

• Para este Tutorial usaremos MySql.
• Base de Datos: prueba.
• Tabla: persona.
  
• Atributos: id (int), nombre (varchar), email (varchar), web (varchar).
• Tabla: publicacion.
• Atributos: id (int), nombre (varchar), personaid (int).
  

Unidades

• Unidad I: Conexión y Mapeo
• Unidad II: Creación de un Registro
• Unidad III: Obtención de un Registro
• Unidad IV: Actualización y Eliminación de un Registro
• Unidad V: Otras Caracteristicas

Si quieres aprender programación web, sólo en la web aprenderás

 

Constructor

El constructor de una clase tiene como principal objetivo el de inicializar el objeto al ser instanciado, colocando así sus atributos en los valores deseados.

El constructor es una función, y como tal puede o no recibir párametros.

En PHP un ejemplo de constructor de una clase seria el siguiente:

public function __construct() {

}

Notemos que la función esta denotada así: __construct(), dos underscore ( __ ) y la palabra construct.

Destructor

El destructor de una clase es muy similar a el constructor, la diferencia radica en que este es llamado cuando es destruido el objeto, en otras palabras eliminado de la memoria, claro es solo en teoria, su objetivo principal es devolver algún objeto o situación a su estado original, por ejemplo, cerrar conexiones con base de datos, o limpiar archivos temporales, o eliminar plantillas usadas, entre otras, ahora el concepto destructor no existe en PHP4 así que cuidado con eso.

El destructor no recibe parámetros.

Un ejemplo seria el siguiente:

public function __destruct() {
        
}

Posee una estructura igual al constructor pero con la palabra destruct, el destructor no funciona muy bien si se hereda esa clase, así que cuidado, dependiendo de lo que se haga sirve o no, y para saberlo se necesita experiencia.

Ejemplo:

Archivo: Estudiante.php

<?php

class Estudiante {//Inicio de la clase

    //Atributos
    private $id;
    private $nombre;

    //Funciones
    public function __construct() {
        $this->id=0;
        $this->nombre="Null";
        echo 'Construyendo <br/>';
        echo 'Nombre: '.$this->nombre.', ID: '.$this->id.'<br/>';
    }

    public function __destruct() {
        echo 'Destruyendo';
    }

}//Fin de la clase

?>

Archivo: index.php

<?php

include 'Estudiante.php';

$estudiante = new Estudiante();

?>

Salida:

Construyendo 
Nombre: Null, ID: 0
Destruyendo

Mejoremos el código, le colocaremos parámetros predefinidos al constructor:

Nuevo Archivo: Estudiante.php

<?php

class Estudiante {//Inicio de la clase

    //Atributos
    private $id;
    private $nombre;

    //Funciones
    public function __construct($id=0,$nombre="Null") {//Parametros predefinidos
        $this->id=$id;
        $this->nombre=$nombre;
        echo 'Construyendo <br/>';
        echo 'Nombre: '.$this->nombre.', ID: '.$this->id.'<br/>';
    }

    public function __destruct() {
        echo 'Destruyendo';
    }

}//Fin de la clase

?>

¿Para qué se usan estos parámetros?, bueno si al instanciar el objeto no se pasan datos por parámetros estos serán los valores que tomaran las variable.

Ejemplo:

Nuevo Archivo: index.php

<?php

include 'Estudiante.php';

$estudiante = new Estudiante(2,"Pedro");

?>

Salida:

Construyendo 
Nombre: Pedro, ID: 2
Destruyendo

Salida sin usar parámetros:

Construyendo 
Nombre: Null, ID: 0
Destruyendo

Recuerda hacer preguntas si tienes dudas en algo...

Clase Abstracta

En la Unidad I expliqué que una clase era un concepto o plantilla y que esta al ser instanciada se transformaba en un objeto en memoria, una clase abstracta sigue siendo un concepto, pero a diferencia de la clase normal (clase concreta) esta no puede ser instanciada.

Una clase abstracta posee funciones abstractas, son métodos que no han sido escritos, sólo está su cabecera, y sólo estas clases pueden representarlos, su objetivo es ser escritos (implementados) por las subclases, y así aplicar el polimorfismo explicado en la Unidad II.

Explicaré mejor las diferencias entre clases abstractas y clases concretas mediante una tabla:

Para crear una clase o función abstracta usaremos la palabra reservada abstract.

Ahora mejorando el código de la Unidad II, la nueva superclase:

Nuevo Archivo: Figura.php

<?php

abstract class Figura {//Inicio de la clase abstracta

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    abstract public function area();//Funcion sin implementacion

}//Fin de la clase

?>

Notemos la sintaxis, en la cabecera de la clase se colocó abstract class, y ahora la función area() también es abstracta, notemos que no tiene llaves {...}, la función termina en punto y coma ;

abstract public function area();//Funcion sin implementacion

Si intentaramos instanciar Figura generaría un error ( $figura = new Figura(); )

Fatal error:  Cannot instantiate abstract class Figura in...

Este dice que no se puede instanciar una clase abstracta.

Los otros archivos quedarían igual.

Interfaz

Una interfaz es una colección de funciones sin implementación, son similares a las clases abstractas, no pueden ser instanciadas, pero además todas las funciones son abstractas, su objetivo principal es obligar a las clases concretas a que implementen todos sus métodos abstractos, así se asegura que todas las clases que la usen o mejor dicho que implementen la interfaz tengan los métodos que deben ser comunes, y asegurar el polimorfismo de los mismos. Si una clase abstracta implementa una interfaz no necesita implementar las funciones de la misma.

Para declarar una interfaz usaremos la palabra reservada interface.

Archivo: IFigura.php

<?php

interface IFigura {//Inicio de la interfaz

    public function area();
    
}//Fin de la interfaz

?>

Ahora cambiemos la clase abstracta Figura, simplemente eliminamos el método area();

Luego veamos como quedaria la clase Rectangulo, para usar una interfaz usaremos la palabra implements:

Nuevo Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura implements IFigura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }
    
}//Fin de la clase

?>

Si no implementaramos area() cuando corrieramos el codigo pasaría esto:

Fatal error:  Class Rectangulo contains 1 abstract method and  must therefore be declared abstract or implement the remaining methods  (IFigura::area) in...

Nos dice que hay un método abstracto declarado en la interfaz y que en Rectangulo no ha sido implementado.

Recordemos incluir la interfaz en el index:

Nuevo Archivo: index.php

<?php

include 'Figura.php';
include 'IFigura.php';//Nueva inclusion
include 'Triangulo.php';
include 'Rectangulo.php';

.
.
.

?>

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Los patrones de diseño se refieren a la arquitectura de un programa, a la forma en la que está construidos, ellos se crean por la necesidad de solucionar algún  problemas de forma efectiva y reusable, además pretenden estandarizar el modo en que se desarrolla e implementa el software, facilitar el aprendizaje de las nuevas generaciones de diseñadores, y generar un criterio de codigo eficiente y la optimización de una aplicación.

Un Diseñador de Software (mejor conocido como programador) demuestra su madurez profesional aplicando dichos patrones que son variados y evocados a distintas soluciones o distintos software.

OOP (programación orientada a objetos)

La oop (object-oriented programming) es una abstracción del mundo real, en otras palabras intenta imitar los objetos y circunstancias de la vida real, así como los objetos de nuestro mundo poseen características (atributos) como: color, peso, tamaño, estatura, entre otros, y comportamientos (funciones, métodos o procedimientos) como: caminar, correr, disparar, buscar, entre otras, estos objetos también los tienen, en forma de código, este código que le da forma a un objeto se le llama "clase" (class).

La oop también es conocida como paradigma de programación orientada a objetos.

PHP es un lenguaje de programación que soporta la oop y es de gran utilidad crear objetos.

Los atributos siempre serán sustantivos y las funciones verbos.

Class

Antes de empezar con el código, se puede decir que un objeto tiene dos niveles, uno que es la clase y otro que es su implementación (instancia) o creación, la clase es la plantilla por la cual se regirá la forma del objeto, por ejemplo la clase Persona, esta tiene atributos como color de cabello, estatura, nacionalidad, nombre entre otros, pero no es ninguna Persona en particular, es solo el concepto de lo que debe ser una Persona, una instancia o creación de esta clase eres tu, y yo, el escritor de este articulo, ambos tal vez con nombres, nacionalidades, y color de cabello distintos, pero los dos somos tangibles, existimos, esa es la diferencia principal entre una clase (concepto) y una instancia (realidad).

La clase es un tipo de dato creado por el desarrollador.

Ahora ¿Cómo transformamos todo esto en código PHP?:

Archivo: Persona.php

 Recomiendo que cada clase se escriba en un archivo con su nombre, es posible crear varias clases en un solo archivo PHP.

<?php

class Persona {//Inicio de la Clase

    //Atributos
    private $nombre;
    
    //Funciones generalmente Públicas
    public function getNombre(){//Puede ser cambiado por obtenerNombre()        
        return $this->nombre;
    }

    public function setNombre($nombre){//Puede ser cambiado por insertarNombre()        
        $this->nombre=$nombre;        
    }

    private function pensar($pensamiento){
        echo $pensamiento;
    }

}//Fin de la Clase

?>

Observemos que tanto los atributos como las funciones están dentro de la clase, eso se llama encapsulamiento.

Las funciones get y set son utilizadas siempre para obtener e insertar los valores de los atributos de la clase, generalmente cada atributo posee estas dos funciones asociadas.

Las funciones y atributos public son la información a la cual se puede acceder desde la instancia de la clase, (el patrón OO, exige que los atributos sean private, pero a nivel de programación se pueden hacer publicos) ejemplo, otra persona puede pedirte tu nombre, pero no puede pedirte tus pensamientos (es solo para ejemplificar), por ende las funciones y atributos private solo pueden ser accedidas dentro de la clase.

La palabra reservada $this-> se utiliza para llamar atributos y funciones de la misma clase, en este caso el nombre.

Mejorando el código:

<?php

class Persona {//Inicio de la Clase

    //Atributos
    private $nombre;
    
    //Funciones generalmente Públicas
    public function getNombre(){//Puede ser cambiado por obtenerNombre()
        $this->pensar('Entrego mi nombre<br/>');//Llamando a la función Privada
        return $this->nombre;
    }

    public function setNombre($nombre){//Puede ser cambiado por insertarNombre()
        $this->pensar('Cambio mi nombre<br/>');//Llamando a la función Privada
        $this->nombre=$nombre;        
    }

    private function pensar($pensamiento){
        echo $pensamiento;
    }

}//Fin de la Clase

?>

Así podemos ver el uso de la función privada.

Ahora:

Archivo: index .php

<?php

   include 'Persona.php';
   $objeto = new Persona();
   $objeto->setNombre('Pedro');
   echo 'Nombre '.$objeto->getNombre();

?>

Para poder darle vida a nuestro objeto primero incluimos el archivo donde se encuentra la clase, luego con la palabra reservada new instanciamos el objeto:

$objeto = new Persona();

Este sentencia crea un objeto Persona en la variable $objeto (esta variable puede tomar cualquier nombre).

y para finalizar usamos sus funciones públicas:

$objeto->setNombre('Pedro');
echo 'Nombre '.$objeto->getNombre();

el resultado seria:

Cambio mi nombre
Entrego mi nombre
Nombre Pedro

Recuerda hacer preguntas si tienes dudas en algo...

Este patrón es muy útil sobre todo si se trabaja con grupos grandes de desarrolladores, ya que se pueden crear estructuras de manera que deban ser seguidas, para que así asegurar el perfecto funcionamiento de la aplicación al ser fusionada.

¿Cómo definimos este patrón?, es un método por el cual los desarrolladores pueden crear y organizar entidades, estas entidades son una simulación del mundo real, y por ende simulan soluciones a problemas reales, en otras palabras se imita de alguna forma como hacemos las cosas a mano, pero en un estructura programada.

Caracteristicas

• Simula actividades del mundo real.
• El usuario crea sus propios tipos de datos.
• Reutilización del código.
• Permite la portabilidad, compatibilidad y robustez, de ahi la creación de FrameWorks.
• Capacidad de encapsular la información y procedimientos.
• Construción de sistemas complejos, con la participación de muchos desarrolladores.
• Mejor mantenimiento y adaptabilidad de modulos.
• Es más entendible.

Pilares Fundamentales

• Encapsulamiento.
• Herencia.
• Clase (Entidad).
• Objeto.
• Polimorfismo.

Analisis

Existe un concepto para el análisis de patrones y de aplicaciones, este se llama Cohesión y Acoplamiento, nos ayuda a observar el grado de funcionalidad del código y de la implementación de una aplicación, son conceptos un tanto dificiles, la cohesión es la capacidad de que los módulos o funciones resuelvan un problema por si solas, generalmente estas son agrupadas, en librerías, en nuestro caso en clases, de manera que simulen la realidad, por ejemplo los usuarios, estos pueden ser eliminados, actualizados, y generados, todos esos módulos (funciones) están evocados hacia una misma entidad, pero cada una resuelve un problema distinto y por si solo, al organizarlos y unirlos creamos la clase Usuario, el acoplamiento se refiere a la dependencia que tiene un módulo de otro, al cambiar uno es necesario hacer cambios en el otro, esto es malo, debemos intentar tener el menor grado de acoplamiento posible en nuestras aplicaciones, solo lo necesario y obligatorio, por ejemplo si en vez de usar una clase Usuario usáramos una función que recibiera el tipo de procedimiento, proceso($proceso), donde $proceso seria, "eliminar", "crear", "actualizar", podría a futuro generar molestias, y perdida de tiempo al intentar hacer grandes modificaciones, y lo peor es que los problemas generalmente aumenta exponencialmente. El diseño orientado a objetos también conocido como programación orientada a objetos nos permite crear estructuras poco acopladas, para así asegurar la compatibilidad y portabilidad de nuestro código, es una muy buena opción implementarla, por supuesto que lleva tiempo, pero a la larga se notará su flexibilidad.

Unidades

• Unidad I
• Unidad II
• Unidad III
• Unidad IV

Recuerda hacer preguntas si tienes dudas en algo...

Este patrón es muy útil sobre todo si se trabaja con grupos grandes de desarrolladores, ya que se pueden crear estructuras de manera que deban ser seguidas, para que así asegurar el perfecto funcionamiento de la aplicación al ser fusionada.

¿Cómo definimos este patrón?, es un método por el cual los desarrolladores pueden crear y organizar entidades, estas entidades son una simulación del mundo real, y por ende simulan soluciones a problemas reales, en otras palabras se imita de alguna forma como hacemos las cosas a mano, pero en un estructura programada.

Caracteristicas

• Simula actividades del mundo real.
• El usuario crea sus propios tipos de datos.
• Reutilización del código.
• Permite la portabilidad, compatibilidad y robustez, de ahi la creación de FrameWorks.
• Capacidad de encapsular la información y procedimientos.
• Construción de sistemas complejos, con la participación de muchos desarrolladores.
• Mejor mantenimiento y adaptabilidad de modulos.
• Es más entendible.

Pilares Fundamentales

• Encapsulamiento.
• Herencia.
• Clase (Entidad).
• Objeto.
• Polimorfismo.

Analisis

Existe un concepto para el análisis de patrones y de aplicaciones, este se llama Cohesión y Acoplamiento, nos ayuda a observar el grado de funcionalidad del código y de la implementación de una aplicación, son conceptos un tanto dificiles, la cohesión es la capacidad de que los módulos o funciones resuelvan un problema por si solas, generalmente estas son agrupadas, en librerías, en nuestro caso en clases, de manera que simulen la realidad, por ejemplo los usuarios, estos pueden ser eliminados, actualizados, y generados, todos esos módulos (funciones) están evocados hacia una misma entidad, pero cada una resuelve un problema distinto y por si solo, al organizarlos y unirlos creamos la clase Usuario, el acoplamiento se refiere a la dependencia que tiene un módulo de otro, al cambiar uno es necesario hacer cambios en el otro, esto es malo, debemos intentar tener el menor grado de acoplamiento posible en nuestras aplicaciones, solo lo necesario y obligatorio, por ejemplo si en vez de usar una clase Usuario usáramos una función que recibiera el tipo de procedimiento, proceso($proceso), donde $proceso seria, "eliminar", "crear", "actualizar", podría a futuro generar molestias, y perdida de tiempo al intentar hacer grandes modificaciones, y lo peor es que los problemas generalmente aumenta exponencialmente. El diseño orientado a objetos también conocido como programación orientada a objetos nos permite crear estructuras poco acopladas, para así asegurar la compatibilidad y portabilidad de nuestro código, es una muy buena opción implementarla, por supuesto que lleva tiempo, pero a la larga se notará su flexibilidad.

Unidades

• Unidad I
• Unidad II
• Unidad III
• Unidad IV

Recuerda hacer preguntas si tienes dudas en algo...

Constructor

El constructor de una clase tiene como principal objetivo el de inicializar el objeto al ser instanciado, colocando así sus atributos en los valores deseados.

El constructor es una función, y como tal puede o no recibir párametros.

En PHP un ejemplo de constructor de una clase seria el siguiente:

public function __construct() {

}

Notemos que la función esta denotada así: __construct(), dos underscore ( __ ) y la palabra construct.

Destructor

El destructor de una clase es muy similar a el constructor, la diferencia radica en que este es llamado cuando es destruido el objeto, en otras palabras eliminado de la memoria, claro es solo en teoria, su objetivo principal es devolver algún objeto o situación a su estado original, por ejemplo, cerrar conexiones con base de datos, o limpiar archivos temporales, o eliminar plantillas usadas, entre otras, ahora el concepto destructor no existe en PHP4 así que cuidado con eso.

El destructor no recibe parámetros.

Un ejemplo seria el siguiente:

public function __destruct() {
        
}

Posee una estructura igual al constructor pero con la palabra destruct, el destructor no funciona muy bien si se hereda esa clase, así que cuidado, dependiendo de lo que se haga sirve o no, y para saberlo se necesita experiencia.

Ejemplo:

Archivo: Estudiante.php

<?php

class Estudiante {//Inicio de la clase

    //Atributos
    private $id;
    private $nombre;

    //Funciones
    public function __construct() {
        $this->id=0;
        $this->nombre="Null";
        echo 'Construyendo <br/>';
        echo 'Nombre: '.$this->nombre.', ID: '.$this->id.'<br/>';
    }

    public function __destruct() {
        echo 'Destruyendo';
    }

}//Fin de la clase

?>

Archivo: index.php

<?php

include 'Estudiante.php';

$estudiante = new Estudiante();

?>

Salida:

Construyendo 
Nombre: Null, ID: 0
Destruyendo

Mejoremos el código, le colocaremos parámetros predefinidos al constructor:

Nuevo Archivo: Estudiante.php

<?php

class Estudiante {//Inicio de la clase

    //Atributos
    private $id;
    private $nombre;

    //Funciones
    public function __construct($id=0,$nombre="Null") {//Parametros predefinidos
        $this->id=$id;
        $this->nombre=$nombre;
        echo 'Construyendo <br/>';
        echo 'Nombre: '.$this->nombre.', ID: '.$this->id.'<br/>';
    }

    public function __destruct() {
        echo 'Destruyendo';
    }

}//Fin de la clase

?>

¿Para qué se usan estos parámetros?, bueno si al instanciar el objeto no se pasan datos por parámetros estos serán los valores que tomaran las variable.

Ejemplo:

Nuevo Archivo: index.php

<?php

include 'Estudiante.php';

$estudiante = new Estudiante(2,"Pedro");

?>

Salida:

Construyendo 
Nombre: Pedro, ID: 2
Destruyendo

Salida sin usar parámetros:

Construyendo 
Nombre: Null, ID: 0
Destruyendo

Recuerda hacer preguntas si tienes dudas en algo...

Clase Abstracta

En la Unidad I expliqué que una clase era un concepto o plantilla y que esta al ser instanciada se transformaba en un objeto en memoria, una clase abstracta sigue siendo un concepto, pero a diferencia de la clase normal (clase concreta) esta no puede ser instanciada.

Una clase abstracta posee funciones abstractas, son métodos que no han sido escritos, sólo está su cabecera, y sólo estas clases pueden representarlos, su objetivo es ser escritos (implementados) por las subclases, y así aplicar el polimorfismo explicado en la Unidad II.

Explicaré mejor las diferencias entre clases abstractas y clases concretas mediante una tabla:

Para crear una clase o función abstracta usaremos la palabra reservada abstract.

Ahora mejorando el código de la Unidad II, la nueva superclase:

Nuevo Archivo: Figura.php

<?php

abstract class Figura {//Inicio de la clase abstracta

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    abstract public function area();//Funcion sin implementacion

}//Fin de la clase

?>

Notemos la sintaxis, en la cabecera de la clase se colocó abstract class, y ahora la función area() también es abstracta, notemos que no tiene llaves {...}, la función termina en punto y coma ;

abstract public function area();//Funcion sin implementacion

Si intentaramos instanciar Figura generaría un error ( $figura = new Figura(); )

Fatal error:  Cannot instantiate abstract class Figura in...

Este dice que no se puede instanciar una clase abstracta.

Los otros archivos quedarían igual.

Interfaz

Una interfaz es una colección de funciones sin implementación, son similares a las clases abstractas, no pueden ser instanciadas, pero además todas las funciones son abstractas, su objetivo principal es obligar a las clases concretas a que implementen todos sus métodos abstractos, así se asegura que todas las clases que la usen o mejor dicho que implementen la interfaz tengan los métodos que deben ser comunes, y asegurar el polimorfismo de los mismos. Si una clase abstracta implementa una interfaz no necesita implementar las funciones de la misma.

Para declarar una interfaz usaremos la palabra reservada interface.

Archivo: IFigura.php

<?php

interface IFigura {//Inicio de la interfaz

    public function area();
    
}//Fin de la interfaz

?>

Ahora cambiemos la clase abstracta Figura, simplemente eliminamos el método area();

Luego veamos como quedaria la clase Rectangulo, para usar una interfaz usaremos la palabra implements:

Nuevo Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura implements IFigura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }
    
}//Fin de la clase

?>

Si no implementaramos area() cuando corrieramos el codigo pasaría esto:

Fatal error:  Class Rectangulo contains 1 abstract method and  must therefore be declared abstract or implement the remaining methods  (IFigura::area) in...

Nos dice que hay un método abstracto declarado en la interfaz y que en Rectangulo no ha sido implementado.

Recordemos incluir la interfaz en el index:

Nuevo Archivo: index.php

<?php

include 'Figura.php';
include 'IFigura.php';//Nueva inclusion
include 'Triangulo.php';
include 'Rectangulo.php';

.
.
.

?>

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Herencia

La herencia se refiera a que una clase B (subclase) puede usar la estructura de una clase A (superclase), igual que en el mundo real las personas heredamos los rasgos físicos de los padres, y no solo los rasgos físicos sino por ejemplo los apellidos.

La herencia es útil para tener un mejor entendimiento de los procesos de un programa de forma jerarquica o para clasificar una serie de clases rehusando el código ya escrito.

Las clases que hereden obtendran todos los atributos y funciones de sus padres, y podran acceder a ellos si son public o protected, como explique en la Unidad I los atributos y funciones private solo se pueden acceder dentro de la misma clase que los usa.

Las clases que hereden pueden agregar a su estructura nuevos atributos y funciones sin afectar a la superclase.

Polimorfismo

El polimorfismo se refiere a funciones que se llaman igual, pero se comportan diferente, básicamente buscan solucionar el mismo problema de diferentes formas.

Primero crearemos la superclase:

Archivo: Figura.php

<?php

class Figura {//Inicio de la clase

    //Atributos
    private $color;
    private $nombre;

    //Funciones
    public function getColor(){
        return $this->color;
    }

    public function setColor($color){
        $this->color=$color;
    }

    public function getNombre(){
        return $this->nombre;
    }

    public function setNombre($nombre) {
        $this->nombre=$nombre;
    }

    public function area(){
        return 0;
    }

}//Fin de la clase

?>

Ahora creamos la primera herencia, para ello usaremos la palabra reservada extends:

Archivo: Triangulo.php

<?php

class Triangulo extends Figura {//Inicio de la clase

    //Atributos
    private $base;
    private $altura;

    //Funciones
    public function getBase(){
        return $this->base;
    }

    public function setBase($base){
        $this->base=$base;
    }

    public function getAltura(){
        return $this->altura;
    }

    public function setAltura($altura){
        $this->altura=$altura;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->base*$this->altura/2);
    }

}//Fin de la clase

?>

Analizando el código vemos que en la cabecera se escribe extends luego de darle nombre a la subclase  en este caso Triangulo, e inmediatamente después el nombre de la superclase.

El Triangulo ahora obtiene los atributos y funciones de Figura.

La función area() se sobrescribe y se le da la nueva forma.

Creando otra subclase:

Archivo: Rectangulo.php

<?php

class Rectangulo extends Figura {//Inicio de la clase

    //Atributos
    private $ladoA;
    private $ladoB;

    //Funciones
    public function getLadoA(){
        return $this->ladoA;
    }

    public function setLadoA($ladoA){
        $this->ladoA=$ladoA;
    }

    public function getLadoB(){
        return $this->ladoB;
    }

    public function setLadoB($ladoB){
        $this->ladoB=$ladoB;
    }

    //Funcion Polimorfica
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

}//Fin de la clase

?>

Analizando la función area() podemos ver que su comportamiento cambia para ambas clases, pero siguen siendo la misma función heredada.

//Triangulo
    public function area(){
        return ($this->base*$this->altura/2);
    }

//Rectangulo
    public function area(){
        return ($this->ladoA*$this->ladoB);
    }

Para finalizar:

Archivo: index.php

<?php

include 'Figura.php';
include 'Triangulo.php';
include 'Rectangulo.php';

$triangulo = new Triangulo();
$triangulo->setNombre("Triangulo");
$triangulo->setAltura(2);
$triangulo->setBase(2);

echo 'Nombre: '.$triangulo->getNombre().', Area: '.$triangulo->area();

echo '<br/>';

$rectangulo = new Rectangulo();
$rectangulo->setNombre("Rectangulo");
$rectangulo->setLadoA(2);
$rectangulo->setLadoB(2);

echo 'Nombre: '.$rectangulo->getNombre().', Area: '.$rectangulo->area();

?>

La salida seria algo así:

Nombre: Triangulo, Area: 2
Nombre: Rectangulo, Area: 4

Recuerda hacer preguntas si tienes dudas en algo...

Los patrones de diseño se refieren a la arquitectura de un programa, a la forma en la que está construidos, ellos se crean por la necesidad de solucionar algún  problemas de forma efectiva y reusable, además pretenden estandarizar el modo en que se desarrolla e implementa el software, facilitar el aprendizaje de las nuevas generaciones de diseñadores, y generar un criterio de codigo eficiente y la optimización de una aplicación.

Un Diseñador de Software (mejor conocido como programador) demuestra su madurez profesional aplicando dichos patrones que son variados y evocados a distintas soluciones o distintos software.

OOP (programación orientada a objetos)

La oop (object-oriented programming) es una abstracción del mundo real, en otras palabras intenta imitar los objetos y circunstancias de la vida real, así como los objetos de nuestro mundo poseen características (atributos) como: color, peso, tamaño, estatura, entre otros, y comportamientos (funciones, métodos o procedimientos) como: caminar, correr, disparar, buscar, entre otras, estos objetos también los tienen, en forma de código, este código que le da forma a un objeto se le llama "clase" (class).

La oop también es conocida como paradigma de programación orientada a objetos.

PHP es un lenguaje de programación que soporta la oop y es de gran utilidad crear objetos.

Los atributos siempre serán sustantivos y las funciones verbos.

Class

Antes de empezar con el código, se puede decir que un objeto tiene dos niveles, uno que es la clase y otro que es su implementación (instancia) o creación, la clase es la plantilla por la cual se regirá la forma del objeto, por ejemplo la clase Persona, esta tiene atributos como color de cabello, estatura, nacionalidad, nombre entre otros, pero no es ninguna Persona en particular, es solo el concepto de lo que debe ser una Persona, una instancia o creación de esta clase eres tu, y yo, el escritor de este articulo, ambos tal vez con nombres, nacionalidades, y color de cabello distintos, pero los dos somos tangibles, existimos, esa es la diferencia principal entre una clase (concepto) y una instancia (realidad).

La clase es un tipo de dato creado por el desarrollador.

Ahora ¿Cómo transformamos todo esto en código PHP?:

Archivo: Persona.php

 Recomiendo que cada clase se escriba en un archivo con su nombre, es posible crear varias clases en un solo archivo PHP.

<?php

class Persona {//Inicio de la Clase

    //Atributos
    private $nombre;
    
    //Funciones generalmente Públicas
    public function getNombre(){//Puede ser cambiado por obtenerNombre()        
        return $this->nombre;
    }

    public function setNombre($nombre){//Puede ser cambiado por insertarNombre()        
        $this->nombre=$nombre;        
    }

    private function pensar($pensamiento){
        echo $pensamiento;
    }

}//Fin de la Clase

?>

Observemos que tanto los atributos como las funciones están dentro de la clase, eso se llama encapsulamiento.

Las funciones get y set son utilizadas siempre para obtener e insertar los valores de los atributos de la clase, generalmente cada atributo posee estas dos funciones asociadas.

Las funciones y atributos public son la información a la cual se puede acceder desde la instancia de la clase, (el patrón OO, exige que los atributos sean private, pero a nivel de programación se pueden hacer publicos) ejemplo, otra persona puede pedirte tu nombre, pero no puede pedirte tus pensamientos (es solo para ejemplificar), por ende las funciones y atributos private solo pueden ser accedidas dentro de la clase.

La palabra reservada $this-> se utiliza para llamar atributos y funciones de la misma clase, en este caso el nombre.

Mejorando el código:

<?php

class Persona {//Inicio de la Clase

    //Atributos
    private $nombre;
    
    //Funciones generalmente Públicas
    public function getNombre(){//Puede ser cambiado por obtenerNombre()
        $this->pensar('Entrego mi nombre<br/>');//Llamando a la función Privada
        return $this->nombre;
    }

    public function setNombre($nombre){//Puede ser cambiado por insertarNombre()
        $this->pensar('Cambio mi nombre<br/>');//Llamando a la función Privada
        $this->nombre=$nombre;        
    }

    private function pensar($pensamiento){
        echo $pensamiento;
    }

}//Fin de la Clase

?>

Así podemos ver el uso de la función privada.

Ahora:

Archivo: index .php

<?php

   include 'Persona.php';
   $objeto = new Persona();
   $objeto->setNombre('Pedro');
   echo 'Nombre '.$objeto->getNombre();

?>

Para poder darle vida a nuestro objeto primero incluimos el archivo donde se encuentra la clase, luego con la palabra reservada new instanciamos el objeto:

$objeto = new Persona();

Este sentencia crea un objeto Persona en la variable $objeto (esta variable puede tomar cualquier nombre).

y para finalizar usamos sus funciones públicas:

$objeto->setNombre('Pedro');
echo 'Nombre '.$objeto->getNombre();

el resultado seria:

Cambio mi nombre
Entrego mi nombre
Nombre Pedro

Recuerda hacer preguntas si tienes dudas en algo...