Daniel Segovia

Blog personal

Archive for the ‘4 – Programación Orientada a Objetos’ Category

Autoload

Un comentario

Cuando se escriben aplicaciones orientadas a objetos en PHP los archivos con las clases generalmente van dentro de una carpeta.
Esto es una practica común para encontrar las clases en determinado lugar.
__autoload no es una función definida en PHP, __autoload es una función que debemos definir y ésta será ejecutada cuando se instancie una clase.
Entonces si nosotros almacenamos todas nuestras clases dentro de una carpeta clases podremos instanciar la clase sin necesidad de incluir el archivo que contenga la definición de la clase. Obviamente si el archivo no está incluido producirá un error.
Un ejemplo muy común es definir el autoload y que este incluya el archivo fuente donde este la definición de la clase.

<?php
//index.php
function __autoload($fileName){
    $file = 'clases/' . $fileName.'.php';
    if (file_exists($file)){
        require_once $file;
    }
}
 
$nuevo = new nuevo;
?>
<?php
//clases/nuevo.php
class nuevo{
    function __construct(){
        echo "Clase 'nuevo' ha sido instanciada";
    }
}
?>

En este ejemplo es importante que tanto el nombre del archivo como el nombre de la definición de la clase sean los mismos para que no produzcan un error.
Cuando hago un new nuevo;, antes de hacer efectiva la instancia se ejecuta la función __autoload (debido a que esta definida) y llega como parametro el string nuevo;.
La función concatena strings ($file = ‘clases/’ . $fileName.’.php’;) y forma el path clases/nuevo.php, luego pregunta si el archivo existe y si la pregunta es afirmativa termina incluyéndolo.
Entonces sin necesidad de incluir el archivo estamos haciendo la instancia de la clase que deseábamos.
Otra de las ventajas de usar autoload es que solamente vamos a incluir los archivos que son necesarios para nosotros. Muchas aplicaciones incluyen “kilos” de código innecesariamente sobrecargando la memoria sin sentido

Written by Daniel Segovia

mayo 16th, 2011 at 6:23 pm

Posted in 4.15 __autoload

Tagged with , , , , ,

Excepciones

Hacer un comentario

Una excepción en PHP es similar a las excepciones en otros lenguajes.
Una excepción puede ser lanzada y atrapada. Dentro de un bloque try definiremos nuestros código para facilitar la captura de posibles excepciones. Cada bloque try debe poseer al menos un bloque catch, y este actuará en caso de que una excepción sea lanzada. La excepción la lanzaremos mediante throw
Cuando una excepción es lanzada todo el código que sigue a ese lanzamiento dentro del bloque try no será ejecutado, entonces el flujo del programa buscará el “catch” correspondiente a ese bloque try. De no haber un catch para ese bloque PHP omitirá un fatal error con un mensaje de “Uncaught Exception”, a menos que este definido un gestor con set_exception_handler().

<?php
function division($dividendo, $divisor) {
    if ($divisor == 0) {
        throw new Exception('Imposible dividir por 0');
    }
    else return $dividendo/$divisor;
}
 
try {
    echo division(10, 5) . "<br />";
    echo division(25, 3) . "<br />";
    echo division(8, 0) . "<br />";
} catch (Exception $e) {
    echo 'Excepción capturada: ',  $e->getMessage(), "\n";
}
 
?>

Resultado

2
8.33333333333
Excepción capturada: Imposible dividir por 0

Un ejemplo dentro de una clase
Es muy común en una clase de base de datos que se lance una excepción cuando no se puede conectar a la base.

<?php
 
class db{
 
    private $link;
 
    function __construct($host, $user, $pass, $db){
        $this->link = false;
        $this->conectar($host, $user, $pass);
        $this->selectDB($db);
    }
 
    function conectar($host, $user, $pass){
        try{
            $this->link = @mysql_pconnect($host, $user, $pass);
            if(!$this->link){
                throw new Exception('No pudo conectarse a la base de datos');
            }
        } catch (Exception $e) {
            echo 'Excepción capturada: ',  $e->getMessage(), "<br />";
        }
    }
 
