Videoconferencia Programación 13/10 - 16:10 - 18:00

Aquí y aquí. 00:00:00

Y estáis viendo la pantalla, ¿verdad? 00:00:10

¿Veis el aula virtual, verdad? 00:00:13

Con el temario. 00:00:18

Sí, ¿no? Vale. 00:00:22

¿Alguien me puede decir por dónde me quedé? 00:00:25

Más o menos. 00:00:27

Yo creo que me quedé por la programación declarativa e imperativa. 00:00:30

¿Alguien recuerda? 00:00:33

Vale. 00:00:41

Antes de empezar con la teoría, esto es lo que vamos a ver hoy. 00:00:42

¿Vale? De Java. 00:00:45

¿Qué vamos a ver hoy? 00:00:46

vamos a ver un poquito los tipos de datos 00:00:48

solo que sepáis el tipo double 00:00:51

vamos a hacer un programa sencillo que es calcular la nota media 00:00:54

de tres notas que vamos a introducir por teclado 00:00:57

tendremos que saber cómo crear un objeto 00:01:01

y ya vamos viendo el operador 00:01:04

y vamos a ver cómo crear un método 00:01:09

muy sencillo y la diferencia entre llamar un método estático 00:01:14

y uno no estático. La clase escáner y el ejercicio para calcular 00:01:17

la nota media de tres letras. Esto es lo que vamos a ver luego 00:01:22

con, nos meteremos ya, tengo ya instalado aquí el 00:01:25

NetBeans y lo haremos aquí. Entonces el programa que vamos a hacer 00:01:29

se puede hacer de tres maneras. Entonces voy a hacer con las tres. 00:01:33

Esto sería por una parte lo que vamos a ver después. 00:01:39

En principio voy a hablar un poquito de la teoría. 00:01:41

esto sigue siendo teoría pura y dura 00:01:44

pero que es necesario que sepáis 00:01:48

si vimos la diferencia entre algoritmo y programa 00:01:51

vimos que un algoritmo 00:01:54

nosotros teníamos un 00:01:55

cuando tengáis alguna duda o lo que sea 00:01:57

me interrumpís 00:02:00

un algoritmo realmente 00:02:01

a ti te van a proponer un problema 00:02:04

y ese problema necesita ser resuelto 00:02:06

por medio de un algoritmo 00:02:09

entonces, diferencia entre el algoritmo y el programa 00:02:10

El algoritmo es un medio que vamos a utilizar para resolver un problema. 00:02:14

¿Cómo tiene que ser? Tiene que caracterizarse por tres cosas. 00:02:21

Una, que tiene que ser preciso. Si no es preciso, indicando paso a paso cómo se tiene que realizar. 00:02:24

Si no es preciso, tenemos un problema, aparte del que ya nos han propuesto. 00:02:34

Tiene que ser preciso. Tiene que estar definido. 00:02:38

O sea, si tú lo ejecutas más de una vez y con los mismos valores, tiene que siempre dar el mismo resultado y debe ser finito. Todo algoritmo va a tener una serie de pasos y tienen que ser finitos, no puede ser algo infinito, sino que tiene que tener un número de pasos finito. 00:02:41

O sea que con un comienzo no fina. Y luego todos los pasos intermedios en primeros. En cambio, un programa que es un conjunto de instrucciones que se codifica en un lenguaje de programación y que lo que hace es permitir que ese algoritmo se pueda ejecutar en un ordenador. 00:03:00

Básicamente es eso. Con respecto a cómo representar los algoritmos, pues tenemos aquí tres métodos. Uno que sería con los diagramas de flujo, que si un diagrama de flujo, 00:03:16

mirad, para que veáis un diagrama de flujo 00:03:31

os voy a poner aquí PSEN 00:03:32

este es un programa sencillito 00:03:34

en el que se programa 00:03:37

el pseudocódigo, ¿vale? 00:03:38

entonces, si yo le pongo 00:03:40

vamos a ponerle 00:03:41

salud 00:03:42

esto nos define aquí un algoritmo 00:03:47

esto no tenéis que saberlo, pero es para que veáis 00:03:50

esto lo doy 00:03:52

en un fundamento de programación 00:03:54

solo es para que veáis 00:03:56

el pseudocódigo, como se representa 00:03:56

en un programa 00:04:00

A ver, tenéis que diferenciar lo que es el diseño del algoritmo, que lo podéis hacer con cualquiera de estas tres cosas, con diagrama de flujo, con una tabla de decisión y con un pseudocódigo. 00:04:01

Con tabla de decisión no me voy a meter, que lo sepáis, que hay una serie de posibles condiciones del problema con sus respectivas acciones, que sepáis eso. 00:04:12

Pero con diagrama de flujo y pseudocódigo, sí. 00:04:20

Y pseudocódigo, este programa nos permite crear programas en pseudocódigo. 00:04:22

otro código. Entonces nosotros le podemos poner aquí, ¿veis? Yo le pongo escribir y 00:04:27

le digo que me escriba hola, ¿cómo te llamas? Y luego después le digo leer, ¿vale? Para 00:04:33

que el usuario pueda poner su propio nombre, ¿vale? Con el teclado. Entonces leer y le 00:04:45

ponemos una variable que le va a llamar nombre. Todo lo que pongas por teclado lo va a meter 00:04:52

dentro de esta variable que se llama nombre. Después, le damos a la vez a escribir y le 00:04:57

decimos el saludo. Hola, ¿cómo estás? Vamos a ponerlo por aquí, coma, nombre. ¿Qué 00:05:01

he hecho aquí? Lo que he hecho es, primero, he escrito una cadena de texto en el que escribir, 00:05:17

Lo que nos va a permitir es leer una cadena de texto en la pantalla. 00:05:22

Leer nos permite leer, el usuario puede escribir, le hacen una pregunta, 00:05:25

se aparece un cursor parpadeando y lo que escriba se va a almacenar en esta variable que se llama nombre. 00:05:30

Acordaos que una variable es una opción de cajón con un nombre donde ahí podemos guardar algo. 00:05:35

¿Qué guardaremos? Pues en función de qué tipo sea la variable. 00:05:40

Si es tipo entera, guardaremos números enteros. 00:05:43

Si es tipo decimal, guardaremos números decimales. 00:05:45

y es tipo cadena, guardaremos 00:05:50

cadenas de texto 00:05:52

después digo que 00:05:54

escriba hola, ¿cómo estás? y a continuación 00:05:56

lo que ha escrito el usuario 00:05:58

en la variable nombre, ¿vale? 00:06:00

y veis 00:06:01

lo primero que me hace es poner hola, ¿cómo estás? 00:06:03

pongo Paco 00:06:06

y me saluda, ¿veis? 00:06:07

hola, ¿cómo estás Paco? ¿veis? este es el algoritmo 00:06:09

me han pedido este algoritmo y lo resuelve 00:06:12

aquí tiene 00:06:13

¿por qué he querido que veáis esto? 00:06:15

no porque quiera que aprendáis este programa 00:06:17

sino porque aquí tiene la oportunidad de que veamos lo que es un diagrama de flujo. 00:06:19

Este programa lo convierte luego en un diagrama de flujo y veis, este algoritmo, como hemos visto, es finito. 00:06:25

Tiene un comienzo y un final con una serie de pasos que van en una única dirección. 00:06:32

Siempre es unidireccional. 00:06:36

Podría ser bidireccional, pero luego, aunque sea bidireccional, el algoritmo seguirá una sola línea. 00:06:38

que lo que hace primero lo representa el inicio y el final del algoritmo 00:06:44

en diagramas de flujo lo representa a través de elipses 00:06:49

y cuando haces una operación de escritura en pantalla 00:06:53

lo representa con este paralelepípedo o rectángulo inclinado 00:06:58

en el que veis que la flecha está hacia arriba 00:07:02

que aquí quiere decir que escribe en pantalla 00:07:04

a continuación pasa a la siguiente línea que es nombre 00:07:06

y lo que hace es otro paralelepípedo 00:07:10

Tanto las operaciones de entrada y salida en el ordenador 00:07:12

Las va a ejecutar y las representa a través de un parámetro 00:07:18

Pero ahora el mismo lo representa como una flecha hacia la variable que yo he puesto 00:07:21

O sea, que lo que escriba irá aquí dentro 00:07:27

A continuación, la siguiente sigue con la flecha 00:07:30

Y sigue a otra operación en la que sería escribir 00:07:33

Y veis, es otro parámetro en el que pone 00:07:36

Hola, ¿cómo estás? 00:07:38

Y esta sería la flecha que indica que es de salida 00:07:39

Aquí terminaría el algoritmo 00:07:42

Esta es la manera 00:07:44

La segunda manera de poder representar 00:07:45

Un 00:07:48

Un 00:07:49

Un algoritmo 00:07:51

Bien con pseudocódigo, que sería esto 00:07:52

O bien con 00:07:56

Con diagrama de flujo 00:07:57

Una vez que tenemos resuelto el problema 00:08:00

Bien con esta vía, bien con esta otra vía 00:08:02

Pasaremos a codificar esto 00:08:04

En algún lenguaje de programación 00:08:06

Y haremos lo que se llama el programa 00:08:07

¿Veis la diferencia entre una cosa y la otra? 00:08:09

¿Vale? 00:08:11

Y aquí tenéis un vídeo con el DGD, que es un programa para principiantes y que nos permite crear diagramas de flujo como el que he hecho yo. 00:08:12

También nos habla de PESAIN, que es un programa que nos permite ejecutar código, vamos, realizar pseudocódigo. 00:08:29

Está muy bien porque es en castellano y es muy sencillo 00:08:38

Y nos permite meter aquí condicionales, bucles, etc. solo dándole con un botón 00:08:43

Paradigma de programación 00:08:49

¿Qué es un paradigma de programación? 00:08:54

Es un modelo básico para el diseño e implementación de programas 00:08:57

Es como si dijéramos una serie de características que va a tener ese lenguaje de programación 00:09:00

A la hora de diseñarlo 00:09:05

que las personas que han diseñado cada uno de los lenguajes de programación se basan en un paradigma. 00:09:07

Eso es lo que compete a esto que aparece aquí. 00:09:13

Es un modelo básico para el diseño e implementación de programas. 00:09:16

Hay una subdivisión en dos, que serían la programación declarativa y la imperativa. 00:09:19

La declarativa no nos importa, es muy diferente a la programación imperativa. 00:09:26

Una programación imperativa es un desarrollo de un algoritmo detallado, como lo que hemos hecho, de arriba a abajo. 00:09:32

A base de una serie de instrucciones que se van ejecutando una detrás de otra. Esto son ejemplos de lenguajes, Python, Java, C++, pero la declarativa se basa en una serie de condiciones o proposiciones y aquí ya no nos importa el resultado, sino en cómo se hace, sino en qué es lo que quiere que haga. 00:09:37

Algunos detalles de la programación declarativa que son, ahora estamos hablando de una programación lo que se llama lógica, en el que se va a solucionar, o sea, el problema que se quiere solucionar lo va a describir, pero no las instrucciones necesarias para generar esa solución. 00:09:59

No sé si me explico. En cambio, en la imperativa sí necesitamos esas instrucciones que necesitas para generar la solución. Aquí no se preocupa por eso, sino por lo que se quiere solucionar. 00:10:22

Un ejemplo de este sería el lenguaje SQL. Este es de indicar que dentro de las generaciones de lenguajes de programación, por ejemplo, la programación imperativa con Java, estos son lenguajes de tercera generación, 00:10:33

Pero en la declarativa serían ya lenguajes de cuarta generación. Dentro de la primera generación estaba el código máquina, ensamblador, etc. Pero el código máquina sería la primera generación, la segunda generación sería el ensamblador y luego la tercera generación serían todos estos lenguajes que hay aquí. 00:10:48

en cuarta generación tendríamos la programación declarativa 00:11:08

como por ejemplo ese 00:11:13

Fases de la programación, creo que esto lo hablamos 00:11:13

pero bueno, hay tres fases 00:11:18

primero, fase de resolución del problema 00:11:20

a ver, aquí te proponen un problema 00:11:22

ese problema, lo primero que vas a hacer es analizar ese problema 00:11:26

si a ti te dan un problema y no entiendes el problema 00:11:31

porque no lo has analizado, es muy difícil que lo vayas a resolver 00:11:35

Entonces esa primera fase sería la de resolución del problema. Para resolverlo lo primero que tienes que saber es entender el problema. Una vez que has entendido el problema, porque has hecho un análisis de ese problema, se encarga de que, por medio de estos métodos que hemos visto aquí arriba, o bien por pseudocódigo o bien por diagrama de flujo, resolver ese problema, resolver el algoritmo que va a resolver el problema. 00:11:39

Esto sería una fase como de diseño. Una vez que ya lo ha resuelto, vas a codificarlo, vas a pasar a la fase de implementación y a testearlo a través de pruebas. 00:12:05

Y luego una última fase sería la fase de explotación y mantenimiento. Es ya cuando el programa está en ejecución en un entorno, 00:12:18

o en un programa empresarial o donde sea, donde se está ejecutando, donde se está utilizando y donde el cliente puede encontrar algún bug 00:12:25

o encontrar algún problema, o incluso pueden sugerir algunas mejoras que puedan llevar otra vez hacia atrás en estas tres fases 00:12:32

y establecer una nueva versión de ese programa. Esa sería la fase de explotación y de mantenimiento. 00:12:44

Fijaos, aquí la fase de resolución del problema habla de un análisis y de un diseño. 00:12:51

El análisis es lo que he dicho yo, que tienes que hacer preguntas sobre ese problema. 00:12:57

Imaginaos, este problema es muy sencillo 00:13:00

Fijaos, me están diciendo que haga un algoritmo 00:13:03

Que permita saludar a un usuario 00:13:08

Escribir su nombre y que el programa le salude 00:13:11

El programa es muy sencillo 00:13:13

Pero primero, imaginaos un algoritmo que os pidan 00:13:16

Que sea muy complejo 00:13:19

A lo mejor el que os solicita que resolváis ese problema 00:13:21

Lo tiene muy claro él 00:13:27

Pero a lo mejor nosotros, que tenemos que codificar, que tenemos que diseñar previamente ese algoritmo, pues no lo tenemos tan claro. Entonces, ¿qué es lo que haríamos lo primero? Es un análisis, realizar preguntas al cliente, ver cuál es la información que tiene ese problema, qué datos son necesarios, bueno, muchas cosas que nos van a permitir entender el problema. 00:13:29

entonces esa sería la fase de análisis 00:13:47

una vez que hemos hecho la fase de análisis 00:13:49

aquí ya se supone 00:13:52

a partir de esta línea 00:13:54

se supone que ya entendemos el problema 00:13:56

como lo entendemos, podemos diseñar 00:13:57

un algoritmo, ¿cómo se diseñaba? 00:14:00

con diálogo de fujo, con tabla de decisiones 00:14:02

con pseudocódigo 00:14:04

hay más métodos, pero bueno, esos serían 00:14:05

principalmente los que os voy a poner aquí en el aula 00:14:07

se diseñaría 00:14:10

¿qué sucede cuando ya se ha diseñado? 00:14:13

pues ya pasamos a la siguiente fase 00:14:16

que es la fase de implementación. Esa fase de implementación también tiene dos subfases. 00:14:17

Una primera fase sería la de codificación. Ahora ya no estamos hablando de algoritmo, problema, diseño. 00:14:22

Estamos hablando de codificación o construcción de un programa, que es diferente con lo que hemos visto como algoritmo. 00:14:30

Y ahora tenemos que codificar ese programa y en esta fase incluso podemos elegir o llegar a un acuerdo 00:14:38

sobre qué lenguaje de programación elegir, porque luego todos los lenguajes de programación 00:14:43

nos sirven para solucionar todos los problemas. 00:14:48

Hay lenguajes de programación que son más aptos para una serie de problemas 00:14:51

y otros lenguajes de programación más aptos para otros problemas. 00:14:53

Entonces, incluso en esta fase podríamos elegir qué lenguaje de programación usar 00:14:56

y para codificar ese algoritmo que ya hemos diseñado. 00:15:00

Lo construimos, lo compilamos, bien a través de un compilador o bien a través de un intérprete. 00:15:05

¿De qué depende esto? 00:15:11

Esto dependerá del lenguaje de programación que utilicemos. Si utilizamos un compilador, serán lenguajes como C, C++, Java, en el que lo que va a hacer, Java sería más a través de un intermedio bytecoded, pero no sería a través de un intérprete. 00:15:11

Bueno, sí, sería una máquina virtual, pero bueno, pongamos C, C++. 00:15:29

Entonces, a través de un compilador que nos va a pasar a transformar el código 00:15:34

escrito en C o C++, nos va a transformar en un ejecutable en código macro. 00:15:39

Por tanto, un compilador es mucho más rápido que lo que puede ser un intérprete. 00:15:47

Bueno, y el compilador en Java estaría en Java C, en el que también nos compilaría, 00:15:53

que nos generaría el bytecode. 00:15:57

En cambio, un intérprete ¿qué hace? 00:15:58

Ya digo, esto dependerá de la elección de uno o de otro 00:16:02

Dependerá del lenguaje de la programación que hayas elegido 00:16:05

Un intérprete, por ejemplo, como puede ser en PHP 00:16:07

¿Qué es lo que hace? 00:16:10

Va leyendo línea a línea cuando está en ejecución 00:16:12

Y va a ejecutar esas líneas 00:16:15

Las va traduciendo y ejecutando línea a línea 00:16:19

Por lo tanto, será más lento que lo que puede ser a través de un compilado 00:16:21

Una vez que ya hemos elegido el lenguaje de programación, hemos elegido si va a ser un concepto de lenguaje de programación, si va a ser a través de un compilador, a través de un intérprete y hemos codificado el programa y lo hemos compilado o lo hemos ejecutado, mejor dicho, pues tenemos que pasar a otra subfase dentro de la implementación que serán las pruebas de ejecución y validación. 00:16:26

Estas pruebas son indispensables a la hora de realizar un programa porque nos va a permitir, dentro del dominio de posibilidades que puede tener ese programa, generar una serie de pruebas que, siempre que se realizan pruebas a un programa, no queda exento al 100% que no tenga un error. 00:16:47

Eso nunca es así. Lo que pasa es que cuando nosotros hacemos una serie de pruebas, esas pruebas las ejecutamos con respecto a lo que queremos probar, a lo que realmente queremos que no falle, 00:17:10

sus valores límite, un montón de pruebas que se pueden realizar y cuantas más pruebas y más vayan enfocadas a lo que nos importa del programa, pues mayor seguridad tendremos de que ese programa funcione de manera correcta y no genera errores. 00:17:23

Pero ningún tipo de pruebas nos da un 100% absoluto de que un programa no tenga error. 00:17:36

Luego ya nos pasa a la tercera fase que sería la explotación 00:17:45

que es la que he dicho antes, aquí se van viendo si hay nuevas necesidades 00:17:49

que va a requerir 00:17:53

introducir cambios en el programa 00:17:56

o si tiene algún error que se detecta a posteriori 00:18:01

que hay que modificar 00:18:04

¿Qué más? Tenemos el ciclo de vida del software 00:18:06

El ciclo de vida del software es una serie de fases 00:18:11

En las cuales pasa el software 00:18:16

Donde pasa a través del software 00:18:17

Digamos, como si 00:18:20

¿Cómo explicarlo? 00:18:24

A lo largo de toda la creación del software 00:18:26

Hay una serie de fases 00:18:29

Y eso se le llama el ciclo de vida 00:18:30

Ese ciclo de vida pasa por estas distintas fases que aparecen aquí 00:18:32

Una de las primeras y la segunda ya nos suena 00:18:38

de lo que hemos dicho antes. Una es la especificación y análisis de requisitos. 00:18:41

El análisis de requisitos sea tanto de requisitos funcionales como de requisitos no funcionales. 00:18:45

Esos análisis de requisitos se hace 00:18:51

con el cliente y se determina qué es lo que necesita 00:18:53

la aplicación, qué es lo fundamental 00:18:56

para su funcionamiento y luego, aparte, también requisitos 00:18:58

no funcionales, pero que pueden implicar 00:19:05

tenga un gran rendimiento en la aplicación 00:19:07

o que tenga una gran seguridad 00:19:13

o ya serían requisitos no funcionales. 00:19:16

Pero todo eso antes de comenzar 00:19:18

tiene que estar detallado 00:19:22

para luego pasar a la fase de diseño. 00:19:24

La fase de diseño es la que hemos visto antes. 00:19:28

Es la fase de diseño de la aplicación 00:19:30

del algoritmo que vayamos a resolver. 00:19:33

Esa fase de diseño se puede realizar tanto en pseudocódigo, se puede realizar en diagramas de flujo, lo que queráis. 00:19:37

Y ya pasa la fase de codificación, que era la fase de implementación que veíamos antes. 00:19:44

Esa fase de codificación es la codificación en lenguaje que uno quiera utilizar o que más se adapte a nuestro problema. 00:19:48

A continuación, una vez en la codificación, hay ciclos de vida donde las pruebas las ponen antes que la codificación. 00:19:58

hay veces en el que en función del problema 00:20:03

crean las pruebas previas incluso a la codificación 00:20:06

eso es en programación extrema 00:20:09

en el que se utiliza primero las pruebas 00:20:11

y luego la codificación 00:20:16

eso da una gran seguridad 00:20:17

pero que sepáis que cuando uno codifica algo 00:20:19

tiene que ir añadido con pruebas 00:20:22

pruebas que cubran el mayor margen de posibilidad 00:20:25

de errores que pueda tener nuestra aplicación 00:20:28

Luego ya pasa la instalación en el lugar donde se vaya a ejecutar y el paso a producir. 00:20:32

Luego queda el mantenimiento, que es lo que hablaba antes de si necesita mejoras, si hay algún error que a posteriori pueda salir, etc. 00:20:38

Con lo cual, si hubiera que realizar alguna mejora o algo, tendríamos que ir otra vez hacia atrás en ese ciclo de vida para poder sacar la nueva versión de la vida. 00:20:45

Pasamos a los lenguajes de programación. Un lenguaje de programación es como un idioma, tiene una serie de reglas léxicas, sintácticas y semánticas. 00:20:57

Es igual, va a estar definido con unas reglas léxicas, o sea, va a tener una serie de palabras reservadas, es el lenguaje, eso se llama la regla léxica, también sintácticas, como uno de esas palabras para formar una frase, esto es igual, podría ser por nuestro idioma. 00:21:11

Y semántica, una vez que ya he unido ese conjunto de palabras en una frase, saber si realmente tiene sentido o no. 00:21:29

Entonces, un compilador que pasa a través de estas tres reglas. 00:21:38

Primero comprueba léxicas, comprueba si esas palabras que aparecen en ese lenguaje son las correctas o no. 00:21:42

Luego, sintácticas, si se han construido bien las frases. 00:21:50

Y semánticas, si luego realmente eso tiene sentido. 00:21:53

Una regla semántica podría ser si un tipo, por ejemplo, una variable tiene el tipo adecuado a la inicialización de la misma. 00:21:56

Bien, ya sabemos lo que es un lenguaje de programación. La gramática del lenguaje serán todas las reglas aplicadas a ese conjunto de símbolos y parábolas especiales de ese lenguaje. 00:22:07

Y aquí tenemos la gramática, está definida por un léxico, una sintaxis y una sema. 00:22:16

El primer lenguaje que surgió fue el lenguaje máquina 00:22:20

que es un lenguaje de primera generación 00:22:24

en el que era un lenguaje lo que se llama de bajo nivel 00:22:27

No sé si lo dije otra vez, pero los lenguajes de bajo nivel 00:22:31

son aquellos que están muy cercanos a la máquina 00:22:34

Los lenguajes de alto nivel son los que están más cercanos a la persona 00:22:37

¿Cómo distingo yo eso? 00:22:41

Un lenguaje muy cercano a la máquina es el que está en un lenguaje que solo entiende el ordenador 00:22:43

Un ordenador solo entiende de ceros y unos 00:22:49

Tensión, no tensión 00:22:52

Un uno, un cero 00:22:54

No entiendo otra cosa 00:22:56

Entonces, lógicamente, si tú le pones un programa 00:22:57

Con ceros y unos 00:23:00

El lenguaje es de bajo nivel 00:23:01

Está muy cercano a la máquina 00:23:04

La máquina lo entiende 00:23:05

Ponte tú a programar 00:23:07

Lenguaje a máquina 00:23:10

Para programas muy sencillos 00:23:11

Pues vale, pero 00:23:14

La cantidad de ceros y unos que se te puede convertir 00:23:15

Es inviable. Entonces, con ello surgieron nuevos lenguajes a partir del lenguaje máquina, que se alejaban un poquito de la máquina y se acercaban un poquito hacia nosotros. ¿Para qué? Para que tuviéramos una mayor facilidad de poderlos programar. 00:23:18

Entonces, los lenguajes de programación vienen de inglés. ¿Por qué? Porque fueron creados por personas americanas o inglesas, entonces por eso aparecen los lenguajes de programación en inglés. 00:23:32

El lenguaje asamblador fue el primero en el que utilizaba reglas memotécnicas, ya introducía estas palabras que aparecen aquí para dividir, para multiplicar, para mover y ya lo que hacía es que se alejaba un poquito del lenguaje de programación, exactamente código máquina y se acercaba un poquito a nosotros, a las personas. 00:23:48

