Aprenda Programacin Orientada a Objetos (POO) en PHP

Por: Stefan Mischook - Septiembre 07 2007

www.killerphp.com - www.killersites.com - www.idea22.com
Prembulo:
La cosa mas difcil para aprender ( ense!ar dicho sea de paso" en P#P orientado
a ob$etos es... lo b%sico. Pero &na 'e( )&e obten*as el conocimiento+ el resto
'endr% m&cho+ m&cho mas f%cil.
Pero no te desanimes, -& has encontrado el t&torial mas f%cil de entender sobre
P.. P#P.
/sto podra sonar como &n reclamo $actancioso... lo se. Pero eso es lo )&e los nerd
del (eit*eist est%n diciendo.
... . al menos es lo )&e he esc&chado.
Vdeos:
0omo &n bon&s e1tra+ he creado &nos t&toriales de 'deo para ti. /llos c&bren el
mismo material como el artic&lo escrito+ son dise!ados para refor(ar el artic&lo.
2 3ntrod&cci4n a P#P .rientado a .b$etos (5:06"
2 Por)&e 7prender P#P .rientado a .b$etos (85:59"
2 .b$etos 0lases en P#P (6:29"
2 0onstr&ir .b$etos en P#P : Parte 8 (;:85"
2 0onstr&ir .b$etos en P#P - Parte 2 (;:58"
2 0onstr&ir .b$etos en P#P - Parte < (9:8="
Si tienes pre*&ntas>comentarios+ p&edes contactarme en: stefan?killersites.com
@racias+
Stefan Mischook
Programacin Orientada a Objetos en PHP
La Pro*ramaci4n .rientada a .b$etos (P.." es &n tipo de pro*ramaci4n a*re*ada
a P#P 6 )&e hace de la constr&cci4n comple$a+ mod&lar re&sable de aplicaciones
web m&cho mas f%cil
0on el lan(amiento de P#P 6+ los pro*ramadores en P#P finalmente tienen el
poder de pro*ramar como los *randes. 7si como Aa'a 0B+ P#P finalmente tiene
&na completa infraestr&ct&ra P...
/n este t&torial+ seras *&iado (paso a paso" a tra'Cs del proceso de constr&ir
traba$ar con ob$etos &sando las capacidades de P... 7l mismo tiempo aprender%s:
2 La diferencia entre constr&ir &na aplicaci4n al estilo anti*&o (por procedimiento"
'ers&s la manera P...
2 0&ales son los principios b%sicos de la P.. como se &san en P#P.
2 0&ando debes &sar P.. en t&s scripts P#P.
La *ente entra en conf&si4n c&ando pro*rama por falta del entendimiento de lo
b%sico 0on esto en mente+ 'amos a pasar lentamente sobre los tema b%sicos de la
P.. mientras creamos n&estros propios ob$etos en P#P.
0on este conocimiento+ podr%s ser capa( de e1plorar P.. a&n mas. Para este
t&torial+ debes entender &n poco lo b%sico de P#P: f&nciones+ 'ariables+
condicionales b&cles o repeticiones.
Para hacer las cosas mas f%cil+ el t&torial se enc&entra di'idido en 2< pasos:
Paso 1:
Primera cosa )&e necesitamos es crear dos pa*inas P#P:
indexp!p
class"libp!p
La P.. trata acerca de crear c4di*o mod&lar+ de manera )&e n&estro c4di*o P#P
orientado a ob$etos sera contenido en archi'os dedicados )&e ser%n insertados en
n&estra pa*ina P#P &sando Dincl&desD de P#P. /n este caso todo n&estro c4di*o
P#P .. estar% en el archi'o P#P:
class"libp!p
..P se re'&el'e alrededor de &na estr&ct&ra constr&ida llamada EclaseE (class". Las
clases son los encar*ados de definir las plantillas )&e posteriormente son &sadas
para la definici4n de ob$etos.
Paso #:
0rea &na clase en P#P
/n 'e( de tener &n mont4n de f&nciones+ 'ariables c4di*o flotando de manera
espont%nea+ para dise!ar s&s scripts P#P o libreras de c4di*os a la manera de
P..+ necesitaras definir>crear t&s propias clases.
Fefines t&s propias clases comen(ando con la palabra cla'e DclassD (clase" se*&ida
del nombre )&e le )&iere dar a s& n&e'a clase.
<?php
class person {
}
?>
Paso $:
7*re*a datos a t& clase
Las clases son los planos de los ob$etos P#P- mas sobre esto l&e*o. Gna de las
*randes diferencias entre las f&nciones clases es )&e la clase contiene ambos
datos ('ariables" f&nciones )&e forman &n pa)&ete llamado &n Dob$etoD. 0&ando
t& creas &na 'ariable dentro de &na clase+ es llamada &na DpropiedadD.
<?php
class person {
var name;
}
?>
%ota: Los datos>'ariables dentro de &na clase (e$: 'ar name " son llamados
DpropiedadesD.
Paso &:
7*re*a f&nciones mCtodos a t&s clases.
Fe la misma manera )&e las 'ariables obtienen &n nombre diferente c&ando son
creadas dentro de &na clase (llamadas: propiedades" las f&nciones tambiCn
referidas como (por los nerds" con &n nombre diferente c&ando son creadas dentro
de &na clase : son llamadas HmCtodosI.
Los mCtodos de las clases son &sados para manip&lar s& propios
datos>propiedades.
<?php
class person {
var $name;
function set_name($new_name) {
$this->name = $new_name;
}
function get_name() {
return $this->name;
}
}
?>
%ota: Jo ol'ides )&e en &na clase+ las 'ariables son llamadas DpropiedadesD.
Paso ':
K&nciones )&e obtienen )&e establecen.
#emos creado dos f&nciones>mCtodos interesantes: *etLname(" setLname(".
/stos mCtodos si*&en &na con'enci4n de P.. )&e t& podr%s 'er en m&chos
len*&a$es (incl&endo Aa'a M&b" donde creas mCtodos )&e establecen
obtienen propiedades en &na clase.
.tra con'enci4n (&na con'enci4n para nombrar" es )&e los nombres para obtener
(*etLname" establecer (setLname" deberan ser similares a los nombres de las
propiedades (name".
<?php
class person {
var $name;
function set_name($new_name) {
$this->name = $new_name;
}
function get_name() {
return $this->name;
}
}
?>
%ota: Jotese )&e los nombres )&e obtienen establecen (setLname *etLname"
hacen $&e*o con el nombre de propiedad asociada (name". Fe esta manera+ si otros
pro*ramadores P#P )&ieren &sar s&s ob$etos+ ellos sabr%n )&e tienes &n
mCtodo>f&nci4n llamado DsetLname("D (establecer nombre"+ el c&al se relaciona
con la propiedad>'ariable llamada DnameD (nombre".
Paso (:
La 'ariable ENthisE
Oa probablemente has notado esta linea de c4di*o:
$this->name = $new_name
/l Nt!is es &na 'ariable incl&ida (constr&ida a&tom%ticamente dentro de todos los
ob$etos" )&e ap&nta al ob$eto act&al. . en otras palabras+ Nthis es &na 'ariable
especial de a&to-referencia. P&edes &sar Nthis para accesar a las propiedades
llamar a otros mCtodos de la clase act&al donde te enc&entras.
function get_name() {
return $this->name;
}
%ota: /sto podra ser &n poco conf&so para ti... esto es por)&e lo estas 'iendo por
primera 'e(+ es &na de a)&ellas capacidades del .. (constr&idas dentro del mismo
P#P 6" )&e hace las cosas a&tom%ticamente para nosotros. Por ahora+ solo piense
de Nthis como &na palabra cla'e ... 0&ando P#P se enc&entra con esta 'ariable+
el motor P#P sabe )&e hacer.
... M& pronto t& tambiCn sabr%s )&e hacer con ella.
Paso ):
3ncl&e t& clase en la pa*ina principal de P#P.
-& n&nca deberas crear t&s clases P#P directamente dentro de las pa*inas
principales de P#P: esto eliminara el prop4sito o esencia del &so de P#P
orientado a ob$etos.
/n 'e( de esto+ la me$or practica es crear pa*inas de P#P separadas )&e solo
conten*an las clases. Fe esta forma accesarias a s&s ob$etos clases P#P
incl&Cndolas en t& pa*ina P#P principal con &n Dincl&deD o Dre)&ireD.
<!"#$%&'( html ')*+,$ --../0$.."%" 12%3+ 45 %ransitional..(6-
-http7..wwww0org.%8.9html4."%".9html4-transitional:t:->
<html 9mlns=-http7..wwww0org.4;;;.9html->
<hea:>
<meta http-e<uiv=-$ontent-%=pe- content=-te9t.html; charset=iso->>?;-4- .>
<title>##' in '2'<.title>
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<.@o:=>
<.html>
%ota: Jota como no hemos hecho nada con n&estra clase a&n. Lo haremos en el
si*&iente paso.
Paso *:
3nstancia>crea t& ob$eto
Las clases son planos>plantillas de ob$etos en P#P. Las clases no se hacen ob$etos
hasta )&e reali(as al*o llamado: instanciamiento.
0&ando t& instancias &na clase+ creas &n instancia de ella ('al*a la red&ndancia"+
creando as el ob$eto.
/n otras palabras+ el instanciamiento es el proceso de crear de &na clase+ &na
ob$eto en memoria. P&e memoriaQ La memoria del ser'idor por s&p&esto.
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
$stefan = new person();
<.@o:=>
<.html>
%ota: La 'ariable Nstefan 'iene a ser la referencia>mane$ador de n&estro n&e'o
ob$eto de persona creado. Oo llamo a Nstefan &n Dmane$adorD+ por)&e &saremos a
Nstefan para controlar &sar el ob$eto persona.
Si e$ec&tas el c4di*o P#P ahora+ no podr%s 'er nada mostrado en la pa*ina. La
ra(4n para esto+ es )&e no le hemos dicho a P#P )&e ha*a al*o con el ob$eto )&e
acabamos de crear.
Paso +:
La palabra cla'e DnewD (n&e'o"
Para crear &n ob$eto f&era de &na clase debe &sarse la palabra cla'e DnewD.
0&ando creas>instancias &na clase+ p&edes opcionalmente a*re*ar lla'es al nombre
de la clase+ como o hice en el e$emplo de aba$o. Para estar claro+ t& p&edes 'er en
el c4di*o de aba$o como o p&de crear mRltiples ob$etos de la misma clase.
Fesde el p&nto de 'ista del motor P#P+ cada ob$eto es s& propia entidad. -iene
sentidoQ
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
$stefan = new person();
$Aimm= = new person;
<.@o:=>
<.html>
Jota: 0&ando estCs creando &n ob$eto+ ase*Rrate de no encerrar el nombre de la
clase en comillas simples o dobles. Meali(ar esto ocasionara &n error a )&e en
'e( de ser &na clase seria &na cadena de caracteres
Por e$emplo:
$stefan = new BpersonB;
... te dar% &n error.
Paso 1,:
/stableciendo las propiedades del ob$eto.
7hora )&e hemos creado>instanciado n&estros dos ob$etos separados DpersonaD+
podemos establecer s&s propiedades &sando los mCtodos (setLname *etLname"
)&e nosotros hemos creado.
-en*a en mente )&e a&n)&e ambos de n&estros ob$etos personas (Nstefan Nnick"
son basados en la misma clase DpersonD+ a lo )&e concierne a P#P+ son ob$etos
totalmente diferentes.
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
$stefan = new person();
$Aimm= = new person;
$stefan->set_name(-Ctefan 3ischooD-);
$Aimm=->set_name(-6icD /a::les-);
?>
<.@o:=>
<.html>
Paso 11:
7ccesando los datos del ob$eto.
7hora nosotros &samos el mCtodo *etLname para obtener acceso a los datos
mantenidos en n&estros ob$etos... son los mismos datos )&e nosotros insertamos en
n&estros ob$etos &sando el mCtodo setLname.
0&ando accesamos a los mCtodos propiedades de &na clase+ &samos el operador
(-S" llamado .perador Klecha o tCcnicamente .perador de .b$etos.
T?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
$stefan = new person();
$Aimm= = new person;
$stefan->set_name(-Ctefan 3ischooD-);
$Aimm=->set_name(-6icD /a::les-);
echo -CtefanBs full name7 - $stefan->get_name();
echo -6icDBs full name7 - $Aimm=->get_name();
?>
<.@o:=>
<.html>
%ota: /l operador flecha (-S" no es el mismo operador &sado con los arre*los
asociati'os: (US".
Kelicitaciones. Oa lle'as la mitad del camino a tra'Cs del t&torial. -iempo para
tomarte &n receso al*o de te. .V de repente &n poco de cer'e(a.
/n bre'e+ habr%s:
2 Fise!ado &na clase P#P.
2 @enerado>creado &n par de ob$etos basado en t& clase.
2 3nsertado datos en t&s ob$etos.
2 Mec&perado datos de t&s ob$etos.
... Jo tan mal para t& primer da en P#P P...
Si no lo has hecho a&n+ ahora es el *ran momento para escribir c4di*o 'erlo en
acci4n en t&s propias pa*inas P#P.
Paso 1#:
Firectamente accesando las propiedades - Jo lo ha*as,
Jo tienes )&e &sar mCtodos para accesar a las propiedades de los ob$etosW P&edes
directamente lle*ar a ellos &sando el operador flecha (-S " el nombre de la
'ariable.
Por e$emplo: con la propiedad Nname (en el ob$eto Nstefan+" t& podras obtener s&
'alor de la si*&iente manera:
$stefan -> name
7&n)&e se p&ede hacer+ es considerado &na mala practica hacerlo por)&e p&ede
lle'ar a &n problema en el camino. Feberas &sar mCtodos como el *etLname para
obtener el 'alor : mas sobre esto l&e*o.
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
$stefan = new person();
$Aimm= = new person;
$stefan->set_name(-Ctefan 3ischooD-);
$Aimm=->set_name(-6icD /a::les-);
.. :irectl= accessing properties in a class is a no-no
echo -CtefanBs full name7 - $stefan->name;
?>
<.@o:=>
<.html>
Paso 1$:
0onstr&ctores
-odos los ob$etos tienen &n mCtodo incorporado llamado &n Dconstr&ctorD. Los
constr&ctores le permiten iniciali(ar las propiedades de s&s ob$etos (trad&cci4n:
dar 'alores a las propiedades" c&ando instancias (creas" &n ob$eto.
%ota: Si creas &na f&nci4n constr&ct(" (si es s& opci4n"+ P#P a&tom%ticamente
llamara el mCtodo>f&nci4n constr&ctor c&ando haas creado el ob$eto desde s&
clase.
/l mCtodo Dconstr&ctD comien(a con dos s&braados (LL" la palabra Econstr&ctE.
/l mCtodo constr&ctor se DalimentaD pro'eendo &na lista de ar*&mentos(como
&na f&nci4n" desp&Cs del nombre de clase.
<?php
class person {
var $name;
function __construct($persons_name) {
$this->name = $persons_name;
}
function set_name($new_name) {
$this->name = $new_name;
}
function get_name() {
return $this->name;
}
}
?>
Para el resto del t&torial+ 'o a detenerme record%ndote )&e:
2 K&nciones U mCtodos
2 Xariables U propiedades
... Oa )&e esto es &n t&torial .rientado a .b$etos de P#P &sare ahora la
terminolo*a .. (.rientado a .b$etos".
Paso 1&:
0rear &n ob$eto con &n constr&ctor.
7hora )&e hemos creado &n mCtodo constr&ctor+ podemos pro'eer &n 'alor para la
propiedad Nname c&ando creemos n&estro ob$eto persona.
Por e$emplo:
$stefan = new person(-Ctefan 3ischooD-);
/sto nos sal'a de tener )&e llamar el mCtodo setLname(" red&ciendo la cantidad de
c4di*o
Los constr&ctores son com&nes son &sados a men&do en P#P+ Aa'a+ etc.
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
$stefan = new person(-Ctefan 3ischooD-);
echo -CtefanBs full name7 - $stefan->get_name();
?>
<.@o:=>
<.html>
/ste es &n pe)&e!o e$emplo de como los mecanismos incorporados dentro de P#P
.. p&eden ahorrar tiempo red&cir la cantidad de c4di*o )&e necesitas escribir.
Menos c4di*o si*nifica menos errores.
Paso 1':
Mestrin*iendo el acceso a las propiedades &sando Dmodificadores de accesoD.
Gno de los f&ndamentos principales de la P.. es la Dencaps&lacionD. La idea es
)&e t& p&edas crear &n c4di*o mas limpio me$or+ si t& restrin*es acceso a las
estr&ct&ras de datos (propiedades" en s&s ob$etos. P&edes restrin*ir acceso a las
propiedades de la clase &sando al*o llamado Dmodificadores de accesoD. /1isten <
modificadores de acceso:
8. P&blico
2. Prote*ido
<. Pri'ado
P&blico es el modificador por defecto. Si*nifica )&e si no lo colocas se as&me )&e
es P&blico.
<?php
class person {
var $name;
pu@lic $height;
protecte: $social_insurance;
private $pinn_num@er;
function __construct($persons_name) {
$this->name = $persons_name;
}
function set_name($new_name) {
$this->name = $new_name;
}
function get_name() {
return $this->name;
}
}
?>
%ota: 0&ando declaras &na propiedad con la palabra D'arD se considera p&blica.
Paso 1(:
Mestrin*iendo acceso a las propiedades. Parte 2.
0&ando declaras &na propiedad como Dpri'adaD solo la misma clase p&ede acceder
a la propiedad.
0&ando &na propiedad es declarada como Dprote*idaD solo la misma clase las
clases deri'adas de esta clase p&eden acceder a la propiedad. /sto tiene )&e 'er
con la herencia... mas de esto l&e*o.
Propiedades declaradas como Dp&blicasD no tienen restricciones de acceso+
si*nifica )&e c&al)&iera las p&ede accesar.
Para a&dar a entender este concepto al*o conf&so de la P..+ intenta el si*&iente
c4di*o mira como reacciona P#P. 0onse$o: Lee los comentarios en el c4di*o
para maor informaci4n
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
$stefan = new person(-Ctefan 3ischooD-);
echo -CtefanBs full name7 - $stefan->get_name();
.E
Cince $pinn_num@er was :eclare: privateF this line of co:e will
generate an error %r= it out!
E.
echo -%ell me private stuff7 - $stefan->$pinn_num@er;
?>
<.@o:=>
<.html>
Paso 1):
Mestrin*iendo el acceso a los mCtodos
7si como las propiedades+ tambiCn p&edes controlar el acceso a los mCtodos
&sando &no de los tres modificadores de acceso:
8. P&blico
2. Prote*ido
<. Pri'ado
Por)&e tenemos modificadores de acceso Q
La ra(4n para modificadores de acceso se p&ede res&mir basicamente en el
control: -iene sentido el hecho de poder controlar como la *ente &sa las clases.
Las ra(ones para los modificadores de acceso otras constr&cciones ..+ p&eden
lle*ar a ser difciles de entender... a )&e somos principiantes a)& 7si )&e date &n
chance.
0on esto dicho+ pienso )&e podemos res&mir decir )&e m&chas constr&cciones
P.. e1isten+ con la idea de )&e m&chos pro*ramadores p&edan estar participando
en &n proecto.
<?php
class person {
var $name;
pu@lic $height;
protecte: $social_insurance;
private $pinn_num@er;
function __construct($persons_name) {
$this->name = $persons_name;
}
private function get
return $this->$pinn_num@er;
}
?>
%ota: Oa )&e el mCtodo *etLpinnLn&mber(" es Epri'adoE+ el Rnico l&*ar donde
p&edes &tili(ar este mCtodo es en la misma clase : tpicamente a tra'Cs de otro
mCtodo Si )&isieras llamar>&sar este mCtodo directamente en t&s pa*inas P#P+
tendras )&e declararlo Dp&blicoD.
%ota de %erd: J&e'amente+ es importante (mientras contin&amos con el
aprendi(a$e" )&e &tilices el c4di*o t& mismo. /sto har% &na diferencia m& *rande
en el aprendi(a$e.
Paso 1*:
Me&tili(ando el c4di*o a la manera P..: herencia
#erencia es la capacidad f&ndamental>constr&cci4n en P.. donde p&edes &tili(ar
&na clase+ como la base para otra clase... & otras clases.
Por)&e hacerloQ
#aciendo esto te permite de forma eficientemente re&tili(ar el c4di*o encontrado
en la clase base. Fi*amos+ )&e )&ieres crear &na n&e'a clase DemploeeD
(empleado"... a )&e podemos decir )&e DemploeeD (empleado" es &n tipo de
DpersonD (clase person menciona anteriormente"+ ellos compartiran propiedades
com&nes mCtodos
... -iene al*o de sentidoQ
/n este tipo de sit&aci4n+ la herencia p&ede hacer t& c4di*o mas li*ero... por)&e
estas re&tili(ando el mismo c4di*o en dos clases distintas. Pero a diferencia de la
forma 'ie$a de pro*ramaci4n en P#P:
8. -& solo tienes )&e tipear el c4di*o &na 'e(.
2. /l c4di*o act&al siendo re&tili(ado+ p&ede ser re&tili(ado en m&chas (ilimitadas"
clases pero es solamente tipeado en &n solo l&*ar... concept&almente+ este es &n
tipo de incl&de(" de P#P.
Mire el si*&iente c4di*o de e$emplo:
.. Be9ten:sB es la pala@ra clave <ue e9tien:e la herencia
class emplo=ee e9ten:s person {
function __construct($emplo=ee_name) {
}
}
Paso 1+:
Me&tili(ando c4di*o con herencia: parte 2
Oa )&e la clase DemploeeD (empleado" esta basada en la clase DpersonD (persona"+
DemploeeD a&tom%ticamente obtiene todas las propiedades p&blicas prote*idas
de DpersonD as como los mCtodos de DpersonD.
Jota de Jerd: Jerds deberan decir )&e EemploeeE es &n tipo de person (persona".
/l c4di*o:
.. Be9ten:sB es la pala@ra clave <ue permite la herencia
class emplo=ee e9ten:s person {
function __construct($emplo=ee_name) {
$this->set_name($emplo=ee_name);
}
}
#as notado como somos capaces de &sar setLname(" en DemploeeD+ a&n)&e no
hemos declarado ese mCtodo en la clase DemploeeD. /sto es por)&e a hemos
creado setLname(" en la clase DpersonD.
%ota de %erd: La clase EpersonE es llamada (por los nerds" la clase DbaseD o la
clase DpadreD por)&e es la clase en la c&al DemploeeD esta basada. /sta $erar)&a
de clase p&ede lle*ar a ser importante a lo lar*o del camino c&ando t&s proectos
sean mas comple$os.
Paso #,:
Me&tili(ando c4di*o con herencia: parte <
0omo p&edes 'er en el fra*mento de c4di*o aba$o+ podemos llamar a *etLname en
n&estro ob$eto+ cortesa de DpersonD.
/ste es &n cl%sico e$emplo de como la P.. p&ede red&cir el n&mero de lineas de
c4di*o (no tiene )&e escribir el mismo mCtodo dos o mas 'eces" mientras
manteniendo s& c4di*o mod&lar m&cho mas f%cil de mantener.
<title>##' in '2'<.title>
<?php inclu:e(-class_li@php-); ?>
<.hea:>
<@o:=>
<?php
.. )sing our '2' o@Aects in our '2' pages
$stefan = new person(-Ctefan 3ischooD-);
echo -CtefanBs full name7 - $stefan->get_name();
$Aames = new emplo=ee(-Gohnn= Hingers-);
echo ----> - $Aames->get_name();
?>
<.@o:=>
<.html>
Paso #1:
Sobrescribiendo mCtodos
7 'eces (c&ando se &sa herencia" p&edes necesitar cambiar como &n mCtodo
f&nciona desde la clase base. Por e$emplo+ di*amos el mCtodo setLname(" en la
clase DemploeeD tiene )&e hacer al*o diferente a lo )&e hace en la clase DpersonD.
-& DsobrescribesD la 'ersi4n de la clase DpersonD de setLname(" declar%ndola de
n&e'o en DemploeeD.
/l c4di*o:
<?php
class person {
.. e9plIcitamente agregan:o propie:a:es :e la clase
.. son opcionales pero una *uena practica
var $name;
function __construct($persons_name) {
$this->name = $persons_name;
}
pu@lic function get_name() {
return $this->name;
}
.. mJto:os protegi:os = propie:a:es restringen el acceso a a<uellos
.. elementos
protecte: function set_name($new_name) {
if (name != -Gimm= %wo Kuns-) {
$this->name = strtoupper($new_name);
}
}
}
.. Be9ten:sB es la pala@ra clave <ue permite la herencia
class emplo=ee e9ten:s person {
protecte: function set_name($new_name) {
if ($new_name == -Ctefan CucDs-) {
$this->name = $new_name;
}
}
function __construct($emplo=ee_name) {
$this->set_name($emplo=ee_name);
}
}
?>
Jotese como setLname(" es diferente en la clase DemploeeD en comparaci4n con
la 'ersi4n encontrada en la clase padre: DpersonD.
Paso ##:
Sobrescribiendo mCtodos: parte 2
7l*&nas 'eces necesitaras accesar a la 'ersi4n de t& clase base de &n mCtodo )&e
sobrescribistes en la clase deri'ada (a 'eces llamada Dclase hi$aD".
/n n&estro e$emplo. Josotros sobrescribimos el mCtodo setLname(" en la clase
DemploeeD.
7hora he &sado este c4di*o:
person77set_name($new_name);
... para accesar la clase padre (person" del mCtodo setLname(".
/l c4di*o:
<?php
class person {
.. agregan:o e9plIcitamente propie:a:es :e clase son opcionales
.. pero es una *uena practica
var $name;
function __construct($persons_name) {
$this->name = $persons_name;
}
pu@lic function get_name() {
return $this->name;
}
.. mJto:os protegi:os = propie:a:es restringen el acceso a
.. a<uellos elementos
protecte: function set_name($new_name) {
if (name != -Gimm= %wo Kuns-) {
$this->name = strtoupper($new_name);
}
}
}
.. Be9ten:sB es la pala@ra clave <ue permite la herencia
class emplo=ee e9ten:s person {
protecte: function set_name($new_name) {
if ($new_name == -Ctefan CucDs-) {
$this->name = $new_name;
}
else if($new_name == -Gohnn= Hingers-) {
person77set_name($new_name);
}
}
function __construct($emplo=ee_name) {
$this->set_name($emplo=ee_name);
}
}
?>
Paso #$:
Sobrescribiendo mCtodos: parte <
Gsando :: permite especficamente nombrar la clase donde )&ieres )&e P#P
b&s)&e &n mCtodo : Dperson::setLname("D dice a P#P )&e b&s)&e setLname(" en la
clase DpersonD.
-ambiCn e1iste &n ata$o si solo )&ieres referir a la clase padre act&al: Gsando la
palabra reser'ada DparentD.
/l c4di*o:
<?php
class person {
.. e9plIcitamente agregar propie:a:es :e las clases es opcional
.. pero @uena practica
var $name;
function __construct($persons_name) {
$this->name = $persons_name;
}
pu@lic function get_name() {
return $this->name;
}
..mJto:os protegi:os restringen el acceso a a<uellos elementos
protecte: function set_name($new_name) {
if (name != -Gimm= %wo Kuns-) {
$this->name = strtoupper($new_name);
}
}
}
.. Be9ten:sB es la pala@ra clave <ue ha@ilita la herencia
class emplo=ee e9ten:s person {
protecte: function set_name($new_name) {
if ($new_name == -Ctefan CucDs-) {
$this->name = $new_name;
}
else if($new_name == -Gohnn= Hingers-) {
parent77set_name($new_name);
}
}
function __construct($emplo=ee_name) {
$this->set_name($emplo=ee_name);
}
}
?>
-omentarios .inales
Solo hemos tocado lo b%sico de P#P ... Pero deberas tener s&ficiente
informaci4n para sentirse c4modo endo hacia adelante.
Mec&erda )&e la me$or manera de tener esto Dbien *rabadoD es escribiendo el
c4di*o por di'ersi4n practicando.
Oo s&*erira crear 80 ob$etos simples )&e ha*an cosas simples+ entonces &sar
estos ob$etos en pa*inas P#P act&ales. Gna 'e( )&e haas hecho eso+ te sentir%s
m& c4modo con los ob$etos.
Por/ue aprender POO en PHP Otra punto de 0ista
Para *ente n&e'a a P.. )&e est%n mas Dc4modosD con el P#P por
procedimiento+ podr%n estar pre*&nt%ndose por)&e deberan molestarse en
aprender conceptos de ob$etos ...
Por)&e tomarse la molestia de aprenderQ
1l mundo de PHP:
/l P#P se esta mo'iendo en la direccion de P... Por e$emplo+ m&cha e1tensiones
importantes del P#P como P/7M Smart son basadas en ... 7si )&e realmente
entender &sar estos frameworks propiamente+ necesitaras entender P#P
orientado a ob$etos.
2as 0entajas practicas34uncionales:
Para pe)&e!os proectos+ &sar P#P orientado a ob$etos podra ser demasiado. /sto
dicho+ el P#P orientado a ob$etos realmente comien(a a brillar c&ando los
proectos se hacen mas comple$os+ c&ando t& tienes mas de &na persona
haciendo el pro*rama.
Por e$emplo:
Si enc&entras )&e tienes+ di*amos 80+ 20 o mas f&nciones enc&entras )&e
al*&nas de las f&nciones est%n haciendo cosas similares... es tiempo de considerar
empa)&etar las cosas en ob$etos &sando P...
POO 5 tu carrera como programador:
P.. es la manera moderna del desarrollo de software todos los len*&a$es
maores (Aa'a+ P/ML+ P#P+ 0B+ M&b" &san este mCtodo de pro*ramaci4n 0omo
desarrollador>pro*ramador de software+ solo tiene sentido (en tCrminos de carrera+"
mantener t&s habilidades act&ali(adas.
Mas all% de hacerte &n pro*ramador de P#P de maor 'alor+ entendiendo P.. en
P#P te dar% conocimientos (conocimientos de P.." )&e t& seras capa( de lle'ar
conti*o a otros len*&a$es.
... 0&ando aprendas P.. en P#P+ aprender%s pro*ramaci4n orientada a ob$etos
para c&al)&ier len*&a$es basado en ...
/ncontraras con tiempo )&e crear proectos P#P basados en ob$etos+ har% t& 'ida
de pro*ramador mas f%cil 0omo &n bon&s adicional+ pronto desarrollaras t& propia
colecci4n de ob$etos re&tili(ables+ )&e te ser'ir%n para otros proectos.
Kinalmente+ tambiCn encontraras )&e el P#P basado en P.. es mas f%cil de
mantener act&ali(ar.
6etos en POO:
P#P .. presenta al*&nos retos en c&anto comien(as por)&e necesitas aprender a
pensar acerca de t&s proectos P#P de &na manera diferente: necesitaras
concept&ali(ar el proecto en tCrminos de ob$etos.
Mas detalles...
Gna 'a comRn de comen(ar &n proecto orientado a ob$etos es comen(ar
dib&$ando &n simple dia*rama de t&s ob$etos. Mientras empie(as a traba$ar con
dia*ramas orientados a ob$etos+ encontraras )&e ellos te a&daran en hacer el
desarrollo de proectos P#P basados en P.. m&chos mas f%ciles
7)& tienes &nos c&antos conse$os acerca de dia*ramas de dib&$os de ob$eto.
2 Gse &n papel &n l%pi(
2 Fib&$a ca$as )&e representen cada ob$eto.
2 /n a)&ellas ca$as+ crea &na lista de s&s mCtodos propiedades.
2 Gsa flechas lineas entre ca$as para denotar relaciones (padre : hi$o" entre
ob$etos.
7si )&e si has estado esperando para saltar en el m&ndo de P#P ..+ ahora es el
me$or momento para hacerlo.
Stefan Mischook
www.killerphp.com
www.killersites.com