Bien vamos a continuar ahora con nuestra clase 3 bien vamos a ir al código de nuestra clase 3 quitamos
estos comentarios y lo particular en esta clase es que vamos a extender de la Clase 1 así que la clase
3 es una clase hija de la Clase 1 bien vamos a crear un constructor de esta clase de la Clase 3 es un
constructor público y vamos a intentar hacer lo mismo que en la Clase 2 en la cual hicimos la prueba
haciendo la llamada a cada uno de los constructores de la Clase 1 vamos a poner algunos comentarios
y también aunque nosotros no agreguemos todas las notas sobre este código ustedes pueden documentarlos
según vamos explicando ya que también la idea no es capturarlos con comentarios sino que ustedes mismos
vayan haciendo las notas respectivas si es que así lo desean.
Así que esa es la llamada al constructor público
esa es la llamada al constructor
protegido o protected
y esa es la llamada al constructor default opacando ya que si se definieron cada uno de estos constructores
en la clase 1
y finalmente la llamada al constructor
privado
así que ahora vamos a modificar nuestra clase 3 lo que vamos a hacer es mandar a llamar los constructores
como hemos comentado muy similar al ejemplo de la clase 2 así que incluso podemos apoyarnos de este
código.
Vamos a hacer cada una de las llamadas
damos formato y podemos observar como empiezan a fallar las pruebas que hemos hecho por ejemplo desde
la clase 2 ya no podemos hacer lo mismo desde la clase 3.
En este caso desde el constructor de la clase 3 podemos mandar a llamar el constructor público pero
ya no podemos crear los objetos como los hicimos desde la clase 2.
En este caso ya no podemos utilizar el constructor protegido ni tampoco el constructor marcado como
default opacas y mucho menos podemos utilizar el constructor privado así que podemos observar que ya
empezamos a tener más restricciones cuando trabajamos desde otra clase sin importar que sea una clase
e hija así que vamos a poner entre comentarios estas llamadas de lo contrario ya no vamos a compilar
nuestro código sin embargo sí tenemos una característica extra que podemos utilizar debido a que la
clase 3 extiende de la clase 1 y esta característica es la siguiente podemos mandar a llamar al constructor
marcado como protegido podemos mandar a llamar a este constructor con dos argumentos desde la clase
3 pero no lo podemos hacer directamente creando objetos sino utilizando la palabra súper así que para
ello podemos utilizar la palabra super y proporcionar dos argumentos para que se manda llamar el constructor
protegido de la clase 1 así que mandamos dos cadenas la cadena 1 cualquier valor la cadena 2.
Sin embargo recordemos que Super debe de ser la primera llamada dentro de un constructor así que esto
debe de ser la primera llamada dentro de este constructor clase 3 y con esto podemos observar que podemos
mandar a llamar al constructor protegido de la clase 1.
Esto debido a que estamos extendiendo la clase 1 y por lo tanto todo lo que se ha marcado como protegido
dentro de la Clase 1 lo podemos acceder sin ningún problema desde otra clase e hija incluso si estamos
en otro paquete así que esa es la característica que podemos hacer uso de los elementos marcados como
protegidos
debido a que estamos haciendo extent de la Clase 1
así que para ello fue que creamos esta prueba de la clase 3 en otro paquete para que pudiéramos poner
a prueba este concepto de llamar a las características de la clase padre todos los elementos marcados
como protegidos.
Ahora vamos a hacer también la prueba como lo hicimos en la Clase 2 podemos apoyarnos de este código
copiamos la función y pegamos el código prueba pero ahora va a ser desde la clase 3
creamos un objeto de la clase 1 y empezamos a llamarlos atributos.
En este caso primero los atributos y posteriormente los métodos podemos observar que el atributo marcado
como público aunque estemos en otra clase y en otro paquete no hay ningún problema podemos seguir utilizándolo.
Pero el atributo marcado como protegido podemos observar que ya no podemos acceder.
Podríamos acceder siempre y cuando ya no utilizáramos la referencia de la Clase 1 sino que debido a
que estamos en una clase hija entonces podríamos acceder pero directamente así que podemos observar
que sí podemos acceder pero sin utilizar la referencia del objeto 1 así que se hace la diferencia en
este caso que estamos en una clase hija de la clase 1 y el atributo definido como package.
También ya no podemos acceder.
Sin importar si utilizamos o no la referencia del objeto debido a que ya estamos en otro paquete y por
lo tanto los atributos que sí podríamos utilizar en la Clase 2 que estábamos dentro del mismo paquete.
En este caso el atributo de opacas ya no lo podemos acceder debido a que ya estamos en otro paquete
así que vamos a poner entre comentarios esa llamada y también la llamada el atributo privado.
Por obvias razones ya no podemos utilizarlo ya estamos en otro paquete y en otra clase bien vamos a
analizar ahora la llamada a los métodos podemos observar que el método público lo podemos seguir llamando
sin ningún problema.
El método protegido de igual manera directamente utilizando la referencia del objeto 1 No podemos mandarlo
a llamar pero si quitamos esta referencia debido a que estamos exteniente de la clase 1 entonces también
podemos acceder a este método protegido de la Clase 1 sin ningún problema debido a que le estamos heredando
de la clase 1 y finalmente el método de opacas.
Tampoco podemos acceder debido a que estamos en otro paquete así que vamos a ponerlo entre comentarios
y también el método privado también ya no podemos acceder debido a que estamos en otra clase y en otro
paquete bien así que vamos a agregar el método main para hacer la prueba de esta clase.
Podemos apoyarnos también del código que agregamos en la Clase 2
importamos la Clase 2 pero en este caso vamos a cambiarlo vamos a crear un objeto de nuestra clase 3
y mandamos a llamar el método prueba desde Clase 3 damos formato
y podemos quitar este impor de la Clase 2 ya que no lo vamos a utilizar
guardamos cambios y ejecutamos y el resultado debe ser el mismo que ya hemos analizado.
Solamente estamos comprobando lo que ya hemos analizado así que estamos mandando llamar el constructor
protegido pero utilizando la palabra super no creando directamente un objeto de tipo protected mandando
llamar el constructor de protected sino utilizando la palabra super que es la forma en que se debe de
realizar.
Cuando estamos extendiendo la clase 1 posteriormente podemos mandar a llamar el constructor vacío sin
ningún problema y posteriormente creamos otro objeto de la clase 1 para poner a prueba cada uno de los
atributos y podemos observar que podemos utilizar solamente el atributo público el atributo protegido
pero sin utilizar una referencia del objeto de la clase 1 sino mandarlo a llamar directamente ese atributo
protegido debido a que lo estamos heredando de la clase 1.
Posteriormente podemos llamar al método público y también al método protegido pero de igual manera sin
utilizar una referencia de la variable de clase 1 sino llamando directamente al método protegido debido
a que lo estamos heredando de la clase 1 hace que esa es otra prueba que estamos haciendo desde la clase
3 la cual extiende de la Clase 1 por lo tanto es una clase hija y estamos en otro paquete en el paquete
2 así que esas son las conclusiones de cada uno de los modificadores de acceso y por último vamos a
analizar la clase 4 pero esto lo vamos a ver en el siguiente vídeo.
Saludos.