Ya teníamos alguna palabra que podíamos entender para poder programar. 00:24:08

Aún así, el código máquina también es un lenguaje en el que es difícil de programar, 00:24:12

pero siempre es mucho más sencillo que programar, por ejemplo, un código máquina. 00:24:19

Después surgieron ya los lenguajes compilados, que son ya los lenguajes de alto nivel. 00:24:25

Pascal, Fortran, CET y demás lenguajes que se parecen mucho más, 00:24:31

O sea, que el ser humano es capaz de interpretar mucho mejor que una máquina. 00:24:36

¿Por qué? Porque ya parece como lo que hablábamos arriba, 00:24:42

con una serie de palabras, unas reglas léxicas, unas sintácticas y semánticas, 00:24:44

que es como nuestro idioma en castellano. 00:24:50

Tiene un léxico, una serie de palabras, una sintaxis, 00:24:53

y es muy parecido a lo que es un lenguaje humano. 00:24:56

De ahí que sean los llamados lenguajes de Aldo. 00:24:59

aquí viene como lo que es un compilador 00:25:02

como genera el código fuente 00:25:05

no me voy a meter mucho en eso 00:25:07

y luego los lenguajes interpretados 00:25:09

ya lo he dicho 00:25:12

Perl, Python, PHP, Javascript 00:25:13

todos estos son lenguajes en el que en vez de 00:25:16

compilar, establecer 00:25:17

y generar el código objeto 00:25:20

con un código 00:25:21

que sería el código fuente 00:25:23

y lo que va a realizar a través de 00:25:25

fijaos, aquí hay una tabla 00:25:28

aquí hay una tabla 00:25:29

en el que el compilador 00:25:31

¿qué es lo que hace? Fijaos lo que hace el compilador 00:25:34

un compilador lo que hace es 00:25:36

analiza el léxico, ve si las 00:25:37

palabras que tú has escrito 00:25:40

en ese código fuente se corresponden 00:25:41

con el lenguaje de programación 00:25:44

que está compilando 00:25:45

luego analiza 00:25:47

a nivel sintáctico si las frases 00:25:50

que has creado en el lenguaje 00:25:52

imaginaos si yo le he creado 00:25:53

fijaos aquí en 00:25:56

Java, pues lo primero que va a hacer 00:25:58

es el lenguaje léxico 00:26:00

el compilador lo primero que va a hacer es 00:26:02

primero coge la palabra public 00:26:03

bueno, empezaría por aquí 00:26:05

coge la palabra public 00:26:07

y hace un análisis léxico, mira a ver si esa palabra existe 00:26:09

mientras las palabras reservadas las dejaba 00:26:12

y ve que sí, que existe 00:26:14

luego coge class y también ve que también existe 00:26:15

a nivel léxico eso no está cumpliendo 00:26:18

luego ve que esto 00:26:20

no existe 00:26:21

pero debe ser 00:26:23

algún literal, algún nombre 00:26:25

que el propio programador ha puesto 00:26:27

A continuación, hace un análisis de esta frase, hace un análisis sintáctico. Ve si todo esto encaja o no. Si poniendo public, class y luego un nombre o un literal, esto encaja o no a nivel sintáctico. 00:26:29

llegar a la conclusión 00:26:46

que sí, está bien escrito 00:26:48

y luego a nivel semántico 00:26:50

a nivel semántico es un poco más complejo 00:26:52

pero es ver si tiene sentido 00:26:54

lo que ha escrito aquí 00:26:56

si este método está dentro de esta clase 00:26:58

pues eso es lo que hace 00:26:59

lo que haría 00:27:01

tanto en C, C++ 00:27:03

como lo haría en Java cuando compila 00:27:05

para formar el bytecode 00:27:07

una vez que ha pasado por esas tres 00:27:08

genera un código intermedio 00:27:11

hay un optimizador de código 00:27:13

aquí, lo optimiza 00:27:15

y a continuación genera el código objeto 00:27:17

y aquí ya tenemos que esto ya es el código 00:27:19

máquina, o sea, los ceros y unos 00:27:21

que va a entender ordenar 00:27:23

eso sería en cuanto a un compilado 00:27:24

en cambio el intérprete que lo pone 00:27:27

aquí, que serían estos lenguajes 00:27:31

de programación, ahora lo que está haciendo 00:27:32

él se pone en ejecución y coge la primera línea 00:27:34

y hace todo eso, pero lo va interpretando 00:27:36

una a una 00:27:39

la intérprete también que es correcto 00:27:40

sigue con la siguiente 00:27:42

no genera un programa ejecutable 00:27:43

como pasaba con el compilado 00:27:46

lógicamente, estos lenguajes de programación 00:27:48

van a ser más lentos 00:27:51

que lo que puede ser un lenguaje en C11 00:27:53

por eso, por ejemplo 00:27:54

cuando tú quieres hacer lo que hablaba antes 00:27:57

en función del problema 00:27:59

¿qué lenguaje de programación 00:28:01

voy a utilizar? 00:28:03

pues fijaos, si yo tengo que hacer 00:28:05

una aplicación que va a 00:28:07

funcionar en tiempo real 00:28:09

¿qué elegiríais? ¿un intérprete o elegiríais un compilado? 00:28:10

yo elegiría C o C++ 00:28:13

¿Por qué? Porque es muy rápido y necesitamos que las respuestas sean en tiempo real. 00:28:15

Entonces, lo realizaría con C o con C++, pero no lo realizaría con Javascript o con Perl. 00:28:21

Y pasamos ya al lenguaje de programación Java. 00:28:31

El lenguaje de programación Java es un lenguaje que tiene una sintaxis muy parecida a C++. 00:28:34

Bueno, en teoría, C++ es un lenguaje de programación que tiene la posibilidad de los punteros. 00:28:43

Cosa que los punteros, un puntero es un acceso directo a memoria. 00:28:50

C y C++ tenían un problema. 00:28:54

Primero, para programar es más complejo debido a los punteros. 00:28:57

Y además, la puedes generar una muy buena accediendo a accesos a memoria y provocando problemas. 00:29:01

¿Qué sucede? Que Java los punteros los tiene camuflados, son de esos dividendos a memoria y veremos cómo los tiene camuflados Java con respecto a hace marcas, pero que sepáis que en Java no hay punteros. 00:29:11

Acordaos que 00:29:26

Necesita Java, que era independiente de la plataforma 00:29:30

Y necesitaba una 00:29:32

Una máquina virtual de Java 00:29:33

Esa máquina virtual de Java lo que hacía era 00:29:36

Ejecutar el bytecode 00:29:39

Que generabas al compilar 00:29:41

Por eso se le llama el byte once 00:29:42

O runner 00:29:45

Se puede hacer 00:29:46

En cualquier lugar, independiente de la plataforma 00:29:49

Si allí tiene una 00:29:51

Máquina virtual, se va a poder ejecutar 00:29:53

También está basado, aparte de, acordaos, en cuanto a los paradigmas, habíamos visto que había dos tipos de paradigmas en declarativo imperativo. 00:29:55

Java es un lenguaje imperativo, pero además también es un lenguaje orientado a objetos. 00:30:12

hay lenguajes en el que tienen varios paradigmas 00:30:18

no solo uno, entonces Java 00:30:21

es un lenguaje orientado a objetos 00:30:23

¿qué quiere decir? que interpreta 00:30:25

tú puedes utilizar también Java 00:30:27

como vamos a hacer aquí 00:30:29

luego lo veremos en un ejemplo de lo de las tres 00:30:30

notas, puedes utilizarlo a través de esta aplicación 00:30:33

como un lenguaje imperativo 00:30:35

sin necesidad de crear, de utilizar 00:30:37

herencia, ni polimorfismo 00:30:39

ni encasulación, etc. 00:30:41

pero Java está 00:30:43

diseñado ¿para qué? para 00:30:45

ser un programa orientado a objetos 00:30:46

para interpretar el mundo real 00:30:50

que tiene a su alrededor todo como un objeto 00:30:52

con una serie de atributos y una serie de 00:30:54

métodos que ya veremos más adelante 00:30:56

esta es una breve historia de 00:30:57

Java, leerlo 00:31:01

no lo voy a repasar, que sepáis 00:31:03

que en Java necesitamos un JDK 00:31:05

que es donde está el compilado y luego 00:31:07

un JRE donde teníamos la 00:31:09

máquina virtual, acordaos que con 00:31:11

el 25 LTS 00:31:13

he utilizado solo JDK 00:31:15

y hemos obviado el JR porque ya viene introducida la máquina virtual dentro de la JDK. 00:31:17

Estas son las distintas plataformas de Java. 00:31:23

Java 2.0, esto de entorno SAN, antiguamente Java pertenecía a SAN Microsystems, que era la empresa. 00:31:27

Luego, posteriormente, la compró Oracle y es Oracle el que habla de esta. 00:31:37

Aquí hablo también de los applets, de lo metido, pero bueno, los applets ya no se utilizan. 00:31:42

Luego, el J2C es pensado para crear aplicaciones, esto sería para aplicaciones de escritorio, el J2C, pero el J2C sería para aplicaciones web empresariales, 00:31:48

tanto en el lado servidor, a través del lado servidor, donde podemos crear una aplicación a nivel de con los servlets, los javabins, bueno. 00:31:58

El JavaFX, que lo veremos, es para generar aplicaciones de Internet enriquecidas. Podríamos crear botones, menús, etc. 00:32:11

Luego tenemos el Java embebido, para entremedio de las cosas, y el JavaCard, que es tecnología que permite la producción de pequeñas aplicaciones Java en tarjetas inteligentes. 00:32:19

con respecto a la 00:32:28

programación orientada 00:32:35

a objetos y Java 00:32:37

ya he dicho que todo se entiende 00:32:38

como un objeto 00:32:41

y 00:32:42

lo único que vamos a hacer 00:32:45

es que 00:32:48

Java, la programación orientada a objetos 00:32:49

se basa en la abstracción 00:32:52

¿qué significa? 00:32:53

que se generan clases 00:32:55

que es como una abstracción 00:32:57

por el mundo real, en el que en esas clases podemos instanciar objetos. 00:32:59

Instanciar objetos de esa clase en el que cada uno tendrá una serie de propiedades 00:33:03

y una serie de métodos diferentes. 00:33:08

Aquí entran tres palabras fundamentales dentro de la promoción ambiental de objetos. 00:33:11

Esto pasa igual tanto en Java, en C++, en Python, que son encapsulación, herencia y polivorcia. 00:33:14

No me meto con encapsulaciones, tener resultados encapsulados de tal manera 00:33:21

que accede a tus clases no tiene necesidad de verla, de ver esa información. Esas variables 00:33:28

de miembro que tienes ocultas solo las pueden utilizar a través de métodos. En cuanto a 00:33:36

la herencia es permitir utilizar una clase que hereda de otra, en la que puede ser utilizar 00:33:42

sus métodos, etc. El polimorfismo lo veremos más adelante. Tampoco quiero que os metáis 00:33:46

mucho con el polimorfismo porque tenemos que verlo como un ejemplo para que sepáis, pero 00:33:53

que sepáis que polimorfismo, la misma palabra lo indica, son muchas formas. Aquí habla 00:33:57

de la independencia de la plataforma y que además permite un trabajo en red. Independencia 00:34:06

de la plataforma porque genera un bytecode que luego se puede ejecutar en cualquier lugar 00:34:13

donde lo lleves donde haya una máquina virtual. Y que trabaja en red, sí, Java ofrece múltiples 00:34:17

posibilidades con la comunicación vía TCP y IP. 00:34:23

Aquí ya se mete con seguridad y simplicidad, 00:34:31

que son dos características del lenguaje Java. 00:34:35

Esto está relacionado tanto con la independencia como con el trabajo en red. 00:34:37

Seguridad, ¿por qué? Porque los posibles accesos a zonas de memoria 00:34:42

sensibles no suceden como sucedían C y C++. 00:34:45

Acordaos, C y C++ utilizan los punteros. Aquí los accesos a memoria 00:34:49

están camuflados, hay acceso a memoria 00:34:53

pero tú no tienes un acceso 00:34:55

directo a memoria 00:34:58

esa es la gran diferencia con C++ 00:34:59

entonces en Java se ha eliminado 00:35:02

esto pasa también en CESAR 00:35:03

CESAR es un lenguaje que es muy parecido 00:35:05

a Java, Microsoft, en el que 00:35:08

también ha camuflado los punteros 00:35:10

porque permite 00:35:11

generar una gran seguridad, imaginaos 00:35:13

en C++, si uno 00:35:16

programa y ejecuta un programa que 00:35:17

permite con punteros acceder directo 00:35:19

a memoria y accede 00:35:22

a lugares de memoria 00:35:23

por ejemplo, los expertos en sistema operativo 00:35:25

o un método a saber 00:35:27

eso provocaba a veces 00:35:28

muchos problemas cuando el que programaba 00:35:31

en C++ no tenía una idea 00:35:33

bien clara 00:35:35

y entonces 00:35:36

puedes producir 00:35:36

grandes problemas de seguridad 00:35:40

en cambio Java o César 00:35:42

son lenguajes en el que 00:35:44

tienen la misma propiedad desde la 00:35:45

programación orientada a objetos pero 00:35:47

al no tener un acceso directo 00:35:49

a memoria pues le da una gran seguridad y luego la simplicidad java es tan potente como ceo temas 00:35:52

más y además es bastante sencillo bueno al principio para poder hacer un poco complejo 00:35:59

pero luego una vez como lo vas viendo ya veis como no es así además está relacionado fijaos 00:36:04

aquí habla del recolector de basura el garbage colector en el que este es el que se va a encargar 00:36:11

descargar de todos los pseudopunteros, que no son punteros, tenemos todos los accesos 00:36:17

a determinados objetos, pues todo ese tipo que son accesos a memoria, va a haber un reconector 00:36:24

de basura que cuando alguna referencia, que aquí lo llama, referencias a un determinado 00:36:31

objeto, deja existir el objeto, pues el reconector de basura elimina esa memoria. Antes eso se 00:36:36

tenía que hacer a través de los punteros por medio de enzimarlas. 00:36:42

aquí tenemos el Java y los bytecodes 00:36:47

y yo creo que voy a parar aquí 00:36:51

y no voy a hablar mucho más 00:36:54

lo único que quiero que veáis 00:36:56

que una vez que implementas el código fuente 00:36:57

lo que tenemos aquí, una vez que implementas este código fuente 00:37:00

a continuación con Java C se produce la compilación 00:37:04

y genera un bytecode 00:37:08

un bytecode que es como un código intermedio 00:37:10

Ese bytecode es el que luego tú puedes llevar a cualquier plataforma, con cualquier sistema operativo y con cualquiera que tenga la máquina virtual de Java, se puede ejecutar dicho bytecode. 00:37:14

Y así funciona Java y en eso consiste el bytecode. 00:37:27

Como dice aquí, es un conjunto de instrucciones en lenguaje de máquina que no son específicas a ningún procesador o sistema de cómputo. 00:37:31

de código de bytes o bytecodes 00:37:37

para una plataforma específica 00:37:40

sería quien los ejecute 00:37:42

independientemente 00:37:43

de la plataforma 00:37:46

todo depende de que tenga 00:37:47

el intérprete de Java o lo que es la máquina 00:37:49

virtual de Java 00:37:52

¿hasta aquí alguna duda? 00:37:54

a ver, separación 00:38:06

ah, lo de separación después de las comillas 00:38:07

es un efecto visual 00:38:12

¿por qué? porque fijaos, yo cuando 00:38:13

hago esto aquí, si le quito la separación 00:38:15

me va a aparecer el nombre Paco pegado a llamas 00:38:18

a los dos puntos y queda feo 00:38:21

¿vale? yo siempre pongo 00:38:22

¿esto qué pasa? 00:38:23

que cuando lo hago aquí 00:38:27

aquí se ha bloqueado 00:38:33

pero bueno, básicamente es eso 00:38:37

y cuando yo le pongo 00:38:39

a ver aquí 00:38:42

cerrar la ventana del editor 00:38:43

ah, que cierre 00:38:45

que cierre esto 00:38:51

vale, si yo le quito el espacio 00:38:53

es visual 00:38:55

cuando le deje agotar 00:38:57

no sé por qué 00:38:58

como me ha quedado esto 00:39:03

como así 00:39:03

si yo le deje agotar 00:39:05

veis 00:39:16

te queda pegado esta 00:39:39

a Paco 00:39:41

le dejo ahí un espacio 00:39:42

para que quede visualmente mejor 00:39:44

nada más que eso 00:39:46

no hay mucha más 00:39:48

opaco 00:39:49

aquí queda el espacio y la frase queda bien 00:39:51

una tontería 00:39:54

bueno, pues 00:39:55

nos vamos a meter ahora con Java 00:39:57

y vamos a ver un ejemplo 00:40:06

aquí tengo lo que vamos a ver 00:40:07

primero, tipos de datos 00:40:10

vamos a poner aquí el 1 00:40:12

y que vamos a ver, el único tipo de datos 00:40:13

acordar de lo que era una variable 00:40:16

Una variable que era un nombre que nosotros le damos donde algo, vamos a guardar algo. 00:40:17

Y además, esa variable, ya que su nombre lo indica, es posible que pueda modificarse, 00:40:26

pueda tener un diferente valor. 00:40:33

La puedes modificar a lo largo de la ejecución del programa. 00:40:35

Y si yo pongo esto, int nota igual a 10, aquí estoy definiendo una variable que se llama nota, la estoy declarando con un tipo entero, así es en Java, int, y con un valor de día. 00:40:38

Lógicamente esto no tendría mucho sentido 00:40:57

¿Por qué? Porque las notas pueden ser decimales 00:41:00

Puedes tener un 4 con 3 o un 8 con 5 00:41:04

Entonces yo no crearía una variable nota con un tipo entero 00:41:07

Veis que aquí el formato es 00:41:15

Entonces yo puedo poner por un double 00:41:17

Que esto sería un tipo decimal 00:41:18

También estaría float 00:41:23

Doble sería para números de mayor tamaño que lo que es un float, pero bueno, en principio lo llamamos como un doble. 00:41:25

Esto nos permite poner valores decimales. 00:41:31

Con int nos daría error. 00:41:35

Entonces, ¿qué partes tiene una variable? 00:41:38

Si la ponemos aquí, tendría... 00:41:41

Primero tienes que definir el tipo. 00:41:45

Después, el nombre de la variable. 00:41:55

y luego le asignamos un valor. 00:41:57

El valor sería el valor que tiene aquí. 00:42:04

Y esto sería para definir y declarar una variable. 00:42:07

Vamos a utilizar el double, que sería para números decimales. 00:42:11

Esto sería la primera parte y que sepáis cómo se define una variable 00:42:16

y cómo se pone el tipo en Java. 00:42:19

Este sería el ejemplo de cómo definir la variable nota con el tipo double. 00:42:22

¿Qué tenemos en cuanto al punto 2? 00:42:29

¿Qué vamos a ver aquí en el punto 2? 00:42:39

Vamos a ver cómo crear un objeto. 00:42:41

Cuando nosotros creamos un objeto, 00:42:42

imaginamos que tenemos una clase que se llama clase perro. 00:42:44

Si yo quiero generar un objeto de la clase perro, 00:42:55

desde otra clase o incluyendo solo la misma clase, 00:42:57

¿cómo se generaría un objeto para generar un objeto dentro de la... 00:43:00

Para generar un objeto de tipo, o una estancia de un objeto perro, tendríamos que poner primero el nombre de la clase. 00:43:06

Después, cómo vamos a llamar a ese objeto. Vamos a llamarle, por ejemplo, Tor. 00:43:28

A continuación hay un operador que es el operador new, que nos está generando un objeto. 00:43:34

Este new perro nos generaría el objeto. 00:43:41

el objeto. Aquí estamos generando un objeto. Lo primero que tienes que poner 00:43:46

es el nombre de la clase, el objeto y luego 00:43:50

el operador name. El poner de nuevo el nombre de la clase 00:43:54

con estos dos paréntesis, lo que nos está indicando es que estamos creando un objeto 00:43:58

y estamos llamando a su constructor, que ya lo veremos, constructor sin parámetros. 00:44:02

Pero que sepáis que este es el formato de cómo 00:44:06

crear un objeto de una clase. 00:44:09

Una vez que ya hemos generado ese objeto, ya con su nombre, con el propio objeto en sí, puedo llamar a métodos y a atributos de esa clase. 00:44:13

Yo puedo decir, llamar al método ladrar, por ejemplo, de esa clase. 00:44:29

Veis aquí, este objeto Tobi, hemos creado un objeto Tobi de la clase perro y a continuación con el cuadrado punto hemos llamado al método ladrar. 00:44:37

¿Cómo sé que estoy llamando a un método? Por los paréntesis, es un método que no tiene parámetros en su interior. 00:44:48

También puedo llamar si no tienen un nivel de restricción privado 00:44:55

Podría llamar a su atributo 00:45:06

Esto sería cómo crear una clase 00:45:13

¿Por qué pongo aquí lo de la clase y lo adelanto? 00:45:17

Más que nada lo adelanto porque cuando hagamos un ejemplo sencillo 00:45:21

vamos a necesitar de la clase 00:45:24

Scanner. Entonces, para 00:45:27

utilizar la clase Scanner 00:45:29

vamos a crear 00:45:31

un objeto de la clase Scanner. ¿Por qué quiero 00:45:33

la clase Scanner? Porque nos va a permitir escribir 00:45:35

de una manera 00:45:37

no muy compleja, 00:45:39

permitir escribir, solicitar 00:45:40

datos por el teclado. 00:45:43

Vamos a hacer un programa en el que nos va a solicitar 00:45:45

tres notas por el teclado y luego nos va a calcular 00:45:47

la línea. Entonces, solo los he 00:45:49

introducido. Ya os digo, todo esto 00:45:51

lo vamos a ver mucho más adelante, pero mucho más adelante, entonces tampoco tenemos mucha 00:45:53

prisa, pero que os vaya ya sonando, ¿vale? 00:45:57

Lo que me interesa es que podamos hacer un programa sencillo. 00:46:01

¿Qué más quiero ver? ¿Cómo crear un método? Un método en cualquier lengua de 00:46:05

programación se va a crear. Aquí en Java, concretamente, 00:46:09

primero se va a crear con un nivel de acceso a ese método. 00:46:18

Que sepáis que existe el método de acceso público, 00:46:22

el método privado 00:46:25

y Protective 00:46:28

el Protective ya lo veremos más adelante 00:46:34

no quiero meter más de eso 00:46:40

pero cuando creamos un método 00:46:42

o un atributo 00:46:43

veis aquí 00:46:45

el método, esto es un método 00:46:49

un método que tiene 00:46:51

un nivel de acceso 00:46:54

tiene 00:46:54

un valor devuelto o void 00:46:57

el nombre del método y luego una serie de parámetros 00:46:59

que van entre paréntesis, esto sería un método 00:47:01

un método por ejemplo 00:47:03

vamos a 00:47:04

definir por ejemplo el método 00:47:07

ladrar 00:47:09

vamos a hacer que sea público 00:47:10

para que cuando alguien cree 00:47:13

un objeto perro 00:47:15

pueda acceder al método 00:47:17

a continuación 00:47:20

vamos a hacer que no devuelva 00:47:21

nada a ese método 00:47:23

y le ponemos siempre que no devuelve nada si le ponemos un point 00:47:24

si devolviera algo pues tendríamos que 00:47:27

poner el tipo que devolvió, si devuelve un entero 00:47:29

pues tendríamos que poner un entero, si se le devuelve un double 00:47:32

pues tendríamos que poner un double, lo que sea 00:47:34

entonces vamos a ponerle void 00:47:36

porque es un método que no va a devolver nada 00:47:38

y le ponemos el nombre 00:47:39

vamos a ponerle el nombre ladrar 00:47:42

¿necesita 00:47:43

parámetros este método? pues 00:47:46

voy a ponerlo como que no necesita 00:47:47

ningún parámetro, entonces se deja vacío 00:47:49

pero lo que nos indica ya 00:47:52

este 00:47:54

este método es que 00:47:55

no va a requerir parámetros ni va a devolver 00:47:58

ningún parámetro, y que va a ser público 00:48:00

¿vale? y a continuación 00:48:02

cuando defines un método, le abres llave 00:48:04

y le cierras llave 00:48:06

y esto sería 00:48:07

un método 00:48:12

esto que aparece aquí 00:48:13

sería un método 00:48:18

lo que pasa es que este método no tiene ninguna línea 00:48:20

adentro, habría que 00:48:22

introducir aquí las líneas para ver 00:48:23

que realiza ese método, entonces cada vez que yo 00:48:30

cree un objeto Tobi, que pertenece 00:48:32

a la clase perro, 00:48:34

y le llame a ladrar, ejecutará 00:48:36

las líneas que aparezcan aquí dentro de este 00:48:38

método llamado ladrar. Esto es igual que aparece 00:48:40

aquí. ¿Veis? Aquí 00:48:42

para poder yo ejecutar una aplicación 00:48:44

necesito de un método. Es 00:48:46

estrictamente necesario. Y ese 00:48:48

método se llama 00:48:50

mail. Mail principal. 00:48:51

O sea, cada vez que yo lo ejecute, va a ir 00:48:54

directamente a ese mail y va a 00:48:56

ejecutar lo que tenga dentro del mail. 00:48:58

Es así. 00:49:00

para las aplicaciones 00:49:01

entonces, veis, es un método 00:49:03

que se ha definido aquí, como público 00:49:05

luego como estático, que veremos 00:49:07

qué es eso, como void, que no devuelve ningún 00:49:09

valor, que se llama main y que 00:49:11

tiene dentro un array de 00:49:13

objetos string, ¿vale? 00:49:15

un array que indica con estos dos corchetes 00:49:17

que ya veremos lo que es, no tenéis que saberlo 00:49:19

aunque os aprendéis por ahora esto de memoria 00:49:21

o sea, de memoria, que sepáis 00:49:23

que es suficiente 00:49:25

cuando yo ejecute de aquí, él directamente 00:49:27

va a ir al main, va a buscar 00:49:29

donde está el método main y va a ejecutar lo que esté dentro del main, ¿vale? 00:49:31

Es lo único que va a hacer. 00:49:35

Si os fijáis, esto, además, necesito siempre, para poder utilizar, 00:49:35

para poder generar cualquier programa en Java, una publicación, 00:49:43

necesito de una clase. 00:49:46

Esta clase está definida aquí como pública, que puede hacer cualquiera, 00:49:48

luego la palabra reservada class y el nombre de la clase. 00:49:52

Y siempre sigue con una llave de apertura y una llave de cierre. 00:49:56

y dentro, veis que está ahí indentado 00:49:59

está el método main 00:50:01

entonces cuando yo lo ejecute, irá a la clase 00:50:02

project1 y ejecutará 00:50:05

el método main y las líneas 00:50:07

que hay adentro las ejecutará 00:50:09

aquí hay un system.out.println que lo que hace es 00:50:10

que llama al objeto out 00:50:13

de la clase system y llama a su método 00:50:15

println, veis que todo está separado por puntos 00:50:17

llama al println para que? 00:50:19

para escribir en pantalla, lo que ponga es 00:50:21

entre comillas dobles, que es esto de aquí 00:50:23

y luego el ln es para que haga un retorno 00:50:24

de cargo y pase a la siguiente línea 00:50:27

Cuando le doy a ejecutar 00:50:29

¿Puedo hacer una pregunta? 00:50:31

Sí, sí 00:50:33

Estás diciendo que el void 00:50:34

Se pone para que no devuelva nada 00:50:37

Pero luego se mete dentro y devuelve 00:50:39

Lo que esté dentro 00:50:41

No, no es ese 00:50:42

Te voy a poner un ejemplo 00:50:45

Este, por ejemplo, no devuelve nada 00:50:46

Pero se mete dentro y ejecuta sus líneas 00:50:52

¿Vale? 00:50:55

Las líneas que sea 00:50:57

Instrucción 00:50:58

Instrucción 2 00:50:59

¿vale? cuando yo llamo 00:51:14

genero el objeto Toby y le llamo 00:51:17

a ladrar, ejecuta estas dos instrucciones 00:51:19

y termina, ¿vale? 00:51:21

ahora vamos a hacer un método 00:51:23

que sea 00:51:25

un método que devuelva 00:51:27

algo, ¿vale? 00:51:30

vamos a poner 00:51:32

obtener 00:51:32

nombre 00:51:39

del perro 00:51:40

¿vale? y aquí ponemos 00:51:42

ahora este sí nos va a devolver 00:51:44

¿el qué? nos va a devolver un string 00:51:46

¿vale? este ejecutará 00:51:47

las instrucciones que tiene dentro 00:51:50

y a continuación tendrá una línea 00:51:51

que ponga un return 00:51:53

¿no? un return 00:51:58

y el 00:51:59

lo que sea ¿vale? 00:52:01

¿veis? la diferencia entre este 00:52:05

método que no devuelve nada y este 00:52:06

método que es, esto es como 00:52:08

los antiguos procedimientos y funciones 00:52:10

el procedimiento no devolvía nada 00:52:12

la función siempre devolvía un valor 00:52:14

Pues aquí este método 00:52:16

No devuelve nada 00:52:18

¿Veis? Ejecuta las instrucciones que hay dentro y ya está 00:52:20

O sea, entra en el método 00:52:22

Primero, genera el objeto Toby 00:52:24

Llama a ladrar, en cuanto lo lleva a ladrar 00:52:26

Se va a este método 00:52:28

Ejecuta la instrucción 1, ejecuta la instrucción 2 00:52:29

Sale y vuelve aquí a esta línea 00:52:32

Y sigue ejecutando las líneas que reviviera 00:52:34

¿Vale? En cambio, si ahora 00:52:36

Aquí en Toby 00:52:38

Después le pongo 00:52:39

Obtener 00:52:41

nombre 00:52:44

esto lógicamente 00:52:46

habrá que ponerlo igualado a algo 00:52:50

string 00:52:52

nombre 00:52:53

igual a todo 00:52:56

¿qué estoy haciendo aquí? 00:52:58

estoy llamando 00:53:00

con el objeto toby al método obtenerNombre 00:53:01

y lo tengo que 00:53:05

igualar a un string, ¿por qué? 00:53:06

porque me va a doblegar un string 00:53:08

¿qué hace? llama al obtenerNombre 00:53:09

ejecuta la sustitución 1, ejecuta la sustitución 2 00:53:12

y luego nos retorna el nombre del perro 00:53:14

y lo mete dentro de la base 00:53:17

de la variable 00:53:18

¿Vale? 00:53:20

Se entiende más o menos 00:53:23

la diferencia entre lo que es 00:53:24

una función, un método con 00:53:26

void y con, dependerá de lo que tú 00:53:28

quieras hacer, si quieres devolver 00:53:30

algo o no lo quieres devolver 00:53:32

¿Hasta aquí bien? 00:53:34

Más o menos 00:53:38

¿Qué más quiero 00:53:38

que veamos? 00:53:40

Diferencia entre estático y no estático 00:53:42

Aquí ya vienen curvas, ¿vale? Entonces, primero voy a hablar de la clase Scanner, ¿vale? 00:53:44

La clase Scanner, solo vamos a saber cómo la clase Scanner, el 5. 00:53:51

Para generar un objeto de la clase Scanner, pues que sepáis que es así, ¿vale? 00:53:59

Vamos a llamarle sc igual a Scanner, a new, ¿recordaos? Estoy generando un objeto de la clase Scanner, ¿vale? 00:54:04

La clase scanner tendrá sus métodos, utilizamos de la misma y requiere de un parámetro cuando crea su objeto, que es system.in, ¿vale? Esto es la clase system y dentro de la clase system el objeto in, in es el objeto que vamos a necesitar para poder pedir un dato y poderlo introducir por tecla, ¿vale? 00:54:11

pero que sepáis que esto es lo que vamos a ver 00:54:34

y esto es lo que va a aparecer en el programa 00:54:36

¿vale? pero aquí 00:54:39

sencillamente estamos llamando a un objeto 00:54:40

de la clase Scanner que le llamamos ST 00:54:42

y que le pasamos un parámetro que es el Systeming 00:54:44

que por ahora, aunque sepáis que 00:54:46

esto es para que podamos escribir en teclado, me vale 00:54:48

¿vale? y luego nos quedaría 00:54:50

la diferencia entre 00:54:52

llamar a un método estático y a uno 00:54:54

no estático, ¿qué significa eso? 00:54:56

aquí 00:54:59

vamos a ponerlo 00:54:59

4, vamos a poner aquí static 00:55:02

y no static. ¿Por qué 00:55:14

quiero hablar un poquito sobre 00:55:21

esto? Porque lo básico para poder empezar 00:55:26

un programa, veis, está utilizando un método, el main es un método estático. 00:55:29

Le pone una palabra reservada que se llama static. 00:55:34

Es un método estático. ¿Eso qué quiere decir? Quiere decir que 00:55:37

Una cosa es cuando yo creo un objeto y llamo a un método del objeto 00:55:40

O un variable miembro del objeto 00:55:46

Y otra cosa es cuando quiero llamar a un método estático 00:55:48

La diferencia entre un método estático es que el método es general para toda la clase 00:55:52

Entonces yo no le voy a llamar instanciando un objeto 00:55:56

Le llamo con el nombre de la clase 00:56:00

Esa es la diferencia 00:56:02

Llamar a un método estático es que le voy a llamar con el nombre de la clase genérico 00:56:03

No va a haber instancias de objetos 00:56:08

es como crear como algo constante 00:56:10

entonces yo cada vez que llame al método main 00:56:13

lo voy a hacer a través del nombre de la clase 00:56:16

no lo voy a hacer a través de la creación de un determinado objeto 00:56:21

si esa palabra no existiera 00:56:24

por ejemplo, imaginaos aquí en el ejemplo que os he puesto 00:56:25

imaginaos que ahora ladrar es estático 00:56:28

pues este método yo no le puedo llamar 00:56:33

con Tobio, creando un objeto y luego llamar 00:56:38

al método ladrar. No, habría que llamarle con el 00:56:43

nombre de la clase. ¿Por qué? Porque va a haber 00:56:47

uno solo para toda la clase. No es como los otros métodos 00:56:53

en los que cada objeto que yo genero es una instancia de esa clase 00:56:57

y esa instancia tendrá un 00:57:01

método, una llamada al método diferente. 00:57:04

No sé si me he explicado más o menos. Bueno, tampoco quiero que por ahora nos metamos mucho, pero que ya os vaya sonando todas estas cosas. Entonces, vamos a hacer un ejercicio que sería para calcular la nota media de tres notas. 00:57:08

Entonces, lo primero que tenemos que hacer aquí sería definir, veis, lo primero que he hecho aquí es archivo, le he dicho nuevo proyecto 00:57:25

Y dentro de nuevo proyecto he generado, mira, si le doy otro nuevo proyecto, he generado una Java with main, que sería una Java aplicación 00:57:37

que es lo que tendría. Yo si le doy a siguiente 00:57:46

me va a generar el nombre, le ponemos el nombre 00:57:48

y veis que aquí ya nos va a 00:57:50

generar una main aplicación con el 00:57:52

propio public 00:57:54

startup de main, ¿vale? 00:57:56

Si le diera a finish nos generaría otro 00:57:58

proyecto. Nos genera una clase 00:58:00

automáticamente que sería con el 00:58:02

nombre del proyecto 00:58:04

y esta Java 00:58:06

pues le llama además con el mismo nombre 00:58:08

que le he puesto, ¿vale? Podríamos 00:58:10

cambiar el nombre de la 00:58:12

clase Java si luego 00:58:13

Pues sí, ¿cómo se puede hacer? 00:58:16

Tú le das al botón derecho y le dices que aquí en refactorizar le puedo renombrar y llamarle de otra manera, ¿vale? 00:58:18

Él automáticamente te va a cambiar todo lo que sea necesario. 00:58:29

Eso también sucede, ¿con qué? Pues con el proyecto. 00:58:32

Yo puedo siempre lo meter en una carpeta .com en My Company Project, que sería el nombre que tiene el proyecto, 00:58:35

pero veis, lo mete en un paquete .com y luego su paquete My Company y luego Project. 00:58:41

Pero esto también lo podemos cambiar, ¿vale? 00:58:45

esto lo podría formar como 00:58:47

refactorizándole y llamándole con otro nombre 00:58:49

vale, aquí sería 00:58:52

vale, yo puedo llamarle y que 00:58:57

venga la carpeta com, por ejemplo 00:59:06

vamos a ver, de 00:59:08

constanza 00:59:09

y luego pues el proyecto 00:59:11

pues lo voy a llamar proyecto 00:59:14

vale 00:59:15

todo esto lo refactoriza 00:59:17

y te lo cambia todo completamente, vale 00:59:20

pero él por defecto te va a generar todo esto 00:59:22

vale, vamos a dejarlo igual 00:59:24

y si veis 00:59:26

aquí no tiene más que una clase 00:59:28

como he dicho antes y tiene 00:59:30

un System.OpenL 00:59:32

le he dado a ejecutar y veis que aparece 00:59:34

aquí el Hello World, que es que 00:59:36

lo saca por pantalla y sale el Hello World 00:59:38

nada más 00:59:40

¿qué es lo que tenemos que hacer en lo primero? 00:59:40

vamos a hacer, sin la clase Scanner, vamos a generar 00:59:44

tres notas, entonces yo tengo que poner 00:59:46

¿el qué? pues un 00:59:48

puedo poner un double 00:59:49

nota1 00:59:51

igual a 5 00:59:54

y a continuación les voy a poner 00:59:58

veis, estoy creando la primera variable que he creado 01:00:00

además son variables que están dentro del método 01:00:04

fuera del método estas variables ya no existirán 01:00:06

una vez que se salga de esta llave 01:00:09

estas variables no existirán 01:00:11

estarán dentro de este método 01:00:13

su ámbito es este método, no están fuera 01:00:14

no son variables miembros de la clase 01:00:16

vamos a meterle una nota 2 y una nota 3 01:00:18

aquí le ponemos un 10 01:00:22

y aquí le ponemos flojero y saco un 1,5 01:00:25

entonces, una vez que tenemos las tres notas 01:00:28

a continuación, lo que queremos hacer 01:00:31

esto nos sirve para escribir en pantalla 01:00:34

le vamos a poner aquí el system 01:00:38

para que primero nos diga 01:00:42

voy a calcular la nota media 01:00:46

de tres notas 01:00:54

vale 01:01:00

a continuación tendremos que hacer la operación 01:01:02

de cálculo, vale, entonces 01:01:05

¿cómo le voy a llamar? si tengo tres 01:01:06

notas que son de tipo double 01:01:09

pues y quiero calcular la media tengo que crear 01:01:11

otra variable que se llame media 01:01:13

que tendrá que ser lógicamente 01:01:14

también de tipo double 01:01:17

entonces le vamos a poner media 01:01:18

y a esta ¿qué le vamos a hacer? 01:01:20

le vamos a decir que es nota 01:01:23

uno más 01:01:25

nota2 más 01:01:26

nota3 01:01:29

y dividido entre 3 01:01:30

¿Veis lo que he hecho aquí? Estoy utilizando 01:01:32

ya operadores. Los operadores los veremos 01:01:35

en el tema 2 01:01:36

pero bueno, para que podamos hacer 01:01:39

un pequeño programita tenemos que introducir 01:01:41

pequeñas cosas. Tenemos el operador más 01:01:43

que lo que hace es que suma esta variable 01:01:45

a esta otra variable y a esta otra variable 01:01:47

y luego lo que hace es una división 01:01:49

en la que luego la divide entre 3 01:01:51

y con eso obtiene el ángulo 01:01:53

A continuación, la sacaríamos por pantalla. Necesitaríamos otra vez el System.out.println. Acordaos, esta es la clase System que tiene un objeto que se llama out y que dicho objeto cuando lo he estanciado, si veis aquí además es una clase estática. O sea, es un objeto estático porque se le llama por el nombre. ¿Veis lo que habíamos visto anteriormente? 01:01:54

el objeto out 01:02:14

se le llama 01:02:16

a través de system 01:02:19

y luego se llama 01:02:21

a su método que se llama println 01:02:23

lo que hace es imprimir esto en pantalla y 01:02:24

hace un retorno de cargo posteriormente 01:02:26

si pusiéramos solo print en vez de ln 01:02:28

lo que haría es 01:02:31

aparecería esto en 01:02:32

la pantalla pero no habría retorno de cargo 01:02:33

si tuviera dos system 01:02:37

out print 01:02:38

escribiría esto y el siguiente system lo escribiría 01:02:39

al lado. Al poner el n nos permite que haga un retorno de carro 01:02:42

y que la siguiente línea aparezca abajo. Entonces le ponemos el n 01:02:46

y le voy a calcular la nota media 01:02:50

de las cerditas. Entonces, ¿a qué nos quedaría? 01:02:54

Nos quedaría imprimir la media. 01:02:57

La media es... y aquí tenemos 01:03:09

que imprimir la media es, pero a continuación de la media es 01:03:14

Tiene que aparecer la media real 01:03:18

Entonces, ¿cómo se concatenan cadenas en Java? 01:03:19

Se concatenan con el operador más 01:03:23

Yo al poner aquí media 01:03:25

¿Qué es lo que hace? 01:03:26

Él coge media 01:03:28

Y como es un double 01:03:29

Lo pasa a cadena 01:03:31

Y concatena esta cadena 01:03:33

Con esta otra cadena 01:03:35

Al darle a ejecutar 01:03:36

Nos sale que la media es 5,5 01:03:38

¿Lo veis? 01:03:46

Este sería un programa sencillo 01:03:48

¿Alguien no ha entendido este programa? 01:03:50

veis, necesitamos tanto el 01:03:52

main y una clase para poder ejecutar 01:03:57

un programa, aquí estamos 01:03:59

ejecutando un programa 01:04:00

o realizando un programa de manera imperativa, no estamos 01:04:03

utilizando, aunque necesitamos una clase para poderlo ejecutar 01:04:04

no estamos realizando 01:04:07

programación orientada a objetos 01:04:09

¿alguien tiene una 01:04:11

duda sobre esto? 01:04:13

bien, pues pasamos a 01:04:19

los decimales con punto siempre 01:04:20

¿no? 01:04:23

sí, vale 01:04:24

pero cuidado, ahora con la clase 01:04:26

escáner, que lo veremos 01:04:29

la clase escáner cuando nos lo pida por pantalla 01:04:30

si se lo pones con punto te da error 01:04:33

él solo lo lee con coma 01:04:35

y ahora lo veremos 01:04:37

entonces vamos a 01:04:38

convertir ahora este 01:04:41

este programa 01:04:42

bueno, no lo he dicho antes pero 01:04:46

yo si quiero escribir un system 01:04:48

cuando le doy al punto 01:04:51

él automáticamente te saca 01:04:53

aquí la línea 01:04:55

para que tú puedas encontrar 01:04:58

lo que tú deseas, ¿ves? 01:04:59

Un objeto out de la clase de printString, ¿vale? 01:05:01

Le das al out y el 01:05:04

automáticamente te lo genera, ¿vale? 01:05:05

Tú le puedes buscar aquí, buscas el método que quieres 01:05:07

utilizar, ¿veis? La cantidad de métodos que 01:05:10

tiene out, print con 01:05:12

un parámetro, printf, 01:05:13

println, ¿veis? 01:05:16

Etcétera. No sólo 01:05:18

estar println con un string, que es lo que 01:05:19

estamos haciendo nosotros todo el rato. 01:05:22

donde puede estar un char, un float, un entero, un log 01:05:23

vale, vamos a ver ahora 01:05:26

vamos a crear un objeto de la clase Scanner 01:05:32

si yo le pongo ScannerSC, le vamos a llamar SC 01:05:35

y le vamos a poner un new Scanner 01:05:39

esta clase es de objeto, necesita un parámetro 01:05:42

cuando su constructor necesita un parámetro para generar ese objeto 01:05:48

Y es system.it. Por ahora, que sepáis que es así y poco más. ¿Vale? Pero ¿qué sucede? Que no hemos importado el paquete que tiene Scanner. Aquí nos está diciendo que no puedo localizarlo. ¿Vale? ¿Por qué no lo puedo localizar? Porque no hemos importado el paquete donde está Scanner. ¿Vale? 01:05:51

Entonces habrá que importar, para importar paquetes se hace con import java.utscanner, lo veis, el mismo ya me lo va poniendo. 01:06:11

Yo, todas las librerías de Java no están por defecto, salvo javaland, pero el resto tienes que importarla. 01:06:28

Si yo quiero utilizar la clase escáner me tengo que ir a donde esté esa clase escáner. ¿Dónde la tengo? 01:06:37

en el paquete java.paqueteUtil 01:06:41

y dentro del paquete útil está la clase 01:06:46

escala, que la veis aquí 01:06:48

siempre se pone 01:06:49

el import, para importar una librería se pone 01:06:52

fuera de la clase 01:06:54

una vez que ya lo hemos importado 01:06:55

se nos ha quitado el 01:06:58

símbolo, y si yo le dejo voltar 01:06:59

no va a hacer nada, porque todavía 01:07:02

no hemos utilizado la clase escala 01:07:04

hará lo mismo que hemos hecho hasta ahora 01:07:05

no va a hacer nada 01:07:07

Entonces, ¿para qué quiero este objeto SC de la clase Scanner? 01:07:09

Pues lo quiero para que el programa nos solicite las notas 01:07:14

y yo las pueda teclear a través del teclado, ¿vale? 01:07:21

Entonces, aquí hemos utilizado Scanner, 01:07:24

voy a calcular la nota media de las tres 01:07:32

Y ahora le ponemos el System.out 01:07:34

Y nos va a solicitar la primera nota 01:07:38

¿Vale? 01:07:52

Para solicitar la primera nota 01:07:53

¿Qué es lo que hacemos? 01:07:55

Que ahora la primera nota 01:07:57

Que acordaos que era un doble 01:07:58

Y se llamaba nota 1 01:07:59

En vez de ponerle yo el valor 01:08:01

Solo va a poner el usuario que esté con el programa 01:08:03

Lo va a escribir en el teclado 01:08:07

Entonces para ello tenemos que utilizar la clase Scanner 01:08:09

que sería sc, que es el objeto que hemos utilizado 01:08:11

y vamos a utilizar un método sui 01:08:14

y vamos a decirle que nos proporcione 01:08:15

el próximo double 01:08:18

porque lo que queremos 01:08:19

es un valor 01:08:22

de tipo double, ¿qué va a hacer aquí? 01:08:24

la clase scanner tiene un método 01:08:26

que se llama next double, que lo que hace es que 01:08:28

permite a través del teclado 01:08:30

reintroducir un double 01:08:32

y a continuación lo captura 01:08:33

y lo mete dentro de la variable 01:08:36

nota1 que hemos creado de tipo double 01:08:38

¿vale? 01:08:40

Todo esto será exactamente igual en todas las líneas, igual en todas las líneas. 01:08:41

¿Veis? He cogido, vamos a comentarlo, creamos objeto de la clase escala. 01:08:55

A continuación, solicitamos la primera nota o teclado a través del objeto llamado sc. 01:09:14

Aquí le estamos diciendo que una vez obtenido el dato por teclado, lo almacena en la variable de tipo double llamada nota1. 01:09:48

Esto ya no lo pongo para estas dos líneas porque realmente es lo mismo. 01:10:22

Esto sería igual, lo voy a hacer para la segunda nota y para la tercera. 01:10:26

A continuación aquí, que es lo que hace, expresión que calcula la nota media de las tres notas introducidas en el teclado, 01:10:31

cuyo valor 01:10:53

lo 01:10:58

introduce 01:11:00

en la 01:11:01

variable 01:11:04

llamada 01:11:06

media 01:11:08

¿vale? 01:11:10

m 01:11:24

vale 01:11:25

a ver aquí 01:11:29

estoy comentando 01:11:31

incluso demasiado ¿no? pero 01:11:34

es para que lo veáis ¿vale? 01:11:35

este sería 01:11:38

método main 01:11:39

de la clase 01:11:45

project1 01:11:46

y aquí tendríamos 01:11:51

clase 01:11:54

project1 01:11:59

con 01:12:02

acceso público 01:12:04

vale, pues ya tenemos 01:12:07

claro que es todo lo que tenemos aquí 01:12:17

a través de la clase 01:12:19

project1, a través de su 01:12:22

public extractivo y main, que va a ser el método 01:12:24

principal que ha de ejecutar 01:12:26

va a ir hacia él 01:12:28

un método con un parámetro 01:12:29

que es este de aquí, lo que hace es que 01:12:32

primero genera un objeto scanner 01:12:34

para generar un objeto scanner necesitamos 01:12:35

el objeto in de la clase system 01:12:38

como parámetro 01:12:40

a continuación imprime 01:12:41

voy a calcular una nota media de 3 notas 01:12:44

a través del println 01:12:46

del objeto out, luego pone 01:12:47

primera nota, dos puntos y a continuación nos pedirá 01:12:51

la primera nota, luego nos pedirá la segunda y luego la tercera 01:12:56

¿vale? primera nota, segunda nota 01:12:59

y tercera nota, ¿vale? ¿cómo lo hace esto? 01:13:04

coge el objeto scanner que hemos creado y llama a su método next double 01:13:13

está diciendo, oye, dame el próximo número 01:13:17

de tipo decimal. ¿Y cómo lo hace? Pues a través del cursor, nos sale un cursor parpadeante 01:13:21

que nos va a indicar que nos pide que nosotros escribamos con el teclado la nota. Una vez 01:13:27

que escribimos la nota, él la va a introducir dentro de la variable nota1, que es de tipo 01:13:33

doble. Aquí la introduce dentro de la variable 2 y la de la nota 3. Después llega a la expresión 01:13:41

media que lo único que hace es 01:13:48

que calcula la suma de las tres notas 01:13:50

la divide entre tres 01:13:52

y todo eso lo introduce dentro de la variable 01:13:53

media 01:13:56

después con este sistema out.ln 01:13:57

lo que va a hacer es que va a imprimir 01:14:00

el valor de la nota 01:14:01

entonces yo cuando ahora lo voy a ejecutar 01:14:03

vamos a ver si está todo bien 01:14:06

fijaos 01:14:07

cuando lo voy a ejecutar 01:14:13

me ha puesto voy a calcular la nota media de tres notas 01:14:16

y aquí nos permite 01:14:19

escribir 01:14:21

Si yo le pongo la nota con un punto, me lo va a dar como error. 01:14:22

¿Por qué? Porque él lo coge como con coma. 01:14:27

Entonces le voy a poner un valor de 4,5. 01:14:31

Cuando le doy a Enter, nos pide la segunda nota. 01:14:33

Le voy a poner un 5,6. 01:14:35

Y cuando le doy a Enter, nos pide la tercera nota. 01:14:38

Le voy a poner un 9, lo voy mejorando. 01:14:41

Vamos a poner un 9,2. 01:14:43

Una vez que nos saca el decimal, la nota media, que sería de un 6,43. 01:14:45

periodo, ¿vale? Y este sería 01:14:51

el programa con 01:14:53

la clase Scanner. 01:14:55

Ya sé que he introducido 01:15:00

muchas cosas, muchos, pero 01:15:01

si queremos hacer algún programa 01:15:02

sencillito, necesito 01:15:05

introducir, y es que Java necesita de toda esta 01:15:07

parafernalia para poder hacer 01:15:09

una suma, una media de tres notas. 01:15:10

¿Alguna duda sobre esto? 01:15:14

¿Queréis que... 01:15:16

Vale, no sé... 01:15:17

Vale, lo pillo. 01:15:22

queréis que lo repase otra vez 01:15:24

el programa 01:15:26

pero si, a ver 01:15:28

el valor de una variable entera y de una variable double 01:15:33

se puede sumar 01:15:35

porque son números 01:15:37

claro, él lo que hace 01:15:39

si yo le pusiera una variable 01:15:40

le pusiera una variable, por ejemplo 01:15:42

a esta nota 01:15:44

y se la pusiera 01:15:46

a ver, no lo podemos hacer aquí 01:15:47

porque le estoy pidiendo, pero imaginaos 01:15:50

que en vez de pedirle a la nota 2 01:15:52

un next double 01:15:54

le voy a pedir un entero 01:15:56

¿vale? vamos a probarlo 01:15:58

entonces en vez de pedirle 01:15:59

un entero, le voy a pedir 01:16:02

un entero con el nextIn 01:16:03

¿vale? de la clase 01:16:06

del objeto de la clase Scanner 01:16:07

entonces claro, esto estaría mal porque como 01:16:09

va a recibir un entero, tendría que poner aquí 01:16:12

un tipo del tipo entero 01:16:14

¿creéis que funcionaría esto? 01:16:15

¿sí o no? sí, funcionaría 01:16:18

¿por qué? porque él lo va 01:16:26

en esta expresión 01:16:28

aquí va a tener un double 01:16:30

aquí va a tener un decimal, aquí tiene un entero 01:16:31

y aquí tiene un decimal 01:16:34

él automáticamente va a convertir las tres notas 01:16:35

y nos va a dar un resultado en decimal 01:16:38

si yo le meto 01:16:39

lo que pasa es que, cuidado 01:16:40

si ahora yo 01:16:43

fijaos 01:16:46

si hay un problema, si yo ahora 01:16:47

no me doy cuenta 01:16:49

y en vez de poner, aquí le vamos a poner un 2.3 01:16:51

pero la segunda nota, ¿qué pasa aquí? 01:16:53

¿qué sucede si le pongo un valor decimal? 01:16:56

¿funcionará o no funcionará? 01:16:59

no le puedo meter porque el objeto 01:17:00

sc de la clase scanner está utilizando el método 01:17:09

está utilizando el método 01:17:13

next in, te está pidiendo el próximo entero 01:17:15

no, te está pidiendo un valor decimal, si yo pusiera aquí un valor decimal 01:17:21

nos daría error, aquí tendría que ponerle un valor entero 01:17:25

para que me lo coja, yo tendría que ponerle por ejemplo 9 y no nos daría 01:17:29

ningún tipo de error, entonces ya nos pediría la tercera nota 01:17:33

y pondríamos un 4.2, también podríamos poner 01:17:37

un 4, él como es un double automáticamente lo va a convertir en un 4.0 01:17:41

¿vale? y nos sacaría la media, ¿qué sucede si yo le doy 01:17:46

a ejecutar y en vez de en la segunda le meto 01:17:49

2.3 y aquí le metemos un 01:17:53

4.5, ¿veis? nos da error 01:17:57

nos da esta excepción que falla 01:18:04

en el que nos dice pues que 01:18:06

fijaos la pila 01:18:08

de métodos 01:18:10

en el que va recorriendo, si lo fijáis 01:18:12

primero under the project 01:18:14

va al main, lo veis aquí 01:18:16

va al main, luego va al next 01:18:18

in y ahí es donde se produce 01:18:20

el error, el next in 01:18:21

es el que ha provocado pues que se genere 01:18:24

toda esta pila de errores 01:18:26

entonces, que necesito 01:18:28

darle a 01:18:30

necesito darle, esto sucede 01:18:31

también lo he dicho antes, si yo le meto la primera nota, le pongo un 3.4 01:18:34

también me da el error, ¿por qué? 01:18:39

porque los coge, como ya lo comentaba anteriormente, para tú poderle 01:18:42

introducir con la clase Scanner un valor decimal, tiene que ser con la coma 01:18:46

por teclado, si tú le metes un valor punto, nos va a generar también 01:18:50

el error, entonces sabemos por tanto que 01:18:53

vamos a cortarlo, sabemos por tanto que la primera nota 01:18:57

lógicamente tiene que ser un decimal 01:19:02

que la segunda tiene que ser un entero 01:19:05

y que la tercera tiene que ser un decimal 01:19:08

automáticamente ¿qué hará? 01:19:11

él automáticamente al hacer la expresión 01:19:13

esta expresión de suma y división 01:19:15

automáticamente convierte a nota 2 01:19:18

implícitamente la convierte en un double 01:19:21

suma tres doubles y lo divide entre tres 01:19:23

y realiza la A 01:19:26

aunque nosotros le hayamos metido un valor decimal 01:19:28

y calcula la media 01:19:30

que es 5.3 01:19:33

¿Algo que no 01:19:35

queráis que aclare sobre el programa? 01:19:46

¿Más o menos se entiende? 01:19:52

No es necesario que lo entendáis 01:19:54

entero, ¿vale? 01:19:55

Sí que vayamos viendo un poquito 01:19:57

cómo es Java 01:19:59

Básicamente quería que estas sesiones 01:19:59

nos sirvan un poquito para ir introduciendo 01:20:03

un poquito de Java 01:20:05

y que ya pues empecéis a tener 01:20:09

pues ligeras nociones 01:20:11

de qué va esto, ¿vale? 01:20:13

no quiero que esto, no es necesario 01:20:14

que lo sepáis, hacer 01:20:16

100% porque todavía no 01:20:18

hemos visto la mayoría de todo lo que hay 01:20:20

aquí, ¿vale? pero 01:20:22

que vayamos, fijaos 01:20:24

hemos hecho ya un programa 01:20:27

en el que hemos podido meter tres valores 01:20:28

un tipo doble por teclado y nos ha 01:20:30

calculado una mail, o sea que ya 01:20:32

hemos hecho alguna cosita 01:20:34

sin tener mucha idea de 01:20:35

de qué rango, ¿vale? 01:20:38

¿verdad? ¿alguna duda? ¿algo? 01:20:40

todavía, ¿no? 01:20:42

Vamos a introducir una mejora al programa y vamos a hacer ahora que el programa en vez de que lo calcule aquí directamente, fijaos, esta operación está aquí metida en el método y no os molesta un poco que podamos delegar esa operación a un método fuera y que cada vez que queramos utilizarla la podamos llamar. 01:20:46

Pues eso es lo que voy a hacer ahora. Ahora lo que voy a hacer es generar un método, para generar un método, acordaos de aquí, cómo se ha generado un método, fijaos, la sintaxis era el acceso al dicho método, public, private o protected, y luego el valor devuelto, vamos a olvidarnos del static, si tiene un valor devuelto o si no, void, 01:21:11

y luego el nombre del método y entre paréntesis si necesita algún parámetro dentro, ¿vale? 01:21:38

Luego se abre una llave y se cierra. Eso es lo que vamos a hacer aquí. 01:21:45

Vamos a crear un método aquí, ¿veis? Pero tiene que estar indentado. 01:21:47

Este método va a estar dentro de esta clase. 01:21:50

Acordaos que esta clase se abre aquí y se cierra aquí. 01:21:52

Y aquí tenemos el método main que se abre aquí y se cierra aquí, 01:21:55

pero que está a su vez dentro e indentado dentro de la clase. 01:21:57

Y aquí vamos a generar otro método dentro de la clase. 01:22:00

le vamos a decir que es un método público 01:22:03

y le vamos a decir que 01:22:04

nos va a devolver un valor de qué tipo 01:22:07

¿quién me puede decir de qué tipo 01:22:09

me va a devolver el valor? este método 01:22:11

¿es necesario que me devuelva algo? 01:22:13

un doble, muy bien 01:22:18

vamos a meterle un doble 01:22:19

y le vamos a llamar 01:22:21

obtener media 01:22:25

tenemos que abrir la llave 01:22:29

y cerrarla, ¿veis? ya está metido 01:22:33

la primera llave, aquí ¿por qué nos sale 01:22:34

este error? nos sale este error porque como devuelve 01:22:37

un doble y no le he puesto un retro pues me va a dar el error hasta que ponga el retro es lo 01:22:38

que lo único que me está indicando que quiero que quiero que tenga parámetros sí o no cuántos 01:22:45

parámetros y tiene la nota pues vamos a ponerle tres parámetros esos parámetros serán de tipo 01:22:54

doble también, ¿no? Entonces, doble 01:23:03

aquí 01:23:05

vamos a llamarle 01:23:08

no 1 01:23:13

no 2 01:23:14

y doble 01:23:19

3, ¿vale? 01:23:20

Y ahora, ¿qué es lo que quiero? 01:23:24

Que en vez de... 01:23:26

El cuidado que 01:23:33

la nota 2 la pusimos como 01:23:33

entera. ¿Cómo? ¿La pusimos 01:23:36

como? Ah, sí, como entera, vale. 01:23:38

Como entera. Aquí, es verdad. 01:23:40

No pasaría 01:23:42

nada porque él automáticamente si la llamamos 01:23:43

con el entero, él automáticamente 01:23:45

le pasaría un doble 01:23:47

si quieres luego lo probamos 01:23:48

porque él siempre 01:23:51

el cajón lo adapta 01:23:54

al cajón más grande, el cajón más grande 01:23:56

sea el doble, entonces lo adaptaría 01:23:58

cogería el entero y al ver 01:24:00

que esto es un 01:24:02

un doble, pues lo transformaría en un doble 01:24:03

entonces 01:24:07

tendríamos las tres notas, aquí tendríamos 01:24:07

que hacer esto, porque ahora 01:24:10

estamos delegando 01:24:15

esa expresión 01:24:16

a este método. Cada vez que le llamemos nos hará esto. 01:24:23

¿Y ahora qué va a retornar? ¿Qué es lo que retornará? Media. Muy bien. 01:24:26

Entonces le metemos media aquí. Media que sería la variable 01:24:37

que nos hace el cálculo y que es de tipo doble y que coincide 01:24:41

con el doble. Aquí nos está diciendo 01:24:45

el error. ¿Por qué? Porque aquí no se llama nota, se llama not. 01:24:49

que son los tres parámetros que hemos recibido 01:24:56

bien, tenemos nuestro método 01:24:59

¿qué es lo que hace este método? va a devolver un double 01:25:12

se llama obtenerMedia y recibe tres parámetros, uno de tipo double 01:25:14

otro y otro, entonces tres los coge, los suma 01:25:18

los divide entre tres y lo mete dentro de la variable media 01:25:21

y luego retorna la variable media que si vemos 01:25:23

el retorno coincide porque media es double 01:25:26

y el valor de retorno de la función es doble 01:25:29

además el método es público, o sea que puedo acceder a él 01:25:33

bien, ya tenemos 01:25:37

esto sería exactamente igual, por el teclado nos pediría 01:25:41

las tres notas y luego ahora lo que habría que hacer es 01:25:45

llamar, aquí llamaríamos 01:25:49

esto, este comentario 01:25:53

y aquí lo que haríamos que es 01:25:55

llamaríamos aquí al método 01:26:09

obtenerMedia 01:26:13

aquí si veis no hay 01:26:14

yo puedo generar aquí un robo 01:26:20

media y no habría problema porque esta variable 01:26:25

media, aunque tengan el mismo nombre 01:26:28

está dentro de un método 01:26:31

entonces fuera de ese método 01:26:33

media no aparecería, no había conflicto 01:26:35

entonces aquí podríamos poner igual 01:26:37

aquí 01:26:39

entonces tendríamos que llamar al propio 01:26:41

entonces aquí se puede 01:26:43

hacer de dos maneras 01:26:45

