Fundamento de poo en php

LOGO
Msig. Ing. Robert Moreira Centeno
mcrobertw@hotmail.com
Septiembre de 2016
TEMA:
«PROGRAMACIÓN ORIENTADA
A OBJETOS EN PHP»
1.- Usando Tomcat de XAMPP como server en NETBEANS.
2.- Método constructor en PHP.
3.- typekit en PHP (solo para clases y arrays).
4.- Herencia en PHP.
5.- Acceso y visibilidad de métodos y atributos.
6.- Métodos y propiedades estáticas en PHP.
7.- Constantes en PHP.
8.- Clases abstractas e interfaces.
9.- Herencia múltiple en PHP (TRAIT).
10.- Excepciones en PHP.
11.- Clases y métodos finales en PHP.
12.- Métodos de destrucción en PHP.
13.- Conversión de objeto a cadenas en PHP.
14.- Sobrecarga de métodos en PHP.
15.- Objetos clonados en PHP.
16.- Autocarga de clases en PHP.
17.- Paquetes y namespaces en PHP .
18.- Búsqueda de clases en PHP.
19.- Búsqueda de métodos en PHP.
20.- API Reflection en PHP (ingeniería inversa de clases).
21.- Constantes mágicas en PHP.
22.- PHP UNIT.
Ejercicios en:
http://ouo.io/IOUUkj

1. Usando Tomcat de XAMPP como server en NETBEANS.
Company Logo
PRIMER PASO.- Modificar el archivo en las líneas
indicadas
SEGUNDO PASO.- Agregar el server dentro de
netbeans

2. MÉTODO CONSTRUCTOR EN PHP
Company Logo
<?php
class persona{
public $edad;
public $nombre;
public function run(){
echo "estoy corriendo";
}
public function __construct($nombre,$edad)
{
$this->nombre=$nombre;
$this->edad=$edad;
}
}
$persona1=new persona("Andrea", 24);
echo $persona1->nombre;
echo " ";
$persona1->run();
?>
- El constructor lleva doble
guion bajo.
- El constructor no se
sobrecarga.

3.- typekit en PHP (solo para clases y arrays).
Company Logo
<?php
class persona{
public $edad;
public $nombre;
public function run(persona $instancia){
echo "estas corriendo en mis latidos
".$instancia->nombre;
}
public function __construct($nombre,$edad) {
$this->edad=$edad;
}
}
$persona1=new persona("Andrea",24);
echo " ";
$persona1->run($persona1);
?>
- El constructor hasta
la fecha de esta
práctica no puede
recibir instancias del
mismo tipo como
parámetro.
- Cualquier otro
método que no sea el
constructor puede tener
como argumento una
instancia del propio
tipo de la clase.

4.- Herencia en PHP.
<?php
class Animal{
public $tipo_sonido=" sin definir";
public function run(){
echo " yo corro ";
}
public function walk(){
echo " yo camino ";
}
public function __construct() {
echo " Ha nacido un animal ";
}
public function getSonido(){
echo $tipo_sonido;
}
}
class Perro extends Animal{
public function __construct(){
$tipo_sonido="ladra";
echo " Ha nacido un perro y ". $tipo_sonido." ";
}
}
class Gato extends Animal{
parent::__construct();
$tipo_sonido="maulla";
echo " Ha nacido un gato y ". $tipo_sonido." ";
}
}
$mascota1=new Gato();
$mascota2=new Perro();
if ($mascota1 instanceof Gato){
echo "Es un gato ";
if ($mascota1 instanceof Animal){
echo "Es un animal ";
}
}
?>
Forma de llamar al
constructor de la
clase principal.
Uso de instanceof para saber a que
clase corresponde una instancia

5.- Acceso y visibilidad de métodos y atributos.
<?php
class Perfil{
protected $email="valor en el padre";
public function setEmail($email){
$this->email=$email;
}
public function getEmail(){
return $this->email;
}
}
}
class HeredandoPerfil extends perfil{
$this->email="valor en el hijo";
}
}
$perfil1=new Perfil();
echo " El mail del primer perfil: ".$perfil1->getEmail();
$perfil2=new HeredandoPerfil();
echo " El mail del segundo perfil: ".$perfil2->getEmail();
?>
Los especificadores PROTECTED Y PUBLIC permiten
la herencia y el mismo resultado:
El mail del primer perfil: valor en el padre
El mail del segundo perfil: valor en el hijo
El especificador PRIVATE restringe la herencia, el
resultado con private es:
El mail del primer perfil: valor en el padre
El mail del segundo perfil: valor en el padre
Tanto PROTECTED como PRIVATE hacen que la
siguiente instrucción lance error:
$perfil1=new Perfil();
echo $perfil1->email;

6.- Métodos y propiedades estáticas en PHP.
Cuando queramos acceder a una constante o
método estático desde dentro de la clase, usamos la
palabra reservada: self.
Cuando queramos acceder a una constante o
método de una clase padre, usamos desde la clase
extendida la palabra reservada: parent
<?php
class AccesoBd{
protected static $host="localhost";
protected static $usuario="root";
protected static $clave="123456";
protected static function imprimirDatosConexion(){
return " host: ".self::$host." usuario:
".self::$usuario." clave: ".self::$clave;
}
echo $this->imprimirDatosConexion();
}
}
class InsertEnTabla extends AccesoBd{
protected $tipoPrivilegio="Insertar";
echo " Llamando al metodo constructor del padre: ";
echo parent::__construct();
echo " Accediendo a una propidad estática: ".self::$host;
echo " Accediendo a una propiedad no estatica: ".$this-
>tipoPrivilegio;
}
}
$instancia1=new AccesoBd();
$instancia2=new InsertEnTabla();
?>
No se concatenan estas dos líneas en una sola
debido a que el INTERPRETE PHP, resuelve primero
la llamada al constructor del padre y luego la
sentencia ECHO, lo que produce una salida no
deseada:
host: localhost
usuario: root
clave: 123456
Llamando al metodo constructor del padre:

<?php
class Configuracion{
const ENVIRONMENT='desarrollo';
}
}
class AccesoEnBd extends Configuracion
{
protected function generandoCadenaConexion(){
if ('desarrollo' == self::ENVIRONMENT){
echo "generando cadena de conexion para ambiente de
desarrollo";
}
}
$this->generandoCadenaConexion();
}
}
$instancia= new AccesoEnBd();
?>
7.- Constantes en PHP.
Las constantes en PHP igual que elementos estáticos
son accedidos con self.
this hace referencia al objeto (propiedades y
métodos que se crean al instanciar una clase).
self hace referencia a la clase (propiedades y
métodos que están disponibles para acceso en una
clase sin necesidad de que esta se instancie.
La importancia de las constantes se ve por
ejemplo en una clase de configuración para
manejo de la cadena de conexión.

8.- Clases abstractas e interfaces (PARTE 1 DE 2).
las clases abstractas nos permiten limitar y/o definir
con precisión las capacidades de cada objeto. En el
ejemplo sería no dable (a menos que se quite el
abstract)una definición como esta:
$fruta = new Fruta();
$fruta->comer();
Ya que de poderse invocar al método comer, no
cabría una interpretación en función de la POO con
una pregunta como por ejemplo:
¿A qué te supo la fruta?
Las clases abstractas entonces son aquellas que no
son instanciadas, se utilizan para definir estructura y
funcionalidad.
En las clases abstractas se puede definir
funcionalidad, en este caso por ejemplo hay
funcionalidad en el método “setColor” de la clase
Fruta.
<?php
abstract class Fruta {
private $color;
abstract public function comer();
public function setColor($c) {
$this->color = $c;
}
}
class Manzana extends Fruta {
public function comer() {
echo " Masticar hasta llegar al Centro";
}
}
class Naranja extends Fruta {
public function comer() {
echo " Pelar la Naranja";
echo " Masticar";
}
}
$manzana = new Manzana();
$manzana->comer();
?>

8.- Clases abstractas e interfaces (PARTE 2 DE 2).
En las interfaces no se puede definir
funcionalidad, es decir ningún método tiene llaves
de entrada y cierre en el que haya código
Las interfaces nos permiten compartir
comportamientos entre objetos no relacionados
<?php
interface iDB{
public function connect();
}
class MySQL implements iDB{
public function connect(){
echo " Conectandose a Mysql";
}
$this->connect();
}
}
class Oracle implements iDB{
public function connect(){
echo " Conectandose a Oracle";
}
$this->connect();
}
}
$conexinMysql=new MySQL();
$conexionOracle=new Oracle();
?>

<?php
class Fruta{
function cosechar(){
echo "la fruta es el ovario...";
}
}
class Verdura{
function cosechar(){
echo "agarrala de cualquier parte...";
}
}
class ClaseQueHereda extends Fruta, Verdura{
}
?>
9.- Herencia múltiple en PHP.
En PHP la herencia múltiple no esta permitida.
<?php
trait Fermentacion{
function fermentar(){
echo "fermentando ". $this->materiaPrima." ";
}
}
class Whisky{
use Fermentacion;
public $materiaPrima="Cereal";
function proceso(){
echo "El whisky se obtiene: ";
echo Fermentacion::fermentar();
}
}
class Cerveza{
use Fermentacion;
public $materiaPrima="Cebada";
function proceso(){
echo "La cerverza se obtiene: ";
echo Fermentacion::fermentar();
}
}
$bebida1=new Whisky();
$bebida2=new Cerveza();
$bebida1->fermentar();
$bebida2->fermentar();
$bebida1->proceso();
$bebida2->proceso();
?>
La variable $materia prima a usarse en el
trait debe especificarse tanto en la clase
Cerveza como en la clase Whisky.
CODIGO 1 CODIGO 2
La referencia
$this es necesaría
debido a que
indicará que se
usa la variable
$materiaPrima de
cada clase.

10.- Excepciones en PHP.
1. La definición de una excepción
siempre debe heredar de la clase
genérica Exception.
2. Una excepción puede ser
lanzada ("thrown"), y atrapada
("catched").
3. Se pueden usar múltiples
bloques catch para atrapar
diferentes clases de excepciones.
4. El código de dentro del
bloque finally siempre se ejecutará
después de los bloques try y catch,
independientemente de que se
haya lanzado una excepción o no.
5. El orden de los catch debe ir
ordenado desde lo más específico
hasta lo más genérico, así se ve
que el último catch es:
catch (Exception $exc)
<?php
class DBException extends Exception{}
class FILEException extends Exception{}
class Main
{
public function __construct()
{
try
{
throw new DBException("No se conecta a la base de datos");
//throw new FILEException("No se conecta al archivo de texto");
}catch (FILEException $exc)
{
echo "Error en archivo de texto: ".$exc->getMessage()." ";
}
catch (DBException $exc)
{
echo "Error en base de datos: ".$exc->getMessage()." ";
}
catch (Exception $exc)
{
echo "Error genérico: ".$exc->getMessage()." ";
}
finally
{
echo "Cerrando medio de almancenamiento usado";
}
}
}
$instancia =new Main();
?>

11.- Clases y métodos finales en PHP.
<?php
class ClasePadre{
final public function metodoQueSePretendeHeredar()
{
echo "Método para heredar";
}
}
class ClaseHija extends ClasePadre{
public function metodoQueSePretendeHeredar()
{
echo "Intentando reescribir método";
}
}
$instancia =new ClaseHija();
?>
<?php
final class ClasePadre{
public function metodoQueSePretendeHeredar()
{
echo "Método para heredar";
}
}
class ClaseHija extends ClasePadre{
public function metodoQueSePretendeHeredar() {
echo "Intentando reescribir método";
}
}
$instancia =new ClaseHija();
?>
La palabra clave final, impide que las clases hijas
sobrescriban un método, antecediendo su
definición con final. Por ello este código
devuelve error al ejecutarlo
Si la propia clase se define como final,
entonces no se podrá heredar de ella. Por
ello este código devuelve error al ejecutarlo.

<?php
class ChuckNorris{
echo "Creando instancia ";
}
public function __destruct() {
echo " Borrando instancia";
}
}
$rangerTexas=new ChuckNorris();
for($i=1;$i<10;$i++){
echo $i."-";
if ($i==5)
unset($rangerTexas);
}
exit();
?>
12.- Métodos de destrucción en PHP.
El método destructor será llamado tan
pronto como no hayan otras referencias a
un objeto determinado (finalizó el script
PHP), o en cualquier otra circunstancia de
finalización (ejecutó la instrucción EXIT, o se
llamo al destructor explícitamente a través
de unset($instanciaCreada))

<?php
class Persona{
public $nombre, $apellido;
public function __construct($nombre,$apellido) {
$this->apellido=$apellido;
}
public function __toString() {
return $this->nombre." ".$this->apellido;
}
}
$donMario=new Persona("Mario", "Cedeño");
echo $donMario;
?>
13.- Conversión de objeto a cadenas en PHP.
El método toString permite configurar a
una clase para que sus instancias no
den error, cuando se las intenta usar
como cadenas de texto.

<?php
class mujer{
public $nombre;
public $colorOjo;
public $tezPiel;
public $signoZodiacal;
public function __construct($nombre, $colorOjo, $tezPiel, $signoZodiacal) {
$this->colorOjo=$colorOjo;
$this->tezPiel=$tezPiel;
$this->signoZodiacal=$signoZodiacal;
}
public function __call($name, $arguments) {
$no_existe_metodo=TRUE;
$verboMetodo= substr($name, 0,3);
$accionMetodo=substr($name, 3);
if ($verboMetodo=='get')
{
$no_existe_metodo=FALSE;
return $this->$accionMetodo;
}
if ($verboMetodo=='set')
{
$no_existe_metodo=FALSE;
$this->$accionMetodo=$arguments[0];
}
if ($no_existe_metodo)
{
throw new Exception("Método no definido");
}
}
}
$Andrea=new mujer("Andrea", "Negro", "Trigueña", "Tauro");
echo $Andrea->getnombre()." ";
$Andrea->setnombre("Karol");
echo $Andrea->getnombre()." ";
echo $Andrea->getprueba();
?>
14.- Sobrecarga de métodos en PHP.
El método call recibe dos parámetros,
uno es el nombre del método al que se
intenta invocar.
Por ejemplo, en la línea:
$Andrea->setnombre("Karol");
El método call recibe como nombre
“setnombre” y en $arguments recibe
“Karol” que estaría en $arguments[0]

<?PHP
class VentanaSingleton{
private static $instancia;
public $aplicacion;
private function __construct(){}
public function construirVentana()
{
if(self::$instancia==null)
{
self::$instancia = new static();
return self::$instancia;
}
}
}
//$ventana=new VentanaSingleton();
$ventana1= VentanaSingleton::construirVentana();
$ventana1->aplicacion="Word";
$ventana2= $ventana1;
$ventana2->aplicacion="Power Point";
echo " Antes de usar la función clone";
echo "Ventana 1 es: {$ventana1->aplicacion} y Ventana 2 es:
{$ventana2->aplicacion}";
$ventana2=clone $ventana1;
$ventana2->aplicacion="Excel";
echo " Después de usar la función clone";
echo "Ventana 1 es: {$ventana1->aplicacion} y Ventana 2 es:
{$ventana2->aplicacion}"
?>
15.- Objetos clonados en PHP.
1. Al definir el constructor como privado
no será posible instanciar usando la
instrucción.
$ventana=new VentanaSingleton();
2. Al usar la instrucción :
$ventana2= $ventana1;
Se hace que ambas apunten a la misma
referencia de objeto en memoria, por lo
tanto la salida será:
Power Point
3. Al usar la instrucción :
$ventana2=clone $ventana1;
Se hace que ambas apunten a distinta
referencia de objeto en memoria, por lo
tanto la salida será:
Power Point y Excel.

16.- Autocarga de clases en PHP.
1. Cada vez que se ejecuta un new y no
encuentra la correspondiente clase, se
dispara la función
“spl_autoload_register()”
2. La función
“spl_autoload_register()”
recibe como argumento el
nombre de las clases que se
quieren instanciar en new:
Config y Config2
<?php
function CargadorClase($class){
include $class.'.php';
}
spl_autoload_register('CargadorClase');
?>
AutoLoad.php
<?php
require_once ('AutoLoad.php');
$instConfig=new Config();
$instConfig2=new Config2();
echo $instConfig::ENTORNO;
echo " ";
echo $instConfig2::ENTORNO;
?>
index.php
<?php
class Config{
const ENTORNO="DESARROLLO";
}
?>
Config.php y Config2.php
Muchos desarrolladores que escriben aplicaciones orientadas a objetos
crean un fichero fuente de PHP para cada definición de clase. Una de
las mayores molestias es tener que hacer una larga lista de inclusiones
al comienzo de cada script (uno por cada clase).
La función spl_autoload_register() registra cualquier número de
autocargadores, posibilitando que las clases e interfaces sean cargadas
automáticamente si no están definidas actualmente.
es una especie de última opción de cargar un archivo que necesitamos
y funciona de la siguiente manera: Cuando se necesita una clase
(haciendo un new, en un extends, un implements, etc…) si la clase no
está cargada se llama a la función mágica spl_autoload_register()

17.- Paquetes y namespaces en PHP (Parte 1 de 2).
1) Siempre que utilicemos un namespace directamente hay que empezar con
un slash invertido. Ejemplo:
$carro = CodeheroCursosCarro::rodar();
2) Para separar los namespaces se utiliza la barra invertida ( ), veamos
algunos subnamespaces validos.
ProyectoBDMySQL
ProyectoBDMongo
3) Cuando tenemos muchas funciones que debemos llamar de varios
namespaces es muy tedioso escribir todas las rutas completas. Para esto
existe la opción de importar namespaces con la sentencia use. Se pueden
importar todos los que sean necesarios, veamos un ejemplo de como
importarlos:

17.- Paquetes y namespaces en PHP (Parte 2 de 2).
1. Pueden ser sustituidos por una
función de autoload.
Facebook.php
index.php
Tweeter.php
<?php
require_once 'redessociales/Facebook.php';
require_once 'redessociales/Tweeter.php';
use redessocialesFacebookPublicacion as Face;
use redessocialesTweeterPublicacion as Tweet;
class Principal{
public $post1;
public $post2;
$this->post1=new Face();
$this->post2=new Tweet();
}
}
$instancia=new Principal();
echo $instancia->post1->getContenido()." ";
echo $instancia->post2->getContenido();
?>
<?php
namespace redessocialesFacebook;
class Publicacion
{
const PLATFORM = 'facebook';
private $estado;
function __construct()
{
$this->estado = "Trotando";
}
public function getContenido()
{
return $this->estado;
}
}
?>
<?php
namespace redessocialesTweeter;
class Publicacion
{
const PLATFORM = 'tweeter';
private $tweet;
function __construct()
{
$this->tweet = "Saliendo de casa";
}
public function getContenido()
{
return $this->tweet;
}
}
?>

<?php
class Animal{
public $numeroPatas;
}
class Perro{
public function morder(){
echo "analizando víctima...";
}
}
//echo class_exists("Animal");
$clases=['Animal','Gato','Perro'];
foreach($clases as $clase){
echo " La clase ". $clase .":" .
(class_exists($clase)?' Si existe ': ' No existe ');
}
?>
18.- Búsqueda de clases en PHP.
Esta función verifica si la clase dada ha sido
definida o no, el nombre es coincidido de
manera insensible a mayúsculas y minúsculas.

<?php
abstract class AcariciarAlAmo{
public function caricia(){echo "Lamiendo la mano..";}
}
interface Enterrar{
public function moverTierra();
}
trait Olfato{
public function oler(){
echo" usando la nariz...";
}
}
class Animal extends AcariciarAlAmo{
Use Olfato;
}
class Perro extends AcariciarAlAmo implements Enterrar{
Use Olfato;
echo " analizando víctima...";
}
public function moverTierra() {
echo " arando con las patas traseras";
}
public function __construct() {}
}
$instancia=new Perro;
var_dump(get_class_methods($instancia));
?>
19.- Búsqueda de métodos en PHP.
Devuelve un array con los nombres de los
métodos definidos para la clase especificada
por class_name. Es caso de error devuelve
NULL.. La salida de la instrucción muestra:
Morder – Método propio
moverTierra – Método de interface
__construct
caricia – Método heredado de clase abstracta
oler – Método del trait usado para herencia
múltiple

<?php
abstract class AcariciarAlAmo{
public function caricia(){echo "Lamiendo la mano..";}
}
interface Enterrar{
public function moverTierra();
}
trait Olfato{
public function oler(){
echo" usando la nariz...";
}
}
class Animal extends AcariciarAlAmo{
Use Olfato;
}
class Perro extends AcariciarAlAmo implements Enterrar{
Use Olfato;
echo " analizando víctima...";
}
public function moverTierra() {
echo " arando con las patas traseras";
}
public function __construct() {}
}
$reflect_class =new ReflectionClass('AcariciarAlAmo');
Reflection::export($reflect_class);
echo $reflect_class->getName()." ";
echo $reflect_class->isAbstract()." ";
echo $reflect_class->isInstantiable()." ";
echo $reflect_class->isInternal()." ";
?>
20.- API Reflection en PHP (ingeniería inversa de clases).
Ofrece varias formas de obtener comentarios
de documentación de funciones, clases y
métodos.

<?php
class FILEException extends Exception{};
class Loger{
public $name;
public static function log($text)
{
try
{
throw new FILEException("No se guardo en el archivo");
} catch (Exception $ex) {
$prefix=date('d-m-Y- h:i:s ::: ');
file_put_contents('log.txt',
$prefix . "Error en el archivo: " . __FILE__ .
" En la línea: " . __LINE__ .
" En la clase: " . __CLASS__ .
" En el método: ".__METHOD__.
" En el trait: ".__TRAIT__."n",
FILE_APPEND);
}
}
}
Loger::log("Mensaje por si acaso");
?>
21.- Constantes mágicas en PHP.
PHP ofrece un largo número
de constantes predefinidas a
cualquier script en ejecución.
Muchas de estas constantes, sin
embargo, son creadas por
diferentes extensiones, y sólo
estarán presentes si dichas
extensiones están disponibles,
bien por carga dinámica o
porque han sido compiladas.
Para este ejemplo fue
necesario crear un
archivo log.txt en el
directorio del proyecto
web.
file_put_contents
recibe 3 argumentos

22.- PHP UNIT (PARTE 1 DE 3) – Probándolo desde
consola
1) Descargar el proyecto PHPUNIT en https://phpunit.de/ se descargará un archivo con extensión PHAR.
Los archivos phar son similares en concepto a los archivo JAR de Java, pero están adaptados a las necesidades y a
la flexibilidad de apliciones de PHP. Un archivo Phar se usa para distribuir una aplicación o biblioteca PHP
completa en un único fichero
2) Configurar para usarlo
2.1 CONFIGURACIÓN PARA USAR PHP UNIT DESDE CONSOLA
- Copiar el archivo descargado dentro del directorio C:xamppphp
- En “variables de Entorno” -> “variables de sistema” agregar la siguiente entrada: C:xamppphp.
- Ejecutar la siguiente instrucción en consola:
<?php
require_once ('AutoLoad.php');
class Operacion extends PHPUnit_Framework_TestCase{
protected $valor1;
protected $valor2;
protected $resultado;
public function testcargar1($v){
$this->valor1=$v;
}
}
$instancia=new Operacion();
$res=$instancia->testcargar1($v);
?>
Para que PHPUnit funcione con el método
de una clase, hay que escribir test delante
del método que quiera probarse, en este
caso: testcargar.
Se debe agregar esta herencia
en la cabecera de una clase que
será revisada con PHPUnit.
Código que arroja error para PHPUnit

netbeans y XAMPP
Este se descarga de la dirección
https://phpunit.de/
PASO 1
PASO 2
PASO 3
Se selecciona el interprete de PHP
Crear un folder llamado test dentro del
proyecto, y generar los dos archivos que
se indican.

netbeans
<?php
class Empleado extends PHPUnit_Framework_TestCase{
public $nombre;
public $salario;
public $alta;
public function __construct($nombre,$salario,$alta) {
$this->salario=$salario;
$this->alta=$alta;
}
public function testgetNombre(){
return $this->nombre;
}
public function testgetSalario(){
return $this->salario;
}
public function testgetAlta(){
return $this->alta;
}
}
$empleado1=new Empleado("Luis", 1000, "Febrero");
$res=$empleado1->testgetNombre();
echo $res;
?>
Código que no arroja error para PHPUnit

Fundamento de poo en php

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (19)

Similar a Fundamento de poo en php

Similar a Fundamento de poo en php (20)

Más de Robert Moreira

Más de Robert Moreira (10)

Último

Último (13)

Fundamento de poo en php