Cita: Estoy comenzando con POO. En internet hay manuales y un sinfín de artículos repetitivos con el funcionamiento básico, pero a la hora de decir aquí estamos y esto quiero conseguir es cuando se nos abre el millón de preguntas. Necesito algún ejemplo avanzado del que aprender (que vaya más allá de la sintaxis propia de definir clases).
Creo que con la explicación de mortiprogramador cubres la parte que corresponde a como hacer las cosas con el lenguaje. Me gustaria como complemento tratar un punto importante que es el diseño orientado a objetos y que se basa en los conceptos básicos ademas de otros principios que se han derivado de la solución y aplicación de los principios básicos que ya debes de saber.
Vamos a usar un ejemplo sencillo; Imagina que tienes que crear una aplicación de recursos humanos para una empresa y uno de los requerimientos es que cuando se contrate a un nuevo Empleado se pueda guardar el nombre junto con un puesto asignado y un salario, ademas debe de ser posible promoverlo a un nuevo puesto con su respectivo cambio de salario.
Muy posiblemente con lo que sabes ahora crees tu clase Empleado :
Código PHP:
Ver originalclass Employee
{
private $name;
private $position;
private $salary;
private static $server = 'localhost';
private static $user = 'miusuario';
private static $pass = 'micontraseña';
private static $dbname = 'mibasededatos';
public function __get($attribute) {
if(property_exists($this, $attribute)) {
return $this->{$attribute};
}
throw new Exception('No existe esta propiedad');
}
public function __set($attribute, $value) {
if(property_exists($this, $attribute)) {
$this->{$attribute} = $value;
}
throw new Exception('No existe esta propiedad');
}
public function save() {
$conn = mysqli_connect(self::$server, self::$user, self::$pass, self::$dbname);
$query = 'INSERT INTO person (name, position, salary) VALUES (?,?,?)';
$stmt->close();
$conn->close();
return $affected_rows;
}
}
Creas tu formulario y registras los datos de la siguiente forma (resumida):
Código PHP:
Ver original$_POST = [
'name' => 'Enrrique Martinez',
'position' => 'Jr Developer',
'salary' => 1024,
];
$employee = new Employee;
$employee->name = $_POST['name'];
$employee->position = $_POST['position'];
$employee->salary = $_POST['salary'];
$enployee->save();
Hasta este punto queda resuelto el problema y funciona, pero no refleja exactamente lo que te pidieron, y comienzas a ver tu código y te das cuenta que puedes usar un constructor para simplificar el código y ademas estas mas cercano a lo que pidieron que se agreguen los datos en el momento que se contrata. Asi que agregas el constructor a tu clase:
Código PHP:
Ver originalpublic function __construct($data) {
foreach($data as $attribute => $value) {
$this->{$attribute} = $value;
}
}
y cambias la parte de la contratación con el cambio
Código PHP:
Ver original$_POST = [
'name' => 'Enrrique Martinez',
'position' => 'Jr Developer',
'salary' => 1024,
];
$employee = new Employee($_POST);
$enployee->save();
Mucho mejor verdad ? Pero te diré que falta en este diseño reflejar mejor la solución del problema así que vamos a abstraer mejor las cosas; si te fijas en la vida real no se crea un empleado se contrata, ademas el empleado se promueve de puesto así que diremos que mi abstracción se representa de esta forma:
Código PHP:
Ver originalinterface EmployeeInterface {
public static function hire($data);
public function promote($newPosition, $withNewSalary);
}
Una interfaz donde el empleado se promueve y se contrata en lugar solo de
"instanciarse" asi que implementemos esta abstracción de nuestro problema con los cambios necesarios en nuestra clase Empleado:
Código PHP:
Ver originalclass Employee implements EmployeeInterface
{
private $name;
private $position;
private $salary;
private function __construct($data)
{
foreach($data as $attribute => $value) {
$this->{$attribute} = $value;
}
}
public static function hire($data)
{
return new self($data);
}
public function promote($newPosition, $withNewSalary)
{
$this->position = $newPosition;
$this->salary = $withNewSalary;
}
public function __get($attribute) {
if(property_exists($this, $attribute)) {
return $this->{$attribute};
}
throw new Exception('No existe esta propiedad');
}
public function __set($attribute, $value) {
if(property_exists($this, $attribute)) {
$this->{$attribute} = $value;
}
throw new Exception('No existe esta propiedad');
}
public function save() {
$conn = mysqli_connect(self::$server, self::$user, self::$pass, self::$dbname);
$query = 'INSERT INTO person (name, position, salary) VALUES (?,?,?)';
$stmt->close();
$conn->close();
return $affected_rows;
}
}
Mi formulario para la contratación queda sin cambio pero necesito ajustar la lógica, así que lo hacemos de la siguiente forma:
Código PHP:
Ver original$_POST = [
'name' => 'Enrrique Martinez',
'position' => 'Jr Developer',
'salary' => 1024,
];
$employee = Employee::hire($_POST);
// si quieres promover al empleado en otro momento
$employee->prmote('Sr Developer', 2048);
$employee->save();
Ahora es mas claro de leer y de entender por tí y tus colaboradores, ademas si tienes que volver a ver el código sera muy claro también para ti saber que esta pasando.
Con cambios mínimos simplificamos el código y a demás hemos hecho un poco mas flexible el código. Y como es esto ?
Sencillo; Ahora imagina que despues de un tiempo de felicidad llega el cliente y te pide que pases todo esto a
Laravel y lo primero que puedes pensar es que tienes que hacer todo de nuevo, o posiblemente no?
Ya que tienes una interfaz en tu solución la puedes usar para resolver la implementación, así que puedes tener facilmente un modelo que resuelva esto en Laravel:
Código PHP:
Ver originalclass Employee extends Model implements EmployeeInterface {
protected $fillable = ['name', 'position', 'salary'];
public static function hire($data) {
return self::create($data);
}
public function promote($newPosition, $withNewSalary)
{
$this->position = $newPosition;
$this->salary = $withNewSalary;
}
}
Ahora si tu lógica original la pasas a un controlador de Laravel todo va a funcionar igual!
Código PHP:
Ver original$employee = Employee::hire($_POST);
$employee->promote('Sr Developer', 2048);
Ahora solo te falta ajustar el hecho de que en laravel las variable se reciben usando un objeto Request: asi que lo anterior quedara de la siguiente forma
Código PHP:
Ver original$employee = Employee::hire($request->all());
$employee->promote('Sr Developer', 2048);
Sencillo no lo crees ?
Es importante tomarte siempre un tiempo para diseñar lo que haces de tal forma que puedas hacer cambios futuros sin tener que rehacer todo de nuevo.
En este ejemplo sencillo usar algunos conceptos de POO nos resolvieron el problema pero existen casos que requieren mas, así que te aconsejo que revises sobre estos temas
- Objeto
- Clase
- Abstracción
- Encapsulamiento
- Generalización
- Polimorfismo
y
- Diseño orientado a objetos
- Patrones
- refactorización
- Pruebas
Para el asunto de interfaces y clases abstractas puedes leer este hilo aquí mismo en el foro:
http://www.forosdelweb.com/f18/difer...erfaz-1108350/
Para finalizar te aliento a que experimentes y tengas paciencia crear código legible y bien diseñado lleva su tiempo, y recuerda;
piensa en tu diseño sin los detalles de implementación 
Respuesta: Clases POO. Teoría. 
Este tema le ha gustado a 2 personas