yo le puedo poner 01:26:46

y llamaríamos a obtener media 01:26:48

o incluso 01:26:58

vale, yo puedo hacerlo de dos maneras 01:27:00

como esto es un método estático 01:27:25

y estoy llamando a un método que no es estático 01:27:27

lo veis, aquí me está dando un error 01:27:31

nos está diciendo, este método es estático 01:27:32

y estoy llamando a un método estático 01:27:36

entonces, ¿cómo podemos resolver esto? 01:27:40

se puede hacer de varias maneras 01:27:42

una manera para poder llamar al método 01:27:44

tener media de esta misma 01:27:47

yo no puedo generar en un método estático 01:27:50

tendría que crear lo primero, se podría hacer de dos maneras 01:27:55

una, yo podría hacer un objeto de la propia clase 01:27:58

y llamar a obtener media 01:28:02

como aparece aquí, la otra manera 01:28:07

es, puedo llamar a este método estático y llamarle desde el nombre de la clase 01:28:11

si yo le puse aquí static, sé que esto 01:28:15

es más complejo de entender 01:28:18

si yo le puse a static 01:28:20

ya se me ha quitado el error 01:28:22

¿por qué? porque yo no puedo llamar 01:28:24

desde un método estático 01:28:26

a un método 01:28:27

yo no puedo llamar 01:28:30

a mi método obtenerMedia 01:28:32

con un dis por ejemplo 01:28:34

que ya veremos lo que es 01:28:36

yo no puedo llamar a mi propio método 01:28:37

de mi primera clase 01:28:40

porque estoy dentro de un método estático 01:28:41

que es un método 01:28:45

de clase, no es un método 01:28:46

de objeto, ¿vale? Esto es difícil de ver, pero 01:28:48

lo veremos bastante más adelante, ¿vale? Pero yo no puedo llamar desde un método 01:28:52

estático, no puedo llamar a otro método que no sea estático 01:28:56

a no ser que cree un objeto de esta misma clase, ¿vale? 01:29:00

Al poner static yo puedo llamar directamente a obtener 01:29:04

media sin tener que crear un objeto, ¿vale? Si yo quitara esto 01:29:08

vamos a poner, vamos a ver si funciona o no 01:29:12

nos dice 01:29:15

algo he puesto mal 01:29:31

a ver 01:29:32

4.3 01:29:33

segunda nota 01:29:34

nos dice que 01:29:38

javascan 01:29:39

ah que es un entero 01:29:40

vale 01:29:41

no ha quitado lo del entero 01:29:41

vale 01:29:42

es aquí 01:29:43

vamos a ajustarlo 01:29:47

bien 01:29:53

yo pongo 4.3 01:29:58

le ponemos 3.4 01:30:00

y le ponemos 01:30:02

5.4 01:30:03

y nos calcula 01:30:04

la media 01:30:05

¿la veis? 01:30:06

ahora está calculando la media 01:30:06

pero lo está haciendo llamando al método, ¿vale? 01:30:08

Está, cuando llega aquí, llama al método, le pasa las tres notas que hemos obtenido por teclado 01:30:12

y llama aquí, o sea, esta línea va aquí, recibe como parámetro nota 1 y lo mete dentro de no 1, 01:30:18

recibe nota 2 y lo mete dentro de no 2 y recibe nota 3 y lo mete dentro de no 3. 01:30:26

¿Qué hace luego? Esas tres notas, las suma y las divide entre 3, lo mete dentro de media 01:30:33

y retorna el valor de media 01:30:38

que era doble 01:30:39

ese valor aparecerá aquí 01:30:41

ese 5,33 01:30:43

en vez de todo esto, aparecerá un 5,33 01:30:45

lo mete dentro de esta onMedia 01:30:48

y a continuación 01:30:49

para que no se os haga lío 01:30:51

yo pongo 01:30:53

media total 01:30:54

y así diferenciamos de la otra variable 01:30:56

¿vale? 01:31:00

se entiende más o menos, esto me preocupa menos 01:31:04

que sepamos cómo llamar este método 01:31:07

me preocupa menos, pero se entiende que 01:31:08

hemos delegado 01:31:10

un algoritmo o una 01:31:12

expresión, la hemos delegado en un método 01:31:14

aparte, para que 01:31:16

la podemos llamar el número de veces que queramos 01:31:18

con el número de valores que 01:31:21

queramos, sin necesidad de que esté aquí dentro del 01:31:22

mail. ¿Se entiende eso? 01:31:24

Yo sí lo entiendo, 01:31:28

lo único que no entiendo es 01:31:29

por qué puedes llamar una cosa que 01:31:30

has declarado posteriormente. 01:31:32

Puedes llamar a una cosa que has 01:31:37

declarado posteriormente. 01:31:40

Claro, a ver 01:31:41

esto es como 01:31:46

una clase, dentro de una clase 01:31:48

hay una serie de métodos 01:31:50

y tú puedes llamar a cualquiera de esos 01:31:52

métodos, ¿vale? 01:31:54

da igual desde donde le llames 01:31:55

como una especie de 01:31:57

de... fijaos 01:32:03

de la indentación, yo puedo llamar 01:32:04

a cualquier método 01:32:06

aquí es que lo estamos haciendo desde esta clase 01:32:08

pero imagínate que lo estamos haciendo desde otra clase 01:32:11

Yo puedo llamar desde otro programa, puedo generar un objeto de Project 1 y llamar al método obtener media. No tiene por qué estar ese método delante, arriba. Yo sí cojo este método, si es lo que te preocupa, y yo le cojo aquí y le pongo aquí. Es lo mismo, ¿vale? Es lo mismo. No sé si es lo que te refieres. 01:32:12

que si no has leído 01:32:40

si lo hubiera visto así no te hubiera hecho la pregunta 01:32:41

porque como está declarado antes 01:32:44

y luego se llama después 01:32:46

como estaba 01:32:47

claro, pero la clase 01:32:49

una vez declarada la clase, cuando lo coge 01:32:51

el compilador para generar el bytecode 01:32:54

él ve cada uno 01:32:56

de los métodos 01:32:58

los ve, cada uno de los métodos, los lee 01:33:00

y es independiente 01:33:02

realmente la ejecución del programa 01:33:05

es esta, desde aquí 01:33:07

y él está ejecutando el programa desde aquí 01:33:09

Pero él, el programa, el compilador, ya ha leído todos los métodos que hay. 01:33:11

Da igual donde los ponga, ¿vale? 01:33:15

Sí, da igual donde estén. 01:33:17

Si está delante, si está detrás. 01:33:24

Él ya, el compilador, lo ha leído. 01:33:25

Sabe que tiene un método main y tiene un método obtenerMedia. 01:33:27

Que el método obtenerMedia tiene tres parámetros de tipo double 01:33:30

y que el método main tiene un parámetro... 01:33:32

Él ya lo sabe. 01:33:37

Pero luego la ejecución es esta. 01:33:38

Empieza aquí, ¿vale? 01:33:39

va directamente al Estatic Web Main 01:33:40

que es una aplicación 01:33:43

y empieza a leer esta línea 01:33:45

y luego esta otra, y luego esta otra 01:33:47

y luego esta otra, pero ya es 01:33:49

conocedor de los métodos que 01:33:51

tiene la clase, ¿vale? 01:33:53

Entonces, ¿qué pasa? Que cuando llama a obtener media 01:33:54

él sabe que tiene 01:33:57

que la clase Project 1 tiene 01:33:58

un método que se llama obtener media y que requiere 01:34:01

de tres parámetros de tipo doble 01:34:03

entonces, lo llama con esos tres 01:34:04

parámetros que coinciden además 01:34:06

con los de i 01:34:08

calcula la media total, se la devuelve 01:34:10

una vez que se la devuelve, pues la puedes imprimir 01:34:13

¿vale? ¿alguna duda más? 01:34:15

a ver, que me he metido en harina 01:34:19

¿sabéis que todo esto 01:34:21

no lo hemos dado? ¿vale? pero es porque 01:34:23

os vaya ya sonando 01:34:25

no tenéis por qué entenderlo todo 01:34:26

¿vale? no hemos dado todavía ni operadores, no hemos dado 01:34:28

ni tipos de datos, no hemos dado 01:34:31

ni variables, no hemos dado 01:34:32

y mucho menos lo que es un objeto 01:34:35

y mucho menos lo que es estático 01:34:37

¿vale? pero bueno que 01:34:38

es lo que tiene Java. 01:34:40

Para poder hacer un programa sencillito 01:34:42

necesitas toda esta 01:34:44

infraestructura. Quizás esto me lo puede 01:34:45

haber ahorrado, ¿vale? La función. 01:34:48

Pero me ha parecido oportuno que 01:34:50

veáis la operación matemática 01:34:52

que la podemos delegar en un método. 01:34:54

¿Vale? ¿Vale? ¿Alguna 01:34:56

duda? 01:35:05

¿Todo ok? 01:35:09

Pues yo, si queréis, 01:35:11

lo dejamos de aquí, ¿vale? 01:35:12

El próximo día, si queréis, 01:35:14

seguimos haciendo programas sencillitos 01:35:16

así tipo como este 01:35:18

y que ya os vaya sonando 01:35:21

el palo estético de InMain 01:35:22

que ya os vaya quedando 01:35:24

que veamos como generar 01:35:27

un método o una función 01:35:29

que utilicemos otro tipo 01:35:30

de valores de datos 01:35:32

y no nos vamos a meter 01:35:34

ni con estructura de control ni condicional 01:35:36

ni nada de eso, eso ya cuando lleguemos al tema 3 01:35:38

pero que hagamos 01:35:41

programas de estos 01:35:42

estos son los tipos de programas que se hacen 01:35:44

para cualquier lenguaje 01:35:46

de programación 01:35:48

procedimental, lo que parece que Java 01:35:50

es orientado a objetos, entonces requiere 01:35:52

como mínimo una clase, es que no podemos 01:35:54

ejecutar algo sin tener una clase 01:35:56

y un método main, es que eso 01:35:58

es impepinable, es así 01:36:00

no podemos ejecutar nada si no tenemos las dos cosas 01:36:02

entonces tenemos que saber de dónde viene 01:36:04

pero para hacer cualquier, si veis 01:36:06

aquí no estamos aplicando 01:36:08

programación orientada a objetos 01:36:09

La única es la extracción de este objeto 01:36:11

pero son programas sencillos, procedimentales 01:36:14

como se haría en cualquier lenguaje de programación que no sea orientado a objetos. 01:36:18

¿Alguna duda? Si queréis lo dejamos aquí. 01:36:27

Si se os ocurren dudas más adelante, no me escribís, lo podéis hacer en el foro o lo que sea. 01:36:31

Os colgaré esta videoconferencia grabada 01:36:37

pero más o menos bien. 01:36:43

no se metió mucha caña 01:36:47

pero es así 01:36:49

estas dos cosas las necesitamos 01:36:51

la clase 01:36:53

y el value statement 01:36:55

lo necesitamos para empezar 01:36:56

entonces que vayamos poco a poco metiendo cosas 01:36:58

y haciendo programas sencillos 01:37:00

por ejemplo el próximo día a lo mejor 01:37:03

hacemos uno, el calcular 01:37:04

una ecuación de 01:37:06

para calcular una ecuación de segundo grado 01:37:07

necesitaríamos un 01:37:11

bueno, lo podemos hacer 01:37:12

haremos otros ejercicios 01:37:13

pues nada, voy a dejar de grabar 01:37:16

y nos vemos el jueves 01:37:25

en cuanto a temas que debemos tener leídos hasta el momento 01:37:32

lo que tenéis que ir en cuanto a temas más que leeros el primero 01:37:39

que es lo único que me preocupa, hemos llegado casi a la mitad 01:37:42

en varias sesiones que las que quedan pues terminaré 01:37:45

que nos acordemos la próxima vez que estamos en Java y los bytecodes 01:37:48

veremos 01:37:52

y lo que quiero es que os miréis este tema 01:37:53

que es lo que me importa 01:37:56

el hacer ejercicios de Java es para 01:37:57

que la sesión sea un poquito más 01:37:59

más llevadera 01:38:02

y para ir adelantando 01:38:04

cosas de Java, aunque todavía no las hemos visto 01:38:06

¿vale? pero que os vaya sonando 01:38:08

nada más 01:38:09

pues nada 01:38:10

nos vemos el jueves que viene 01:38:21

¿vale? 01:38:23

Videoconferencia Programación 13/10 - 16:10 - 18:00 - Contenido educativo

Del mismo autor…

Videoconferencia Presentación Módulo Fundamentos de Programación

Videoconferencia Programación 08-10-26

Videoconferencia Presentación Fundamentos de Python. 07/10/26

Videoconferencia 6_10_26 Programacion

Video presentación Módulo

Instalación Apache NetBeans 31