    function selectDB($db){
        try{
            if(@mysql_select_db($db, $this->link) || !$this->link){
                throw new Exception('No puede seleccionarse la base de datos "'.$db.'"');
            }
        } catch (Exception $e) {
            echo 'Excepción capturada: ',  $e->getMessage(), "<br />";
        }
 
    }
}
 
//usuario, contraseña y db correctas
$db = new db('localhost', 'usuario', 'passok', 'encuentas');
//usuario y contraseña fallidas
$db = new db('localhost', 'usuario', 'passfaild', 'encuenstas');
//usuario y contrasebas correctas y nombre de db fallida
$db = new db('localhost', 'usuario', 'passok', 'dbfaild');
 
?>

Written by Daniel Segovia

mayo 6th, 2011 at 11:53 am

Posted in 4.14 Excepciones

Tagged with , , , , ,

Final para métodos y clases

Hacer un comentario

Hasta ahora hemos visto que heredando una clase podemos sobreescribir métodos en una nueva implementación. Sin embargo, hay momentos donde queremos que determinados métodos no sean sobreescritos, para esto tenemos la palabra reservada final

<?php
class Base {
   final public function test() {
       echo "Llamada a Base::test()<br />";
   }
}
 
class Implementacion extends Base {
   public function test() {
       echo "Llamada a Implementacion::test()<br />";
   }
}
// Devuelve un error Fatal: Fatal error: Cannot override final method Base::test() in test.php on line 12
?>

Sí la clase es definida como final no se ésta no podrá ser extendida.

<?php
final class Base {
   public function test() {
       echo "Llamada a Base::test()<br />";
   }
}
 
class Implementacion extends Base {
   public function test() {
       echo "Llamada a Implementacion::test()<br />";
   }
}
// Devuelve un error Fatal: Fatal error: Class Implementacion may not inherit from final class (Base) in test.php on line 12
?>

Written by Daniel Segovia

abril 25th, 2011 at 1:59 pm

Posted in 4.13 Final

Tagged with , ,

Extender interfaces

Hacer un comentario

Siguiendo con interfaces veamos con se extienden.
Al igual que las clases lo hacen con la palabra reservada extends

Usaremos parte del ejemplo anterior con la interfaz extendible, ahora trabajaremos con la luz, para encenderla o apagarla debemos tener una llave de luz.

<?php
 
interface llave{
    public function interruptor();
}
 
interface encendible extends llave{
    public function encender();
    public function apagar(); 
}
 
class luz implements encendible{
 
    protected $estado;
 
    function __construct(){
        $this->setEstado(false);
    }
 
    public function getEstado(){
        return $this->estado;
    }
 
    public function setEstado($nuevoEstado){
        $this->estado = $nuevoEstado;
    }
 
    public function encender(){
        $this->setEstado(true);
        echo "La luz ha sido se encendida<br />";
    }
 
    public function apagar(){
        $this->setEstado(false);
        echo "La luz ha sido se apagada<br />";
    }
 
    public function interruptor(){
        if($this->getEstado()){
            $this->apagar();
        }else{
            $this->encender();
        }
    }
 
}
 
$luz = new luz;
$luz->interruptor(); //La luz ha sido se encendida
$luz->interruptor(); //La luz ha sido se apagada
$luz->interruptor(); //La luz ha sido se encendida
$luz->interruptor(); //La luz ha sido se apagada
?>

Written by Daniel Segovia

abril 20th, 2011 at 6:16 pm

Posted in 4.12 Interfaces

Interfaces

Hacer un comentario

Las interfaces de objetos en PHP nos permiten especificar los métodos que deberán ser implementados por una clase sin tener que definir que acciones realizarán.
La palabra reservada para definir interfaces en PHP5 es interface
Todos los métodos declarados en la interfaz deben ser public
Para trabajar con una interfaz se usa la palabra reservada implements. Todos los métodos que están definidos en la interfaz deberán estar en la clase sino esto producirá un fatal error. Cada clase puede implementar más de una interfaz y esto se realiza llamando a cada interfaz separadas por coma.
Una clase no puede implementar interfaces que posean nombres de funciones con el mismo nombre, sino esto produciría una colisión.
Al escribir una interfaz esta puede extender de otra, al igual que las clases, utilizando extends.

Veamos las interfaces con un ejemplo practico.
Pensemos en una moto y en un cartel de publicidad, a la vista no tienen nada en común, pero puede que sí lo tengan.
Pero tienen cosas en común, ambos necesitan en algún momento ser encendidos, la moto para que funcione y el cartel necesita encender las luces cuando es de noche. Lo mismo a la inversa ambos “objetos” en algún momento necesitan ser apagados.
Entonces tenemos que la moto y el cartel necesitan ser encendidos y apagados en algún momento, con este ejemplo concreto podremos definir una interfaz que obligue a las clases tener el método encender y apagar.

<?php
interface encendible{
    public function encender();
    public function apagar(); 
}
 
class moto implements encendible{
 
    protected $nafta;
    protected $estado;
 
    function __construct(){
        $this->setNafta(2);
        $this->setEstado(false);
    }
 
    public function getNafta(){
        return $this->nafta;
    }
 
    public function setNafta($litros){
        $this->nafta = $litros;
    }
 
    public function getEstado(){
        return $this->estado;
    }
 
    public function setEstado($nuevoEstado){
        $this->estado = $nuevoEstado;
    }
 
    public function descontarNafta($litros){
        $this->setNafta($this->getNafta() - $litros);
    }
 
    public function encender(){
        if($this->getNafta() > 0){
            if(!$this->getEstado()){
                $this->setEstado(true);
                $this->descontarNafta(1);
                echo "La moto ha sido se encendida<br />";
            }else{
                echo "La moto se encuentra encendida<br />";
            }
        }else{
            echo "La moto no tiene nafta<br />";
        }
    }
 
    public function apagar(){
        if($this->getEstado()){
            $this->setEstado(false);
            echo "La moto ha sido se apagada<br />";
        }else{
            echo "La moto se encuentra apagada<br />";
        }
    } 
}
 
class cartel implements encendible{
 
    protected $estado;
 
    function __construct(){
        $this->setEstado(false);
    }
 
    public function getEstado(){
        return $this->estado;
    }
 
    public function setEstado($nuevoEstado){
        $this->estado = $nuevoEstado;
    }
 
    public function encender(){
        if(!$this->getEstado()){
            $this->setEstado(true);
            echo "El cartel publicitario ha sido se encendido<br />";
        }else{
            echo "El cartel publicitario se encuentra encendido<br />";
        }
    }
 
    public function apagar(){
        if($this->getEstado()){
            $this->setEstado(false);
            echo "El cartel publicitario ha sido se apagado<br />";
        }else{
            echo "El cartel publicitario se encuentra apagado<br />";
        }
    }
}
 
$moto = new moto;
$moto->encender(); //La moto ha sido se encendida
$moto->encender(); //La moto se encuentra encendida
$moto->apagar(); //La moto ha sido apagada
$moto->apagar(); //La moto se encuentra apagada
$moto->encender(); //La moto ha sido se encendida
$moto->apagar(); //La moto ha sido apagada
$moto->encender(); //La moto no tiene nafta
//Si seguimos jugando la moto se va a romper
 
echo "<hr />";
 
$cartel = new cartel;
$cartel->encender(); //El cartel publicitario ha sido se encendido
$cartel->encender(); //El cartel publicitario se encuentra encendido
$cartel->apagar(); //El cartel publicitario ha sido se apagado
$cartel->apagar(); //El cartel publicitario se encuentra apagado
 
?>

Written by Daniel Segovia

abril 19th, 2011 at 1:24 pm

Posted in 4.12 Interfaces

Abstracción en clases y métodos

Un comentario

PHP5 introduce el soporte para clases y métodos abstractos.
La palabra reservada para crearlos es abstract
No está permitido instanciar una clase que haya sido definida como abstract. Los métodos definidos como abstract deben obligatoriamente estar dentro de una clase abstract y éstos métodos solo declararán la estructura y nunca su implementación.
Cuando se hereda de una clase abstracta, todos los métodos de tipo abstract deben ser redefinidos en la clase child y en esa definición deben tener en mismo nivel de visibilidad o una menos restrictiva.

