Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 8-01-24 - 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 8 de enero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues vamos a hacer entonces un pequeño repasito, ¿vale?, para situarnos. 00:00:00
Recordad que estábamos ya metiéndonos, silencio, 00:00:07
con la estructura de los programas que son, silencio. 00:00:18
Andrés, recordad que estábamos ya en el tema de clases de objetos, 00:00:24
en el cual estábamos viendo la estructura que tienen los programas orientados a objetos, ¿vale? 00:00:31
Entonces, lo que vimos en el primer tema era la programación estructurada, 00:00:41
que es cómo construir algoritmos que resuelvan problemas concretos, 00:00:46
pues el factorial de un número, da dos, tres números, da no sé qué, 00:00:52
pues dadas siete cadenas, ver cuántas cadenas tienen siete vocales. 00:00:56
Bueno, pues vimos cómo, mediante las sentencias de programación estructurada, 00:01:02
que son la asignación a variables, las decisiones y los bucles, 00:01:06
cómo construir algoritmos para resolver esos problemas. 00:01:12
Y eso, ¿a qué nos llevaba? 00:01:15
A una serie de sentencias una tras otra, y ya está, punto, pelota. 00:01:19
Una serie de sentencias una tras otra, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, pa, 00:01:23
para construir ese algoritmo que resolvía nuestro problema. 00:01:28
Bueno, entonces, lo que dijimos es, vale, si tenemos que programar así todo, 00:01:32
pues entonces una cosa complicada pueden ser diez mil líneas, 00:01:38
porque nuestros programas estructurados son una línea tras otra, 00:01:43
eso está claro, una línea tras otra. 00:01:46
Entonces, si la aplicación es gorda y hace muchas cosas, 00:01:48
pues esa línea tras otra pueden ser doscientas mil líneas. 00:01:51
¿Eso es manejable? No, eso no es manejable. 00:01:55
¿Eso es actualizable? 00:01:58
Si tengo yo que cambiar alguna cosita de la aplicación, no es actualizable. 00:02:00
¿Qué hago yo con doscientas mil líneas? 00:02:03
¿Eso es reutilizable? No es reutilizable. 00:02:05
¿Cómo reutilizo yo doscientas mil líneas? 00:02:08
No es nada de eso. 00:02:10
Conclusión, esos programas de doscientas mil líneas una tras otra, 00:02:11
las programaciones estructuradas no tienen futuro. 00:02:15
Conclusión, vamos a organizar ese código, 00:02:17
ese código vamos a organizarlo de otra manera, 00:02:21
vamos a organizarlo de otra manera. 00:02:24
Y ahí llegó la programación orientada a objetos. 00:02:26
Y en eso estábamos, en este tema, 00:02:30
de cómo construir programas siguiendo esa forma de programar. 00:02:33
¿Vale? 00:02:39
Entonces, para construir programas siguiendo esa forma de programar, 00:02:40
ahora es necesario incorporar otra forma de verlo. 00:02:45
Hasta ahora nosotros orientábamos la solución de nuestros problemas 00:02:52
a una secuencia de acciones. 00:02:58
Ahora hace esto, ahora hace esto, ahora hace esto, ahora hace esto. 00:03:00
Esa es la programación estructurada, ¿no? 00:03:03
Una secuencia de órdenes. 00:03:05
Hace esto, hace esto, hace esto, hace esto. 00:03:06
Es decir, nuestros programas están orientados a la acción. 00:03:09
Hace esta cosa, ahora hace esta cosa, ahora hace esta cosa. 00:03:12
¿Vale? 00:03:15
Pues cuando saltamos a la programación orientada a objetos, 00:03:16
ahora hay que incorporar otra perspectiva. 00:03:18
Y es que nuestros programas no van a estar orientados 00:03:21
solo a la acción, hace esto, hace esto, hace esto, 00:03:23
sino también orientados a la descripción de, 00:03:26
vale, hace esto, pero ¿con qué? 00:03:30
¿Con qué lo vas a hacer? 00:03:32
¿Con alumnos? 00:03:34
¿Con matrículas? 00:03:35
¿Con facturas? 00:03:36
Entonces, la programación orientada a objetos implica ahora 00:03:37
incorporar esa otra cosa. 00:03:39
Incorporar, vale, voy a hacer una aplicación. 00:03:41
Mi aplicación no va a ser solo una secuencia de órdenes, 00:03:44
como era en el tema 1. 00:03:47
No va a ser solo una secuencia de órdenes. 00:03:49
También me incorporo a una descripción 00:03:51
de la realidad con la que van a trabajar esas órdenes. 00:03:54
Bueno, pues esa nueva perspectiva llega con la programación orientada a objetos. 00:03:58
Entonces, antes de empezar a programar, 00:04:01
antes de empezar a programar, 00:04:03
uno tiene que hacer un análisis en el que dice, 00:04:04
muy bien, esta aplicación que yo voy a hacer, 00:04:06
esta aplicación, ¿con qué trabaja? 00:04:08
¿Trabaja con empleados? 00:04:11
¿Trabaja con muebles? 00:04:14
Porque es una empresa de muebles. 00:04:16
¿Trabaja con facturas? 00:04:18
¿Trabaja con clientes? 00:04:19
¿Con qué trabaja? 00:04:20
Eso hay que pensarlo antes de empezar a programar. 00:04:22
¿Vale? 00:04:25
Porque todas las aplicaciones trabajan con cosas, 00:04:26
porque sirven para cosas, ¿no? 00:04:28
Bueno, pues entonces, 00:04:30
cuando uno ha hecho ese primer análisis, 00:04:31
llega a la conclusión de que hay unas cosas 00:04:33
que llamábamos entidades, ¿verdad? 00:04:35
Unas cosas que llamábamos entidades, 00:04:38
que son las cosas con las que mi aplicación trabaja, 00:04:43
las que va a gestionar, 00:04:46
las que va a manejar, ¿vale? 00:04:48
Las que va a manejar. 00:04:50
Bueno, nosotros hicimos nuestro ejemplo 00:04:52
con una aplicación que trabajaba con clientes 00:04:55
y trabajaba con pedidos. 00:04:58
Habíamos identificado dos entidades 00:05:01
en esa aplicación de ejemplo, 00:05:04
habíamos identificado dos. 00:05:05
Mi aplicación va a gestionar clientes y pedidos. 00:05:06
Vale, y todo eso, todo eso, 00:05:09
es antes de empezar a programar, 00:05:11
antes de empezar a tirar líneas de código. 00:05:13
¿Vale? 00:05:16
Primero hay que describir la realidad 00:05:17
con la que mi aplicación va a trabajar. 00:05:19
Bueno, cuando ya tenemos descrita 00:05:21
y ya tenemos, 00:05:23
va a trabajar con clientes, con pedidos, 00:05:24
ya podemos empezar a pensar en programar. 00:05:27
¿Vale? 00:05:30
Y ahora queda lo primero que programamos. 00:05:31
Pues cada entidad, 00:05:34
cada entidad, 00:05:36
se convertía en una clase. 00:05:38
¿Verdad? 00:05:40
Cada entidad se convertía en una clase. 00:05:41
Ahora esto ya sí es hacer código. 00:05:45
Esto ya sí es hacer código. 00:05:48
Cada entidad se convertía en una clase. 00:05:50
Y vimos cómo se programaba una clase. 00:05:52
Pues la palabra reservada a clase, 00:05:54
el nombre de la entidad, 00:05:56
recomendablemente empezando en mayúscula, 00:06:00
para seguir un estilo de código homogéneo para todos, 00:06:05
universal, 00:06:11
que facilite, 00:06:12
que otros entiendan microgramas, 00:06:13
que lo facilite, 00:06:15
empezando con mayúscula. 00:06:16
Y luego ya aquí dijimos dos partes. 00:06:17
Dentro de la clase 00:06:20
tenemos dos partes. 00:06:22
La primera parte, ¿cómo la llamábamos? 00:06:25
Que alguien me lo diga. 00:06:28
Propiedades. 00:06:31
¿Vale? 00:06:32
Y la segunda parte. 00:06:37
Métodos. 00:06:39
Vale. 00:06:45
En la parte de propiedades 00:06:46
nos tocaba decidir 00:06:48
todas aquellas características 00:06:54
que nos interesaban, 00:06:56
que caracterizasen al cliente. 00:06:59
Las que le interesan a la aplicación, 00:07:01
lógicamente. 00:07:03
Si a la aplicación le va a interesar el NIF, 00:07:04
el nombre, 00:07:06
pues una propiedad por cada característica 00:07:08
que nos interese caracterizar. 00:07:11
¿Cómo declarábamos esas propiedades? 00:07:13
Una vez identificadas. 00:07:15
Declarábamos exactamente igual 00:07:17
que se declara cualquier variable. 00:07:18
Ya hemos aprendido a declarar variables. 00:07:20
Ya hemos aprendido los tipos de datos primitivos. 00:07:22
Byte, short, int, long, double, float, char y boolean. 00:07:28
Esos primitivos. 00:07:33
Y luego tipos de datos objetos. 00:07:34
O sea, variables que son objeto, 00:07:37
como string, por ejemplo. 00:07:38
Ya hemos aprendido a declarar variables 00:07:40
de esos tipos, ¿no? 00:07:41
Pues las propiedades son variables. 00:07:43
Se declaran como se declaran las variables. 00:07:45
String, NIF, string, nombre, las que yo quiera. 00:07:47
Así se declaran. 00:07:50
¿Vale? 00:07:52
Entonces, 00:07:53
la clase, 00:07:56
y esto es lo más importante de entender, 00:07:58
la clase, 00:08:00
era la plantilla. 00:08:01
La que me decía, 00:08:03
cuando haya un cliente, 00:08:04
o dos, o tres, o veintisiete clientes, 00:08:06
cuando mi aplicación ya se esté ejecutando, 00:08:08
ya esté en ejecución, 00:08:11
porque ya existan clientes físicos que gestionar, 00:08:13
cuando esté en ejecución, 00:08:16
esos clientes físicos, 00:08:18
uno, dos, tres o mil, 00:08:19
tendrán estas propiedades. 00:08:21
NIF, nombre, 00:08:23
cada uno tendrá las suyas propias 00:08:24
con sus propios valores. 00:08:27
¿Vale? 00:08:30
Bueno, pues eso nos llevaba al concepto de objeto. 00:08:31
Entonces, la clase 00:08:37
es la plantilla que define 00:08:39
qué características van a caracterizar 00:08:41
a cada objeto cliente cuando exista. 00:08:43
Y ahora ya, 00:08:47
el objeto es un ejemplo concreto, 00:08:48
un ejemplo concreto de esta clase. 00:08:51
Luego, objetos de una clase puede haber 00:08:54
doscientos mil trescientos cuarenta. 00:08:57
¿Vale? 00:08:59
Clases solo hay una, 00:09:00
porque es la plantilla. 00:09:01
Objetos concretos o ejemplos concretos 00:09:03
de esa clase, 00:09:05
doscientos mil. 00:09:06
A los objetos también se le llama instancias. 00:09:09
Y por eso, 00:09:14
crear un objeto de una clase 00:09:16
se le suele llamar instanciar la clase. 00:09:18
Instanciar la clase 00:09:21
es crear un ejemplo concreto. 00:09:23
Entonces, 00:09:25
una clase se la puede instanciar 00:09:26
veintisiete mil veces. 00:09:28
Tantas como objetos quiera yo crear. 00:09:30
¿Vale? 00:09:33
¿Y en qué momento se instancia la clase? 00:09:34
¿O en qué momento se crean los objetos? 00:09:37
Cuando yo ya tenga un programa principal 00:09:40
que ya quiera ejecutar para hacer cosas concretas. 00:09:43
Y eso será esa otra clase diferente, 00:09:46
que era una clase especial, 00:09:49
que era la clase main. 00:09:51
¿Vale? 00:09:57
Entonces, 00:09:58
dentro de mi aplicación orientada a objetos, 00:09:59
que ahora ya van a ser muchas clases, 00:10:01
pues tendré mis clases entidad. 00:10:03
Mi clase cliente, 00:10:05
mi clase pedido, 00:10:06
las que yo necesite. 00:10:07
Tantas como realidades diferentes maneje mi aplicación. 00:10:08
Y además de esas clases, 00:10:11
tendré otra, 00:10:13
que es la principal. 00:10:15
Que es un poquito especial, 00:10:17
porque esa clase no está asociada 00:10:19
a ninguna realidad, 00:10:21
a ninguna entidad. 00:10:22
Esa es la clase que se llama ejecutar, 00:10:23
que es la que la máquina virtual ejecuta. 00:10:25
Entonces, 00:10:27
esa clase es otra clase más 00:10:28
a la hora de programarla. 00:10:30
Uno la programa con clases como todas 00:10:31
y le da un nombre al que le dé la gana. 00:10:33
Normalmente le damos el nombre 00:10:35
de principal o main, 00:10:37
porque tiene un significado especial esa clase, 00:10:39
que es la ejecutable, 00:10:42
entre comillas. 00:10:43
Y esta clase especial 00:10:45
es la que tiene aquí 00:10:47
este metodito, 00:10:49
que ya nos sabemos de memoria, 00:10:50
la cabecera, 00:10:51
que tiene que ser esta obligatoriamente, 00:10:52
public, static, void, main, bla, bla, bla. 00:10:54
Esto que nos sabemos de memoria. 00:10:59
Y estas líneas de aquí, 00:11:03
este ya es nuestro programa 00:11:10
como lo entendemos del primer tema. 00:11:12
Y del primer tema entendemos 00:11:14
que nuestro programa es una serie de sentencias 00:11:16
una tras otra. 00:11:18
Claro, pues ese será nuestro programa, 00:11:19
el que va aquí, 00:11:21
una serie de sentencias una tras otra. 00:11:22
Pero ahora ya estas sentencias, 00:11:24
además de ser los if, los while, 00:11:26
lo que nos haga falta, 00:11:28
serán sentencias que puedan 00:11:29
crear objetos de esas clases que tenemos. 00:11:31
Antes no teníamos clases nuestras hechas, 00:11:33
que representaban realidades, 00:11:36
no las teníamos. 00:11:38
Entonces no instanciábamos objetos, 00:11:39
no instanciábamos ninguno, 00:11:41
simplemente trabajábamos o con números 00:11:42
o con cadenas como mucho. 00:11:44
No trabajábamos con nada más. 00:11:46
Pero ahora ya podemos crear objetos 00:11:48
de estas clases, 00:11:50
ya podemos crearlos en nuestro programa 00:11:51
para trabajar con ellos. 00:11:54
Ya podemos instanciarlos 00:11:56
para trabajar con ellos. 00:11:57
¿Y cómo se instancia un objeto 00:12:00
cuando yo lo necesito? 00:12:02
Porque en mi aplicación 00:12:04
quiero trabajar con un cliente Pepito. 00:12:05
Pues ya lo sabemos, 00:12:08
porque ya lo hicimos. 00:12:10
Que en mi aplicación 00:12:12
quiero que aparezca el cliente Pepito 00:12:13
porque voy a trabajar con él, 00:12:15
con ese ejemplo concreto. 00:12:16
Pues tendré que declarar 00:12:18
ese objeto, 00:12:20
el nombre de la clase, 00:12:22
el nombre que le doy al objeto, 00:12:24
el que me dé la gana, 00:12:26
¿y cómo lo instanciábamos? 00:12:29
Pues new, nombre de la clase, 00:12:31
y esto de aquí. 00:12:35
¿Vale? 00:12:41
Con lo cual esto ahora 00:12:42
es otra variable más de mi programa, 00:12:44
es otra variable más. 00:12:46
Igual que esta. 00:12:48
Igual que esta es una variable n, 00:12:51
pero es entera. 00:12:53
Daniel. 00:12:56
No te perdono. 00:12:59
Pues esta es otra variable más, 00:13:00
es otra variable más de mi programa. 00:13:03
Esta es la variable c. 00:13:05
La diferencia entre la variable c 00:13:07
y la variable n 00:13:08
es que c es una variable de tipo objeto 00:13:09
y n es una variable de tipo primitivo. 00:13:12
Entonces n 00:13:15
es el espacio directamente aquí en memoria 00:13:17
de cuatro bytes 00:13:19
para guardar el numerito, 00:13:20
27, 12, menos 15, 00:13:22
y c es otra variable de mi programa, 00:13:24
pero c ya sabemos que en memoria 00:13:27
es otra cosa. 00:13:30
C en memoria es, 00:13:31
pues es otro espacio 00:13:39
que se llama c, 00:13:41
pero este espacio 00:13:43
es una dirección de memoria 00:13:45
y esta dirección de memoria 00:13:47
¿dónde lleva? 00:13:49
Pues lleva a un espacio más grandote 00:13:50
en la memoria RAM 00:13:53
donde estarán los valores concretos 00:13:55
de las propiedades de este objeto c. 00:13:57
Pues el valor concreto de la propiedad nil, 00:14:00
el valor concreto de la propiedad nombre, 00:14:02
las propiedades que tenga. 00:14:05
Aquí. 00:14:07
¿Vale? 00:14:08
Pero es otra variable más. 00:14:09
C es otra variable más de mi programa, 00:14:10
igual que lo es n, 00:14:12
pero esta es una variable objeto, 00:14:13
con lo cual es esto en realidad, 00:14:15
pero es otra variable, c. 00:14:17
Entonces, ahora ya trabajamos 00:14:19
con dos tipos de variables. 00:14:20
Variables primitivas 00:14:22
y variables objeto, 00:14:25
que ya sabemos cómo funcionan por dentro. 00:14:27
Entonces, como la variable objeto c, 00:14:30
la variable objeto c en realidad 00:14:32
tiene dentro muchas cosas, 00:14:35
tiene dentro muchas cosas, 00:14:37
pues lo que nos interesa de c 00:14:39
son sus apartaditos, 00:14:41
sus casillas, 00:14:42
es lo que nos interesa de c. 00:14:43
Por eso, cuando queremos acceder, 00:14:45
por ejemplo, al nombre del cliente 00:14:47
para darle un valor, 00:14:49
pues hacíamos c. 00:14:52
para decir de c, 00:14:54
que c es todo, c es todo, 00:14:56
pues de c quiero acceder al nombre, 00:14:59
pues c.nombre. 00:15:01
¿Vale? 00:15:09
Entonces, la variable objeto 00:15:10
tiene muchas cosas dentro. 00:15:12
Ella sola por sí misma no es nadie, 00:15:14
nada más que una dirección de memoria. 00:15:16
No tendría sentido que yo hiciera c igual 00:15:18
a algo aquí, 00:15:20
que fuera un string, un número, 00:15:22
no tendría sentido, 00:15:23
porque c lo único que puede recibir 00:15:24
es una dirección de memoria, 00:15:26
es lo único que puede recibir c, 00:15:27
no puede recibir nada más 00:15:28
que una dirección de memoria. 00:15:29
Lo que tiene sentido 00:15:31
es que yo acceda 00:15:32
a los diferentes apartaditos de c, 00:15:34
a lo que se llaman los campos, 00:15:36
el campo nombre, el campo nid. 00:15:38
¿Vale? 00:15:43
Y mi programa puede tener 200.000 clientes, 00:15:44
clientes de 1, 00:15:46
clientes de 2, 00:15:47
clientes de 3, 00:15:48
todos los que le den la gana. 00:15:49
Y todos ellos serán de esta clase. 00:15:51
Todos los que le den la gana. 00:15:53
Y todos ellos tendrán 00:15:55
su propio conjunto de propiedades 00:15:57
con sus propios valores. 00:15:59
Todos tendrán cada uno el suyo. 00:16:01
Cada uno tendrá su nid, 00:16:03
cada uno su nombre, 00:16:04
cada uno su edad. 00:16:05
¿Vale? 00:16:07
Y ahora ya mi aplicación 00:16:08
con estos clientes 00:16:09
hará lo que quiera con todos ellos. 00:16:10
Pues meterse en un bucle 00:16:12
para ver cuántos de ellos 00:16:13
son mayores de edad. 00:16:16
Pues meterse en un bucle 00:16:18
para recorrerlos todos 00:16:19
y darles un nombre. 00:16:20
Pues lo que me pida mi aplicación. 00:16:21
La aplicación tendrá una serie 00:16:23
de requisitos, 00:16:24
que es lo que tiene que hacer. 00:16:25
Bueno, pues ya mi aplicación 00:16:27
hará, construirá aquí las sentencias 00:16:29
lo que tenga que hacer 00:16:32
con esos clientes. 00:16:33
O con esos pedidos 00:16:35
o con lo que sea. 00:16:36
¿Vale? 00:16:40
Bueno, pues clarísimo, 00:16:41
de nuevo, 00:16:43
se supone que ya estaba 00:16:44
lo que es una clase, 00:16:45
lo que es un objeto 00:16:47
y cómo se crean objetos 00:16:48
y cómo se accede 00:16:50
a las propiedades 00:16:52
o campos de ellos. 00:16:53
Y sobre todo el sentido 00:16:54
que tiene todo eso, claro. 00:16:55
Entonces esto no sale de la nada. 00:16:57
Una aplicación de producción 00:16:58
de trabajadores de objetos 00:16:59
no sale de la nada. 00:17:00
Sale de que uno haya hecho 00:17:01
un análisis previo 00:17:02
y haya decidido, 00:17:04
primero, 00:17:05
qué entidades quiere gestionar. 00:17:07
Y cada una de ellas 00:17:10
qué propiedades va a tener. 00:17:11
Y con ese análisis previo 00:17:13
ya se puede empezar, 00:17:15
ya se puede poner uno 00:17:16
a construir ya su programa principal 00:17:17
y decidir qué cosas tiene que hacer. 00:17:19
¿Vale? 00:17:21
Bueno, ¿alguna duda sobre esto? 00:17:24
No. 00:17:28
Vale, pues la otra parte, 00:17:31
los métodos. 00:17:32
¿Qué eran los métodos? 00:17:35
Pues trocitos de código 00:17:37
entre llaves 00:17:38
con un nombrecito. 00:17:39
Esos eran los métodos. 00:17:40
Puede haber uno o mil métodos. 00:17:42
Trocitos de sentencias 00:17:44
con un nombrecito 00:17:46
que cada objeto de esta clase 00:17:48
podía invocar. 00:17:53
Esos eran los métodos. 00:17:54
Entonces la diferencia 00:17:56
entre los objetos 00:17:57
y las variables primitivas normales 00:17:59
como esta n, por ejemplo, 00:18:01
es que esta variable n 00:18:03
solamente vale para 00:18:04
recibir un valor 00:18:06
con n igual a 7 00:18:07
o entregarlo, 00:18:09
porque yo se le asigne a otra 00:18:10
m igual a n. 00:18:12
¿Vale? 00:18:13
Pues aquí está n 00:18:14
entregando su valor 00:18:15
para que lo reciba m 00:18:16
y aquí está n 00:18:17
recibiendo el 7. 00:18:18
Pues solo para eso 00:18:19
valen las variables primitivas. 00:18:20
Para recibir un valor 00:18:22
y tenerlo ahí guardadito 00:18:23
y para entregárselo 00:18:25
a otra variable 00:18:26
dentro de una expresión 00:18:27
o como sea, 00:18:28
solo valen para esa. 00:18:29
Bueno, pues las variables objeto 00:18:30
valen para algo más. 00:18:32
Para recibir valor, 00:18:34
por supuesto. 00:18:35
En sus campos, claro. 00:18:36
En sus campos. 00:18:38
Para recibir valor, 00:18:39
por supuesto. 00:18:40
Pero también valen 00:18:41
para llamar a métodos. 00:18:42
Para llamar a trozos de código 00:18:44
de sus clases. 00:18:46
¿Vale? 00:18:49
¿Vale? 00:18:51
Por ejemplo, si mi clase pedido, 00:19:21
las dos propiedades 00:19:23
que hemos decidido 00:19:24
que nos interesan del pedido, 00:19:25
porque es lo que necesita 00:19:27
la aplicación, 00:19:28
pues si hemos decidido 00:19:29
que lo que necesitamos saber 00:19:31
de cada pedido 00:19:33
es su descripción 00:19:34
y el precio, 00:19:39
pues por ejemplo, 00:19:40
podríamos haber decidido 00:19:41
solamente estas dos propiedades. 00:19:43
Porque si de cada pedido 00:19:45
solo nos interesa eso, 00:19:47
pues no hay que meter 00:19:48
más propiedades 00:19:49
que hacen falta. 00:19:50
¿Vale? 00:19:51
Entonces, 00:19:53
luego uno, 00:19:55
una vez ya decidido 00:19:56
las entidades 00:19:57
y decidido las propiedades, 00:19:58
pues tiene que construir 00:20:00
la aplicación pensando, 00:20:01
vamos a ver, 00:20:02
los pedidos, 00:20:03
¿qué acciones 00:20:04
me va a interesar a mí 00:20:05
hacer con ellos? 00:20:06
¿Qué acciones 00:20:07
me va a interesar 00:20:08
hacer con los pedidos? 00:20:09
Pues con los pedidos 00:20:10
te va a interesar 00:20:11
subirles el precio 00:20:12
o ponerles IVA 00:20:14
o lo que sea. 00:20:15
O cambiarles la descripción. 00:20:16
Bueno, 00:20:18
pues una vez 00:20:19
identificadas 00:20:20
qué acciones 00:20:21
interesa hacer 00:20:22
con los pedidos, 00:20:23
uno puede incorporar 00:20:24
esas acciones 00:20:25
en métodos. 00:20:26
¿Vale? 00:20:30
Entonces, 00:20:31
en este, 00:20:32
por ejemplo, 00:20:33
que una acción 00:20:34
los pedidos 00:20:37
sea, 00:20:38
por ejemplo, 00:20:39
mostrar el precio 00:20:40
con el IVA 00:20:41
o más que mostrar, 00:20:42
devolver el precio 00:20:43
con IVA, 00:20:44
por ejemplo. 00:20:45
Eh, 00:20:47
pasándole 00:20:48
un IVA 00:20:49
desde fuera, 00:20:50
porque el IVA 00:20:51
a lo mejor es diferente 00:20:52
en función del tipo 00:20:53
de pedido, 00:20:54
pues el IVA 00:20:55
puede ser distinto. 00:20:56
Puede ser 10, 00:20:57
16, 00:20:58
el que sea. 00:20:59
Bueno, 00:21:00
pues entonces, 00:21:01
como esa es una acción 00:21:02
concreta 00:21:03
que queremos que hagan 00:21:04
los pedidos, 00:21:05
queremos que hagan los pedidos, 00:21:06
que es devolvernos 00:21:07
su precio con el IVA 00:21:08
que yo le diga, 00:21:09
pues entonces 00:21:10
nos haríamos un método 00:21:11
para esa acción, 00:21:12
devolver precio 00:21:13
con el IVA. 00:21:14
Y ahora, 00:21:15
¿cómo programábamos 00:21:16
los métodos? 00:21:17
Pues había varias cosas 00:21:18
que, 00:21:20
eh, 00:21:21
a las que atacábamos. 00:21:22
Primero decidir el nombre. 00:21:24
El nombre. 00:21:25
Lo más explicativo posible. 00:21:26
Me da igual que tenga 00:21:28
100 caracteres 00:21:29
el nombre del método. 00:21:30
Me da lo mismo. 00:21:31
Da igual. 00:21:32
Como si es así. 00:21:33
Da lo mismo. 00:21:35
Si luego, 00:21:36
con el autocompletado 00:21:37
uno lo escribe, 00:21:38
siempre. 00:21:39
Pero, 00:21:40
métodos de nombres cortos, 00:21:41
una aplicación, 00:21:43
todo es una aplicación 00:21:44
y los nombres de los métodos 00:21:45
son, 00:21:46
subir, 00:21:47
bajar, 00:21:48
sumar. 00:21:49
Eso lo tiras a la basura 00:21:50
porque no entiendes 00:21:51
que hace ese método. 00:21:52
¿Vale? 00:21:53
Entonces, 00:21:54
el nombre lo más largo posible. 00:21:55
no obligatorio, 00:21:57
empezando con minúscula, 00:21:58
recordad, 00:21:59
como práctica de programación 00:22:00
que deberíamos todos seguir 00:22:02
porque va a facilitar 00:22:03
que uno en una aplicación 00:22:04
entienda. 00:22:05
Cuando ve de repente 00:22:06
las cosas sueltas, 00:22:07
le dirás si eso es método, 00:22:08
si es clase, 00:22:09
si es constructor. 00:22:10
Entonces, 00:22:11
empezando con minúscula. 00:22:12
Luego, 00:22:13
lo siguiente que decidíamos. 00:22:14
Esta acción, 00:22:16
que va a ser el pedido, 00:22:18
esta acción, 00:22:19
necesita alguna información 00:22:20
aparte de las propiedades 00:22:23
del pedido 00:22:26
porque las propiedades 00:22:27
tienen acceso directo, 00:22:28
están aquí. 00:22:29
Entonces, 00:22:30
no hay que pasarlas ni nada. 00:22:31
Bueno, 00:22:33
pues en este caso hemos dicho 00:22:34
que esta acción en concreto 00:22:35
lo que va a hacer va a ser, 00:22:36
va a ser, 00:22:37
sumarle al precio el IVA, 00:22:38
pero le tengo que informar yo 00:22:40
de cuánto es ese IVA 00:22:42
porque a veces será de 10, 00:22:43
de 16, 00:22:44
de 20, 00:22:45
le tengo que informar. 00:22:46
Ah, 00:22:47
pues entonces para este método 00:22:48
necesito una información 00:22:49
desde fuera, 00:22:50
necesito. 00:22:51
Pues entonces se la paso aquí 00:22:52
en la lista de parámetros. 00:22:53
¿Vale? 00:22:56
Y aquí podría tener uno 00:22:57
o muchos parámetros, 00:22:58
los que necesite esa acción 00:22:59
en concreto. 00:23:00
Si tiene más de uno, 00:23:01
pues separados por comas. 00:23:02
Y cada uno de ellos 00:23:04
indicado como se declaran 00:23:05
las variables, 00:23:06
no tenía más. 00:23:07
¿Vale? 00:23:08
Pues entonces uno aquí 00:23:09
ya hace lo que tuviera que hacer, 00:23:10
pues ¿qué vamos a hacer? 00:23:11
Sumarle al precio 00:23:12
el porcentaje de esto, 00:23:14
que sería 00:23:18
precio por IVA entre 100. 00:23:20
Vale, 00:23:29
entonces esto, 00:23:30
pues imaginamos que se lo, 00:23:31
por ejemplo, 00:23:33
se lo asignamos a una variable, 00:23:34
resultado, 00:23:37
y ahora ¿qué? 00:23:41
Hemos dicho que queremos 00:23:42
que haga este método, 00:23:43
devolver eso como de retorno, 00:23:44
devolverlo. 00:23:46
Vale, 00:23:47
pues entonces poníamos un return 00:23:48
y aquí después del return 00:23:50
hay que poner 00:23:51
el valor que yo quiero 00:23:53
que se devuelva, 00:23:55
que solo puede ser uno. 00:23:56
El método solo puede devolver 00:23:57
una cosa. 00:23:59
Eso es una movida, 00:24:00
solo puede devolver una cosa. 00:24:01
Vale, 00:24:03
pues devuelve esto. 00:24:04
Con lo cual, 00:24:05
¿qué me falta a mí ahora 00:24:06
para declarar el método correctamente? 00:24:07
Poner aquí el tipo de dato 00:24:09
de lo que devuelve. 00:24:11
¿Que devuelva un double? 00:24:13
Pues tendría que poner aquí double. 00:24:15
¿Vale? 00:24:19
¿Es obligatorio que todos los métodos 00:24:21
devuelvan algo? 00:24:22
No, 00:24:23
a lo mejor un método 00:24:24
lo único que tiene que hacer es, 00:24:25
por ejemplo, 00:24:26
modificar las propiedades. 00:24:27
Perdóname. 00:24:30
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
8 de enero de 2024 - 11:12
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
470.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid