Saltar navegación

2024-10-15-Programacion - 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 15 de octubre de 2024 por Jose Manuel M.

155 visualizaciones

Clasificación lenguajes de programación. Introducción a POO. HolaMundo en Java desde consola y desde Eclipse

Más información Transcripción

Descargar la transcripción

Buenos días, os hago esta grabación porque es el día 15 de octubre, porque el día 14, la tutorial de ayer, la estuve grabando, pero resulta que la aplicación no tenía seleccionado el audio y nos quedó un bonito vídeo, pero sin audio. 00:00:01
Así que os voy a repasar los contenidos de los que habíamos estado hablando ayer y os hago un pequeño resumen. Os subo este vídeo en sustitución de lo que era la grabación de la clase de ayer. 00:00:15
mirad estuvimos hablando en primer lugar de un cierto modo de clasificar los lenguajes de 00:00:25
programación hay muchos mecanismos pero uno de ellos va en función de lo cercano que están las 00:00:32
instrucciones que utilizamos para programar a la propia arquitectura hardware de los equipos 00:00:39
donde va a correr el programa o más cercano a la forma en la que los seres humanos vemos la 00:00:45
realidad digamos entonces unos son lenguajes de bajo nivel y los que están próximos a los 00:00:51
procesadores y los otros son lenguajes de alto nivel los lenguajes de alto nivel el más típico 00:00:57
es la forma de programar en código máquina donde el programador en realidad conoce el juego 00:01:04
instrucciones que utiliza el procesador y lo que mete realmente son combinaciones de ceros y unos 00:01:15
esto podría ser un tipo de instrucción que entiende el procesador y a partir de aquí hace ciertas cosas 00:01:20
El hardware en informática trabaja en sistema binario, con lo cual lo que utilizas son ceros y unos y las instrucciones en última instancia son ejecutadas por los equipos bajo este modelo. 00:01:26
Imaginad lo complicado que sería si una tienda nos solicita un programa para la gestión de su inventario, hacer un programa en base a ceros y unos que termine dando respuesta a esos requisitos que nos plantea la tienda. 00:01:41
A partir de aquí se empiezan a dar diferentes niveles de extracción, es decir, ir de alguna forma encasulando los códigos que van entendiendo el hardware en cosas más legibles por los seres humanos. 00:01:55
Y lo siguiente que tenemos es el lenguaje asamblador, en el cual ya por lo menos no trabajamos con ceros y unos y las instrucciones son del tipo de move, de mover a una zona de memoria un determinado valor, ADD si queremos sumar dos valores numéricos, pero aún así todavía esto queda lejísimos de cómo entendemos nosotros el problema que se quiera resolver. 00:02:07
En este caso sería el realizar el inventario de una determinada tienda. 00:02:30
Según vamos avanzando, nos encontramos con lenguajes de alto nivel. 00:02:37
Y estos sí que intentan que se plantee el código que resuelve el algoritmo sobre el que queremos trabajar 00:02:44
de una forma muy parecida a como nosotros pensamos, a como el ser humano piensa. 00:02:53
Y dentro de estos, bueno, pues tenemos en última instancia los lenguajes funcionales, 00:03:00
En cualquier lenguaje hay que respetar una determinada sintaxis de cómo funciona, pero este tipo de lenguajes lo que hacen es que buscan que describas el problema y ellos a través de las compilaciones terminan convirtiendo eso que has dicho tú a lo que sería un lenguaje máquina que al final es necesario para que corra dentro del orden. 00:03:05
Y otra vez en esta categoría de lenguajes de alto nivel serían los lenguajes del paradigma de la programación orientada a objetos. 00:03:26
programación orientada a objetos, que es el tema que nos cubre en esta asignatura 00:03:37
y en particular utilizaremos el lenguaje Java. 00:03:43
Otra clasificación que podemos hacer en los lenguajes que me interesa destacar aquí 00:03:49
es la que tiene que ver con los lenguajes que son ejecutados y los que son interpretados. 00:03:54
En los lenguajes ejecutados se desarrolla el código según la sintaxis y la semántica que tenga ese lenguaje, 00:04:00
por ejemplo en el lenguaje C++, en un fichero que normalmente tendrá una extensión que será .c o .gc, 00:04:05
ponemos el código tal cual nos define este lenguaje y lo que se hace es realizar una compilación 00:04:15
mediante un programa que es el compilador. 00:04:23
Este programa lo que hace es coger este código en C, valida su sintaxis, su semántica 00:04:27
y como salida nos proporciona un código máquina. 00:04:34
Este código máquina será propio de una plataforma de ejecución hardware. 00:04:41
Si nuestro programa en C queremos que corra en otra plataforma diferente, 00:04:46
tendremos que utilizar un compilador que volverá a tener como origen el mismo código C, 00:04:51
pero nos sacaría una combinación de código máquina, secuencias de ceros y unos, 00:04:56
que tendría un procesador diferente. 00:05:02
Con lo cual, para trabajar en diferentes plataformas, en los lenguajes que decimos que son ejecutados, el compilador es diferente en cada uno de los casos, obteniendo diferentes resultados de código máquina. 00:05:04
Y luego están los interpretados. En esta categoría es donde vamos a meter nosotros Java, aunque siempre se dice que hay otros interpretados más puros que Java, como puede ser Python. 00:05:19
Java a veces lo catalogan como semi-interpretado, pero bueno, nosotros lo vamos a considerar como interpretado en este caso. 00:05:31
y lo que hacemos es que en esta ocasión en java el código fuente, es decir, donde nosotros ponemos con sintaxis y semántica java 00:05:38
la solución que queremos dar a la resolución del algoritmo, lo introducimos en ficheros que tienen extensión .java. 00:05:49
Nuevamente le pasamos un compilador que valida que este código es correcto, por lo menos en cuanto a su escritura, su sintaxis y semántica 00:05:56
Y una vez que hemos hecho esto, tenemos un ficherito que tiene extensión .class. Este ficherito extensión .class, que también se llama bytecode, es algo intermedio, no es ni el lenguaje, ni un código máquina que entiendan una arquitectura, ni es el código Java, ya que hemos aplicado con el compilador sobre él ciertas validaciones. 00:06:05
qué pasa con este bytecode es que antes de ejecutarlo en una plataforma en cualquiera 00:06:28
de ellas tendremos que pasarle otro programa que es el intérprete intérprete es capaz de 00:06:35
entender bytecode en java y este es el que nos saca como resultado código máquina en esta 00:06:41
ocasión será el intérprete el que será diferente para cada una de las plataformas y el compilador 00:06:52
será común a todas ellas dándonos un bytecode común que va a ejecutarse en un hardware o en otro. 00:06:57
¿Qué ventajas nos proporcionan los lenguajes ejecutados? Pues típicamente, como la compilación 00:07:05
ya se ha realizado y tenemos ya el código máquina, la plataforma hardware es capaz de coger ese 00:07:11
código máquina y ponerlo en marcha de forma muy rápida. En los interpretados, nosotros lo que 00:07:16
distribuimos es el bytecode y en todos los ordenadores, dependiendo de la plataforma 00:07:21
hardware que tengan tendrán un intérprete que será algo distinto y cada vez que queramos ejecutar 00:07:27
nuestro programa se cogerá este bytecode y será necesario hacer uso del intérprete entonces el 00:07:33
tiempo de procesamiento que lleva este intérprete digamos que es una penalización en cuanto al 00:07:40
rendimiento en los programas interpretados pero la ventaja es que nosotros no tenemos que estar 00:07:44
compilando nuestro programa como desarrolladores para diferentes plataformas porque es común a 00:07:51
todas ellas. Dicho esto y centrándonos en Java, pues tenemos que Java es un lenguaje que utiliza 00:07:57
la programación orientada a objetos, lenguaje de alto nivel y es interpretado. Una segunda cosa 00:08:10
de la que estuvimos hablando en la tutoría era un poco del ciclo de vida de los proyectos. 00:08:29
Os comentaba en la universidad, yo al menos estudié una asignatura, no sé si se irá 00:08:33
cuando hice informática, que se llamaba Ingeniería de Software. Y hacía un repaso de las diferentes 00:08:38
fases por las que debemos pasar cuando estamos realizando un proyecto. Un proyecto en nuestro 00:08:43
caso va a ser software, pero un proyecto general de ingeniería. E incluso os comentaba que 00:08:49
es una secuencia de cosas que en realidad hacemos nosotros en nuestro día a día para 00:08:54
cualquier actividad entonces en primer lugar se identifican digamos las necesidades que tenemos 00:08:59
podemos definir unos requisitos de lo que lo que estamos planteando nos luego haríamos un diseño 00:09:06
que es plantear cómo vamos a resolver están esas necesidades que se han planteado luego tenemos un 00:09:13
desarrollo que sería la propia la propia implementación de la implementación de 00:09:27
la solución que hemos diseñado podríamos hacer unas pruebas para más o menos tener 00:09:35
ciertas garantías de que ese desarrollo funciona una entrega podríamos considerarlo como una 00:09:40
puesta en producción si es un programa y luego bueno pues una última fase que llevaría un 00:09:48
mantenimiento que podría ser o bien correctivo o bien evolutivo correctivo para solucionar un 00:09:55
posible problema que hayamos en el que hayamos caído cuando hicimos el desarrollo y tenemos 00:10:05
que solucionarlo porque está dando errores evolutivo porque se nos ha pedido algo adicional 00:10:10
a nuestro programa que tenemos que incluir donde nos encontramos nosotros en esta asignatura nos 00:10:17
encontramos principalmente en estas dos fases. Y en particular en esta, que es realizar nuestros 00:10:22
programas en Java. Todas estas fases en la asignatura de entornos de desarrollo, 00:10:30
dedicaréis algunos temas, hablar un poquito de ellas y muy en particular en la parte de diseño, 00:10:41
trabajaréis con diagramas de UML casi con toda seguridad. En la parte de pruebas haréis pruebas 00:10:47
de caja blanca, de caja negra, digamos que en torno al desarrollo 00:10:53
tiene un recorrido más por todo este ciclo de vida y programación 00:10:57
en particular por en lo que vendría a ser el 00:11:01
desarrollo. Una vez que hemos ubicado un poco Java en los lenguajes 00:11:05
de programación y en la fase donde trabajamos 00:11:15
pues otra cosa que os comentaba es 00:11:19
algunos conceptos así como muy generales, una visión muy general de la programación orientada 00:11:22
objetos. Al ser de alto nivel, intenta acercarse a nuestra forma de ver los problemas. Y os ponía 00:11:28
como ejemplo el desarrollo de una clase, de la tutoría sobre la que estábamos trabajando. 00:11:33
Entonces decíamos, vamos a intentar identificar qué actores participan en el desarrollo de una 00:11:41
clase. Y decíamos, bueno, pues parece razonable que haya un profesor, que haya algún profesor, 00:11:51
Parece razonable que haya alumnos y, bueno, decíamos, parece razonable que la clase se desarrolle en un aula. 00:11:58
En principio, en nuestro contexto, para dar respuesta a los requisitos, que sería el enunciado del problema que queremos hacer, 00:12:05
estos son los actores que pensamos podrían participar. 00:12:12
En la programación orientada a objetos, lo que hacemos es que para cada uno de estos actores, identificaremos una clase. 00:12:15
En la programación orientada a objetos, uno de los términos clave, una de las palabras clave son las clases. Las clases son esquemas de qué caracteriza a un determinado profesor en este ejercicio, porque hablaremos de la clase profesor y qué acciones es capaz de hacer. 00:12:23
Entonces nosotros cogeremos y en nuestro programa, dentro del código diremos, vamos a definir una clase, aparecen otras palabras por ahí de las que iremos hablando durante el curso, la clase profesor, es decir, en nuestro programa va a participar algún profesor en algún momento. 00:12:41
Y los profesores tienen unas determinadas características. Todo lo que define al profesor, ponemos esta cabecera o asignatura como firma de la clase, que es un término que se utiliza, y lo encerramos entre una apertura de llave y un cierre de llave. 00:12:57
Todo lo que tenga que ver con la clase profesor va a estar definido dentro de este ámbito, de estas llaves. 00:13:13
¿Y qué definimos en toda clase en la programación orientada a objetos, sea Java o sea cualquier otro de los lenguajes? 00:13:21
Definimos unos determinados parámetros o características. 00:13:27
Estos parámetros son de diferentes tipos y será, por ejemplo, los profesores tienen una edad. 00:13:37
Sí, dentro del contexto nos parece que puede ser relevante en el programa la edad que tienen los profesores, porque el enunciado en algún momento así lo define. 00:13:44
Los profesores pueden tener un nombre, y los profesores pueden tener un número de la seguridad social, y NUMSEC, porque como el desarrollo de la clase se realiza en el ámbito de trabajo, pues igual este dato en este programa podría llegar a ser importante. 00:13:53
Estas son características que tendrán los profesores. 00:14:10
A todo profesor que participe en nuestro programa le podremos dar una edad, un nombre y un número de la seguridad social. 00:14:13
Son los parámetros, características o atributos. 00:14:22
Son formas de llamar a estas características que se definen en las clases. 00:14:27
Y luego los profesores pueden realizar una serie de acciones que las identificamos como métodos. 00:14:32
Entonces, esta serie de acciones típicamente aparecen como verbos, public, y será, por ejemplo, el método saluda. 00:14:43
Y los métodos suelen llevar aquí una apertura y cierre de corchetes, a veces con información aquí dentro, 00:14:54
y haremos desarrollándolo. Y fijaros que hemos utilizado un verbo. Normalmente los métodos, como son acciones, 00:15:00
pues aparecerán con verbos, los atributos pues no aparecerán con verbos 00:15:07
porque no son acciones, son características que puedan tener. Entonces cuando un profesor 00:15:11
que participe en nuestro programa quiera realizar la acción de saludar 00:15:16
lo que el programa pondrá en marcha será aquel código que 00:15:20
pongamos aquí entre las llaves de apertura y cierre del método 00:15:24
saludar. Además un profesor podrá 00:15:28
poner 00:15:32
tarea. Pues cuando durante el programa queramos que un profesor ponga tarea, invocaremos de alguna 00:15:38
forma a este método poner tarea que está relacionado con la clase profesor y la serie de actividades 00:15:49
que serán serán aquellas que nosotros codifiquemos en nuestro lenguaje en Java dentro de las llaves 00:15:54
del método poner tarea. Pero esto quiere decir la clase profesor que haya un profesor haciendo 00:16:00
cosas en nuestro programa. No, las clases vendrían a ser un esquema de las características y las 00:16:09
acciones que van a ser capaces de hacer los profesores, pero todavía no ha cobrado vida 00:16:14
ningún profesor en nuestro programa para llevar a cabo esa acción. Otro de los actores que hemos 00:16:19
visto es la clase alumno. En la clase alumno podríamos coger e identificarla también dentro 00:16:26
de nuestro código. En este caso pondríamos aquí la clase alumno y aquí tendríamos las características 00:16:33
y atributos que tienen en este caso los alumnos, porque los estamos definiendo dentro del ámbito 00:16:39
de la clase alumno. Puede ser que el número de la seguridad social no sea relevante para el alumno, 00:16:43
pero sí el número de asignaturas en las que están matriculados. Este es un atributo que caracteriza 00:16:48
a los alumnos y no tiene nada que ver con los profesores. En cambio, el número de seguridad 00:16:56
social es un atributo que caracteriza a profesores y nada que ver con alumnos. En cambio, hay algunas 00:17:00
características que son comunes por el hecho de ser personas, tanto profesores como alumnos, 00:17:06
que es que tengan un nombre y una edad, pues bueno, pues puede aparecer en las dos clases. 00:17:11
De la igual forma que los parámetros, tenemos los métodos, que son las acciones que van a hacer los alumnos en nuestro programa. 00:17:16
Vamos a considerar que los alumnos también podrán saludar, y a lo mejor este código es diferente, vamos a ponerlo con máses, 00:17:23
cuando saluda un alumno, a lo mejor saluda de forma diferente a cuando saluda un profesor, 00:17:31
por eso aquí podemos poner el código Java diferente, cuando realice la acción de saludar al profesor, 00:17:34
a cuando la realice el alumno. 00:17:40
Y los alumnos, pues igual no tienen que poner tarea, 00:17:43
si tienen que hacer la acción de estudiar. 00:17:48
Pues aquí pondremos la acción de estudiar para el alumno 00:17:50
y el código que se ejecuta cada vez que solicitemos 00:17:53
que un alumno quiera estudiar. 00:17:56
Insisto en que las clases no identifican a un profesor en particular, 00:18:00
la de arriba, ni a diferentes alumnos, 00:18:06
sino que son los esquemas de características y acciones que van a realizar tanto profesores como alumnos cuando cobren vida. 00:18:08
En una puesta en marcha de nuestro programa en particular, podríamos suponer que hay un profesor que se llama José 00:18:16
y tres alumnos que se llaman Rubén, Sandra, Noah, vamos a poner un cuarto, y Valeria, estos cuatro alumnos. 00:18:22
El profesor José, cuando cobre vida, estos que son los que le van a cobrar vida, serán objetos, 00:18:33
que son todos los términos que aparecen en la programación 00:18:40
orientada a objetos, fijaros que lo lleva el propio nombre de la programación 00:18:43
son objetos de estas clases 00:18:46
es decir, son instancias que de verdad participan 00:18:49
que cobran vida de esas características 00:18:52
entonces cuando José, que lo vamos a considerar un profesor 00:18:54
queramos darlo de alta en nuestro programa, diremos 00:18:58
del tipo profesor hay uno que se llama José 00:19:00
es decir, José será un profesor 00:19:04
entonces a José le podremos poner una edad 00:19:07
de esta forma, poniendo ahí edad 00:19:10
y ¿por qué le podemos poner una edad 00:19:11
a José, que es un profesor? 00:19:13
porque dentro de la clase profesor 00:19:16
hemos definido una característica que es la edad 00:19:17
entonces podemos decir que tiene 00:19:19
30 años 00:19:23
a José le podemos poner un nombre 00:19:24
¿por qué? porque es una de las características 00:19:26
o de los parámetros que hemos definido 00:19:29
para la clase profesor 00:19:31
entonces cogemos y decimos que 00:19:33
y José será capaz 00:19:37
de saludar, si ponemos aquí 00:19:39
jose saludar, decimos que jose, que es un profesor, realice la 00:19:41
acción de saludar. Y jose, como es un profesor, no venimos a 00:19:50
profesor, buscamos saludar y vemos que efectivamente es una 00:19:53
de las acciones que son capaces de hacer los profesores y 00:19:56
durante este proceso de saludo, lo que hará será las acciones 00:20:00
que hayamos identificado en el método de saludar aquí en este 00:20:04
código. Igual que hemos hecho para jose, bueno, esto tiene una 00:20:07
sintaxis Java regular 00:20:11
es muy parecida pero habría que hacer 00:20:14
más cosas 00:20:16
Rubén que es un alumno, pues podríamos definir 00:20:16
un alumno 00:20:20
que es Rubén 00:20:20
y ahora a Rubén podríamos darle 00:20:22
por ser un alumno, un nombre 00:20:25
una edad 00:20:27
podríamos decir que está matriculado 00:20:31
un número de asignaturas y podríamos ponerla 00:20:34
a estudiar, entonces Rubén haría estas acciones 00:20:36
cuando Rubén estudias 00:20:38
vamos a poner Rubén a estudiar 00:20:39
otro alumno que podría ser Valeria 00:20:40
lo identificamos en el programa como Valeria 00:20:48
y podríamos decir que Valeria tiene 00:20:54
tiene 10 años 00:20:58
o 15 años 00:21:05
fijaros como Rubén y Valeria 00:21:07
tienen un mismo esquema de características y de comportamiento 00:21:11
pero cada uno empieza a tener sus peculiaridades 00:21:15
en el momento en que a Rubén le podemos dar una edad 00:21:18
y a Valeria otra distinta 00:21:20
fijaros que nuestro programa empieza a cobrar vida 00:21:22
y empieza a hacer cosas en el momento que instanciamos 00:21:25
objetos de las clases para las cuales 00:21:28
hemos definido sus esqueletos 00:21:29
y toda esta interacción será la que 00:21:31
buscará, la que tendrá el objetivo 00:21:33
de dar respuesta al algoritmo 00:21:35
que implemente los requisitos 00:21:37
que nos habíamos planteado 00:21:40
para este problema, así como un esquema 00:21:42
general, haremos mil clases durante el curso 00:21:45
y bueno, pues ya 00:21:48
iréis viendo, esta es la diferencia 00:21:50
entre clases y objetos 00:21:53
dos elementos de los que 00:21:54
aparecen en la programación orientada a objetos 00:21:57
y tienen mucha presencia. 00:21:59
Mirad, lo siguiente de lo que hablábamos 00:22:04
era de, en la tutoría, 00:22:06
estoy como concentrándolo todo mucho, 00:22:09
pero intentando no dejarme ningún detalle. 00:22:11
Si luego falta alguno, 00:22:13
pues ya me preguntáis en los foros 00:22:14
y os comento. 00:22:15
Decíamos que los programas 00:22:18
los realizamos a través de entornos de desarrollo, 00:22:19
IDES. 00:22:22
IDES son las siglas 00:22:23
Integrated Development Environment, 00:22:25
entornos de desarrollo. 00:22:30
Cuando vamos a hacer un programa, pues primero tenemos que escribir su código. 00:22:30
Entonces lo hacemos en un ficherito que tenga extensión .java. 00:22:35
Como es un lenguaje Java interpretado, tendremos que compilarlo. 00:22:39
Compilar un programa en Java se realiza con un ejecutable que es Java, compilador de Java. 00:22:49
Y luego para de verdad ejecutarlo, tendremos que llamar el intérprete. 00:22:58
¿Os acordáis que os hablaba antes del intérprete? Pues el intérprete en Java se llama Java, que será diferente para cada plataforma hardware y el compilador será común en todas ellas. 00:23:03
Entonces, cuando nosotros trabajamos con un ordenador como clientes, que es lo más habitual, no como desarrolladores, que es el rol en el que estáis vosotros dentro de la asignatura, lo único que queremos es llamar al intérprete para programas ya desarrollados en Java, de los cuales nos habrán de alguna forma entregado el bytecode. 00:23:15
Igual va integrado dentro de otra aplicación, no lo vemos tal cual, pero sería el resultado de haber compilado a alguien, un programador, un programa, nos da el bytecode que probablemente esté en un fichero .class o en un fichero .hard porque de alguna forma han comprimido muchos .class para que hagan una función más global. 00:23:40
Y esto nosotros lo lanzaremos como usuarios normales con nuestro intérprete Java. Nosotros no somos en principio conscientes de que tenemos un intérprete en nuestra máquina, pero junto con el resto del software, sistema operativo, está ese intérprete que cuando lancemos nosotros la solicitud de ejecutar el bytecode, se pondrá en marcha y será capaz de interpretarlo y darnos el resultado que el programa tenga en marcha. 00:24:00
si nosotros queremos coger el rol de desarrolladores 00:24:27
entonces sí que tenemos que compilar el programa 00:24:32
y el compilador normalmente no está integrado en nuestros ordenadores 00:24:34
¿por qué? porque en nuestro día a día la gente no suele ser compilador 00:24:39
no suele ser programadora de Java 00:24:43
entonces lo que tenemos que hacer es instalar el JDK 00:24:44
JDK son las siglas de Java Development Kit 00:24:48
de desarrollo para realizar programas en Java y este JDK es el que incluye el compilador de Java 00:24:53
y el JDK también instala ya un JRE que está relacionado con JRE que es el Java Runtime Environment 00:25:03
en torno de ejecución de Java que digamos que es el que podría tener el intérprete. 00:25:13
En definitiva, para poder compilar nuestros programas hechos en C, necesitamos un compilador que viene integrado en este paquete y en vuestro ordenador. Si vosotros no queréis utilizar la máquina virtual que os proporciono yo en el aula, tendréis que instalar el JDK y si utilizáis la máquina virtual que os he proporcionado, pues ya me he preocupado yo de que esté integrada. 00:25:21
nosotros pasito a pasito podemos utilizar un editor 00:25:46
para hacer nuestro fichero .java, llamar 00:25:51
al compilador para obtener el bytecode 00:25:55
y luego llamar al intérprete que es java 00:25:58
para ver el resultado de nuestro programita, esto lo podemos hacer pasito 00:26:02
a pasito o podemos utilizar un IDE que integra todas estas aplicaciones 00:26:07
y además nos da muchísimos más servicios para que nos vaya resultando 00:26:11
cuando estemos haciendo grandes proyectos no vaya resultando más fácil que no tener que trabajar 00:26:15
con herramientas tan con herramientas tan simples como las que os comentaba las formas hoy vamos a 00:26:20
hacer un pequeño un mini programa típico programa hola mundo utilizando permitirme la expresión a 00:26:26
pelo estas herramientas e ignorando de momento el id vamos a ello la máquina no está no es la 00:26:32
máquina virtual la máquina virtual la tengo por aquí abrimos un terminal en la máquina virtual 00:26:45
que os he pasado y bueno la máquina virtual está basada en una versión de debian con el 00:26:50
jd que ha instalado tiene un y de que se clase instalado otro y de que no vamos a utilizar pero 00:26:57
el de uso muy didáctico por si alguien quiere investigar un poquito que es el blue jota y tiene 00:27:03
aquí instalado también PSINT que nos sirve para definición de pseudocódigo, que es algo que 00:27:09
trabajaréis más en entornos de desarrollo, aunque en este tema 1 de programación os hablo algo de 00:27:16
ello y no voy a entrar mucho en detalle porque en realidad se escapa un poco del ámbito de lo que 00:27:20
pedimos en programación y dedicaré más el tiempo a Java más que a PSINT, independientemente como os 00:27:28
decía ayer de que si tenéis alguna duda me la preguntéis en el foro e intento 00:27:35
echaros una mano. Ahora voy a hacer algunas cuantas cosas que son 00:27:39
comandos en terminal de linux que no tenéis por qué conocer y no os 00:27:46
preocupéis en exceso porque tampoco van a ser requisito para esta asignatura. Si 00:27:53
en la asignatura en sistemas informáticos trabajaréis con estos 00:27:57
comandos, ahí os los pedirán, yo no, pero bueno para enseñaros ciertas cosas es 00:28:00
imprescindible tener que utilizarlos y hacer comando which nos permite localizar un programa 00:28:05
ejecutable dentro del sistema archivo en linux entonces por ejemplo el intérprete java se pone 00:28:12
el wish java nos dice que se encuentra en esta ruta este sistema operativo linux organiza los 00:28:17
directorios y los archivos empezando en algo que es una barra que podría ser el equivalente en 00:28:25
windows para los que estén más familiarizados con una unidad de disco por ejemplo la unidad 00:28:31
de disco c o la unidad de disco de esa parte de ahí hay directorios de ahí cuelgan otros 00:28:36
directorios en algunos también hay archivos en linux es un poco la misma idea lo único que en 00:28:41
lugar de empezar con una unidad de disco empezamos con la barra y en particular el intérprete de java 00:28:47
se encuentra en esta ruta que si os fijáis por aquí dentro de la ruta aparece algo como jdk 00:28:54
que es ese Java Development Kit, ese entorno 00:28:59
de desarrollo, digamos, que he instalado yo en este Debian 00:29:04
para que podamos realizar programas con él. Aquí, ayer 00:29:07
había realizado, había creado un directorio 00:29:19
prueba que en Linux se puede crear con mkdir 00:29:23
vamos a poner un prueba2, pues ahora 00:29:26
si pongo un ls que nos lista la información que hay dentro de 00:29:31
dentro de un directorio en particular pues ya veremos que tenemos prueba y probados que acabo 00:29:35
de crear en el directorio prueba que hice ayer tenemos esta información voy a borrar los ficheros 00:29:40
que no me interesan voy a borrar todo si lo hago desde cero vamos a crear un fichero que vamos a 00:29:49
llamar prueba o hola y vamos a poner extensión punto java porque en punto en ficheros con 00:30:03
extensión punto java es donde ponemos nosotros nuestro código en este lenguaje y aquí vamos a 00:30:11
poner código que es código java definimos una clase que vendría a ser una clase del estilo de 00:30:17
la persona o alumno de las que os hablaba antes pues sería un actor que participaría en nuestro 00:30:24
programa y dentro de esta clase ponemos unas llaves que identifican el ámbito donde trabaja 00:30:29
esta clase. Vamos a poner pública aquí, ya os contaré estas etiquetas para qué sirven. Dentro de la clase 00:30:36
hola vamos a definir un método de los que hablábamos antes, algo que va a realizar una 00:30:45
acción. Entonces hay todo programa cuando proyecto en java cuando lo vamos a realizar tiene un punto 00:30:50
de inicio y este punto de inicio es un método que se llama main el método principal que tiene aquí 00:30:58
he puesto unas cuantas palabritas que iremos conociendo etiquetas main el nombre del método 00:31:09
como decía los métodos van entre llaves y a veces pueden tener cierta información aquí esto 00:31:15
probablemente el próximo día os lo cuente y si no algo más algo más adelante pero de momento 00:31:24
no os preocupéis demasiado. Simplemente sabéis que este método es el punto 00:31:29
de inicio desde el que igual se va a ejecutar nuestro programa. 00:31:33
¿Y qué vamos a hacer en este main? Vamos a utilizar 00:31:37
un método que es el método println 00:31:40
que está definido en una clase que es la clase 00:31:50
system.out. Y diremos, esta clase no la hemos definido. 00:31:55
Efectivamente, tenemos bastante suerte y es algo común 00:31:59
a muchos de los lenguajes y es que cuando se realiza un lenguaje aparte se crea un montón 00:32:02
de código para que se lleven a cabo ciertas acciones que típicamente vamos a utilizar 00:32:08
nuestros programas y de esta forma no tengamos en cada uno de nuestros programas que implementar 00:32:13
ese código. En particular System.out, hablaremos de ello, lo que hace es sacar por consola, 00:32:19
por la pantallita algo que imprime y en este caso va a ser hola dam sería un primer hola mundo 00:32:27
entonces el código java que tenemos entre manos es la clase hola el método main punto de inicio de 00:32:35
mi proyecto y lo único que hace este método es mostrar por pantalla con un println hola mundo 00:32:41
hola dam perdón este println está en realidad codificado en algún sitio que donde es en las 00:32:47
librería de Java y está disponible 00:32:59
porque se importa en nuestro proyecto 00:33:01
lo tenemos importado en nuestro proyecto 00:33:03
para poder utilizarlo 00:33:05
junto al resto del código Java 00:33:07
que sí que pongamos nosotros 00:33:09
y que intentará dar solución particular 00:33:10
a los requisitos que se nos piden 00:33:13
para nuestro programa. Bueno, una vez 00:33:15
hecho nuestro ficherito 00:33:18
Java con un editor 00:33:20
comando more en Linux nos permite 00:33:22
ver el contenido sin editarlo, fijaros 00:33:25
ahí lo tenemos 00:33:27
¿Qué es lo que tenemos que hacer? Hemos dicho 00:33:28
con un programa punto java pues lo primero que tenemos que hacer es compilar lo cual era el 00:33:31
compilador de java javas como podemos ver dónde se encuentra pues con el comando wii 00:33:35
entonces llamamos a este programa compilador de java que está en esta ruta digamos y decimos que 00:33:43
lo que queremos es compilar el código que hemos puesto nosotros el lenguaje java se toma un 00:33:52
momentito y ahora si hacemos un ls aquí vemos que junto con el o la punto java ya tenemos el 00:33:59
hola.class y este hola.class ya no está desarrollado en código java tal cual, sino que está en bytecode. 00:34:04
De hecho, si ponemos aquí un mor de hola.class, vemos que ya nos entiende el código con tanta facilidad 00:34:13
como el .java, aunque sí que vemos algunas palabras por ahí. Pero es ese bytecode que vas a ver el intérprete 00:34:21
de java leer para convertirlo al código máquina que es donde se está ejecutando el programa que 00:34:27
será dependiente de la plataforma hardware cuál es el intérprete de java hemos dicho java que 00:34:37
donde se encuentra pues se encuentra en la misma ruta que el compilador entonces para aquí es donde 00:34:46
tenemos el bytecode fijaros para ejecutar nuestro programa vamos al intérprete e indicamos 00:34:55
el bytecode que sería en principio punto clas pero el intérprete me gusta más que no se lo 00:35:07
pongamos el punto clase entonces vamos aquí y fijaros como el resultado de nuestro programa 00:35:13
es que nos muestra por pantalla hola damm que realmente lo que habíamos puesto nosotros que 00:35:17
sucediese cuando se ejecutase el método main que es el punto inicio el programa hacia una 00:35:25
salida por pantalla de hola dam y efectivamente si volvemos a lanzar la ejecución es el resultado 00:35:29
que obtenemos es decir hemos con el editor nano editado un fichero punto java hemos metido ahí 00:35:36
el código lo hemos compilado con el compilador java nos ha dado el base code con el fichero con 00:35:45
extensión punto clash y hemos llamado al intérprete java y nos ha lanzado la ejecución convirtiendo 00:35:51
ese bytecode al código máquina 00:35:59
que entiende la plataforma 00:36:01
donde está corriendo 00:36:03
la plataforma hardware y nos ha soltado 00:36:05
el holadam este 00:36:07
dicho esta, esta secuencia es la última 00:36:08
vez que vamos a utilizar ya, vamos a hacer 00:36:13
un programita, aunque este era muy sencillote 00:36:15
a través de un terminal, a partir 00:36:17
de ahora ya utilizaremos IDES 00:36:19
que nos resultan mucho más cómodos 00:36:21
para ir haciendo nuestros programas 00:36:23
entre los IDES 00:36:25
hay diferentes, está 00:36:27
de DIN, si está Eclipse, Intelij, bueno pues yo he elegido Eclipse. Si alguien quiere utilizar 00:36:29
algún otro, no es un inconveniente para la asignatura porque nos vamos a centrar en Java. 00:36:39
Bueno, si elegís otro y tenéis que hacer alguna cosa en la opción de menú en particular, pues yo 00:36:44
estaré menos familiarizado, igual os puede ayudar un poquito menos, pero si alguien 00:36:50
ya viene programando desde hace tiempo y le apetece utilizar otro, pues no es problema. 00:36:54
Bueno, ayer cuando abríamos no había nada. Hoy ya tenemos el ejercicio de ayer, el hola mundo desde Eclipse. Y os cuento un poquito lo que os decía, aunque no cogeis los programas desde cero, o si ya veremos. 00:37:02
Mirad, cuando Eclipse empieza a guardar toda la información de los trabajos, de los proyectos que hagamos en un espacio de trabajo que podemos nosotros seleccionar cuando instalamos por primera vez Eclipse. 00:37:21
¿Dónde dije yo que tuviese su espacio de trabajo la instalación de Eclipse que tenemos en nuestra máquina virtual? 00:37:36
Pues en el directorio pwd nos dice el directorio actual, barra home, barra devian, y cree un directorio que se llama Eclipse Workspace. 00:37:45
Si nos vamos a este directorio, veréis que existe dentro del espacio de trabajo Eclipse, existe un único directorio, que es el directorio hola, 00:37:54
Que coincide con el proyecto que habíamos creado ayer. Vamos a crear otro proyecto diferente. Vamos a poner el proyecto Hola2. Automáticamente se ha venido aquí y ha creado un directorio Hola para un primer proyecto, un directorio Hola2 para un segundo proyecto. 00:38:06
Os comentaba también ayer que a la hora de crearse un proyecto, de momento vacío, o la 2, se crea este ficherito que permite meter unas directrices para ver cómo luego diferentes clases en proyectos grandes son capaces de interactuar unas con otras. 00:38:29
Al menos de momento, para nuestros programas que van a ser muy pequeños, vamos a borrar esto. No vamos a querer considerarlo, que nos va a traer inicialmente más problemas que beneficios, aunque a la larga para proyectos grandes es algo que podría llegar a resultarnos útil. 00:38:48
tenemos nuestro proyecto y el proyecto si nos venimos aquí, fijaros se ha creado la 2, si pongo aquí o la 2, me voy a la 2, tenemos dos directorios, uno src y otro bin, en el src es donde se van a ir guardando 00:39:02
los ficheros que vayamos creando punto java es decir con el código fuente y una vez compilados 00:39:19
se irán guardando en el directorio bien es decir como una vez compilados se irán creando aquí los 00:39:25
ficheros punto clash que serán los que tengan el base code de aquellos ficheros punto java con 00:39:32
código fuente que tengamos en sr vamos a crear una clase para replicar el ejercicio que habíamos 00:39:37
dicho antes aquí desde terminal, en este proyecto, entonces cogemos 00:39:46
y decimos new class, y esta class 00:39:50
la vamos a llamar hola2. Fijaros, hola2, aquí 00:39:54
nos muestra el clase, un fichero con extensión .java, y si nos venimos aquí 00:40:01
ahora, cdsrc, nos ha metido 00:40:05
ese ficherito .java en la ruta del proyecto hola2 00:40:09
src. Si me voy a bin y pongo el s, ya 00:40:13
directamente el crearlo, aunque esté vacío, ya me he creado un bytecode que será respuesta de la 00:40:20
información que tenga el punto java en el que se encuentra en el directorio src. Y ahora vamos a 00:40:26
poner aquí el mismo código que me había puesto antes. public static void main string rs, entre 00:40:34
llaves para el método esto el método esto la clase el método main que es el 00:40:49
punto de inicio del programa y sacamos por pantalla 00:40:54
utilizando el método println que lo tenemos disponible de librerías en java 00:41:00
porque nosotros no lo hemos programado hola desde eclipse ponemos 00:41:06
Entonces salvamos aquí, en la ruta src del proyecto tenemos el ficherito .java, en la ruta bin tenemos el ficherito .class con el base code asociado a este código que hemos puesto. 00:41:16
es decir, Eclipse 00:41:39
automáticamente está llamando al compilador Java 00:41:42
y va creando según el código fuente 00:41:45
que pongamos aquí, según vayamos dando al botón 00:41:49
salvar también, va creando el bytecode 00:41:51
el punto class asociado 00:41:55
para ejecutarlo, que habíamos hecho desde el terminal 00:41:57
pues habíamos llamado al intérprete de Java 00:42:01
aquí que podemos hacer, pulsar el botón run 00:42:02
por ejemplo, o a través de la opción run 00:42:06
run aquí, entonces si pulsamos 00:42:08
fijaros como 00:42:11
nos inicia el proyecto 00:42:13
busca el punto de entrada 00:42:15
que es el main, ejecuta su 00:42:17
código y esta ejecución del código 00:42:19
nos saca por consola 00:42:20
igual que había pasado antes, uno la 00:42:22
desde Eclipse 00:42:24
directamente tiene ya también 00:42:25
una ventanita de consola para ir 00:42:28
nos dando este tipo de resultados 00:42:31
con el IDE hemos podido hacer todo mucho más 00:42:32
integrado y con mucha más 00:42:36
a través de botones que no como lo habíamos hecho a través de a través del terminal y bueno si no me 00:42:38
dejo nada yo creo que esto es todo lo que aunque dándole más tiempo y con más calma y atendiendo 00:42:48
vuestras posibles consultas estos fueron los conceptos que vimos ayer en la tutoría así que 00:42:53
aquí paro y si tenéis alguna cuestión me preguntéis en los foros y si no en la próxima tutoría nos 00:42:59
vemos. Un saludo. 00:43:06
Autor/es:
JM
Subido por:
Jose Manuel M.
Licencia:
Reconocimiento
Visualizaciones:
155
Fecha:
15 de octubre de 2024 - 10:13
Visibilidad:
Clave
Centro:
IES ALONSO DE AVELLANEDA
Duración:
43′ 10″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
66.17 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid