Post on 28-Mar-2016
description
Guía de POO en PHP• Eugenio Zuriel Torres
Hernández• Arturo Baruch
Hernández Pérez
1 Elementos que conforman una clase (atributos y metodos)Atributos: Los atributos describen el estado del objeto. Un atributo consta de dos partes, un nombre de atributo y un valor de atributo. Los objetos simples pueden constar de tipos primitivos, tales como enteros, caracteres, boolen, etc. Los objetos complejos pueden constar de pilas, conjuntos, listas, arrays, etc, o incluso de estructuras recursivas de alguno o todos de sus elementos.
$suma=new Suma();$suma->cargar1(10);$suma->cargar2(10);$suma->operar();
Métodos ( operaciones o servicios ) describen el comportamiento asociado a un objeto. La ejecución de un método puede conducir a cambiar el estado del objeto o dato local del objeto.
class Suma extends Operacion{ public function operar() { $this->resultado=$this->valor1+$this->valor2; }}
2 Referencia this
El $this es una variable incluida (construida automáticamente dentro de todos los objetos) que apunta al objeto actual. O en otras palabras, $this es una variable especial de auto-referencia. Puedes usar $this para accesar a las propiedades y llamar a otros métodos de la clase actual donde te encuentras. function get_name() { return $this->name; }
3 Diferentes formas para el paso de argumentos a un métodopasar argumentos a un método:
privados y públicos
4 Devolver un valor desde un métododevolver un valor desde un método:$micaja->introduce("algo"); $micaja->muestra_contenido(); Con estas dos sentencias estamos introduciendo "algo" en la caja y luego estamos mostrando ese contendido en el texto de la página. Nos fijamos que los métodos de un objeto se llaman utilizando el código "->".
<html><head><title>Pruebas</title></head><body><?phpclass Opcion { private $titulo; private $enlace; private $colorFondo; public function __construct($tit,$enl,$cfon) { $this->titulo=$tit; $this->enlace=$enl; $this->colorFondo=$cfon; } public function graficar() { echo '<a style="background-color:'.$this->colorFondo. '" href="'.$this->enlace.'">'.$this->titulo.'</a>'; }}
class Menu { private $opciones=array(); private $direccion; public function __construct($dir) { $this->direccion=$dir; } public function insertar($op) { $this->opciones[]=$op; } private function graficarHorizontal() { for($f=0;$f<count($this->opciones);$f++) { $this->opciones[$f]->graficar(); } } private function graficarVertical() { for($f=0;$f<count($this->opciones);$f++) { $this->opciones[$f]->graficar(); echo '<br>'; } } public function graficar() { if (strtolower($this->direccion)=="horizontal") $this->graficarHorizontal(); else if (strtolower($this->direccion)=="vertical") $this->graficarVertical(); } }
$menu1=new Menu('horizontal');
$opcion1=new Opcion('Google','http://www.google.com','#C3D9FF');
$menu1->insertar($opcion1); $opcion2=new
Opcion('Yahoo','http://www.yahoo.com','#CDEB8B');
$menu1->insertar($opcion2); $opcion3=new
Opcion('MSN','http://www.msn.com','#C3D9FF');
$menu1->insertar($opcion3); $menu1->graficar(); ?> </body> </html>
5 El constructorEl constructor es un método especial de una clase. El objetivo fundamental del constructor es inicializar los atributos del objeto que creamos.Básicamente el constructor remplaza al método inicializar que habíamos hecho en el concepto anterior.Las ventajas de implementar un constructor en lugar del método inicializar son:El constructor es el primer método que se ejecuta cuando se crea un objeto.El constructor se llama automáticamente. Es decir es imposible de olvidarse llamarlo ya que se llamará automáticamente.Quien utiliza POO (Programación Orientada a Objetos) conoce el objetivo de este método.Otras características de los constructores son:El constructor se ejecuta inmediatamente luego de crear un objeto y no puede ser llamado nuevamente.Un constructor no puede retornar dato.Un constructor puede recibir parámetros que se utilizan normalmente para inicializar atributos.El constructor es un método opcional, de todos modos es muy común definirlo.
Veamos la sintaxis del constructor: public function __construct([parámetros]) { [algoritmo] }Debemos definir un método llamado __construct (es decir utilizamos dos caracteres de subrayado y la palabra construct). El constructor debe ser un método público (public function).
6 La herencia
Es una propiedad que permite que los objetossean creados a partir de otros ya existentes,obteniendo características (métodos yatributos) similares a los ya existentes.
<?class cinta_video extends soporte{ private $duracion;
function __construct($tit,$num,$precio,$duracion){ parent::__construct($tit,$num,$precio); $this->duracion = $duracion; }
public function imprime_caracteristicas(){ echo "Película en VHS:<br>"; parent::imprime_caracteristicas(); echo "<br>Duración: " . $this->duracion; }}
function __construct($tit,$num,$precio,$duracion){ parent::__construct($tit,$num,$precio); $this->duracion = $duracion;}
$micinta = new cinta_video("Los Otros", 22, 4.5, "115 minutos");echo "<b>" . $micinta->titulo . "</b>";echo "<br>Precio: " . $micinta->dame_precio_sin_iva() . " euros";echo "<br>Precio IVA incluido: " . $micinta->dame_precio_con_iva() . " euros";
?>
7 El polimorfismoEs Ia capacidad que tienen Ios objetos de unaclase de responder al mismo mensaje oevento en funcion de Ios parametrosutilizados durante su invocacion.
<?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 ?>
8 Diferencia entre public, private y protected Public
Los elementos declarados como Public son accesibles tanto desde fuera como desde dentro de la clase.
PrivateLos elementos declarados como Private son accesibles sólo desde la misma clase donde fueron definidos.
ProtectedLos elementos declarados como Protected son accesibles desde la misma clase donde fueron definidos y en sus subclases.
Private <?php class
Vehiculo { private $marca; function __construct($marca) { $this->marca=$marca; } } $micoche = new Vehiculo("Toyota"); echo $micoche->marca; ?>
Protected <?php class Vehiculo
{ protected $marca; function __construct($marca) { $this->marca=$marca; } } class Coche extends Vehiculo { function __construct($marca) { $this->marca=$marca; } } $micoche = new coche("Toyota"); echo $micoche->marca; ?>
Public<?php class Vehiculo { public $marca; function __construct($marca) { $this->marca=$marca; } } $micoche = new Vehiculo("Toyota"); echo $micoche->marca; ?>
9 Clase abstractaExpresa Ias características esenciales de unobjeto, Ias cuales distinguen al objeto de Iosdemás.
<? Php abstract class Animal { public $tipo; function sonido(){ } function queHaceTodoElDia(){ /* nota: no se considera adecuado implementar un método en un clase abstracta. */ echo "algo "; } } class Perro extends Animal { function sonido(){ echo "guau guau "; } function tiraLeUnHueso(){ echo "ahi va ese huesito"; } } class Gato extends Animal { function sonido(){ echo "miau miau "; } function queHaceTodoEldia(){ echo "dormir "; } } $miPerro = new Perro(); $miGato = new Gato(); // $miAnimal = new Animal(); no permitido $miPerro->sonido(); $miPerro->queHaceTodoElDia(); $miPerro->tiraLeUnHueso(); echo "<br>"; $miGato->sonido(); $miGato->queHaceTodoElDia(); ?>
10 Definición de interfaceInterfaces de objetosLas interfaces de objetos permiten crear código con el cual especificamos qué métodos deben ser implementados por una clase, sin tener que definir cómo estos métodos son manipulados. Las interfaces son definidas utilizando la palabra clave interface, de la misma forma que con clases estándar, pero sin métodos que tengan su contenido definido.
implements ¶Para implementar una interfaz, se utiliza el operador implements. Todos los métodos en una interfaz deben ser implementados dentro de la clase; el no cumplir con esta regla resultará en un error fatal. Las clases pueden implementar más de una interfaz si se deseara, separándolas cada una por una coma.
<?php
abstract class animal { abstract function getowned(); private $age;
protected function __construct($age) { $this->age = $age; }
public function getage() { return $this->age; } } interface insurable { public function getvalue(); }
class pet extends animal implements insurable { private $name; public function __construct($name,$age) { parent::__construct($age); $this->name = $name; } public function getname() { return $this->name; } public function getowned() { return ("Owner String"); } public function getvalue() { return ("Priceless"); } }
class house implements insurable { public function getvalue() { return ("Rising fast"); }
} ?>
<body><h1>Interface class code</h1>
<?php
$charlie = new pet("Charlie",6); $catage = $charlie -> getage(); $catname = $charlie -> getname(); print "$catname is $catage years
old!<br><br>";
if ($charlie instanceof pet) print ("charlie is a pet<br>");
if ($charlie instanceof animal) print ("charlie is an animal<br>");
if ($charlie instanceof house) print ("charlie is a house<br>");
if ($charlie instanceof insurable) print ("charlie is insurable<br>");
?> <hr> </body>