Bien vamos a continuar con nuestro ejercicio.
Ahora vamos a realizar la prueba de la Clase 2 vamos a hacer los cambios respectivos.
En esta clase quitamos estos comentarios y esta clase se encuentra en el mismo paquete que la clase
1 así que vamos a hacer algunas pruebas considerando esta cuestión que están en los nuevos paquetes.
Vamos a crear un constructor público de esta clase 2 va a ser un constructor vacío y lo que vamos a
intentar hacer es acceder al constructor de la Clase 1 así que vamos a lo siguiente prueba de constructores
de la Clase 1 considerando que estamos en el mismo paquete en una clase 2.
En primer lugar vamos a intentar crear un nuevo objeto de la clase 1 y podemos observar que podemos
acceder a los siguientes constructores vamos a dividir nuestras clases para que podamos observar el
código de la clase 1 y de la Clase 2.
Aquí damos clic derecho y seleccionamos documentarlo
y con eso podemos elevar el Código de la clase 1 y vamos a agregar este código de la Clase 2 así que
lo que estamos haciendo en este momento es mandar a llamar el constructor de la Clase 1 el constructor
vació que en este caso es un constructor público así que podemos observar que podemos mandar a llamar
sin ningún problema a este tipo de constructores y posteriormente vamos a intentar llamar el constructor
protegido de la clase 1 el cual tiene dos argumentos así que vamos a mandar a llamar el constructor
de la clase 1 con dos argumentos y podemos observar que el mismo nos proporciona esta ayuda podemos
llamar el constructor con un argumento el cual también es público o el constructor con dos argumentos
pasamos cualquier valor en este caso solamente queremos probar que podemos mandar a llamar este constructor
sin ningún problema así que podemos ver que podemos mandar a llamar este constructor protegido desde
otra clase debido a que estamos en el mismo paquete y ahora vamos a intentar llamar o crear un objeto
de la clase 1 utilizando el constructor de tipo de fought opacas en este caso no estamos asignando estas
variables que estamos creando.
Estos objetos no los estamos asignando a ninguna variable debido a que no nos interese realizar más
acciones con los objetos que vamos a crear de estas clases así que solamente estamos poniendo a prueba
los tipos de constructores que podemos mandar a llamar así que mandamos a llamar el constructor con
tres argumentos de tipo string
y podemos observar que podemos mandar a llamar este constructor sin ningún problema no nos marca ningún
tipo de error aquí simplemente es un warning que nos indica que no estamos asignando este objeto a ninguna
variable ya que como hemos comentado en este momento no nos interesa asignar el objeto que estamos creando
a ninguna variable así que vamos a ignorar ese Guarne y por último vamos a intentar llamar al constructor
privado de la Clase 1 que en este caso recibe 4 argumentos de tipo string así que vamos a apoyarnos
de este código que ya tenemos y le pasamos un cuarto argumento para mandar a llamar el constructor privado
y podemos observar el mensaje que el constructor Clase 1 con 4 argumentos tiene acceso privado de la
clase 1 y por lo tanto nos está marcando error de compilación.
Así que los constructores privados no pueden ser llamados desde otras clases sin importar si estamos
dentro del mismo paquete.
Así que no podemos llamar a constructores privados desde otras clases.
Sin importar si estamos en el mismo paquete bien así que con esto ya estamos poniendo a prueba cada
uno de los constructores de la clase 1 y ahora vamos a poner a prueba los métodos.
Vamos a intentar llamar a los métodos de la clase 1 los métodos que hemos creado
el método público método protegido método de Foll y método privado.
Así que vamos a crear un método.
Public void
prueba desde Clase 2.
Creamos un objeto de la Clase 1
la variable se llama C1
y ahora vamos a intentar acceder a los elementos de esta clase primero a los atributos vamos a ver a
qué tipo de atributo podemos acceder.
Tenemos el atributo pùblico protegido default y privado y vamos a intentar acceder a cada uno de ellos
desde la clase 2.
Vamos a hacer más grande ya esta clase porque ya vamos a tener problemas para visualizar el código así
que vamos a regresar a esta clase de lado izquierdo damos clic derecho y colaboramos para restaurar
los tabuladores del lado izquierdo.
Simplemente presionamos en este icono
y con esto ya hemos restaurado cada uno de los elementos también del lado izquierdo el tabulador de
proyectos archivos y servicios y en la parte inferior en la de Gádor vamos a ampliar este código y vamos
a hacer la prueba vamos a intentar llamar el atributo público de la clase 1.
Todo va a ser referente a la clase 1 así que vamos a utilizar la variable C1 e intentamos acceder al
atributo público.
Podemos observar que incluso Blyde nos muestra que sí podemos acceder así que sin ningún problema en
este caso podemos acceder al atributo público ahora al atributo protegido
también podemos acceder sin ningún problema
el atributo de foll opacas.
Vamos a ver si podemos acceder lo y también nos muestra este atributo de Font así que también sin ningún
problema podemos acceder a
y finalmente el atributo privado
así que escribimos C1 y podemos observar que la idea ya no nos muestra ese atributo.
Incluso si tratamos de escribirlo atributo
privado
élide nos arroja el mensaje que el atributo privado tiene modificador acceso privado en la Clase 1 por
lo tanto no podemos acceder a ese atributo desde otra clase.
Así que todo lo que sea privado no lo vamos a poder acceder desde otra clase.
Solamente desde la misma clase bien y ahora vamos a tratar de acceder a los métodos
imprimimos un sello de línea y tratamos de acceder al método público
por medio de la variable C1.
Llamamos al método público y podemos observar que podemos acceder sin ningún problema a los métodos
públicos o solamente al método protegido.
Seleccionamos el método protegido y también podemos acceder sin ningún problema
el método de foll o package
debido a que estamos en el mismo paquete.
Podemos acceder también sin ningún problema.
Método de FAW
y finalmente el método privado
C1 y tratamos de mandar al método privado.
Podemos observar que ya no lo despliega el IDE y también si lo escribimos
podemos va que nos manda el mensaje que el método privado tiene acceso privado en la clase 1 por lo
tanto no podemos acceder ya que estamos desde otra clase así que con eso estamos haciendo la prueba
de la clase 2.
Vamos a agregar un método main para que podamos ejecutar esta clase.
Vamos a crear un objeto de esta clase Clase 2 creamos el objeto c 2
y con esta línea lo que vamos a hacer es ejecutar el constructor de esta clase de la Clase 2 y vamos
a poder observar que estamos accediendo a cada uno de los constructores de la Clase 1 los constructores
que ya hemos analizado el constructor de públic protected de foll pero ya no podemos acceder al constructor
privado y posteriormente mandamos a llamar el método prueba de clase 2 y con eso se van a ejecutar cada
una de las llamadas a los atributos y los métodos que hemos analizado vamos a guardar cambios y ejecutamos
el resultado va a ser el mismo que ya hemos analizado simplemente para comprobar que esto funciona según
el análisis que hemos hecho.
Así que desde la clase 2 podemos mandar a llamar el constructor vacío que es público de la clase 1 también
el constructor protegido con dos argumentos también el constructor de packages de la clase 1 pero ya
no podemos mandar a llamar el constructor privado de la clase 1.
Posteriormente creamos el objeto para hacer la prueba de los atributos y podemos llevar los atributos
que estamos accediendo el atributo público con el valor de atributo público según hemos establecido
el atributo protegido.
También podemos acceder el default opacas también sin ningún problema pero el atributo privado debido
a que estamos en otra clase aunque estemos en el mismo paquete ya no podemos acceder.
También el método público podemos acceder sin ningún problema.
El método protegido de la clase 1 también el método de foll opacas también podemos acceder sin problema
pero el método privado ya no podemos acceder.
Así que en este caso estamos haciendo el análisis de cada uno de los elementos de cada uno de los modificadores
de acceso que hemos definido en la clase 1.
Pero probándolo desde la clase 2 que se encuentra en el mismo paquete bien vamos a dejar hasta aquí
este vídeo y en el siguiente vídeo vamos a analizar la clase 3 que va a ser una clase e hija de la clase
1 pero en otro paquete nos vemos el siguiente vídeo.
Saludos.