Clase 8 de 19 • Curso de Programación Orientada a Objetos en PHP
Contenido del curso
Carlos Eduardo Gomez García
Abraham Flores Cosme
Carlos Eduardo Gomez García
María Sierra
Platzi Team
Cristian Andres Ladino Peña
Kenet Andrés Chungandro Montenegro
Jose Montenegro
Usuario anónimo
Aldo Miguel Ortiz Parodi
Alberto Ramírez Caballero
Jimmy Buriticá Londoño
Edgar Oswaldo Vargas Jara
Billy Rustrian Burgos
Ronnie Bejerano
Joel Dominguez Merino
Marco Antonio Leon Matias
José Alberto Ortiz Vargas
Reinaldo Mendoza
Martin Campos
José Darío Bedoya Ortiz
Bruno Salazar
Jhon Fabio Cardona Martinez
Jimmy Buriticá Londoño
Beder Danilo Casa Condori
Beder Danilo Casa Condori
Julio Cardenas
En lo personal, pienso que el tema de herencia debió de haber sido el primer tema a explicar antes de meternos con el resto de temas porque muchas cosas hacen referencia de alguna manera a la herencia. Pero trataré de explicarlo de una mejor manera:
public: Es una propiedad publica, a la cual puedo acceder desde cualquier parte de mi código y puedo modificarla sin problemas:
<?php class User { public $name; } $pablito = new User; $pablito->name = "Pablito"; ?>
Esto es posible porque $name es una propiedad publica, por tanto, puedo acceder desde fuera de la clase, la clase abarca desde la llave de apertura hasta la llave de cierre de la clase.
protected: Esta propiedad es exclusiva de PHP, basicamente, hace que esta propiedad NO pueda ser accedida desde fuera de mi clase, pero SI puede ser accedida desde cualquier otra clase que herede a mi clase, ¿Qué es herencia? No te preocupes, ya casi llegamos a ese tema, pero que el nombre te vaya dando una idea, por tanto, este ejemplo:
<?php class User { protected $name; } $pablito = new User; $pablito->name = “Pablito”; ?>
Mandaría un error, pues $name es protected y no puedo llamarla desde fuera de la clase, pero este otro ejemplo:
<?php class User { protected $name; } class Pablito extends User{ public function poner_nombre($nombre){ $this->name = $nombre; } } $pablito = new Pablito; $pablito->poner_nombre("Pablito"); ?>
Si funcionaría, pues las clases que heredan de mi clase SI pueden acceder.
private: Este nos indica que nada, absolutamente nada que NO esté dentro de mi clase va a poder acceder a esa propiedad o método, ni aunque la heredes, esa propiedad va a estar disponible única y estrictamente dentro de mi clase, por lo que el ejemplo anterior daría error (Si hubiésemos puesto private $name), pero el siguiente ejemplo funcionaría a la perfección:
<?php class User { protected $name; public function poner_nombre($nombre) { $this->name = $nombre; } } $pablito = new User; $pablito->poner_nombre("Pablito"); ?>
De esta forma y con ejemplos creo que se entiende mejor lo que es el alcance :D
Bien explicado amigo, había olvidado como funciona al 100% protected
En el último ejemplo debió ser:
private $name;
Disculpar xD
Alcance o Encapsulamiento
El alcance hace referencia al encapsulamiento o principio de ocultación. Esto nos ayuda cuando estamos trabajando con herencia.
<?php class User { // public // protected // private public const PAGINATE = 25; public $username; // protected $username; // private $username; public function getUsername() { # code... } // Poner en mayúsculas nos ayuda crear rutas absolutas y no relativas var_dump(__DIR__); }
Para esconder datos vamos a utilizar los modificadores de acceso:
Gracias excelente aporte
Buen resumen 💪
🤔 El alcance o encapsulamiento nos permite garantizar la integridad de los datos.
8. Alcance o Encapsulamiento
Si coloco una variable tipo (principio de ocultación o encapsulación):
public dentro de una clase, podrá ser accedida fuera de ella y también heredada.protected dentro de una clase, no podra ser accedida fuera de ella, pero sí podrá ser heredada.private dentro de una clase, no podra ser accedida fuera de ella, ni tampoco podrá ser heredada.Comparto el código revisado en clase:
<?php class User { //public //protected //private public const PAGINATE = 25; //var_dump(__DIR__); public $username; //protected $username; //private $username; public function getUser() { // code } }
public -> Cualquiera puede acceder a estos elementos. protected -> Solo la clase padre e hijos pueden acceder a estos elementos. private -> Solo la clase padre puede acceder a estos elementos.
👍
Veo que PHP maneja los mismos conceptos de Java en muchas de sus estructuras.
¿Los elementos encapsulados con Protected pueden ser accedidos por clases al mismo nivel, ósea dentro del mismo paquete o solo a través de herencia?
Abstracción y alcance, resuelve muchos problemas de seguridad en los login
La verdad batalle mucho con el tema de constantes dándoles diferentes tipos de alcance :( Comparto mi apunte de la clase de hoy con los resultados comentados. . Base
<?php /* El alcance o encapsulamiento define la visibilidad que tendra una propiedad, constante o método de una clase... Dependera del alcance para que algo pueda ser accedido desde uno u otro lugar por ejemplo, otro archivo, clase heredada o misma clase. Los tipos de alcances son: - public: Si se usa un alcance de este tipo, la propiedad, constante o método podra ser leído, accedido o modificado desde cualquier parte de nuestro sistema. - private: Si se usa este tipo de alcance, la propiedad, constante o método solo podra ser leído desde la misma clase donde se esta declarando, es decir, no se podra editar desde fuera de la clase. - protected: Si se usa este tipo de alcance, es muy similar al 'private' ya que solo puede ser accedido desde la misma clase PERO, si una clase hereda de la clase principal, esta clase hija podra acceder a las propiedades, constantes y métodos de la clase. */ // Declarando una clase con propiedades, constantes y métodos de un alcance diferente class Basee{ // Definiendo propiedades y constantes public $namePublic = "Joel Publico"; private $namePrivate = "Joel Private"; protected $nameProtected = "Joel Protected"; public const agePublic = 22; private const agePrivate = 32; protected const ageProtected = 42; // Definiendo métodos function saludarProtected(){ echo "¡Hola, mi nombre protected es: $this->nameProtected y mi edad protected es: ".$this::ageProtected; } } ?>
. Cached
<?php include_once('Basee.php'); // Creando una clase que herede de 'Base' class Cached extends Basee{ public function saludarCached(){ echo "Hola, estoy desde cached!"; } } // Creando una instancia de la clase 'cached' $cached1 = new Cached; // Accediendo a propiedades del la clase heredada 'Basee' echo $cached1->namePublic . "\n"; // Joel Publico echo $cached1->namePrivate . "\n"; // Notice: Undefined property: Cached::$namePrivate echo $cached1->nameProtected . "\n"; // Fatal error: Uncaught Error: Cannot access protected property Cached::$nameProtected // Accediendo a constantes de la clase heredada 'Base' echo $cached1::agePublic . "\n"; // 22 echo $cached1::agePrivate . "\n"; // Fatal error: Uncaught Error: Undefined class constant 'agePrivate' echo $cached1::ageProtected . "\n"; // Fatal error: Uncaught Error: Cannot access protected const Cached::ageProtected // Accediendo a los métodos de la clase heredada 'Base' $cached1->saludarProtected(); // ¡Hola, mi nombre protected es: Joel Protected y mi edad protected es: 42 echo "\n"; // Accediendo al método de la clase 'Cached' $cached1->saludarCached(); // Hola, estoy desde cached! echo "\n"; ?>
Alcance/Encapsulamiento es limitar quienes tienen permitido interactuar con el contenido(propiedades, métodos) de nuestras clases.
Al alcance o encapsulamiento también se le conoce como SCOPE y si, el scope puede definirse como un lugar desde el que puedes acceder a un espacio.
Es correcto, generalmente se usa mas escope, este por ser un curso en espanol supongo que por eso uso alcance
Si este es del curso de POO, bien
Aquí les dejo una breve explicación sobre el alcance: El alcance o encapsulamiento es una técnica que permite restringir el acceso a ciertos atributos y métodos. Por ejemplo: public: permite el acceso a todos los elementos de una clase protected: atributos o métodos que pueden ser usados si tienen herencia padre e hijo. private: Impide el acceso a los métodos o atributos a otras clases.
Alcance o Encapsulamiento
Hace referencia al encapsulamiento o principio de oculatación. Nos ayuda cuando trabajamos con la herencia, para esto tenemos:
Public: Los elementos públicos son aquellos que se pueden acceder a lo largo de todo el sistema
Protected: Solo pueden acceder los elementos de las clases que se heredan
Private: Solo puede ser accedido a través de la misma clase.
Con lo anterior se garantiza la integridad de los datos.
<?php class User { // public // protected // private public const PAGINATE = 25; // public $username; // protected $username; // private $username; public function getUsername(){ // ... } } ?>
Cuando escribimos el encapsulamiento garantizamos la integridad de los datos.
Para ilustrar el concepto de encapsulamiento y alcance en PHP, aquí tienes un ejemplo complejo que utiliza las visibilidades pública, protegida y privada:
class Usuario { public $nombre; protected $email; private $contraseña; public function __construct($nombre, $email, $contraseña) { $this->nombre = $nombre; $this->email = $email; $this->contraseña = $contraseña; } public function mostrarNombre() { return $this->nombre; } protected function mostrarEmail() { return $this->email; } private function mostrarContraseña() { return $this->contraseña; } } class Administrador extends Usuario { public function mostrarDatos() { return $this->mostrarEmail(); // Acceso a método protegido } } $usuario = new Usuario("Juan", "juan@example.com", "1234"); echo $usuario->mostrarNombre(); // Funciona // echo $usuario->mostrarEmail(); // Error: acceso protegido // echo $usuario->mostrarContraseña(); // Error: acceso privado $admin = new Administrador("Pedro", "pedro@example.com", "abcd"); echo $admin->mostrarNombre(); // Funciona echo $admin->mostrarDatos(); // Funciona, accede al email
En este ejemplo, nombre es público y accesible desde cualquier instancia, email es protegido y solo accesible en la clase Usuario y sus subclases, mientras que contraseña es privada y solo accesible desde la clase Usuario.
El encapsulamiento en PHP se refiere a la restricción del acceso a los datos de una clase, garantizando la integridad de estos. Se definen tres niveles de acceso:
Esto permite ocultar detalles de implementación y proteger la información sensible, como contraseñas, asegurando que solo métodos internos puedan modificar datos críticos.
Mi resumen:
