Saltar navegación

Desarrollo de clases 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de diciembre de 2022 por Stefano C.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, vamos a grabar, todo lo que digáis me lo autoriza que esto sea grabado, y vamos 00:00:00
a ver un poquito más sobre los objetos, en particular sobre el desarrollo de clases. 00:00:10
Este es un apartado que incluye varios conceptos sobre los que hablaremos un ratito para entenderlos 00:00:16
y luego después hay una tanda de ejercicios que va más o menos a trabajar sobre estos. 00:00:26
El primer concepto es el metodomain, el metodomain ya lo conocéis, ya lo habéis usado mil veces, 00:00:34
sin embargo vamos a verlo, no lo digo más en profundidad, entenderlo un poquito mejor. 00:00:42
El prototipo, el prototipo es sustancialmente las palabras claves que se han utilizado para crear el metodomain, 00:00:50
es el que siempre utilizamos, public static, void main, string, array, args. 00:00:57
Entonces, main es el nombre, es como se llama este método, es el metodomain, es un método público, 00:01:04
se puede ejecutar públicamente, esto no lo hemos visto todavía, lo veremos al final de estas transparencias que son los varios cambios. 00:01:13
Static es que es un método estático, no se refiere a un objeto concreto, se ejecuta en ámbito estático, 00:01:22
de hecho nosotros no creamos un objeto para luego poder ejecutar el main, se ejecuta directamente. 00:01:30
No devuelve nada, void, no se espera que devuelva nada de esto, y pilla como parámetro un array de strings. 00:01:36
Cosa que siempre hemos escrito aquí, y nunca nos hemos preguntado que es esto. 00:01:46
Y ahora iremos a ver que es esta cosa aquí. 00:01:52
En general, este es el punto de acceso a mi programa, cada sistema, cada conjunto de clases, cada conjunto de objetos, 00:01:59
y tened en cuenta que ahora cuando empezaremos la programación orientada a objetos, tendremos muchas clases, 00:02:08
muchas clases de objetos distintos que trabajarán entre ellos, mandándose mensajes, llamando un método de un a otro, 00:02:16
pero tendrá siempre que haber en todo este conjunto de no se cuantas clases, un punto que es de aquí empieza mi programa. 00:02:25
Este es el punto donde todo empieza, y esto normalmente suele ser el método main. 00:02:34
El string of args es sustancialmente los parámetros con que ejecuto mi programa. 00:02:44
Vosotros os acordáis que cuando hicimos la clase miclase a principio, una de las primeras prácticas que hicimos fue ejecutar una clase desde línea de comando. 00:02:52
Entonces lanzamos dos comandos, por un lado el javac de miclase.java, y esto lo que hacía era crear un miclase.class, os acordáis, 00:03:04
era la primera parte, era como un compilador de java, pero sabemos que java no es compilado, es interpretado, 00:03:16
tenemos un programa que se llama la java virtual machine, que lo que hace es leer el punto class, 00:03:23
que hay un lenguaje especial que se llama el bytecode, que es la mitad entre el java y el lenguaje máquina, 00:03:31
y lo que hace es ejecutar e interpretar cada una de las instrucciones del lenguaje máquina y pasársela al procesador. 00:03:37
Cuando nosotros llamamos java miclase, él ejecuta miclase empezando desde el main. 00:03:46
¿Qué pasa si yo llamo java miclase y luego le pongo detrás algo, tres y otra cosa? 00:03:53
¿Si lanzo esto en vez que solo java miclase? 00:04:03
¿Qué le pasa a estas cosas de aquí, que normalmente son los parámetros? 00:04:07
Si vosotros habéis utilizado en algunas otras asignaturas la línea de comando, el cmd, 00:04:11
y habéis hecho un ping, habéis hecho cualquier comando, muchas veces el comando es el programa que vais a ejecutar, 00:04:17
y luego detrás tiene un conjunto de parámetros que se pueden lanzar. 00:04:24
Imaginémonos que yo hago un programa que necesita parámetros, que cuando se lanza necesita parámetros, 00:04:29
como este de aquí, que necesita esta palabra, este número y otra palabra. 00:04:35
¿Dónde acaban estos parámetros de aquí dentro de mi programa? 00:04:39
Pues acaban en args. 00:04:44
Cuando yo ejecuto java miclase algo, tres, otra cosa, en args de cero, en la posición cero de mi array args, 00:04:47
encontraré esta palabra de aquí, algo, como string. 00:05:00
¿Por qué como string? Porque es un array string. 00:05:04
¿Sí? 00:05:09
Luego está otra palabra que es tres, entonces en args de uno encontraré tres. 00:05:11
Cuidado, como string, porque no es un entero, no es el entero tres, es la cadena de caracteres, 00:05:17
el carácter tres y nada más. 00:05:25
Que luego yo pueda de alguna forma convertir ese carácter de allí en un número, pues eso ya veremos que se puede hacer. 00:05:28
Pero por ahora es el string tres, es esta cosa de aquí. 00:05:35
Y en args de dos, otra cosa. 00:05:50
Imaginémonos que yo esté dentro de un main, estoy en el método main. 00:05:54
La pregunta es, ¿cómo puedo saber cuántos parámetros me han pasado? 00:06:00
Imaginémonos que nosotros estamos en una clase, clase prueba. 00:06:16
Estoy aquí dentro. 00:06:25
Estoy aquí dentro, ¿vale? 00:06:31
Y la pregunta es, quiero saber aquí dentro en tiempo de ejecución, cuando se ejecute esto, cuántos parámetros me han pasado. 00:06:34
¿Cómo sabré cuántos parámetros me han pasado? Pues con args.length. 00:06:46
args.length. 00:06:52
Esta cosa de aquí me define cuántas posiciones tiene args. 00:06:57
Y como por cada parámetro que me dan, yo lo voy a poniendo en una posición distinta, pues al final si me han dado cinco parámetros, pues tendré cinco posiciones. 00:07:05
Entonces args.length será cinco. 00:07:17
Entonces esto, por ejemplo, se puede utilizar para hacer cosas como, imaginaos, si args.length es igual a cero. 00:07:22
Si alguien ha intentado lanzar mi programa sin darme ningún parámetro de ejecución, y yo necesito parámetros de ejecución, pues le puedo poner, 00:07:40
sigo diciendo, este programa se usa así. 00:07:55
Y ponerle las instrucciones para poderla lanzar. 00:08:06
Java, prueba tu nombre. 00:08:16
Entonces, ¿qué pasa? Que si yo lanzo este programa aquí, me dirá, mira, este programa se usa así. 00:08:25
Java, prueba tu nombre. 00:08:35
Entonces ahora ya sé que no puedo lanzar Java prueba solo, sino necesito añadirle otro parámetro aquí que sea tu nombre. 00:08:37
¿Qué hace esto? 00:08:47
Si no, esto quiere decir que args.length no es igual a cero, y por lo tanto hay algo en args.length, hay al menos la posición cero. 00:08:49
Y, por ejemplo, lo que hace mi programa es decirte, hola, más args de cero. 00:09:02
Fijaos que aquí args de cero no está por ningún lado, nadie lo ha rellenado. 00:09:16
Y si yo lo lanzo, pues siempre me dará este de aquí porque no le he puesto ningún nombre. 00:09:21
Si lo lanzara desde línea de comando, desde el cmd, y escribiera Java prueba y mi nombre, Stefano, pues probablemente me escribiría hola Stefano. 00:09:27
¿Cómo hago en Eclipse para que cuando él se ejecute tenga algo en los parámetros? 00:09:39
Como argumento. 00:09:48
En ejecución aquí puedo utilizar Run Configurations. 00:09:50
En Run Configurations hay una opción de argumentos. 00:10:02
Lo que yo escribo aquí es como si lo escribiera después de Java prueba. 00:10:07
Entonces escribo Stefano aquí, es como si estuviera lanzando Java prueba Stefano. 00:10:13
Entonces, ahora cuando lo lanzo, porque ahora ya algo hay, Stefano lo ha puesto dentro de args de cero, 00:10:20
por lo tanto args.length no es cero, sino es uno, por lo tanto me va en la rama else y aquí me puede escribir. 00:10:34
¿Para qué me pueden servir estas cosas? 00:10:43
Porque a veces nosotros podemos hablar con el usuario y decirle, no, yo lanzo un programa y digo, vale, usuario, dame tu nombre y yo escribo su nombre. 00:10:46
Pero otras veces yo no tengo interacción con un usuario, yo tengo que hacer una operación. 00:10:56
Y esta operación tiene que estar hecha sobre un fichero, sobre un objeto, sobre algo. 00:11:02
O un string, o que use algo que al momento de ejecutarlo me digan cuáles son los argumentos, cuáles son los parámetros que voy a utilizar. 00:11:09
Si pensáis en un programa como el copiar ficheros, que no sé si lo habéis visto, xcopy, nombre del fichero, espacio, otro nombre del fichero, 00:11:19
que copia el primer fichero dentro del segundo fichero. 00:11:29
Pues los dos ficheros al fin y al cabo son parámetros. 00:11:33
Si yo quisiera hacer la clase copia fichero, que lo que hace es pillar dos ficheros y copiarlos de uno a otro y usarlo directamente en línea de comando, 00:11:36
pues lo debería hacer con esta cosa aquí. 00:11:45
A lo mejor en un futuro, en algunos ejemplos y en algunas circunstancias, usaremos este fichero, este array. 00:11:49
La cosa fundamental de por qué lo estamos viendo es para saber qué es esto. 00:12:01
Porque desde el día uno lo hemos puesto allí y no sabíamos hasta ahora para qué servía. 00:12:05
A partir de ahora sabemos tanto para qué sirve y cómo lo puedo utilizar dentro del Eclipse. 00:12:10
¿Dudas? 00:12:23
Esto es string.args. 00:12:32
Otros conceptos que nos interesan a nivel de clase. 00:12:34
Como hay un método main, normalmente en un conjunto de clases debería haber una clase main. 00:12:38
La clase main no se tiene que llamar main. 00:12:44
Tiene que existir una clase que se llame main así. 00:12:47
No necesariamente. 00:12:51
Pero cuando yo hago un proyecto, sobre todo si el proyecto es suficientemente grande, 00:12:54
y hemos dicho ahora que tengo varias clases y muchas clases y me las encuentro allí, 00:12:58
debería ser relativamente fácil saber cuál es la clase que yo lanzo. 00:13:03
Pensad al ejemplo que hemos hecho antes del examen, que había la clase alumno, había la clase prueba. 00:13:08
Yo si me encuentro un montón de ficheros.java, no sé dónde está el punto de acceso de mi programa. 00:13:18
Por lo tanto, normalmente cuando yo hago una estructura, un proyecto con muchas clases, 00:13:27
debería elegir una clase y decir esta es la clase que se ejecuta. 00:13:32
Esta es la que tiene el main. 00:13:35
Todos los demás clases no necesariamente no tienen que tener el main. 00:13:37
Pueden tenerlo, pero no es el punto de acceso de mi programa. 00:13:43
Normalmente, las otras clases pueden tener un main para hacer pruebas concretas de esa clase. 00:13:47
Yo podría poner en el ejemplo que hacíamos antes de alumno, un main dentro de alumno, 00:13:56
para probar el objeto alumno. 00:14:03
Creo un objeto alumno, le pruebo los métodos, le pongo unos datos y cosa por el estilo. 00:14:06
Pero luego, mi programa de verdad no es eso. 00:14:11
Esta práctica de poner un método main dentro de una clase para probarla, 00:14:16
prácticamente hoy en día se usa poco porque hay otras utilidades como el JUnit, 00:14:21
que son pruebas unitarias, que lo veremos más adelante, 00:14:27
a lo mejor lo veréis en el entorno de programación, eso ya lo veremos. 00:14:31
Pero son bacterias de pruebas que yo hago para probar extensamente mis clases, mis objetos. 00:14:34
Entonces, en vez de hacerlo con un main allí dentro que hago lo que me da la gana, 00:14:43
pues tengo esta bacteria de pruebas que está hecha para otros equipos desarrolladores, 00:14:46
a lo mejor de mi empresa, para que me digan, si tú haces todas estas pruebas y todas las pruebas te dan ok, 00:14:53
pues probablemente tu objeto hace las funcionalidades por las que está pensado. 00:14:59
Pero lo veremos más adelante. 00:15:06
Por ahora, para nosotros, si vosotros estáis haciendo un examen, un ejercicio que tiene 5 clases, 00:15:09
y habéis creado la clase alumno que tiene su método de calcular media, 00:15:14
y queréis probar ese alumno, pues os hacéis un main dentro de esa clase, 00:15:20
allí dentro creáis un objeto, le rellenáis las notas y probáis la clase media, el método media, 00:15:24
para ver si funciona. 00:15:30
Pero no es el punto de acceso de todo el sistema, es el punto de acceso para probar alumno. 00:15:32
¿Me entendéis? 00:15:37
Por otro lado, deberíais crear una clase que podría llamarse main, 00:15:39
porque es fácil de detectar, o podría llamarse de otra forma, 00:15:43
como el ejemplo de DAIO competición, ¿os acordáis? 00:15:48
Que allí dentro había el main, esa era mi clase main en el examen. 00:15:51
Vale, no tiene por qué llamarse main, pero es la clase detonante, 00:15:57
la clase que hace partir todo mi proyecto. 00:16:02
Concepto de static y no static, que ya hemos repasado hace un momento, 00:16:04
pero vamos a hacerlo un poquito más en detalle. 00:16:11
Un método o una variable puede ser static o no static. 00:16:14
Cuando no es estático, cuando no se considera un método no es estático. 00:16:21
No se usa cuando me estoy refiriendo a algo que depende de un objeto concreto, 00:16:27
o sea, esa variable, ese atributo o ese método, 00:16:34
necesita ser llamado sobre un objeto concreto, 00:16:40
porque utiliza características de ese objeto concreto para funcionar. 00:16:47
¿Vale? 00:16:53
Eso quiere decir que si hago la misma operación, acceder a una variable, 00:16:54
o llamar un método sobre objetos distintos, 00:16:58
el resultado que puedo obtener es distinto, 00:17:02
porque usará objetos o usará variables propias del objeto. 00:17:07
Un atributo de una clase aparecerá en todas las instancias de esa clase, 00:17:18
y por cada instancia tiene un valor distinto de ese atributo, 00:17:22
y ese atributo no es estático, porque cada instancia tiene su propio atributo. 00:17:25
Un valor distinto, o sea, el valor puede ser el mismo, 00:17:30
pero son copias distintas del mismo valor. 00:17:34
Cuando yo tengo un atributo que no es estático, 00:17:43
quiere decir que cada objeto tiene su propia copia. 00:17:46
Cada objeto tiene su celda de memoria donde dentro almacenará ese valor. 00:17:49
¿Vale? 00:17:56
Y que dos objetos distintos tienen dos valores distintos, 00:17:57
si yo cambio en uno, no lo estoy cambiando en el otro. 00:18:02
¿Vale? 00:18:05
El valor de esa variable. 00:18:06
Cuidado que si luego esa variable es un objeto, 00:18:08
puede haber cosas un poquito más complejas, 00:18:10
pero lo hablaremos más después. 00:18:12
¿Vale? 00:18:14
Pensadlo como int. 00:18:15
Si yo tengo una persona con int edad. 00:18:16
¿Vale? 00:18:19
Si yo tengo dos personas, dos objetos personas, 00:18:20
la variable int de que estas objetos personas son separadas, son distintas. 00:18:22
¿Vale? 00:18:28
Si yo cambio la edad de un objeto, no la estoy cambiando en otro. 00:18:29
¿Si? 00:18:32
Los dos pueden tener la misma edad, 00:18:33
pero son dos valores separados, son dos trozos de memoria separados. 00:18:35
Digámoslo así. 00:18:39
¿Si? 00:18:40
Y el método no es estático cuando tú lo tienes que llamar sobre un objeto concreto. 00:18:41
Al llamar este método sobre un objeto concreto, 00:18:46
utilizará valores, atributos y hará operaciones sobre ese objeto, 00:18:49
no sobre los otros objetos. 00:18:54
¿Si? 00:18:57
Entonces, en un cierto sentido, si no es estático, 00:18:58
tiene una independencia por cada objeto distinto. 00:19:00
Cada objeto distinto es independiente de lo que hace, 00:19:04
de los valores que tiene con respecto a otros objetos. 00:19:08
Dudas. 00:19:12
Ejemplo. 00:19:15
¿Vale? 00:19:17
Pillamos la clase rectángulo. 00:19:18
Aquí está la clase rectángulo. 00:19:21
¿Qué modeliza? 00:19:23
Modeliza un rectángulo. 00:19:25
¿Vale? 00:19:26
¿Qué necesito poner para un rectángulo? 00:19:27
Pues un entero que es el largo del rectángulo, 00:19:29
y un entero que es el ancho del rectángulo. 00:19:32
¿Vale? 00:19:34
Estos son sus atributos. 00:19:35
¿Qué valores, qué métodos tiene? 00:19:37
¿Vale? 00:19:41
No tiene un constructor, no se lo he puesto, 00:19:42
pero tiene un método que es el método setData. 00:19:44
¿Vale? 00:19:48
Aquí podría poner el public. 00:19:49
No pone public, pero no cambia nada por ahora. 00:19:50
El método setData pilla dos variables, 00:19:52
L y B, 00:19:55
y pone que L es largo, 00:19:57
y B es el ancho. 00:19:59
Ya está. 00:20:01
Esto debería ser A. 00:20:02
Pero bueno. 00:20:03
Se me ha colado la vida. 00:20:04
¿Si? 00:20:05
Tiene otro método que es el método Area. 00:20:06
Fijaos que Area no tiene parámetros. 00:20:09
Y lo que hace es calcular el área de este rectángulo. 00:20:11
¿Vale? 00:20:16
Utilizando estos datos de aquí. 00:20:17
Y después de haber calculado el área, la devuelvo. 00:20:19
¿Si? 00:20:23
Entonces, ¿cómo uso estas cosas? 00:20:24
Por ejemplo, aquí tengo un Main. 00:20:26
¿Vale? 00:20:28
Esta sería la clase Main. 00:20:29
¿Si? 00:20:30
Y lo que hace es crearme dos rectángulos. 00:20:31
¿Si? 00:20:34
Fijaos que los rectángulos no tienen constructor. 00:20:35
Por lo tanto, es un constructor vacío. 00:20:37
En este momento, yo he creado dos objetos rectángulos, 00:20:39
y los dos tendrán 0 y 0 en sus valores. 00:20:43
¿Vale? 00:20:47
Porque 20 por defecto vale 0. 00:20:48
Y luego, sobre el rectángulo 1, 00:20:50
llamo el método setData. 00:20:54
Este setData de aquí. 00:20:56
¿Vale? 00:20:58
Que recibe dos parámetros. 00:20:59
Son 5 y 6, por ejemplo. 00:21:02
Si yo hago esta cosa de setData 5 y 6, 00:21:05
lo que quiere decir es que he cambiado, 00:21:09
he modificado el rectángulo 1. 00:21:11
Que ahora tendrá rectángulo1.largo será 5, 00:21:13
y rectángulo1.ancho será 6. 00:21:19
Justo. 00:21:24
¿He cambiado algo de rectángulo 2? 00:21:25
No. 00:21:28
Son dos instancias completamente separadas. 00:21:29
No dependen una de otra. 00:21:32
¿Si? 00:21:34
Y cuando calculo rectángulo1.área, 00:21:35
lo que me hará es ir a mirar este método 00:21:41
sobre rectángulo 1. 00:21:46
Este método pillará largo y ancho. 00:21:48
Largo ahora vale 5, 00:21:50
y ancho ahora vale 6. 00:21:52
Por lo tanto me hará 6 multiplicado 5, 00:21:55
y aquí el resultado, 00:21:58
cuando escribo área de rectángulo 1, 00:22:00
será el resultado de la operación 5x6. 00:22:02
¿Si? 00:22:06
Ahora voy a llamar setData sobre el otro objeto. 00:22:08
Entonces esto modificará los datos de rectángulo 2, 00:22:13
no de rectángulo 1. 00:22:17
Rectángulo 1 es completamente independiente. 00:22:19
Y cuando llamo el mismo método, 00:22:21
es siempre área, es el mismo código, 00:22:23
pero sobre un objeto distinto, 00:22:25
ahora los datos que estoy utilizando 00:22:28
no son los de rectángulo 1, 00:22:31
sino son los de rectángulo 2. 00:22:33
Entonces serán 1 y 3. 00:22:36
Largo 1, ancho 3, 1x3, 3. 00:22:39
Entonces área valdrá 3. 00:22:44
Entonces el resultado de llamar área 00:22:46
sobre rectángulo 1 00:22:50
dependerá de los valores de rectángulo 1, 00:22:52
y el resultado de llamar área sobre rectángulo 2 00:22:55
dependerá de los valores de rectángulo 2. 00:22:59
Fijaos que estos métodos, 00:23:01
como tanto setData, 00:23:04
se están llamando sobre una instancia. 00:23:05
Esta de aquí, rec1 y rec2, 00:23:08
son instancias de la clase rectángulo. 00:23:11
¿Dudas? 00:23:16
Todo esto estamos en un ejemplo 00:23:21
de métodos no estáticos. 00:23:24
¿Veis que aquí estático no existe? 00:23:26
No lo he puesto. 00:23:28
El único estático que aparece es esto, 00:23:29
porque es el main, 00:23:30
porque tiene que ser así, 00:23:31
es el punto de acceso a mi programa. 00:23:33
Pero luego aquí todo lo que estoy haciendo 00:23:35
son sobre instancias, no sobre clases. 00:23:37
¿Dudas? 00:23:43
¿Cuándo en vez se utiliza el estático? 00:23:46
¿Cuándo tenemos que ver algo con estático? 00:23:54
Un entorno es estático cuando me refiero 00:23:57
a algo que no pertenece a un objeto concreto, 00:24:00
sino a la clase. 00:24:03
Es algo que tiene que ver con la clase, 00:24:05
no con una instancia de esa clase. 00:24:08
Son métodos o son variables 00:24:11
que no tienen nada que ver con un objeto o con otro. 00:24:14
En un objeto o en otro objeto distinto 00:24:17
el método o esa variable es lo mismo. 00:24:21
No dependen de si lo estoy utilizando 00:24:26
sobre una instancia o sobre otra. 00:24:30
Son independientes de la instancia. 00:24:32
Entonces una variable estática tendrá el mismo valor 00:24:36
para cualquier objeto que la use. 00:24:38
Si un objeto usa esa variable 00:24:40
o otro objeto usa esa variable, 00:24:41
no es que dependen de la instancia, 00:24:43
sino que valdrá el mismo valor. 00:24:45
Es como si las varias instancias 00:24:47
compartieran esta variable 00:24:51
y cuando uno modifica esta variable 00:24:54
todos los demás ven esa modificación. 00:24:56
No hay un trozo de memoria por cada instancia 00:25:00
donde dentro se guarda un valor, 00:25:04
sino que hay un trozo de memoria solo 00:25:06
y todos los que la usan 00:25:09
utilizan ese trozo de memoria. 00:25:11
Por lo tanto, si alguien lo modifica 00:25:12
todos verán esa modificación. 00:25:14
Y un método estático no se llama sobre un objeto, 00:25:18
sino que se llama sobre una clase. 00:25:22
Entonces un método estático 00:25:24
no puede tener acceso a las variables no estáticas. 00:25:26
Si yo tengo un objeto, 00:25:33
tengo mi objeto rectángulo 1, 00:25:38
con dentro su largo y su ancho. 00:25:41
Estos son trozos de memoria 00:25:44
donde dentro le pongo que era 5 y 6. 00:25:46
Este es el 1. 00:25:50
Luego tenía otro rectángulo distinto 00:25:51
que era el 2, que tenía lado 1, 00:25:54
largo 1 y ancho era 3. 00:25:57
Cada instancia tiene sus propios valores. 00:26:02
Si ahora yo creo un método, una variable estática, 00:26:07
esta variable está fuera de los objetos. 00:26:11
Y yo pongo aquí un valor. 00:26:14
Si este objeto de aquí, 00:26:17
con un método o de alguna forma, 00:26:19
modifica esto y lo cambia a 5, 00:26:21
también este objeto ve este cambio. 00:26:24
Porque no pertenece al objeto, 00:26:28
pertenece a la clase. 00:26:30
Todo esto son instancias de la misma clase. 00:26:37
Y la clase tiene un trozo de memoria 00:26:40
que es compartido por todas las instancias. 00:26:43
O si es público, hasta por otros objetos. 00:26:48
Pero los objetos que acceden a este espacio de memoria 00:26:52
que no depende de una instancia concreta. 00:26:57
Depende de la clase. 00:27:00
Y si yo tengo un método estático, 00:27:05
lo representaremos. 00:27:08
Este es un método estático que hace algo, no lo sé. 00:27:10
Este método estático, si usa ancho o usa largo, 00:27:14
no sabe si tiene que utilizar esto o este de aquí. 00:27:18
Porque si es estático no hace referencia a un objeto. 00:27:22
Por lo tanto no lo puede utilizar. 00:27:25
Un método estático puede utilizar solo variables estáticas. 00:27:27
Porque si yo uso algo no estático, 00:27:32
debería saber de qué objeto lo estoy utilizando. 00:27:35
Y este método no lo sabe, a menos que no se lo he pasado por parámetro 00:27:39
o he hecho algo especial. 00:27:43
Entonces, lo que me interesa es que quede claro 00:27:46
que hay dos mundos. 00:27:49
El mundo estático, que es todo lo que se refiere a la clase, 00:27:51
pero que es, en un cierto sentido, independiente 00:27:54
de cuántas instancias hay o de qué instancias haya. 00:27:57
Mientras el mundo no estático, 00:28:01
que es profundamente dependiente 00:28:05
de la instancia sobre la que trabaja. 00:28:10
Entonces, por un lado, por ejemplo, 00:28:15
hay los métodos estáticos que se llaman sobre la clase 00:28:18
y los métodos no estáticos que se llaman sobre una instancia, 00:28:21
sobre un objeto. 00:28:25
Vamos a ver un ejemplo de método estático. 00:28:29
Imaginámonos esta clase estática de aquí. 00:28:35
Esta clase estática tiene un intero estático 00:28:40
que se llama operaciones hechas. 00:28:44
Esto es que quiero saber cuántas operaciones se han hecho. 00:28:47
Cada vez que haré una de las operaciones que tengo aquí 00:28:51
en mi clase, quiero sumar uno a esto. 00:28:55
No me importa si lo está haciendo uno u otro. 00:28:59
Lo que quiero hacer es que si se hace una operación, 00:29:03
se suma una aquí. 00:29:06
Al final, en clase estática, en esta variable de aquí, 00:29:08
tendré el número de operaciones hechas. 00:29:12
¿Cuántas operaciones se pueden hacer? 00:29:15
Pues tengo dos métodos estáticos, 00:29:17
que son cálculo área de rectángulo. 00:29:19
Oye, es lo mismo que antes. 00:29:21
Pero fijaos que ahora tiene dos parámetros. 00:29:24
Porque ahora no puede hacer cálculo área de rectángulo 00:29:27
sin parámetros. 00:29:30
Porque me diría, ¿y cuál es el largo y el ancho? 00:29:32
No tengo un objeto al que referirme 00:29:35
y este objeto tiene un ancho y un largo 00:29:38
y entonces hago la multiplicación entre este ancho y el largo. 00:29:40
En un entorno estático no tengo instancias. 00:29:43
Por lo tanto, no tengo objetos, no tengo... 00:29:46
¿Qué hago? Pues se lo paso por parámetro. 00:29:49
Lo puede hacer, sí. 00:29:52
Calcular un área de rectángulo si me dan el largo y el ancho 00:29:54
lo puede hacer hasta sin saber de qué objeto estoy hablando. 00:29:57
¿Sí o no? 00:30:01
Entonces en este caso haría largo por ancho, 00:30:03
fijaos, sumo uno a esta variable de aquí 00:30:06
para decir que he hecho una operación, 00:30:10
he hecho calcular área de rectángulo 00:30:12
y luego devuelvo la área de rectángulo. 00:30:14
Y luego está, calcula perímetro de rectángulo 00:30:17
que es otra operación que necesita, 00:30:20
también necesita los dos lados. 00:30:22
Lo calculará de forma distinta, suma uno 00:30:25
a las operaciones hechas. 00:30:28
Entonces tanto que calcule el área como calcule el perímetro 00:30:31
sumo uno a cuantas operaciones he hecho 00:30:34
y luego devuelvo. 00:30:37
Esta es una clase estática. 00:30:39
¿Por qué? Porque no tiene nada aquí que no sea estático. 00:30:41
Justo. 00:30:46
¿Tiene sentido hacer objetos de esta clase? 00:30:47
¿Hacer clase estática x es igual a new clase estática? 00:30:49
La pregunta es entonces, 00:30:55
¿la variable estática y operación hechas 00:30:57
opera en toda la clase? 00:31:00
Pertenece a la clase. 00:31:02
¿Y si haces una variable que sea una clase 00:31:03
¿opera en todo el paquete? 00:31:04
¿Cómo? 00:31:06
¿Si haces una variable que sea una clase 00:31:07
¿opera en todo el paquete? 00:31:09
Si haces una variable, por ejemplo, static string 00:31:12
En vez de public clase estática, no puedes poner 00:31:18
Public static class 00:31:22
No, no puede, por ahora. 00:31:25
No, en principio no. 00:31:32
Public static class me pillas 00:31:34
porque no lo he visto en vida mía 00:31:36
pero no me atrevo a decir que no se puede. 00:31:38
Entonces se lo debería mirar. 00:31:41
Oye, esto se ha grabado. 00:31:43
No, lo sé, pero no os lo digo. 00:31:44
Miradlo vosotros en Google. 00:31:46
Para casa. 00:31:49
Esta es la clase estática. 00:31:52
Os pongo otra vez esta de aquí para fijaros. 00:31:55
La clase no estática tenía sus atributos 00:31:58
y programitas, métodos que utilizan estos. 00:32:02
¿Podría un método no utilizar estos? 00:32:08
Sí. 00:32:10
Podría tener un método de rectángulo 00:32:11
que no va a utilizar estos. 00:32:14
Sería un poco raro, pero podría 00:32:16
en algunos casos tener sentido. 00:32:18
Mientras que la clase estática, si os fijáis, 00:32:23
tiene sus variables estáticas, 00:32:26
pero lo que está haciendo es 00:32:28
no es dependiente de un objeto. 00:32:30
Esta es la cosa importante. 00:32:32
No tiene instancias aquí. 00:32:33
No tiene sentido crear una clase estática, 00:32:35
un objeto de la clase estática, 00:32:38
porque no tiene algo que dependa 00:32:39
de la clase estática. 00:32:42
No es un valor que dependa 00:32:44
de una instancia en concreta. 00:32:47
No tiene nada que no sea estático. 00:32:48
¿Cómo uso esta? 00:32:50
Me hago mi clase estática main, 00:32:52
donde tengo el main. 00:32:55
Y, por ejemplo, tengo dos rectángulos. 00:32:57
Este es el rectángulo 2. 00:33:00
Uno de largo 3 es ancho 6. 00:33:01
El otro de largo 1 es ancho 3. 00:33:03
Y puedo hacer algo parecido con el otro. 00:33:06
El rectángulo 1 tiene área. 00:33:08
Y ahora me llamo el método 00:33:10
calcular el rectángulo 3,6. 00:33:12
¿Dónde llamo este método? 00:33:16
¿Sobre un objeto? 00:33:18
No, lo llamo sobre la clase. 00:33:19
¿Por qué? Porque es estático. 00:33:21
¿Podría quitar esta parte de aquí 00:33:24
y dejar sólo calcular el rectángulo? 00:33:26
No, porque en esta clase de aquí 00:33:28
no está definido calcular el rectángulo. 00:33:31
El método está definido en esta clase de aquí. 00:33:34
Entonces, si yo le estoy diciendo 00:33:37
utilizar este método de esta clase. 00:33:39
Como cuando hacemos math.random. 00:33:43
Quiero utilizar el método random 00:33:46
definido en la clase math. 00:33:48
¿En una instancia de la clase math? 00:33:50
No, en la clase math. 00:33:51
Es estático. 00:33:53
Y esto me da 3x6. 00:33:56
Y lo escribe. 00:34:00
Y luego lo que voy a hacer del otro rectángulo. 00:34:02
Cuidado que aquí no estoy creando 00:34:04
rectángulos nuevos. 00:34:06
No estoy creando objetos. 00:34:08
No hay instancias. 00:34:10
Pero utilizo el calcular al rectángulo 00:34:12
y ya está. 00:34:14
Esto podría ser una suite 00:34:16
de métodos de geometría 00:34:18
para calcular el área del cuadrado, 00:34:23
el área del rectángulo, 00:34:26
el área del círculo, 00:34:27
el área de no sé qué. 00:34:28
Y que luego yo utilizo esta suite 00:34:29
cuando quiero utilizar 00:34:31
alguna de estas formas 00:34:33
y calcular el área de alguna de estas formas. 00:34:34
Sin necesidad de crearme un objeto 00:34:37
para poder calcular esa cosa. 00:34:39
¿Sí? 00:34:41
Como es la clase math. 00:34:43
La clase math es un conjunto 00:34:45
de métodos relacionados con la matemática 00:34:47
como hacer un número aleatorio, por ejemplo, 00:34:51
que están allí 00:34:53
y yo puedo utilizarlas. 00:34:55
La clase math tiene otros métodos 00:34:57
como calcular la raíz cuadrada. 00:34:59
Calcular la raíz cuadrada 00:35:01
y hacer un objeto 9 00:35:03
para luego poder llamar 00:35:05
9.raíz cuadrada 00:35:07
y sacarme 3. 00:35:09
Yo llamo math.sqrt 00:35:11
square root 00:35:13
raíz cuadrada 00:35:15
y le pongo el número que quiero hacer 00:35:17
la raíz cuadrada, 9. 00:35:19
Y el resultado es 3. 00:35:21
Y eso no depende de un objeto. 00:35:23
Se entiende la diferencia. 00:35:25
¿Y qué pasará al final? 00:35:27
Bueno, aquí calcula un perímetro. 00:35:29
Fijaos que yo no tengo un objeto. 00:35:31
Si quiero calcular ahora 00:35:33
el perímetro del primer rectángulo 00:35:35
tengo que volver a ponerle 3.6. 00:35:37
¿Se entiende esto? 00:35:39
Y la pregunta es 00:35:43
si ahora después de estas 3 00:35:45
1, 2 y 3 00:35:47
hago 00:35:49
he hecho clase estática punto operaciones 00:35:51
hecha operaciones 00:35:53
¿Cuánto me escribe aquí? 00:35:55
¿Vale? 00:35:59
Porque cada uno de estos métodos 00:36:01
ha sumado 1 00:36:03
a operaciones hechas. 00:36:05
Entonces operaciones hechas 00:36:07
al principio cuando he arrancado todo 00:36:09
era 0. 00:36:11
La primera vez que he ejecutado esto ha sumado 1. 00:36:13
La segunda vez ha sumado 2. 00:36:15
Y la tercera ha sumado 3. 00:36:17
Por lo tanto ahora vale 3. 00:36:19
¿Esto pertenece a un objeto? 00:36:21
No. 00:36:23
¿Dudas? 00:36:25
¿Puedes mezclar dentro de lo que sería 00:36:27
la clase estática? 00:36:29
¿Dices esto? 00:36:35
No, no. 00:36:37
¿Dices esto? 00:36:39
Sí, puedes. 00:36:41
¿Estática y no estática pueden coexistir? 00:36:43
Muy buena pregunta. 00:36:45
¿Vale? 00:36:47
Habría hecho la misma pregunta. 00:36:49
Entonces yo puedo hacer 00:36:51
una clase que tenga 00:36:53
algunas componentes 00:36:55
que sean propias 00:36:57
de la clase 00:36:59
y entonces sean estáticas 00:37:01
y algunas componentes 00:37:03
que sean propias de un objeto concreto 00:37:05
y que entonces sean no estáticas. 00:37:07
¿Cómo es esta clase aquí, por ejemplo? 00:37:09
Yo me he creado 00:37:11
una clase rectángulo. 00:37:13
¿Vale? 00:37:15
Cada rectángulo puede tener instancias 00:37:17
que tendrán ancho y largo. 00:37:19
Ancho y largo depende del objeto. 00:37:21
Quiero contar cuántos rectángulos 00:37:23
se han creado. 00:37:25
Para crear cuántos rectángulos se han creado 00:37:29
si este rectángulo creado 00:37:31
fuera 00:37:33
no estático, o sea, si borras 00:37:35
estático, cada rectángulo 00:37:37
tendría una copia 00:37:39
de esta variable 00:37:41
y todos valdrían cero. 00:37:43
Entonces cuando creo un rectángulo 00:37:45
y le sumo uno 00:37:47
todos valdrían uno y todos 00:37:49
crearían que solo hay un rectángulo. 00:37:51
El mismo. 00:37:53
Sin embargo, si lo pongo como 00:37:55
rectángulo estático, o sea, 00:37:57
el rectángulo creado es estático, ya esto 00:37:59
no pertenece a la instancia. 00:38:01
¿Vale? No está 00:38:03
aquí dentro esta información. 00:38:07
Sino está aquí fuera. 00:38:09
Y cuando este 00:38:11
suma uno porque ha sido creado 00:38:13
se suma aquí. 00:38:15
Y cuando creo uno nuevo 00:38:17
se suma siempre aquí. 00:38:19
Y por lo tanto ahora hay dos 00:38:21
rectángulos creados. 00:38:23
Veamos el código. 00:38:27
Aquí lo que estoy creando es 00:38:31
un constructor que recibe 00:38:35
un ancho y un largo 00:38:37
asigna el ancho y el largo 00:38:39
como tiene que asignarlo 00:38:41
pero cada vez que se ejecute 00:38:43
este 00:38:45
constructor 00:38:47
lo que se está haciendo es sumar 00:38:49
uno a esta variable 00:38:51
que es una variable de clase. 00:38:53
Fijaos también que 00:38:55
las variables 00:38:57
estáticas están en cursiva. 00:38:59
¿Vale? Entonces lo podéis 00:39:01
saber más fácilmente. 00:39:03
Entonces el primer rectángulo 00:39:05
se creará su propio ancho y largo 00:39:07
suyos de ese objeto 00:39:09
pero sumará uno a una variable compartida 00:39:11
digamos así, una variable global 00:39:13
se puede decir. 00:39:15
Cuando el segundo rectángulo 00:39:17
hace esta cosa otra vez 00:39:19
se creará su propio ancho y largo 00:39:21
suyos que no tienen nada que ver con la otra 00:39:23
instancia 00:39:25
pero sumará uno a la misma 00:39:27
variable estática. 00:39:31
Entonces ahora vale dos. 00:39:33
Luego tengo mi método no estático 00:39:39
que usa 00:39:41
variables no estáticas 00:39:43
entonces si lo llamo 00:39:45
su rectángulo uno 00:39:47
me hará su ancho por su largo 00:39:49
y si lo llamo su rectángulo dos 00:39:51
me hará el ancho del rectángulo dos 00:39:53
por el largo del rectángulo dos 00:39:55
es decir que este método depende 00:39:57
del objeto sobre el que lo llamo 00:39:59
por lo tanto este método 00:40:01
se tendrá que llamar sobre un objeto 00:40:03
rectángulo uno punto área 00:40:05
o rectángulo dos punto área 00:40:07
y fijaos que no recibe 00:40:09
ningún parámetro 00:40:11
¿Por qué no recibe parámetros? 00:40:13
Porque los tiene 00:40:17
¿Si? 00:40:19
Ese objeto ya tendrá esos dos parámetros 00:40:21
entonces usa esos 00:40:23
¿Se entiende? 00:40:27
Y luego está 00:40:29
un método estático por ejemplo 00:40:31
que es total de rectángulos 00:40:33
creados. Cuando yo lanzo este método 00:40:35
total de rectángulos creados 00:40:37
me devuelve rectángulos creados 00:40:39
me devuelve este valor de aquí 00:40:41
¿Habría podido acceder a este valor 00:40:47
de otra forma? 00:40:49
Si yo escribo rectángulo 00:40:51
punto 00:40:53
rectángulos creados 00:40:55
accedería al mismo valor 00:40:57
Y aquí en el futuro 00:41:01
luego lo veremos más en detalle 00:41:03
Si yo quisiera que la gente pudiera tocar 00:41:05
esta cosa desde fuera 00:41:07
pues entonces aquí le pondría un private 00:41:09
Si pongo private 00:41:13
pues esta cosa de aquí 00:41:15
ya no se puede hacer rectángulo 00:41:17
punto rectángulos creados 00:41:19
no se puede acceder a esta variable 00:41:21
desde fuera 00:41:23
entonces la única forma 00:41:25
para poder leer esta variable 00:41:27
sería con este método 00:41:29
que es público 00:41:31
porque nadie podría cambiarlo 00:41:35
nadie podría entrar en rectángulo 00:41:37
hacer rectángulo punto rectángulos creados 00:41:39
igual 7 00:41:41
porque no se puede acceder desde fuera 00:41:43
la única forma para cambiarlo 00:41:45
es esta línea de aquí 00:41:47
que se ejecuta cuando creo un rectángulo 00:41:49
entonces me estoy 00:41:51
garantizando que 00:41:53
los rectángulos creados son efectivamente 00:41:55
los que se han hecho con un constructor 00:41:57
volveremos sobre este concepto 00:41:59
¿Dudas? 00:42:01
Por ahora me interesa la diferencia 00:42:05
entre estático y no estático 00:42:07
estático 00:42:09
todo lo que se refiere a la clase 00:42:11
no a una instancia de la clase 00:42:13
instancias distintas de las clases 00:42:15
ven el mismo comportamiento 00:42:17
no estático 00:42:21
depende de la instancia sobre la que lo llamo 00:42:23
sobre qué funciona 00:42:27
un método estático 00:42:29
pero pueden ser también variables estáticas 00:42:31
o no estáticas 00:42:33
¿Dudas? 00:42:35
Este es fácil 00:42:43
¿Cómo se organiza el código? 00:42:45
Nosotros organizamos códigos en clases 00:42:47
ya lo hemos visto 00:42:49
hay una clase principal y luego otras clases que usaré 00:42:51
desde la clase principal 00:42:53
ya veremos si hacemos ejemplos 00:42:55
existe también una forma 00:42:57
de organizar un poco mejor 00:42:59
las clases que son los paquetes 00:43:01
yo puedo crear un paquete 00:43:05
que contiene dentro varias clases 00:43:07
si yo tengo normalmente 00:43:09
un sistema muy complejo 00:43:11
que tiene muchas 00:43:13
clases 00:43:15
sería complejo 00:43:17
y sobre todo 00:43:19
que yo pueda organizar de alguna forma 00:43:21
porque hay un cierto 00:43:23
número de clases que se ocupan 00:43:25
de un cierto tema y otras clases de un tema 00:43:27
distintos y que tiene sentido 00:43:29
organizar estas dos 00:43:31
de alguna forma pues puedo crear paquetes 00:43:33
un paquete pues lo creo 00:43:37
fácilmente 00:43:39
desde aquí 00:43:41
normalmente nosotros todo lo que hemos hecho ahora 00:43:45
lo hemos puesto en un default package 00:43:47
el package sería el paquete 00:43:49
si yo creo un nuevo puedo crear 00:43:51
un nuevo paquete 00:43:53
crear un nuevo paquete le doy un nombre 00:43:55
por ejemplo 00:43:57
geometría 00:43:59
entonces ahora he creado 00:44:01
un paquete geometría 00:44:03
y las clases 00:44:05
que creo aquí dentro 00:44:07
si os fijáis 00:44:17
pertenecen al 00:44:19
paquete geometría 00:44:21
esto es el comando 00:44:25
que se da al principio para decirle 00:44:27
a que paquete pertenece 00:44:29
me espero 00:44:31
que el paquete geometría este en el 00:44:33
paquete geometría, si lo muevo a otro 00:44:35
paquete que no sea el paquete geometría y le dejo esto 00:44:37
pues posiblemente se enfade 00:44:39
y esto me permite 00:44:43
organizar mejor mi 00:44:45
programa, podría hacer todo sin paquetes 00:44:47
la ventaja es que 00:44:49
luego si yo hago un paquete geometría muy interesante 00:44:51
y lo quiero reutilizar 00:44:53
puedo importar 00:44:55
este paquete por otro lado 00:44:57
¿os suena algo importar un paquete? 00:44:59
¿os acordáis 00:45:05
cuando 00:45:07
hacía scanner 00:45:09
es igual a new scanner 00:45:11
de algo ¿vale? 00:45:15
y le decía 00:45:17
importa 00:45:19
¿qué estoy haciendo aquí? 00:45:21
estoy yendo a un paquete que se llama 00:45:25
java, que dentro tiene 00:45:27
un paquete que se llama util 00:45:29
que son utility de java 00:45:31
y me pillo 00:45:33
la clase scanner 00:45:35
y la importo en mi programa 00:45:37
es como si hubiese copiado 00:45:39
esa clase en mi proyecto 00:45:41
y ahora la puedo utilizar 00:45:43
pues si yo hago el paquete 00:45:45
geometría, pues en un lado 00:45:47
podría importar 00:45:49
aquí import 00:45:51
geometría o importo lo que sea 00:45:53
punto lo que sea geometría 00:45:55
y tendría todo lo que 00:45:57
lo que tengo todo desarrollado 00:45:59
aquí pues ahora lo tengo en el otro programa 00:46:01
estas son cosas un poco más avanzadas 00:46:05
a lo mejor luego lo utilizaremos más adelante 00:46:07
pero por ahora simplemente que sepáis que 00:46:09
existen y que podéis utilizar los paquetes 00:46:11
para organizar mejor 00:46:13
estos ejercicios 00:46:15
por ejemplo hasta ahora 00:46:17
hemos hecho un proyecto nuevo 00:46:19
por cada bloque 00:46:21
de ejercicios 00:46:23
pues ahora podríais hacer un único proyecto 00:46:25
que sea en ejercicio de java 00:46:27
y poner un paquete por cada uno 00:46:29
de los bloques de ejercicio 00:46:31
por ejemplo 00:46:33
y que más 00:46:39
entonces esto es para organización 00:46:43
de código 00:46:45
yo diría que 00:46:47
nos paramos por ahora aquí 00:46:49
y esto lo vemos el viernes 00:46:51
no es mucho 00:46:53
pero 00:46:55
Idioma/s:
es
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
15
Fecha:
13 de diciembre de 2022 - 14:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 57″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
560.53 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid