Taller > PHP > Program. Objetos
Modificadores de Acceso en PHP
En la Programación Orientada a Objetos (OOP), los modificadores de acceso controlan cómo se accede a las propiedades y métodos de una clase desde diferentes partes del programa. PHP ofrece tres tipos de modificadores de acceso: public, protected y private.
¿Qué son los Modificadores de Acceso?
Los modificadores de acceso definen el nivel de visibilidad de las propiedades y métodos dentro de una clase. Esto es útil para proteger la integridad de los datos y asegurar que solo se acceda a ellos de manera controlada.
Tipos de Modificadores de Acceso:
public: Las propiedades o métodos definidos como public son accesibles desde cualquier lugar. Este es el modificador por defecto si no se especifica otro.
protected: Las propiedades o métodos protected solo pueden ser accedidos dentro de la clase y sus clases derivadas (clases que heredan de esa clase).
private: Las propiedades o métodos private solo pueden ser accedidos dentro de la clase donde fueron definidos.
Ejemplo de Modificadores de Acceso en Propiedades
Veamos cómo funcionan los modificadores de acceso en las propiedades de una clase:
<?php
class Animal {
public $nombre; // Propiedad pública
protected $especie; // Propiedad protegida
private $edad; // Propiedad privada
// Constructor para inicializar las propiedades
public function __construct($nombre, $especie, $edad) {
$this->nombre = $nombre;
$this->especie = $especie;
$this->edad = $edad;
}
// Método público para mostrar el nombre
public function mostrarNombre() {
return "El animal es: " . $this->nombre;
}
// Método protegido para mostrar la especie
protected function mostrarEspecie() {
return "Especie: " . $this->especie;
}
// Método privado para mostrar la edad
private function mostrarEdad() {
return "Edad: " . $this->edad . " años";
}
}
$perro = new Animal("Rex", "Canino", 5);
echo $perro->mostrarNombre(); // OK: método público
// No es posible acceder a métodos o propiedades protegidas o privadas desde fuera
// echo $perro->mostrarEspecie(); // ERROR
// echo $perro->mostrarEdad(); // ERROR
?>
Explicación del código
Propiedad nombre (pública): Se puede acceder y modificar desde cualquier parte del programa.
Propiedad especie (protegida): Solo es accesible dentro de la clase Animal y sus subclases.
Propiedad edad (privada): Solo es accesible dentro de la clase Animal, lo que protege completamente esta información de cualquier modificación externa.
Ejemplo con Métodos Protegidos y Privados
Los modificadores de acceso también se aplican a los métodos, determinando quién puede llamarlos. Veamos un ejemplo donde definimos métodos con diferentes niveles de visibilidad:
<?php
class Vehiculo {
public $marca; // Propiedad pública
protected $modelo; // Propiedad protegida
private $kilometraje; // Propiedad privada
// Constructor para inicializar las propiedades
public function __construct($marca, $modelo, $kilometraje) {
$this->marca = $marca;
$this->modelo = $modelo;
$this->kilometraje = $kilometraje;
}
// Método público para obtener la marca
public function obtenerMarca() {
return "Marca: " . $this->marca;
}
// Método protegido para obtener el modelo
protected function obtenerModelo() {
return "Modelo: " . $this->modelo;
}
// Método privado para obtener el kilometraje
private function obtenerKilometraje() {
return "Kilometraje: " . $this->kilometraje . " km";
}
// Método público que puede acceder a los métodos privados o protegidos
public function obtenerDetalles() {
return $this->obtenerModelo() . ", " . $this->obtenerKilometraje();
}
}
$auto = new Vehiculo("Toyota", "Corolla", 50000);
echo $auto->obtenerMarca(); // OK: método público
// No es posible llamar directamente a métodos protegidos o privados desde fuera
// echo $auto->obtenerModelo(); // ERROR
// echo $auto->obtenerKilometraje(); // ERROR
// Sin embargo, podemos acceder a ellos desde dentro de la clase
echo $auto->obtenerDetalles(); // OK: usa métodos protegidos y privados
?>
Explicación del código
Método obtenerMarca() (público): Se puede llamar desde cualquier parte.
Método obtenerModelo() (protegido) y obtenerKilometraje() (privado): Solo se pueden llamar desde dentro de la clase Vehiculo, lo que protege el acceso a estos detalles.
El método obtenerDetalles() permite acceder a los métodos protegidos y privados desde dentro de la clase.
Modificadores de Acceso y Herencia
Las clases derivadas pueden acceder a las propiedades y métodos protegidos de la clase padre, pero no pueden acceder a los elementos privados. Veamos un ejemplo con herencia:
<?php
class Persona {
protected $nombre;
private $edad;
public function __construct($nombre, $edad) {
$this->nombre = $nombre;
$this->edad = $edad;
}
protected function mostrarNombre() {
return "Nombre: " . $this->nombre;
}
private function mostrarEdad() {
return "Edad: " . $this->edad . " años";
}
}
// Clase Estudiante que hereda de Persona
class Estudiante extends Persona {
public function mostrarDetalles() {
return $this->mostrarNombre(); // OK: método protegido accesible en clase hija
// return $this->mostrarEdad(); // ERROR: método privado no accesible
}
}
$estudiante = new Estudiante("Carlos", 20);
echo $estudiante->mostrarDetalles(); // OK: accede al método protegido
?>
Explicación del código
La clase Estudiante hereda de Persona, por lo que puede acceder al método protegido mostrarNombre().
Sin embargo, el método privado mostrarEdad() no está disponible en la clase derivada, lo que demuestra la diferencia en el nivel de acceso entre protected y private.
Conclusión
Los modificadores de acceso son una herramienta clave en la Programación Orientada a Objetos (OOP) para controlar la visibilidad y el acceso a las propiedades y métodos de una clase.
Utilizando public, protected y private, puedes estructurar tu código de manera más segura y organizada, protegiendo la integridad de los datos y controlando cómo interactúan las distintas partes del programa con los objetos.