<?php
abstract class claseabstracta{
 
    // Forzando a definir este método
    abstract protected function getValue();
 
    public function imprimir(){
        echo $this->getValue();
    }
}
 
class clasecomun extends claseabstracta{
 
    protected function getValue() {
        return "clasecomun";
    }
}
 
$ob = new clasecomun;
echo $ob->imprimir();
?>

Written by Daniel Segovia

abril 15th, 2011 at 2:04 pm

Posted in 4.11 Abstracción

Parent y self

Hacer un comentario

PHP cuenta con 2 palabras reservadas más para trabajar dentro de las clases.
self:: hace referencia a la clase en la que estamos trabajando y se usa para acceder a propiedades y métodos estáticos o constantes.
parent:: hace referencia a la clase base

<?php
class Uno{
 
    static $mensaje = "Imprimo desde la clase 1";
 
    public function ejemplo(){
	echo self::$mensaje . "<br />";
    }
 
}
 
class Dos extends Uno{
 
    static $mensaje = "Imprimo desde la clase 2";
 
    public function ejemplo(){
	parent::ejemplo();
	echo self::$mensaje . "<br />";
    }
}
 
 
$ob = new Dos;
$ob->ejemplo();
?>

Written by Daniel Segovia

abril 14th, 2011 at 4:55 pm

Posted in 4.10 Parent y Self

Polimorfismo

Hacer un comentario

Probablemente sea la característica más importante de la programación orientada a objetos.
Describiendo una situación de la vida real será mucho más fácil entenderlo.
Supongamos que una persona puede elegir entre 2 vehículos Fiat o Ferrari, ambos tienen la posibilidad de avanzar como característica común. Ahora sí bien la finalidad de la acción es avanzar, y ambos vehículos lo puede realizar, lo harán de maneras diferentes, más rápido, con más potencia y también consumarán más o menos nafta dependiendo el vehículo elegido. Focalicemos nuestro problema en el consumo de nafta.
Este tipo de problemas podríamos resolverlo con algunos if o también con switch para descontar la cantidad de nafta adecuada o ejecutar métodos de diferentes objetos para realizar dicha tarea.
Pero para este tipo de necesidades y más tenemos polimorfismo
Entonces el polimorfismo nos permite a un mismo nombre de método representar código diferente.

Veamos el ejemplo de los vehículos representados en el código

<?php
class Vehiculo{
 
    protected $nafta = 100; //Comienza con 100 litros de nafta
 
    public function getNafta(){
	return $this->nafta;
    }
}
 
class Ferrari extends Vehiculo{
 
    public function avanzar(){
        $this->nafta -= 20;
    }
}
 
 
class Fiat extends Vehiculo{
 
    public function avanzar(){
        $this->nafta -= 8;
    }
}
 
class Usuario {
 
    private $vehiculo;
 
    function __construct($objeto){
	$this->vehiculo = $objeto;
    }
 
    public function avanzarVehiculo(){
	$this->vehiculo->avanzar();
    }
 
    public function nafta(){
	return $this->vehiculo->getNafta();
    }
}
 
$usuario1 = new Usuario (new Fiat);
$usuario1->avanzarVehiculo();
 
$usuario2 = new Usuario (new Ferrari);
$usuario2->avanzarVehiculo();
 
echo "Al Fiat del usuario 1 le quedan " . $usuario1->nafta() . " litros de nafta<br/>";
// Al Fiat del usuario 1 le quedan 92 litros de nafta
echo "Al Ferrari del usuario 2 le quedan " . $usuario2->nafta() . " litros de nafta<br/>";
// Al Ferrari del usuario 2 le quedan 80 litros de nafta
?>

Como podemos observar el constructor de la clase Usuario recibe como parámetro un objeto, éste será el vehículo con el que trabajará el usuario.
La clase Usuario posee el método avanzarVehiculo el cual trabajará directamente con el objeto que hemos pasado en el constructor y asignado posteriormente a la propiedad vehiculo.
De está manera podríamos tener infinidad de vehículos para elegir y cada uno de ellos tendrá su clase con sus especificaciones y Usuario jamás sabría con que vehículo estamos trabajando.

