Clases 2 (Modificadores acceso y static) - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
Voy a grabar este vídeo, por lo tanto, si habláis, me autorizáis a que grabe.
00:00:00
Vale, entonces, hemos visto el Main, hemos visto la diferencia entre Static y no Static,
00:00:08
ahora luego haremos ejemplos y probaremos un poco las cosas.
00:00:17
Vamos a hablar de otro tema más sencillo, que es la organización del código.
00:00:22
Hasta ahora nosotros principalmente lo que hemos hecho es crear clases,
00:00:33
creamos un proyecto y creamos clases allí dentro.
00:00:38
Algunos de vosotros sí que han empezado a crear paquetes, lo que se llaman packages.
00:00:41
La idea es que yo pueda estructurar mejor las varias secciones de mi código,
00:00:47
las varias secciones de mi sistema, creando paquetes de clases.
00:00:55
Todas las clases que están relacionadas con un tema más amplio, más general,
00:01:01
las puedo poner dentro del mismo package.
00:01:13
De esta forma organizo mejor el código y se queda más fácil de mantener
00:01:16
y sobre todo más fácil de reutilizar.
00:01:25
En principio no, porque los ejercicios que hacemos nosotros son ejercicios que son sencillos.
00:01:32
Cuando yo hago un proyecto, que es un proyecto serio, estoy haciendo una escuela
00:01:40
y hay un montón de cosas que tener en cuenta,
00:01:45
entonces a lo mejor puedo crear paquetes distintos, uno para gestionar la parte del personal,
00:01:48
otro paquete que se ocupe de la parte didáctica o académica de las asignaturas.
00:01:55
Todo lo que es relacionado a alumnos, profesores y cosas por el estilo,
00:02:03
a lo mejor lo meto en un package y lo suelto en otro package.
00:02:08
Esto no quiere decir que luego entre packages no se puedan ver,
00:02:11
hay formas para crear un objeto que está en otro package o cosas por el estilo.
00:02:15
¿Conocéis vosotros Scanner?
00:02:20
¿Scanner está en vuestro proyecto?
00:02:24
¿La clase Scanner la habéis escrito vosotros en vuestro programa?
00:02:33
Se accede a ella que está en otro package,
00:02:38
de hecho al principio si os acordáis estaba el import, import java.util.scanner,
00:02:41
eso es un package, un package,
00:02:48
o sea el package java que contiene un sotopackage que es el package útil
00:02:51
que tiene dentro la clase Scanner.
00:02:57
Entonces yo lo que puedo hacer es irme a otro package,
00:02:59
importar o todo el package entero o algunas de las clases.
00:03:01
Cuando yo creo packages, al principio de mi clase tengo que poner package
00:03:07
y el nombre del paquete.
00:03:13
Si vosotros lo habéis hecho alguna vez, ahora hacemos un ejemplo,
00:03:15
pues os lo ponen automático, si lo hacéis bien.
00:03:17
La idea es que estos packages, cómo se organizan los packages,
00:03:21
si vais a mirar luego dentro del file system,
00:03:30
cómo se están estructurando las carpetas, etc, etc,
00:03:35
los paquetes, etc, etc,
00:03:40
veréis que se utilizan unas carpetas,
00:03:42
cada package es una carpeta,
00:03:46
que estarán, si hay subpackages habrá carpetas dentro,
00:03:48
y luego dentro pondremos los puntos java.
00:03:51
Para entender esto, la mejor cosa es hacer un ejemplo.
00:03:54
Y aquí por ejemplo, esta es la situación actual,
00:04:00
tengo un proyecto nuevo con una clase prueba,
00:04:04
está en el default packages,
00:04:08
esto quiere decir que no hay package.
00:04:10
Si voy a mirar,
00:04:12
dónde está mi workspace,
00:04:17
debería estar por aquí.
00:04:20
Dentro del workspace, que está esta cosa de metadatos
00:04:25
que se os crea cuando creáis el workspace,
00:04:29
hay todos los proyectos, cada carpeta es un proyecto distinto.
00:04:33
Estas carpetas se corresponden con los proyectos que tengo aquí.
00:04:38
En particular, está el proyecto de hoy,
00:04:42
este de aquí,
00:04:47
si lo busco aquí hay una carpeta que tiene el mismo nombre.
00:04:48
Si entro dentro de esta carpeta, tengo varias cosas,
00:04:52
nos interesa principalmente,
00:04:58
search en bin,
00:05:00
search es los fuentes,
00:05:02
es esta carpeta de aquí,
00:05:05
se corresponde, si entro dentro de source,
00:05:07
encuentro prueba.java.
00:05:12
Aquí directamente porque no hay ningún package,
00:05:16
es solo el paquete por defecto que es nada.
00:05:19
Si me voy a bin,
00:05:23
encuentro las clases.
00:05:26
Automáticamente Eclipse,
00:05:30
lo que hace es pillarme lo que está en la carpeta source,
00:05:33
compilarlo usando Java C,
00:05:39
de esto y de todas las otras cosas que están en la carpeta source,
00:05:42
y me guarda el resultado en la carpeta bin.
00:05:45
Estos luego son los que usa para ejecutarlo
00:05:49
cuando yo le doy al botón verde para que empiece a ejecutar.
00:05:52
¿Qué pasa si ahora creo aquí un nuevo package?
00:05:57
Me dice, ¿cómo se llama el package?
00:06:07
Le digo, ¿se llama HAKUNO?
00:06:11
Fijaos que se enfada,
00:06:17
mejor que el nombre del package sea en lowercase,
00:06:21
y luego le doy Finish.
00:06:29
Si os fijáis, aquí me ha creado un package vacío.
00:06:31
¿Qué pasa en el mundo del file system?
00:06:35
Que si ahora entro en source,
00:06:40
existe una carpeta nueva que es HAKUNO.
00:06:42
Este es el package, dentro no hay nada.
00:06:45
Si yo lo hago desde la aplicación,
00:06:51
la aplicación se da cuenta de esto.
00:06:57
Si yo lo hago desde fuera,
00:06:59
luego tendré que decirle a la aplicación,
00:07:01
oye mira, lo he creado.
00:07:04
Entonces, consejo, casi siempre hacerlo desde la aplicación.
00:07:05
Si usáis un IDE, haced todo desde el IDE.
00:07:08
No hagáis cosas a mitad desde fuera del IDE,
00:07:12
porque buscad la forma de cómo se hace en NetBeans,
00:07:15
en Eclipse, en Intellij, en lo que sea,
00:07:21
pero no lo hagáis vosotros directamente.
00:07:24
Porque a veces no se da cuenta,
00:07:27
y luego hay una diferencia entre lo que hay aquí y lo que hay.
00:07:29
Si ahora yo pido prueba,
00:07:37
y lo muevo dentro de HAKUNO,
00:07:39
veis que aquí se queda package1,
00:07:43
veis que aquí me ha añadido esto.
00:07:46
Entonces ahora esta clase es parte de este package,
00:07:51
y si voy aquí, veo que dentro de HAKUNO,
00:07:56
ahora está prueba.java.
00:08:00
¿Puedo hacer subpackages?
00:08:04
Sí.
00:08:07
Botón derecho, nuevo package,
00:08:09
veis que aquí me ha escrito ya HAKUNO,
00:08:12
y le pongo punto, subpack 1.
00:08:16
Este punto, lo que me está diciendo,
00:08:22
es que soy un subpackage del package anterior.
00:08:26
Le doy a finish,
00:08:32
y veis que subpack me lo ha creado dentro de pack,
00:08:34
como hijo de pack.
00:08:39
Si quiero crear un package 2,
00:08:41
entonces veis que pack1 y pack2 son hermanos,
00:08:51
pero subpack es interno a esto.
00:08:55
Entonces puedo hacer así.
00:08:59
Está bloqueado.
00:09:05
Fijaos que ahora me dice que el package al que pertenece prueba
00:09:10
es package.pack1.subpack1.
00:09:14
Si en algún momento yo tuviera que trabajar con prueba ahora,
00:09:19
debería llamarla pack1.subpack1.prueba,
00:09:25
¿sí?
00:09:31
O importar directamente prueba como import pack1.subpack1.prueba,
00:09:32
y ya está.
00:09:40
¿Ok?
00:09:42
Recuerdaos cuando aquí,
00:09:43
scanner, scanner, es igual a new scanner,
00:09:45
en el system.in,
00:09:49
aquí me dice import scanner.
00:09:57
Veis que aquí estoy importando del package java,
00:10:02
que tiene un subpackage que se llama útil,
00:10:06
estoy importando la clase scanner,
00:10:09
y entonces solo la puedo utilizar tranquilamente.
00:10:14
¿Sí?
00:10:17
También si yo digo, mira, de java.util,
00:10:19
hay un montón de cosas en este package,
00:10:22
y me interesan todas,
00:10:25
podría utilizar esto.
00:10:27
Esto me está diciendo,
00:10:30
importa todas las clases que están dentro del package java.util.
00:10:31
¿Y qué hay en java.util?
00:10:39
Ya que estamos,
00:10:41
yo me puedo ir a api.java,
00:10:42
de java.util,
00:10:47
y aquí está un poco todo lo que está aquí dentro,
00:10:52
todas estas clases,
00:10:57
todas estas clases,
00:11:00
de una de ellas debería ser scanner.
00:11:03
Sí, sí.
00:11:10
Algunas se van quitando,
00:11:13
algunas se van a marcar como deprecated,
00:11:15
que quiere decir no la uses,
00:11:19
porque ya tiene algún problema,
00:11:22
que la dejamos allí,
00:11:25
para que programas hechos anteriormente que la usen,
00:11:27
no dejen de funcionar,
00:11:31
pero si tú estás haciendo un programa nuevo,
00:11:33
pues deberías usar una alternativa,
00:11:35
normalmente allí mismo te lo dice,
00:11:37
te dice, mira no uses esta, usa esta otra.
00:11:39
Y luego,
00:11:42
algunas veces si ven que es un problema de seguridad,
00:11:43
o cosa por el estilo,
00:11:46
pues la quitan.
00:11:47
Y tú te puedes ir a scanner,
00:11:48
y ver qué puedes hacer con scanner,
00:11:51
entonces aquí te describe qué es scanner,
00:11:53
cómo funciona,
00:11:55
por qué,
00:11:56
bla, bla, bla,
00:11:57
te dice todos los constructores que tienes de scanner,
00:11:58
y te dice todos los programas,
00:12:02
los métodos que puedes utilizar sobre scanner.
00:12:06
Ahora de estas,
00:12:10
hay mogollón.
00:12:12
Estas son todas las clases,
00:12:21
que están ya creadas dentro de Java,
00:12:23
y que tú puedes reutilizar,
00:12:27
para alguna de tus proyectos.
00:12:29
Son unos cuantos.
00:12:32
Entonces,
00:12:35
cuando tú dices,
00:12:36
oye mira,
00:12:37
quiero hacer una comunicación a internet,
00:12:38
pues posiblemente por aquí hay alguna clase,
00:12:40
que te ayuda,
00:12:44
porque una parte de esta comunicación,
00:12:46
ya está programada,
00:12:48
y tú en vez de reprogramarla desde cero,
00:12:49
pues usas socket,
00:12:51
usas inetadress,
00:12:53
usas server socket,
00:12:54
cosas que te permiten de comunicarte así.
00:12:55
Oye mira,
00:12:58
quiero hacer un trabajo sobre matemática,
00:12:59
y necesito operaciones matemáticas,
00:13:02
pues te buscas la clase math,
00:13:04
o pico,
00:13:06
m, n, o,
00:13:07
m, m, m,
00:13:08
ma, ma, ma, ma,
00:13:09
math,
00:13:10
Oracle ahora mismo,
00:13:17
pero bueno,
00:13:19
el desarrollador de Java.
00:13:20
Math,
00:13:22
vale,
00:13:23
y aquí dentro de math,
00:13:24
yo puedo irme a mirar,
00:13:26
todo lo que me permite hacer math,
00:13:27
math me permite,
00:13:29
por ejemplo,
00:13:30
aparte que me da algunos campos,
00:13:31
como el valor de pi,
00:13:33
o el valor de los logaritmos naturales,
00:13:35
y cosas por estilo,
00:13:40
y a partir de allí,
00:13:42
por ejemplo,
00:13:43
si yo quiero el método abs de un valor,
00:13:44
esto me da el valor absoluto,
00:13:46
de un double,
00:13:48
de un float,
00:13:49
de un int,
00:13:50
de un long,
00:13:51
esto es el arcoseno,
00:13:52
de un valor,
00:13:54
me da el arco tangente,
00:13:56
el redondeado hacia arriba,
00:13:58
el copiar el signo de un valor,
00:14:01
el coseno de,
00:14:06
que se yo,
00:14:08
exponencial,
00:14:09
el exponente se ha dicho,
00:14:10
que se yo,
00:14:12
vale,
00:14:13
por aquí encontráis un montón de operaciones matemáticas,
00:14:14
esto por ejemplo,
00:14:20
la potencia,
00:14:21
para hacer a elevado a la b,
00:14:22
pues uso esto,
00:14:24
creo que lo usamos una vez,
00:14:25
pregunta para vosotros,
00:14:27
este señor de aquí,
00:14:29
¿estático o no?
00:14:31
quien dice,
00:14:38
si es estático,
00:14:39
quien dice,
00:14:42
no, no es estático,
00:14:43
quien dice,
00:14:46
me gustaría estar en casa en el sofá,
00:14:47
porque estoy triste,
00:14:49
vale,
00:14:51
esto me dice,
00:14:53
esto de aquí,
00:14:54
¿vosotros lo usaríais sobre un objeto o no?
00:14:55
¿necesita un objeto que me dé que valor hacer,
00:14:58
para poder hacer a elevado a la b o no?
00:15:01
y por ejemplo,
00:15:16
yo hago a elevado a la b,
00:15:17
¿el valor que me devuelve,
00:15:21
que tipo tiene?
00:15:22
porque los parámetros no son de un objeto,
00:15:32
es como cuando haces,
00:15:38
si es,
00:15:40
para que sea estático,
00:15:42
para que sea no estático,
00:15:44
es esta situación de aquí,
00:15:47
donde yo llamo área,
00:15:50
¿y donde están los parámetros?
00:15:53
dentro del rectángulo 1,
00:15:55
que es un objeto,
00:15:57
que tiene su ancho,
00:15:58
pero cuando en vez es estático,
00:16:00
como no tienes un objeto,
00:16:04
que te da el ancho y el largo,
00:16:06
entonces el método es estático,
00:16:08
y te pide el largo y el ancho,
00:16:09
y aquí es lo mismo,
00:16:11
POU te dice a y b,
00:16:13
y te hace a elevado a la b,
00:16:15
si hubiese un objeto exponente,
00:16:17
que dentro tiene dos parámetros,
00:16:24
que son base y exponente,
00:16:26
entonces tendría un método,
00:16:28
que es calcular,
00:16:30
que simplemente lo que hace,
00:16:31
es pillarse la base,
00:16:33
y hacerla el exponente,
00:16:34
pero como no hay un objeto,
00:16:36
y como todos estos métodos de aquí,
00:16:38
todas estas operaciones aquí,
00:16:40
son operaciones matemáticas,
00:16:41
al fin y al cabo,
00:16:43
al que le paso los parámetros,
00:16:44
para hacer esta operación matemática,
00:16:45
pues entonces son todos estáticos,
00:16:47
si te fijas son todos estáticos,
00:16:49
nunca crearás un objeto math,
00:16:51
siempre usarás math punto,
00:16:53
la operación que quieres hacer,
00:16:55
esta es una clase estática,
00:16:58
puramente estática,
00:17:00
¿Entonces lo que habías dicho,
00:17:02
de una potencia ligada a un exponente,
00:17:04
eso por ejemplo no sería estático?
00:17:07
Si yo me creara un objeto,
00:17:10
que es objeto expo algo,
00:17:13
que dentro tiene dos parámetros,
00:17:18
que es mi base y mi exponente,
00:17:20
entonces este es un objeto,
00:17:22
y yo lo hago para crear un valor,
00:17:23
lo que hago es crear un nuevo objeto,
00:17:26
diciendo tu base es 3,
00:17:28
y tu exponente es 4,
00:17:30
y luego está un método calcular,
00:17:31
que me pilla 3,
00:17:33
me lo eleva a la 4,
00:17:34
y me devuelve lo que sea,
00:17:35
pues entonces no,
00:17:36
sería todo no estático,
00:17:37
pero a lo mejor no es un buen planteamiento,
00:17:40
luego se complica,
00:17:46
cada vez que yo quiero hacer A elevado a la B,
00:17:47
tengo que crear un nuevo objeto,
00:17:49
poniendo A, poniendo B,
00:17:51
y luego pedirle cálculate,
00:17:52
mientras aquí directamente lo pido,
00:17:54
eso se me explica,
00:17:56
entonces volviendo a los sub packages,
00:17:59
fijaos que aquí también,
00:18:03
lo que ha hecho es que ahora tiene PAC1 y PAC2,
00:18:05
que son hermanos,
00:18:08
y que si yo entro dentro de PAC1,
00:18:10
está sub PAC1,
00:18:12
y dentro de PAC1 está esto,
00:18:13
esto era sobre organización de código,
00:18:29
también aquí se habla del importar,
00:18:33
otra cosa que hemos hablado,
00:18:39
y que tenemos que tener en cuenta,
00:18:44
es overloading o sobrecarga,
00:18:45
que es que yo en una misma clase,
00:18:48
puedo crear 5 métodos,
00:18:50
que se llaman igual,
00:18:53
los 5 métodos se llaman,
00:18:55
calcular área,
00:18:59
pero que cada uno me pille parámetros distintos,
00:19:00
uno me pilla solo un lado,
00:19:04
uno me pilla el lado de la altura,
00:19:05
uno me pilla el otro lado,
00:19:07
uno me pilla el lado y la hipotenusa,
00:19:09
que se yo,
00:19:11
la idea es que se puede sobrecargar un método,
00:19:14
cuando se sobrecarga,
00:19:17
cuando se llaman igual,
00:19:18
el nombre es el mismo,
00:19:20
lo que cambia es la firma,
00:19:22
la firma es nombre y tipo de parámetros,
00:19:24
no es lo mismo calcular área sin nada,
00:19:30
que calcular área de string,
00:19:33
que calcular área de string int,
00:19:36
cada uno será un método distinto,
00:19:38
se asume que todos hagan lo mismo,
00:19:40
calcular área,
00:19:43
pero me dan parámetros distintos,
00:19:44
ejemplo,
00:19:46
aquí hemos visto al principio,
00:19:52
aquí por ejemplo tengo un método
00:19:54
que me devuelve el valor absoluto,
00:19:56
y está sobrecargado,
00:19:58
que yo lo puedo pedir sobre un double,
00:20:01
lo puedo pedir sobre un float,
00:20:04
lo puedo pedir sobre un int,
00:20:05
lo puedo pedir sobre un long,
00:20:06
hace lo mismo,
00:20:08
siempre te doy el valor absoluto de este número,
00:20:10
si es negativo lo pongo positivo,
00:20:12
si es positivo lo dejo así,
00:20:13
pero este de aquí te acepta un double,
00:20:17
¿cuál uso?,
00:20:20
si yo llamo math.abs de 3,
00:20:22
me usa esto,
00:20:25
si yo llamo math.abs de 3.0,
00:20:27
me usa esto,
00:20:31
si yo llamo math.abs de 3f,
00:20:33
me usa esto,
00:20:37
¿a la vez o no?
00:20:51
Siempre que tenga nombre,
00:21:09
yo creo que te lo permito,
00:21:11
siempre que la firma sea distinta,
00:21:13
no puedo hacer static, saludo,
00:21:16
y luego static, saludo,
00:21:19
que te llame a ti mismo,
00:21:22
no static, saludo,
00:21:24
que te llame a tu nombre,
00:21:26
porque sería la misma firma,
00:21:28
entonces no,
00:21:30
¿me explico?
00:21:31
Aquí tengo una prueba,
00:21:38
me digo, voy a hacer un método,
00:21:40
el método es public, static, saludo,
00:21:42
y digo, si eso, hola,
00:21:49
ahora puedo hacer uno,
00:22:03
que en vez de dependa de mi nombre,
00:22:05
porque prueba tiene string, nombre,
00:22:08
y decir, vuelvo a hacer saludo,
00:22:14
que ahora haga esto,
00:22:19
más dis.nombre,
00:22:21
y que no sea static,
00:22:23
son distintos,
00:22:26
este es static y este no,
00:22:28
pero la firma es la misma,
00:22:30
entonces en este caso no lo puedo hacer,
00:22:35
¿dónde? ¿aquí o aquí?
00:22:44
Si aquí le pongo, por ejemplo,
00:22:46
string, nombre,
00:22:48
y luego aquí hago más nombre,
00:22:50
esto funciona,
00:22:54
y tengo la versión estática,
00:22:56
que no depende del objeto,
00:22:59
porque cualquiera puede llamar,
00:23:01
saluda Estefano,
00:23:02
y te dice, hola Estefano,
00:23:03
saluda Antonio,
00:23:04
hola Antonio,
00:23:05
saluda Sara, hola Sara,
00:23:06
o este de aquí,
00:23:08
que en vez se llama sobre el objeto,
00:23:09
porque no te dice quien saludar,
00:23:12
quien te dice saludar es dis.nombre,
00:23:14
este objeto que es este de aquí,
00:23:16
entonces esto lo llamo como instancia.saludo,
00:23:19
y esto lo llamo como prueba.saludo,
00:23:24
de quien quiero saludar,
00:23:27
Si
00:23:31
Para poder sobrecargar un método,
00:23:40
la firma tiene que ser distinta,
00:23:44
la firma es el nombre,
00:23:46
y luego los tipos de parámetros,
00:23:48
como este es nombre de string,
00:23:50
y este es nombre de void,
00:23:52
pues me va.
00:23:54
O a lo mejor usa variables estáticas que están aquí.
00:24:01
Tened en cuenta también,
00:24:09
que que pasa si yo aquí le pongo dis.
00:24:11
¿Por qué se enfada?
00:24:22
¿Por qué?
00:24:25
Porque dis haría referencia a la instancia en la que me has llamado,
00:24:28
pero ese es estático,
00:24:33
no lo estás llamando sobre una instancia,
00:24:34
entonces no existe,
00:24:36
entonces no lo puede hacer,
00:24:38
me dice,
00:24:39
estás haciendo referencia,
00:24:41
no puedes usar dis,
00:24:43
esta palabra,
00:24:45
in a static context,
00:24:47
no puedes hacer referencia a esta instancia,
00:24:50
en un contexto que no tiene instancias,
00:24:53
que es estático.
00:24:56
Pregunta,
00:25:00
y si aquí en vez tuviera una variable estática,
00:25:01
string,
00:25:11
fijaos que si es estática,
00:25:17
te la pone en cursiva,
00:25:19
la puedo usar aquí,
00:25:23
¿la puedo usar aquí?
00:25:26
O de hecho de otra forma,
00:25:42
esto sería prueba.gato,
00:25:45
esto sería prueba.gato,
00:25:48
¿sí?
00:25:56
¿Cómo?
00:25:58
Es que como estoy dentro de la misma clase,
00:26:00
y es estática,
00:26:03
me refiero a la clase,
00:26:04
entonces si la quito,
00:26:05
él entiende que es esa,
00:26:07
es esta,
00:26:09
porque es la única,
00:26:10
pero imagínate que yo fuera en otra clase,
00:26:11
y quiero usar esta variable aquí,
00:26:14
pues entonces la debería llamar como prueba.gato,
00:26:16
ahora hacemos ejemplos,
00:26:22
entonces entiende el concepto de overloading,
00:26:24
¿sí?
00:26:29
Algunas veces no ha servido,
00:26:30
la última cosa que tenemos que ver hoy,
00:26:32
es la encapsulación y visibilidad,
00:26:35
y con esto hemos acabado.
00:26:38
Vale, esto ya lo hemos visto,
00:26:42
pero vamos a ver que opciones tenemos,
00:26:44
siempre que yo,
00:26:46
por favor chicos,
00:26:47
hola,
00:26:48
siempre que yo defina un atributo,
00:26:50
o un método,
00:26:53
¿vale?
00:26:55
Le puedo decir,
00:26:56
quién puede ver este atributo,
00:26:58
o este método,
00:27:03
¿sí?
00:27:05
¿Cómo funciona?
00:27:06
Seguramente siempre dentro de la clase
00:27:07
que estoy utilizando,
00:27:11
yo puedo ver mis métodos,
00:27:13
y mis atributos,
00:27:15
siempre,
00:27:16
¿vale?
00:27:17
Pero puede ser que yo quiera
00:27:18
que gente fuera de mi clase
00:27:20
pueda utilizar estos métodos,
00:27:23
o puede ser que no quiera
00:27:25
que lo quieran ver
00:27:30
y lo quieran utilizar,
00:27:32
por eso tengo unos modificadores,
00:27:33
¿vale?
00:27:37
Tengo cuatro modificadores posibles,
00:27:38
Public,
00:27:40
Protected,
00:27:41
Packaged,
00:27:42
y Private,
00:27:43
¿sí?
00:27:44
¿Cómo funciona esto?
00:27:46
Si es publico,
00:27:47
publico quiere decir
00:27:48
que todos los pueden ver,
00:27:50
sean en mi clase,
00:27:53
o sean en la clase fuera,
00:27:54
¿sí?
00:27:56
No está protegido.
00:27:57
El siguiente paso es Protected,
00:27:59
Protected quiere decir,
00:28:02
oye,
00:28:04
no todos lo pueden ver,
00:28:05
no todos pueden utilizar estos métodos,
00:28:06
no todos pueden utilizar estos atributos,
00:28:07
¿quién puede hacerlo?
00:28:10
Solo los que están en mi mismo paquete,
00:28:12
o que heredan de mí.
00:28:16
¿Qué quiere decir?
00:28:19
No lo sé,
00:28:21
por eso está en rojo.
00:28:22
No sabemos todavía qué es la herencia,
00:28:24
cuando veremos la herencia
00:28:26
volveré a sacar esto
00:28:28
y os diré,
00:28:30
¿os acordáis Protected?
00:28:31
Pues a esto,
00:28:32
¿sí?
00:28:33
Pero por ahora,
00:28:34
Protected es
00:28:35
mi mismo paquete,
00:28:36
mi clase,
00:28:38
mi paquete,
00:28:39
o sea,
00:28:40
todas las clases de mi paquete
00:28:41
y todas las clases que hereden de mí,
00:28:42
independientemente que sean de mi paquete o no.
00:28:44
¿Qué quiere decir?
00:28:46
No lo sé,
00:28:47
veré.
00:28:48
Package,
00:28:50
esto es,
00:28:51
todas las clases que pertenecen a mi mismo package,
00:28:53
¿vale?
00:28:56
Todas las que están en mi mismo package,
00:28:57
pues pueden acceder a mis métodos,
00:28:59
a este método que he marcado como package,
00:29:01
o algo así.
00:29:03
Si no pongo nada,
00:29:04
si no me equivoco,
00:29:06
es esto.
00:29:07
No me acuerdo nunca si es esto o esto,
00:29:10
si no pongo nada.
00:29:12
Que esto añade,
00:29:15
además de los paquetes,
00:29:16
los heredados,
00:29:17
que no sabemos qué es,
00:29:18
por lo tanto,
00:29:19
por ahora esto no existe,
00:29:20
rojo,
00:29:21
pero existe,
00:29:22
pero por ahora no sabemos bien,
00:29:23
¿sí?
00:29:25
Porque para entender esto,
00:29:26
te tengo que explicar la herencia,
00:29:27
que no la hemos visto todavía.
00:29:28
Y el último es Private,
00:29:30
se puede utilizar solo dentro de esta clase.
00:29:32
Entonces,
00:29:37
hay un método,
00:29:38
solo dentro de esta clase,
00:29:39
hay un atributo,
00:29:40
solo dentro de esta clase.
00:29:41
Esto me sirve,
00:29:42
y lo hemos hecho ya en varios ejemplos,
00:29:43
para decir,
00:29:44
oye, mira,
00:29:45
yo tengo un atributo que es mi nombre,
00:29:46
y yo no quiero que,
00:29:48
cuando tú crees un alumno que tenga este nombre,
00:29:50
gente desde otras clases,
00:29:53
desde otro lado,
00:29:55
la clase,
00:29:56
qué sé yo,
00:29:57
una clase que ha escrito un tercero,
00:29:59
pueda acceder a mi clase y cambiarme el nombre.
00:30:01
O,
00:30:05
para hacer un ejemplo más concreto,
00:30:06
edad,
00:30:07
¿vale?
00:30:08
Yo no quiero que una persona desde fuera
00:30:09
pueda acceder a edad
00:30:11
y poner "-37",
00:30:13
porque la edad negativa no existe.
00:30:15
Si yo lo pongo Public,
00:30:18
este atributo,
00:30:20
cualquiera desde fuera puede acceder
00:30:21
y darle el valor que le da la gana,
00:30:24
porque es una variable como cualquier.
00:30:26
Si yo quiero poder poner algo,
00:30:28
decir,
00:30:31
oye, mira, no,
00:30:32
espera,
00:30:33
que si alguien intenta modificarlo,
00:30:34
haz una verifica,
00:30:35
lo pongo Private,
00:30:36
entonces nadie puede acceder allí.
00:30:38
Y luego me creo un método,
00:30:40
un método set,
00:30:42
¿vale?
00:30:44
set nombre,
00:30:45
set edad,
00:30:46
que es un método.
00:30:47
Entonces,
00:30:49
cuando alguien desde fuera
00:30:50
intenta cambiar la edad,
00:30:51
tiene que pasar por ese método.
00:30:53
No está cambiando directamente la variable,
00:30:55
está llamando ese método.
00:30:57
Y yo, como programador,
00:30:59
puedo poner en ese método
00:31:01
una serie de controles,
00:31:03
de decir,
00:31:04
si ese número que me están intentando poner
00:31:05
es negativo,
00:31:07
no lo cambies.
00:31:08
¿Eh?
00:31:10
Y ahora hacemos ejemplos de eso.
00:31:11
Estos son modificadores de acceso
00:31:14
para atributos y métodos.
00:31:17
Cualquier método,
00:31:20
cualquier atributo que vosotros queráis,
00:31:21
puede ser Public,
00:31:22
Protected,
00:31:23
Packaged o Private.
00:31:24
O nada.
00:31:25
Si no le pongo nada,
00:31:26
creo que es esto,
00:31:28
no me acuerdo nunca.
00:31:29
Si es Protected o Packaged.
00:31:30
Si no le pongo nada.
00:31:32
Ahora lo vemos.
00:31:33
Es Packaged.
00:31:35
Modificadores para las clases.
00:31:40
Nosotros hasta ahora hemos siempre
00:31:44
hecho Public y Class.
00:31:45
¿Sí?
00:31:47
Pero yo puedo hacer también
00:31:48
Clases Secas.
00:31:49
Sin poner nada.
00:31:50
Que es como si pusiera Packaged,
00:31:52
Class.
00:31:54
¿Vale?
00:31:55
Estas son clases
00:31:56
que están protegidas,
00:31:57
que no se ven desde fuera,
00:31:59
que se ven solo dentro de mi Package.
00:32:01
¿Para qué me sirve?
00:32:05
Porque a veces,
00:32:07
yo quiero hacer una clase alumno
00:32:08
y dentro de la clase alumno
00:32:10
haya algunos valores de alumno
00:32:12
que yo quiero modelizar
00:32:15
que no se modelizan
00:32:17
con un tipo primitivo,
00:32:19
sino que se modelizarían
00:32:21
como otra clase.
00:32:22
Pero esta otra clase
00:32:24
no quiero que se use desde fuera.
00:32:25
Quiero utilizarla solo dentro de aquí,
00:32:27
solo dentro del alumno.
00:32:28
Entonces la creo así.
00:32:30
La creo sin nada.
00:32:31
Ahora hacemos ejemplo.
00:32:33
Y también se pueden poner
00:32:36
modificadores al permiso
00:32:40
de creación de objetos.
00:32:41
O sea, en los constructores.
00:32:43
Nosotros hasta ahora
00:32:45
los constructores
00:32:46
los hemos hecho todos Public.
00:32:47
Entonces se pueden crear
00:32:50
desde cualquier clase.
00:32:51
Cualquier clase puede crear un objeto
00:32:52
de la clase que estoy creando yo.
00:32:54
Pero se puede poner también Packaged.
00:32:57
Entonces se puede crear
00:32:59
solo dentro de las clases
00:33:00
de mi mismo paquete.
00:33:01
O Protected,
00:33:02
entonces solo el mismo paquete
00:33:03
o heredados.
00:33:05
Y Private,
00:33:07
que solo lo puedo crear
00:33:08
dentro de esta clase.
00:33:09
¿Vale?
00:33:12
Y con esto...
00:33:18
- Subido por:
- Stefano C.
- Licencia:
- Reconocimiento
- Visualizaciones:
- 8
- Fecha:
- 15 de enero de 2024 - 11:52
- Visibilidad:
- Clave
- Centro:
- IES ROSA CHACEL
- Duración:
- 33′ 20″
- Relación de aspecto:
- 4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
- Resolución:
- 960x720 píxeles
- Tamaño:
- 176.93 MBytes
