Índice
|
|
Clases y Objetos |
==> PHP | Clases
<?php
class Carrito {
var $items; // Items en nuestro carrito de compras
// Agregar $num articulos de $artnr al carrito
function agregar_item($artnr, $num) {
$this->items[$artnr] += $num;
}
// Tomar $num articulos de $artnr del carrito
function retirar_item($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} elseif ($this->items[$artnr] == $num) {
unset($this->items[$artnr]);
return true;
} else {
return false;
}
}
}
?> | | Una clase es una colección de variables y funciones que trabajan con éstas variables. Una clase es definida usando la siguiente sintaxis: |
|
Cerrar |
|
==> PHP | Auto carga de Objetos
<?php
function __autoload($class_name) {
require_once $class_name . '.php';
}
$obj = new MyClass1();
$obj2 = new MyClass2();
?> | | Puede definir una función __autoload la cual es llamada automáticamente en caso de que intente usar una clase que no ha sido definida aún. Al llamar esta función la ejecución del script da una última oportunidad de cargar la clase antes de que PHP falle con un error. |
|
Cerrar |
|
==> PHP | Constructores y Destructores
<?php
class BaseClass {
function __construct() {
print "In BaseClass constructor\n";
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "In SubClass constructor\n";
}
}
$obj = new BaseClass();
$obj = new SubClass();
?> | | Las clases que tienen un método constructor llaman a este método cada vez que se crea un nuevo objeto, para cualquier inicialización que el objeto puede necesitar antes de ser usado. |
|
Cerrar |
|
==> PHP | Constructores y Destructores II
<?php
class MyDestructableClass {
function __construct() {
print "In constructor\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "Destroying " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?> | | Como los constructores, los destructores de la clase padre no serán llamados explícitamente por el compilador. Para ejecutar un destructor padre, se debe tener una llamada explícita a parent::__destruct() en el cuerpo del destructor. |
|
Cerrar |
|
==> PHP | Visibilidad de los miembros
<?php
/**
* Define MyClass
*/
class MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // Works
echo $obj->protected; // Fatal Error
echo $obj->private; // Fatal Error
$obj->printHello(); // Shows Public, Protected and Private
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// We can redeclare the public and protected method, but not private
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj->public; // Works
echo $obj2->private; // Undefined
echo $obj2->protected; // Fatal Error
$obj2->printHello(); // Shows Public, Protected2, not Private
?> | | Los miembros de la clase debe estar definidos con public, private o protected. |
|
Cerrar |
|
==> PHP | Visibilidad de los métodos
<?php
/**
* Define MyClass
*/
class MyClass
{
// Contructors must be public
public function __construct() { }
// Declare a public method
public function MyPublic() { }
// Declare a protected method
protected function MyProtected() { }
// Declare a private method
private function MyPrivate() { }
// This is public
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // Works
$myclass->MyProtected(); // Fatal Error
$myclass->MyPrivate(); // Fatal Error
$myclass->Foo(); // Public, Protected and Private work
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// This is public
function Foo2()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // Fatal Error
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Works
$myclass2->Foo2(); // Public and Protected work, not Private
?> | | Los métodos de clase deben ser definidos con public, private o protected. Los métodos sin ninguna declaración son tomados como public. |
|
Cerrar |
|
==> PHP | Alcance del operador de resolución (::)
Ejemplo :: desde afuera de la definición de la clase
<?php
class MyClass {
const CONST_VALUE = 'A constant value';
}
echo MyClass::CONST_VALUE;
?>
Ejemplo :: desde dentro de la definición de la clase
<?php
class OtherClass extends MyClass
{
public static $my_static = 'static var';
public static function doubleColon() {
echo parent::CONST_VALUE . "\n";
echo self::$my_static . "\n";
}
}
OtherClass::doubleColon();
?> | | El alcance del operador de resolución (también llamado Paamayim Nekudotayim) o en términos simples, dobles dos puntos, es un símbolo que permite acceso a los miembros o métodos estaticos, constantes, y eliminados de una clase. |
|
Cerrar |
|
==> PHP | La palabra reservada 'Static'
<?php
class Foo
{
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
class Bar extends Foo
{
public function fooStatic() {
return parent::$my_static;
}
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n"; // Undefined "Property" my_static
// $foo::my_static is not possible
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?> | | Declarar miembros de clases o métodos como estáticos, los hace accesibles desde afuera del contexto del objeto. Un miembro o método declarado como estático no puede ser accesado con una variable que es una instancia del objeto y no puede ser redefinido en una extensión de la clase. |
|
Cerrar |
|
==> PHP | Constantes De la Clase
<?php
class MyClass
{
const constant = 'constant value';
function showConstant() {
echo self::constant . "\n";
}
}
echo MyClass::constant . "\n";
$class = new MyClass();
$class->showConstant();
// echo $class::constant; is not allowed
?> | | Es posible definir valores constantes en cada clase manteniendo el mismo valor y siendo incambiable. Las constantes difieren de las variables normales en que no se usa el símbolo $ para declararlas o usarlas. |
|
Cerrar |
|
==> PHP | Abstracción de Objetos
<?php
abstract class AbstractClass
{
// Force Extending class to define this method
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// Common method
public function printOut() {
print $this->getValue() . "\n";
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValues($prefix) {
return "{$prefix}ConcreteClass1";
}
}
class ConcreteClass2 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
?>
El resultado del ejemplo seria:
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
| | es permitido crear una instancia de una clase que ha sido definida como abstracta. Cualquier clase que contenga por lo menos un método abstracto debe también ser abstracta. Los métodos definidos como abstractos simplemente declaran el método, no pueden definir la implementación |
|
Cerrar |
|
==> PHP | Interfaces de Objetos
<?php
// Declare the interface 'iTemplate'
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// Implement the interface
// This will work
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}
// This will not work
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
}
?> | Las interfaces de objetos permiten crear código el cual especifica métodos que una clase debe implementar, sin tener que definir como serán manejados esos métodos.
Las interfaces son definidas usando la palabra reservada 'interface', de la misma manera que las clases estándar, pero sin que cualquiera de los métodos tenga su contenido definido.
|
|
Cerrar |
|
==> PHP | Sobrecarga
<?php
class Setter
{
public $n;
private $x = array("a" => 1, "b" => 2, "c" => 3);
private function __get($nm)
{
echo "Getting [$nm]\n";
if (isset($this->x[$nm])) {
$r = $this->x[$nm];
print "Returning: $r\n";
return $r;
} else {
echo "Nothing!\n";
}
}
private function __set($nm, $val)
{
echo "Setting [$nm] to $val\n";
if (isset($this->x[$nm])) {
$this->x[$nm] = $val;
echo "OK!\n";
} else {
echo "Not OK!\n";
}
}
private function __isset($nm)
{
echo "Checking if $nm is set\n";
return isset($this->x[$nm]);
}
private function __unset($nm)
{
echo "Unsetting $nm\n";
unset($this->x[$nm]);
}
}
$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump(isset($foo->a)); //true
unset($foo->a);
var_dump(isset($foo->a)); //false
// this doesn't pass through the __isset() method
// because 'n' is a public property
var_dump(isset($foo->n));
var_dump($foo);
?>
El resultado del ejemplo seria:
Setting [a] to 100
OK!
Getting [a]
Returning: 100
Setting [a] to 101
OK!
Getting [z]
Nothing!
Setting [z] to 1
Not OK!
Checking if a is set
bool(true)
Unsetting a
Checking if a is set
bool(false)
bool(true)
object(Setter)#1 (2) {
["n"]=>
int(1)
["x:private"]=>
array(2) {
["b"]=>
int(2)
["c"]=>
int(3)
}
}
| | Las llamadas a métodos y los accesos a los miembros pueden ser sobrecargadas por medio de los métodos __call, __get y __set. Estos métodos serán accionados cuando su objeto u objeto heredado no contengan los miembros o métodos que está intentado accesar. |
|
Cerrar |
|
==> PHP | Sobrecarga de Métodos
<?php
class Caller
{
private $x = array(1, 2, 3);
public function __call($m, $a)
{
print "Method $m called:\n";
var_dump($a);
return $this->x;
}
}
$foo = new Caller();
$a = $foo->test(1, "2", 3.4, true);
var_dump($a);
?>
El resultado del ejemplo seria:
Method test called:
array(4) {
[0]=>
int(1)
[1]=>
string(1) "2"
[2]=>
float(3.4)
[3]=>
bool(true)
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
| Los métodos de la clase pueden ser sobrecargados para ejecutar código personalizado definido en la clase al definir este método en particular. El parámetro $value es el nombre de la función que se pidió usar. Los argumentos que fueron pasados en la función serán definidos como una matriz en el parámetro $arguments. El valor regresado del método __call() será regresado a quien haya llamado al método.
|
|
Cerrar |
|
==> PHP | Interacción de Objetos
<?php
class MyClass
{
public $var1 = 'value 1';
public $var2 = 'value 2';
public $var3 = 'value 3';
protected $protected = 'protected var';
private $private = 'private var';
function iterateVisible() {
echo "MyClass::iterateVisible:\n";
foreach($this as $key => $value) {
print "$key => $value\n";
}
}
}
$class = new MyClass();
foreach($class as $key => $value) {
print "$key => $value\n";
}
echo "\n";
$class->iterateVisible();
?>
El resultado del ejemplo seria:
var1 => value 1
var2 => value 2
var3 => value 3
MyClass::iterateVisible:
var1 => value 1
var2 => value 2
var3 => value 3
protected => protected var
private => private var
| | PHP 5 provee una forma para que los objetos a ser definidos puedan interactuar a través de una lista de campos, con, por ejemplo una sentencia foreach. Por defecto, todas las propiedades visibles serán usadas para la interacción. |
|
Cerrar |
|
==> PHP | Patrón Factory
<?php
class Example
{
// The factory method
public static function &factory($type)
{
if (include_once 'Drivers/' . $type . '.php') {
$classname = 'Driver_' . $type;
return new $classname;
} else {
throw new Exception ('Driver not found');
}
}
}
?>
Otro ejemplo
<?php
// Load a MySQL Driver
$mysql = Example::factory('MySQL');
// Load a SQLite Driver
$sqlite = Example::factory('SQLite');
?> | | El patrón Factory permita la instancia de objetos en tiempo de ejecución. Es llamado el patrón Factory puesto que es responsable de "manufacturar" un objeto. |
|
Cerrar |
|
==> PHP | Patrón Singleton
<?php
class Example
{
// Hold an instance of the class
private static $instance;
// A private constructor; prevents direct creation of object
private function __construct()
{
echo 'I am constructed';
}
// The singleton method
public static function singleton()
{
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c;
}
return self::$instance;
}
// Example method
public function bark()
{
echo 'Woof!';
}
// Prevent users to clone the instance
public function __clone()
{
trigger_error('Clone is not allowed.', E_USER_ERROR);
}
}
?> | | El patrón Singleton aplica a situaciones en las cuales hay la necesidad de ser una sola instancia de una clase. El ejemplo más común de esto es una conexión de base de datos. Implementando este patrón permite a un programador hacer esta simple isntancia fácilmente accesible a muchos otros objetos. |
|
Cerrar |
|
==> PHP | Métodos mágicos __sleep y __wakeup
<?php
class Connection {
protected $link;
private $server, $username, $password, $db;
public function __construct($server, $username, $password, $db)
{
$this->server = $server;
$this->username = $username;
$this->password = $password;
$this->db = $db;
$this->connect();
}
private function connect()
{
$this->link = mysql_connect($this->server, $this->username, $this->password);
mysql_select_db($this->db, $this->link);
}
public function __sleep()
{
mysql_close($this->link);
}
public function __wakeup()
{
$this->connect();
}
}
?> | La intención de usar __sleep es cerrar cualquier conexión a base de datos que el objeto pueda tener, terminar de enviar cualquier dato o ejecutar tareas similares de limpieza. También, la función es útil si tiene objetos muy grandes los cuales no necesitan mantenerse completos.
La intención de __wakeup es reestablecer cualquier conexión a base de datos que se pueda haber perdido durante la serialización y ejecutar otras tareas de reinicialización. |
|
Cerrar |
|
==> PHP | El método __toString
<?php
// Declare a simple class
class TestClass
{
public $foo;
public function __construct($foo) {
$this->foo = $foo;
}
public function __toString() {
return $this->foo;
}
}
$class = new TestClass('Hello');
echo $class;
?> | | El método __toString permite a una clase decidir como actuar cuando es convertida en cadena. |
|
Cerrar |
|
==> PHP | La palabra reservada 'Final'
<?php
class BaseClass {
public function test() {
echo "BaseClass::test() called\n";
}
final public function moreTesting() {
echo "BaseClass::moreTesting() called\n";
}
}
class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called\n";
}
}
// Results in Fatal error: Cannot override final method BaseClass::moreTesting()
?>
Otro ejemplo
<?php
final class BaseClass {
public function test() {
echo "BaseClass::test() called\n";
}
// Here it doesn't matter if you specify the function as final or not
final public function moreTesting() {
echo "BaseClass::moreTesting() called\n";
}
}
class ChildClass extends BaseClass {
}
// Results in Fatal error: Class ChildClass may not inherit from final class (BaseClass)
?> | | PHP 5 introduce la palabra reservada 'final', la cual prevee que las clases hijo puedan sobreescribir un método, usando el prefijo 'final' en la definición del método. Si la clase en sí misma es definida como 'final' entonces no puede ser extendida. |
|
Cerrar |
|
==> PHP | Clonando un objeto
<?php
class SubObject
{
static $instances = 0;
public $instance;
public function __construct() {
$this->instance = ++self::$instances;
}
public function __clone() {
$this->instance = ++self::$instances;
}
}
class MyCloneable
{
public $object1;
public $object2;
function __clone()
{
// Force a copy of this->object, otherwise
// it will point to same object.
$this->object1 = clone($this->object1);
}
}
$obj = new MyCloneable();
$obj->object1 = new SubObject();
$obj->object2 = new SubObject();
$obj2 = clone $obj;
print("Original Object:\n");
print_r($obj);
print("Cloned Object:\n");
print_r($obj2);
?>
El resultado del ejemplo seria:
Original Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 1
)
[object2] => SubObject Object
(
[instance] => 2
)
)
Cloned Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 3
)
[object2] => SubObject Object
(
[instance] => 2
)
)
| | Crear una copia de un objeto con una replica de todas sus propiedades no es siempre lo que se desea hacer. Un buen ejemplo de la necesidad de copiar los constructores, es si se tiene un objeto el cual representa una ventana GTK y el objeto contiene los recursos de esta ventana GTK, cuando se crea un duplicado, puede quererse crear una nueva ventana con las mismas propiedades y hacer que el nuevo objeto tenga los recursos de la ventana nueva. |
|
Cerrar |
|
==> PHP | comparación de objetos
<?php
function bool2str($bool)
{
if ($bool === false) {
return 'FALSE';
} else {
return 'TRUE';
}
}
function compareObjects(&$o1, &$o2)
{
echo 'o1 == o2 : ' . bool2str($o1 == $o2) . "\n";
echo 'o1 != o2 : ' . bool2str($o1 != $o2) . "\n";
echo 'o1 === o2 : ' . bool2str($o1 === $o2) . "\n";
echo 'o1 !== o2 : ' . bool2str($o1 !== $o2) . "\n";
}
class Flag
{
public $flag;
function Flag($flag = true) {
$this->flag = $flag;
}
}
class OtherFlag
{
public $flag;
function OtherFlag($flag = true) {
$this->flag = $flag;
}
}
$o = new Flag();
$p = new Flag();
$q = $o;
$r = new OtherFlag();
echo "Two instances of the same class\n";
compareObjects($o, $p);
echo "\nTwo references to the same instance\n";
compareObjects($o, $q);
echo "\nInstances of two different classes\n";
compareObjects($o, $r);
?>
El resultado del ejemplo seria:
Two instances of the same class
o1 == o2 : TRUE
o1 != o2 : FALSE
o1 === o2 : FALSE
o1 !== o2 : TRUE
Two references to the same instance
o1 == o2 : TRUE
o1 != o2 : FALSE
o1 === o2 : TRUE
o1 !== o2 : FALSE
Instances of two different classes
o1 == o2 : FALSE
o1 != o2 : TRUE
o1 === o2 : FALSE
o1 !== o2 : TRUE
| | Cuando se usa el operador de comparación (==), las variables del objeto son comparadas de una forma simple, digase: Dos instancias de objetos son iguales si tienes los mismos atributos y valores, y son instancias de la misma clase. |
|
Cerrar |
|
Índice |
Todo lo que sueñas, se puede diseñar. 