Written by Daniel Segovia

abril 14th, 2011 at 12:18 pm

Posted in 4.9 Polimorfismo

Tagged with , , ,

Herencia en clases

Hacer un comentario

La herencia en el concepto de objetos es muy importante y consiste en crear una clase y que ésta herede los métodos y propiedades de otra clase.
Ahora bien, pensemos en que momento nos serviría tener los métodos y propiedades en diferentes clases sí al fin y al cabo solo voy a construir un objeto.
Es cierto que podría poner todos los métodos y propiedades dentro de 1 sola clase e instanciar ésta, pero lo más importante en herencia es la reutilización que podemos darle a las clases.
Imaginemos un auto, todos los vehículos tienen cosas en común, poseen ruedas, volantes, luces y también poseen muchas acciones en común como avanzar, frenar o doblar.
Todas éstas cosas en común pueden ir en una clase base y cuando nos topemos con vehículo que tenga determinadas particularidades como ser levanta vidrios electrónicos, stereo MP3 o Air Bug podemos crear un clase especial para éste tipo de vehículo y hacerla heredar de la clase base que ya tiene todos los problemas resueltos a lo que un vehículo se refiere.
La palabra reservada para hacer herencia de clases es extends

Veamos un ejemplo de una calculadora.
Crearemos una clase con las operaciones aritméticas básicas y luego crearemos una clase con operaciones más complejas que para resolverse usarán las operaciones básicas.

<?php
class Operaciones {
 
    public function suma($primero, $segundo){
	return $primero + $segundo;
    }
 
    public function resta($primero, $segundo){
	return $primero - $segundo;
    }
 
    public function division($primero, $segundo){
	return $primero / $segundo;
    }
 
    public function multiplicacion($primero, $segundo){
	return $primero * $segundo;
    }
}
 
$operaciones_basicas = new Operaciones;
 
echo $operaciones_basicas->suma(10,15);
echo "<br />";
echo $operaciones_basicas->resta(40,25);
echo "<br />";
echo $operaciones_basicas->division(30,5);
echo "<br />";
echo $operaciones_basicas->multiplicacion(8,7);
echo "<br />";
 
unset($operaciones_basicas);
 
/* Ahora crearemos una clase para realizar operaciones complejas */
 
class Operaciones_complejas extends Operaciones{
 
    function porcentaje($numero, $porcentaje){
	$parcial = $this->multiplicacion($numero, $porcentaje);
	$resultado = $this->division($parcial, 100);
	return $resultado;
    }
}
 
$operaciones_complejas = new Operaciones_complejas;
 
echo $operaciones_complejas->porcentaje(50,15);
echo "<br />";
?>

Written by Daniel Segovia

abril 13th, 2011 at 5:15 pm

Posted in 4.8 Herencia

Tagged with , , , ,

Constantes en clases

Hacer un comentario

Ya hemos visto las constantes globales. Ahora veremos como trabajar las constantes dentro de las clases.
Para definir las constantes dentro de una clase usaremos la palabra reservada const
Las constantes pueden ser accedidas sin instanciar la clase, como las propiedades estáticas, y también a través de un método

<?php
class Estados {
    const ACTIVO = 1;
    const PENDIENTE = 2;
    const ERROR = 3;
 
    public function getActivo(){
	return self::ACTIVO;
    }
}
 
echo Estados::ERROR;
$ob = new Estados;
echo $ob->getActivo();
?>

Written by Daniel Segovia

abril 13th, 2011 at 3:09 pm

Posted in 4.7 Constantes

Tagged with , , ,

Métodos estáticos

Hacer un comentario

Similar a las propiedades estáticas PHP soporta métodos estáticos. Significa que son parte de la clase pero no serán parte del objeto cuando sea construido. Por esto no podremos acceder con $this a éstos métodos pero sí accederemos con self

<?php
class Estados {
    const ACTIVO = 1;
    const PENDIENTE = 2;
    const ERROR = 3;
 
    static function getActivo(){
	return "Activo" . self::separador();
    }
 
    static function separador(){
	return "<hr />";
    }
 
    public function getActivoFromPublicMethod(){
	return $this->getActivo();
    }
 
}
 
echo Estados::getActivo();
$ob = new Estados;
$ob->getActivoFromPublicMethod(); //ERROR
?>

Written by Daniel Segovia

abril 13th, 2011 at 3:08 pm

Posted in 4.6 Visibilidad

Propiedades estáticas

Hacer un comentario

Cómo ya hemos visto tenemos propiedades public, private y protected pero tenemos una más, las propiedades estáticas.
La palabra reservada para éstas es: static

Las propiedades o métodos de clases como estáticos los hacen accesibles sin necesidad de una instanciación de la clase, esto se hace con el nombre de la clase :: nombre_de_propiedad_o_metodo. Una propiedad declarada como static no puede ser accedida con un objeto de clase instanciado (pero si se puede con métodos estáticos).

El acceso a la propiedad static

<?php
class MiClase {
    static $miVariableEstatica = 0;
}
echo MiClase::$miVariableEstatica;
?>

El acceso a la propiedad static por medio de un método

<?php
class MiClase {
    static $miVariableEstatica = 0;
    function miMetodo(){
        print self::$miVariableEstatica;
    }
}
$obj = new MiClase();
$obj->miMetodo();
?>

Written by Daniel Segovia

abril 12th, 2011 at 5:35 pm

Posted in 4.6 Visibilidad

Tagged with , , ,

Métodos public, private y protected

Hacer un comentario

Los niveles de acceso y visibilidad son los mismos para los métodos que para las propiedades.

Public son accesibles de cualquier lugar.

<?php
class miClase
{
    public function getMensaje(){
        return "Bienvenido";
    }
 
}
 
 
$ob = new miClase();
echo $ob->getMensaje(); // Funciona
?>

Protected son accesibles sólo de la clase donde fue declarada, por herencia y clases parent

<?php
class miClase
{
    protected function getMensaje(){
	return "Bienvenido";
    }
 
}
 
class miClase2 extends miClase
{
    protected function getMensaje2(){
	return "si";
    }
 
    public function showProtected(){
	$mensajes = $this->getMensaje2() . " - " . $this->getMensaje();
	return $mensajes;
 
    }
}
 
 
$ob = new miClase2();
echo $ob->getMensaje(); // ERROR
echo $ob->getMensaje2(); // ERROR
echo $ob->showProtected(); // FUNCIONA
?>

Private pueden accederse solamente desde la clase donde fueron definidas.

<?php
class miClase
{
    private function getMensaje(){
	return "Bienvenido";
    }
 
    public function showPrivate(){
	return $this->getMensaje();
    }
 
}
 
class miClase2 extends miClase
{
    private function getMensaje2(){
	return "Si si si";
    }
 
    public function showPrivate2(){
	return $this->getMensaje2();
    }
 
    public function showAllPrivate(){
	$mensajes = $this->getMensaje2() . " - " . $this->getMensaje(); //el llamado a getMensaje producirá error
	return $mensajes;
 
    }
}
 
 
$ob = new miClase2();
echo $ob->getMensaje(); // ERROR
echo $ob->getMensaje2(); // ERROR
echo $ob->showPrivate(); // FUNCIONA
echo $ob->showPrivate2(); // FUNCIONA
echo $ob->showAllPrivate(); // ERROR
?>

Written by Daniel Segovia

abril 12th, 2011 at 4:04 pm

Posted in 4.6 Visibilidad

Tagged with , , , , , , , ,

Propiedades public, private y protected

Hacer un comentario

Public son accesibles de cualquier lugar.

<?php
class miClase
{
    public $propiedad = 'Public';
 
    function getProperty(){
        return $this->propiedad;
    }
 
}
 
 
$ob = new miClase();
echo $ob->propiedad; // Funciona
echo $ob->getProperty(); // Funciona
?>

Protected son accesibles sólo de la clase donde fue declarada, por herencia y clases parent

<?php
class miClase
{
    protected $propiedad = 'protected';
 
    function getProperty(){
        return $this->propiedad;
    }
 
}
 
class miClase2 extends miClase
{
	function getProperty2(){
		return $this->propiedad;
	}
}
 
 
$ob = new miClase2();
echo $ob->propiedad; // ERROR
echo $ob->getProperty(); // Funciona
echo $ob->getProperty2(); // Funciona
?>

Private pueden accederse solamente desde la clase donde fueron definidas.

<?php
class miClase
{
    private $propiedad = 'protected';
 
    function getProperty(){
        return $this->propiedad;
    }
 
}
 
class miClase2 extends miClase
{
	function getProperty2(){
		return $this->propiedad;
	}
}
 
 
$ob = new miClase2();
echo $ob->propiedad; // ERROR
echo $ob->getProperty(); // Funciona
echo $ob->getProperty2(); // ERROR
 
?>

Written by Daniel Segovia

abril 4th, 2011 at 1:44 pm

Posted in 4.6 Visibilidad

Tagged with , , , , , , ,

Visibilidad

Hacer un comentario

Para acceder a métodos y propiedades tenemos disponibles 3 diferentes tipos de acceso

  1. Publico: La palabra reservada es public: Los miembros declarados como public serán accesibles de cualquier lugar
  2. Protegido: La palabra reservada es protected: Los miembros declarados como protect serán accesibles sólo de la clase misma, por herencia y clases parent
  3. Privado: La palabra reservada es private: Los miembros declarados como private serán accesibles solamente desde la clase que fueron definidos

Written by Daniel Segovia

abril 4th, 2011 at 12:11 pm

Posted in 4.6 Visibilidad

Accidiento a métodos y propiedades con $this

Hacer un comentario

Durante la ejecución de un método de un objeto, automaticamente se crea la varible $this, está hace referencia al objeto en el que estamos trabajando. Es decir, desde un método podemos acceder a otros métodos o propiedades dentro del objeto.

Como vimos en el ejemplo de Representación de un diagrama tenemos la siguiente clase

<?php
 
class vehiculo{
    private $nombre;
 
    function setNombre($nombre){
        $this->nombre = $nombre;
    }
 
    function getNombre(){
        return $this->nombre;
    }
 
};
?>

En las funciones setNombre y getNombre usamos $this para acceder a la propiedad nombre.

[NOTA]
Para acceder a una propiedad o métodos usamos -> son el signo $ por delante de la propiedad, es decir $this->nombre
De la misma manera cuando tenemos un objeto instanciado y queremos acceder a los métodos o propiedades, $objeto->getNombre() u $objeto->nombre

Written by Daniel Segovia

marzo 16th, 2011 at 12:28 pm

Posted in 4.5 $this

Destructor

Hacer un comentario

Los destructores son la oposición a los constructores.
Los destructores son funciones que realizan las tareas que se necesita ejecutar cuando un objeto no existe mas.
Hay 2 situaciones donde un destructor puede ser llamado, cuando todas las referencias a un objeto son destruidas o cuando PHP finaliza toda la solicutud, esto se debe a que PHP libera la memoria y el objeto es destruido.

En este ejemplo el destructor se ejecutará por que nosotros estaremos eliminando todas las referencias de ese objeto.

<?php
class Bienvenido{
 
	function mensaje(){
		echo "Hola a todos <br />";
	}
 
	function __destruct(){
		echo "El objeto fue destruido";
	}
}
 
$objeto = new Bienvenido();
$objeto->mensaje();
$objeto = null;
 
?>

En este caso el destructor se ejecuta por que termina la ejecución

<?php
class Bienvenido{
 
	function mensaje(){
		echo "Hola a todos <br />";
	}
 
	function __destruct(){
		echo "El objeto fue destruido";
	}
}
 
$objeto = new Bienvenido();
$objeto->mensaje();
?>

Written by Daniel Segovia

marzo 11th, 2011 at 12:54 pm

Posted in 4.4 Destructor

Tagged with , ,

Constructor

Un comentario

Las instancias de una clase son creadas con la palabra reservada new como hemos visto en el ejemplo anterior. Cuando un new es ejecutado se crea una instancia de la clase y se forma el objeto. Una copia de las propiedades y métodos son replicadas al objeto y se llama al constructor de la clase sí este fue definido previamente. El constructor no es más que una simple función con un nombre preestablecido. El nombre es __construct.
Los constructores pueden aceptar argumentos y éstos son enviados cuando se instancia la clase con new

Un ejemplo.

<?php
 
class vehiculo{
    private $nombre;
 
    function __construct($nombre){
        $this->setNombre($nombre);
        echo 'Se ejecuto el constructor';
        echo '<hr />';
    }
 
    function setNombre($nombre){
        $this->nombre = $nombre;
    }
 
    function getNombre(){
        return $this->nombre;
    }
 
};
 
$ford = new vehiculo('Ford');
 
echo $ford->getNombre();
echo "<hr />";
?>

Written by Daniel Segovia

marzo 11th, 2011 at 11:52 am

Posted in 4.3 Constructor

Tagged with , , , ,

Representación del diagrama

Hacer un comentario

Vamos a llevar al código el diagrama de vehiculo

<?php
 
class vehiculo{
    private $nombre;
 
    function setNombre($nombre){
        $this->nombre = $nombre;
    }
 
    function getNombre(){
        return $this->nombre;
    }
 
};
 
$ford = new vehiculo;
$ford->setNombre('Ford');
 
$alfa = new vehiculo;
$alfa->setNombre('Alfa Romeo');
 
echo $ford->getNombre();
echo "<hr />";
echo $alfa->getNombre();
echo "<hr />";
?>

En la representación del diagrama podemos ver que la palabra reservada class la usamos para definir la clase y con la palabra reservada new instanciamos la clase y creamos el objeto

Written by Daniel Segovia

marzo 4th, 2011 at 12:31 pm

Posted in 4.3 Clases

Tagged with , , ,

Clases

Hacer un comentario

Las clases son templates de los objetos y describen que métodos y propiedades tendrán.
Un ejemplo, tenemos una concesionaria en la cual vendemos automoviles.
La clase sería vehículos y cada auto sería un objeto que viene del “esqueleto” vehículos.

La representación de la clase sería de la siguiente manera.

Representación de una clase

Written by Daniel Segovia

marzo 2nd, 2011 at 2:18 pm

Posted in 4.3 Clases

Tagged with , ,

Objetos

Hacer un comentario

La diferencia entre la programación orientada a objetos y la programación funcional es que los datos y el código estarán dentro de entidades, las cuales son conocidas como objetos.

Las aplicaciones orientadas a objetos usualmente son un número de objetos que interactuan entre sí, cada objeto normalmente es una entidad de un problema, el cual contiene un grupo de propiedades y métodos.

Las propiedades generalmente son datos almacenados en variables y los métodos son funciones que le dan soporte al objeto para hacer todo tipo de manipulación sobre sí mismo.

Written by Daniel Segovia

marzo 1st, 2011 at 1:13 pm

Posted in 4.2 Objetos

Introducción a la programación orientada a objetos

Hacer un comentario

PHP tiene suporte para objetos desde la versión 3, aunque fue realmente mucho más usado desde la versión 4.
Desde mayo del 2000, donde salió la primera versión de PHP 4, en adelante la programación orientada a objetos creció y creció a pasos agigantados. PHP debio reescribirse desde cero para tener una base más sólida con soporte a objetos. Para julio de 2004 llego la primera release de PHP 5 agregando features y cambiando el compartamiento de la base de objetos.

Sí eres nuevo en PHP este capítulo te ayudará a entender el mundo de objetos en PHP, al finalizarlo habrás aprendido.

  • EL modelo básico de programación orientada a objetos
  • Creación de objetos y como contralarlos
  • Diferentes tipos de accesos
  • Los beneficios de usar clases
  • Algunos tips

Written by Daniel Segovia

febrero 28th, 2011 at 12:58 pm

Posted in 4.1 Introducción