Saltar navegación

Intro Prog 2 - 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 16 de septiembre de 2025 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, esta es la segunda clase. Vamos a seguir de donde hemos dejado ayer. Estamos hablando de compilador e intérprete. Si habláis, me autorizáis a grabar vuestra voz en la grabación. 00:00:01
¿Vale? Entonces, aquí tenemos un esquema que lo que hace es comparar un poquito compilador e intérprete en base a algunos parámetros. ¿Vale? Por ejemplo, hablamos de la entrada, de lo que recibe el input. ¿Vale? Un compilador necesita el programa completo entero, hemos dicho. 00:00:17
Entonces, si ha acabado mi programa, se lo paso y a este punto el compilador creará lo que tenga que hacer. 00:00:36
Un intérprete, en vez de va línea por línea de código, interpreta siempre una sola línea. 00:00:43
Yo podría hacer hasta un programa parcial, ejecutarlo en un intérprete y ver hasta dónde llega. 00:00:48
La salida, el compilador crea un código objeto, crea un código máquina, digamos así, 00:00:55
que luego será enlazado con las librerías y se podrá ejecutar. 00:01:01
Sin embargo, el intérprete no produce un código objeto, porque simplemente recibirá la línea y esa línea hará algo para que se ejecute, ¿vale? 00:01:05
Pero no me crea un fichero donde yo puedo ver la traducción, digamos así, ¿sí? 00:01:17
Mecanismo de trabajo. La compilación se realiza antes de la ejecución, o sea, que yo antes hay una fase de compilación en la que compilo mi programa 00:01:24
Y ahora que tengo el programa ejecutable, lo ejecuto, mientras que la compilación y ejecución se realizan simultáneamente en el intérprete. 00:01:33
¿Qué quiere decir? Que es como si cada línea de código yo la compilaras, no el programa entero, más línea por línea, 00:01:42
y una vez compilada en lenguaje que puede entender el procesador, pues lo ejecuto. 00:01:50
¿Entiendes? 00:01:56
velocidad 00:01:57
el compilador suele ser más rápido 00:01:59
en el sentido de lo que se produce 00:02:03
con el compilador, el programa compilado 00:02:04
suele ser más rápido 00:02:07
por respecto a un programa interpretado 00:02:08
que es más, por lo que hemos 00:02:10
dicho antes, que 00:02:12
la compilación aquí la hago una vez 00:02:13
sola, al principio, luego ya 00:02:16
tengo todo compilado, mientras aquí 00:02:18
hasta si yo repito un mismo trozo 00:02:20
de código, lo vuelvo a 00:02:22
compilar, a interpretar una y otra 00:02:24
vez y otra vez por lo tanto es más de memoria el requisito de memoria es más debido a la creación 00:02:26
de código objeto vale tener en cuenta que si yo tengo un compilador lo que quiero hacer a 00:02:33
nivel de memoria secundaria nivel de espacio físico tengo mi código original y tengo que 00:02:38
crear un nuevo fichero que tendrá dentro mi código compilado y todas las librerías compiladas 00:02:43
enlazadas dentro. Entonces, posiblemente 00:02:50
el ejecutable viene una cosa grande. 00:02:53
¿Sí? 00:02:56
Sin embargo, a nivel 00:02:56
de intérprete, requiere menos memoria 00:02:59
física, digamos, menos memoria secundaria 00:03:01
porque no se 00:03:03
crea un código intermedio. Es simplemente 00:03:05
leo el origen y lo ejecuto. 00:03:07
No hay otro fichero. Hay el fichero 00:03:09
origen y su ejecución. 00:03:11
¿Sí? 00:03:13
Sin embargo, podríamos 00:03:15
razonar sobre memoria principal, 00:03:16
o sea RAM, que 00:03:19
dependerá. Porque tened en cuenta que esto 00:03:20
necesitará sólo la memoria 00:03:23
del programa, mientras que 00:03:24
el intérprete necesita la memoria 00:03:27
del programa y también la memoria 00:03:29
para ejecutar el intérprete. 00:03:31
Que gastará recursos. 00:03:33
A lo mejor es un intérprete ligero. 00:03:34
Pero algo gastará. 00:03:36
Los errores. 00:03:39
El compilador muestra todos 00:03:41
los errores después de la compilación. 00:03:42
Todos al mismo tiempo. Entonces si yo le doy a 00:03:44
compilar, y me empezará 00:03:46
decir aquí falta un punto y coma y no has puesto me esperaba que tú pusiera 00:03:49
esto en vez de has puesto este otro aquí falta una paréntesis después de verlo 00:03:54
compilar sin embargo el intérprete yo lo puedo lanzar y él cuando llega a la 00:03:58
línea que da problemas pues hasta allí ha funcionado y allí me dice a ver mira 00:04:02
aquí hay un error entonces a nivel de debugging esto puede ser una cosa más 00:04:07
interesante de utilizar la recepción de errores a nivel de 00:04:11
compilación es más compleja vale justo porque te da errores de golpe y a lo mejor los errores que 00:04:17
te da el compilador no es el error de verdad a lo mejor tú has hecho un error al principio que 00:04:23
te has olvidado un punto y coma y entonces el arrastra este problema intentando entender lo 00:04:29
que viene después de este punto de coma pero a lo mejor se equivoca que a lo mejor te dice 00:04:35
mira aquí falta una paréntesis pero en realidad no falta una paréntesis falta paréntesis porque 00:04:38
Él ha contado mal porque a raíz de ese punto y coma 00:04:42
ha arrastrado un error y ya no entiende que es el programa. 00:04:45
Entonces luego tú pones ese punto y coma 00:04:49
y el error que era allí de la paréntesis 00:04:51
se soluciona mágicamente. 00:04:52
Es un poquito más complejo. 00:04:56
También porque quien ha hecho este compilador, 00:04:58
quien ha hecho el programa del compilador, 00:05:01
tiene que haber hecho un buen trabajo 00:05:02
para que el compilador te dé información 00:05:04
sobre cuál es el error. 00:05:09
qué ha pasado, por qué te estoy diciendo 00:05:10
que hay un error. 00:05:13
Es comparativamente más fácil 00:05:15
cuando hay un intérprete, justo porque, siempre 00:05:17
es mejor la razón, yendo línea por línea, 00:05:18
tú puedes llegar hasta un cierto momento, hasta aquí ha ido todo bien, 00:05:20
y ahora, ¿qué pasa? 00:05:23
Lenguaje de programaciones 00:05:26
que son 00:05:27
con compilador, C, C++, 00:05:29
C Sharp, 00:05:31
Dice, Script, 00:05:33
Scala, no lo conozco, 00:05:35
hay varios, 00:05:37
típicamente C++ y C Sharp hoy en día se utilizan 00:05:39
información así, no sé como se llama, pero para que lo sepáis, C Sharp en realidad es C++++ 00:05:47
son cuatro más, pues el intérprete en vez de interpretado son Java 00:05:55
php, perl, python, ruby, estos lenguajes de programación tienen un interno 00:06:05
en realidad ya va muy bien 00:06:12
dudas? va, otro tema, paradigmas de programación 00:06:16
vale entonces esto ya un poquito lo hemos hablado vale pero es un paradigma de 00:06:25
programación es a la hora de programar un sistema complejo como me enfoco como 00:06:30
lo diseño, qué herramientas tengo, qué tengo en cuenta, cómo me pongo a trabajar. Nosotros 00:06:37
empezaremos o hablaremos de programación estructurada. Los primeros ejercicios que 00:06:45
haremos estarán en este paradigma y luego iremos escalando. Cuando hablamos de programación 00:06:49
estructurada, se utiliza una técnica que genera programas que solo permiten utilizar 00:06:55
tres estructuras de control. 00:07:02
Secuencias, alternativas 00:07:05
e iterativas. 00:07:07
Es decir, que cuando estamos aquí 00:07:08
podemos hacer tres cosas con nuestros programas. 00:07:10
La primera es la secuencia. 00:07:13
Haz este 00:07:15
comando, luego el siguiente, luego el siguiente, 00:07:15
luego el siguiente. Un bloco de instrucciones 00:07:19
ejecutados en secuencia. 00:07:21
La base. 00:07:22
Pero también tenemos los condicionales 00:07:24
o alternativas. Yo puedo decir 00:07:27
a mi programa, oye, mira, cuando llegas aquí 00:07:29
Comprueba una condición. Mira si este valor es mayor que 3. Mira si el usuario te ha dado ya su nombre. 00:07:31
Mira si este trozo de memoria está lleno o no. En base a la verdad o no verdad de esta condición, ejecuta un trozo u otro trozo. 00:07:41
esto se suele llamar 00:07:56
las sentencias is 00:07:59
o las sentencias condicionales 00:08:00
yo llego aquí, hasta ahora 00:08:03
hacia secuencial esto, esto, esto 00:08:05
y hago un momento que digo, si 00:08:07
esta condición es verdadera 00:08:08
si un número que me has 00:08:11
dado es mayor que 10 00:08:13
entonces sigue con este bloque 00:08:14
de instrucción, si es 00:08:17
falso, si el número que me has dado es menor 00:08:19
o igual a 10, pues entonces 00:08:21
el bloque de 00:08:23
las instrucciones que tiene que ejecutar no es éste, sino es éste otro. Entonces se crean dos 00:08:25
posibilidades, dos posibles ejecuciones, dependiendo de la condición que se verifica. Estas se llaman 00:08:31
condiciones. Y luego están los iterativos. O sea, yo tengo un bloque de instrucciones y quiero que 00:08:41
este bloque de instrucciones se repita una y otra vez y otra vez y otra vez, por ejemplo, mientras 00:08:47
que una condición sea verdadera. Mírame si este número es 10. Mientras que este 00:08:52
número es 10, haz este bloque y vuelve a comprobar que si este número es 10. 00:08:58
Si sigue siendo 10, pues sigue. Si sigue siendo 10, pues sigue. Cuando este número ya no será 10 00:09:04
por alguna razón, pues sáltate este bloque y sigue abajo de este bloque. 00:09:09
son el while o el for, los núcleos, etc. Entonces, con estas tres cosas, la posibilidad de hacer 00:09:17
comandos secuenciales, la posibilidad de decir, este comando hazlo, pero solo si una condición, 00:09:24
si no hace otra cosa. Y la posibilidad de decir, oye, mira, este bloque lo tienes que repetir 00:09:31
unas cuantas veces, ¿vale? Pues puede hacer programación estructural. Y es la base de la programación 00:09:37
que nosotros tenemos que aprender. 00:09:44
¿Vale? Entonces, 00:09:47
el primer trimestre 00:09:48
será principalmente orientado 00:09:49
a que nosotros entendamos bien 00:09:52
esta cosa. 00:09:54
¿Sí? Ahora, cuando nosotros 00:09:56
sabemos ya hacer la programación 00:09:58
estructurada, sabemos trabajar con la programación 00:10:00
estructurada, pues hay 00:10:02
paradigmas que son más potentes de la 00:10:04
programación estructurada. Estas herramientas 00:10:06
son las básicas, pero son 00:10:08
un destornillador y un 00:10:10
martillo, y ahora tienes que 00:10:12
construir un castillo. Y con un 00:10:14
destornillador o un martillo no se construyen 00:10:16
muchos castillos. Se necesitan 00:10:18
otras herramientas. A lo mejor 00:10:20
lo puedes hacer, pero tardarías mucho. 00:10:21
¿Vale? Y no te sale un gran mercado. 00:10:24
Entonces, se cambió 00:10:26
de paradigma de programación 00:10:28
¿Vale? Hacia la programación 00:10:30
modular. La programación modular me dice 00:10:32
simplemente que lo que sabemos 00:10:34
hacer en programación estructurada 00:10:36
vamos a hacerlo por módulos. 00:10:37
O sea que cuando yo 00:10:41
me enfrento a un programa complejo, a un sistema complejo, a un sistema grande, a un programa que 00:10:42
tiene una cierta dificultad, en vez de enfrentarme a él en programación estructurada simplemente 00:10:51
tirando código, antes hago una fase de diseño. Lo divido en bloques, en módulos. Cada módulo 00:10:56
será dependiente de alguna forma con los otros módulos y habrá una forma, un módulo general, 00:11:05
que será como el organizador de los otros módulos. 00:11:11
Si vosotros pensáis a un sistema operativo, 00:11:14
que todavía no lo habéis visto, no lo veréis, 00:11:16
hay un kernel, ¿vale? 00:11:18
Que es el núcleo, es la parte que hace las cosas de verdad 00:11:20
del sistema operativo. 00:11:24
Y luego hay un montón de otros módulos 00:11:26
que se conectan con este kernel. 00:11:28
Por ejemplo, hay un módulo que se encarga 00:11:32
de la comunicación en red. 00:11:33
Entonces, todo lo que es comunicación en red 00:11:35
irá en el módulo de redes. 00:11:37
Habrá otro que se encarga de escribir y leer desde disco duro. 00:11:40
Entonces, habrá un sistema de gestión de entrada y salida que será otro módulo del sistema operativo. 00:11:46
Y así, así, así, otro que será la interfaz gráfica. 00:11:53
Entonces, todo lo que es la interfaz gráfica, el pillar donde va el ratón, los cliques del ratón, enseñarlo en la pantalla, etc. 00:11:56
Estará en el módulo de la interfaz gráfica. 00:12:04
Cada uno es separado de los demás y tiene sus propias funcionalidades y proporciona una interfaz, proporciona una forma para que otros módulos puedan pedirles de hacer cosas. 00:12:06
Es el kernel que le dirá al sistema de gestión de ficheros, oye mira, yo tengo esta información y el usuario me ha dado al botón guardar y por lo tanto quiero que estos datos tú me los escribas en el disco duro. 00:12:21
El kernel activa lo que tiene que activar para que se escriba en el disco duro 00:12:37
y será el módulo de escritura en ficheros que hará lo que tiene que hacer para escribir en el fichero. 00:12:41
Lo que se hace es pensar en varios módulos, diseñar mi sistema en módulos 00:12:48
para que cada módulo sea lo más independiente posible 00:12:54
y que a este punto yo pueda hasta separar el trabajo de los módulos. 00:12:57
asignar a un grupo de trabajo, un equipo 00:13:03
oye, vosotros vais a desarrollar 00:13:06
la parte gráfica, mientras 00:13:07
otro estará desarrollando el kernel 00:13:09
mientras otro estará desarrollando 00:13:11
cómo se acceden a los ficheros. Y estos pueden 00:13:13
trabajar en paralelo porque 00:13:15
luego lo que contará 00:13:17
es la interfaz. Es 00:13:19
estos puntos de conexión 00:13:21
entre módulos que un módulo puede 00:13:23
pedir a otro. Si tú 00:13:25
respetas esos, luego cómo 00:13:27
se hacen las cosas dentro te da igual. 00:13:29
yo tengo la función escribe en fichero 00:13:31
como se escribe en fichero me da igual 00:13:34
será otro equipo 00:13:36
que lo desarrolle 00:13:37
pero yo sé que desde 00:13:39
el kernel puedo solicitar 00:13:42
escriben estos datos en fichero 00:13:44
con este formato, con este 00:13:46
modo, con este mecanismo 00:13:48
una vez que lo he hecho 00:13:50
ya he pasado la pelota a otro 00:13:52
módulo que 00:13:54
trabaja 00:13:56
esto es un poco la programación 00:13:57
modular. La programación modular evoluciona en la programación orientada a objetos. 00:14:00
En la programación orientada a objetos, en vez de hablar de módulos en general, lo que se 00:14:07
hace es hablar de clases y objetos. Entonces yo, por cada módulo en un cierto sentido, lo que hago 00:14:13
es estructurarlo 00:14:21
en base a agentes 00:14:23
no sé cómo definirlos 00:14:25
a ver si aquí viene algo 00:14:30
que me puede 00:14:33
unidades, ¿vale? Algo genérico 00:14:33
que representa 00:14:37
un trocito de mi 00:14:38
programa, y yo a este 00:14:41
trocito le doy todos los datos 00:14:43
que necesite, todas las funcionalidades 00:14:45
que necesitas, y una vez que lo he 00:14:47
implementado, yo lo tengo allí y lo puedo utilizar 00:14:49
allá donde lo necesite. Si yo creo la estructura que modeliza una persona, que entonces tendrá su 00:14:51
nombre, su apellido, su DNI, su edad, su... no lo sé, su dirección, etcétera, etcétera, etcétera. Una vez que yo he 00:14:58
definido esto con lo que puede hacer una persona, una persona puede saltar, una persona puede 00:15:05
saltar, una persona puede moverse, no lo sé. Lo que yo necesito para mi programa, una vez que lo tenga, 00:15:11
allá donde tenga que utilizar una persona, yo puedo reutilizar este objeto, esta clase. 00:15:16
Entonces, si ahora quiero modelizar alumnos, los alumnos son personas, 00:15:23
puedo utilizar la clase Persona para modelizar alumnos. Si ahora quiero modelizar profesores, 00:15:28
como los profesores también parece que no, pero son personas, pues entonces puedo reutilizar 00:15:34
también el módulo, o sea, la clase de personas para los profesores. Y así, así, así, ¿vale? 00:15:39
es una modularidad 00:15:46
pero quizás un poquito más 00:15:49
fina y al mismo tiempo más 00:15:51
abstracta, más genérica 00:15:53
yo hago clases 00:15:54
que representan conceptos más 00:15:56
genéricos y luego uso estas clases 00:15:58
en forma de objetos, veremos la 00:16:01
diferencia, para crear 00:16:03
lo que hace mi programa 00:16:04
se utiliza algo más interesante 00:16:08
como antes comunicaban entre sí 00:16:10
los módulos, ahora comunican entre sí 00:16:20
los propios objetos 00:16:21
las propias clases 00:16:24
entonces tengo mis objetos 00:16:25
creados y estos objetos podrán 00:16:27
interactuar entre ellos 00:16:29
pidiéndose cosas, haciendo 00:16:32
funciones, llamando 00:16:33
proceduras que 00:16:36
sustancialmente harán 00:16:38
Hacer al final lo que quiero que haga mi programa. 00:16:40
Si mi programa es una escuela, una gestión de escuela, 00:16:42
pues sí tendré, por ejemplo, que el aula puede añadir un alumno, 00:16:45
puede quitar un alumno, puede... 00:16:49
Bueno, sí, todas estas cosas. 00:16:52
¿Vale? 00:16:54
Hasta aquí, general. 00:16:57
¿Vale? 00:17:00
Hemos hablado de, en general, de lenguajes de programación genéricos. 00:17:00
Ahora vamos a meternos en lo que vamos a usar nosotros. 00:17:06
O sea, todo lo que hemos aprendido o que hemos oído hasta ahora de compilación, interpretación, orientado a objetos y cosas por el estilo, vamos a aplicarlo al lenguaje que hemos elegido nosotros, que he elegido nosotros para este curso, ¿vale? 00:17:08
Que es Java, o Java, o Java, dependiendo de dónde queréis colocar la pronunciación de esta palabra, ¿vale? 00:17:26
Es un lenguaje de programación orientado a objetos, ¿vale? 00:17:36
Entonces, es del paradigma más interesante de los que hemos visto. 00:17:39
Aún así, el primer trimestre nosotros ignoraremos casi toda la parte orientada a objetos y lo trataremos como estructural, ¿vale? 00:17:43
Y veremos que esto nos comporta un pequeño problema. 00:17:54
Que algunas cosas que deberían ser muy fáciles porque son programas sencillos, muy, muy sencillos, 00:17:59
pues nos vendrán con mucho código que no entendemos qué es, que tenemos que escribir y no entendemos por qué está allí. 00:18:05
Porque mi programa es esto y luego tengo que poner un montón de cosas antes y después para que funcione y para qué. 00:18:13
Pues el para qué lo veremos más adelante. 00:18:19
Lo veremos cuando entenderemos que es un objeto en una clase 00:18:21
Y entenderemos 00:18:24
Ah, he estado programando orientado a objetos desde el primer día 00:18:25
Y no lo sabía 00:18:28
¿Vale? 00:18:29
Pero, ok 00:18:30
Su objetivo fundamental es crear aplicaciones independientes de la plataforma 00:18:31
Subyacente 00:18:36
Write once, run everyone 00:18:37
¿Qué quiere decir? 00:18:39
Java está pensado para que sea portable 00:18:40
¿Vale? 00:18:42
Java está pensado para que tú escribas un programa 00:18:44
Y que este programa se ejecute en cualquier sistema 00:18:46
¿Ve? 00:18:49
Es un poco la filosofía parecida a la interpretación, ¿sí? 00:18:50
O sea, yo lo que necesitaría es que en los ordenadores esté instalado algo, ¿vale? 00:18:55
Ese algo es la Java Virtual Machine, la máquina virtual de Java, que actuará más o menos como intérprete. 00:19:02
Entonces, cuando yo quiero usar Java en algún ordenador, la primera cosa que tengo que hacer es instalar allí algo que permita la ejecución de la Java Virtual Machine, del intérprete de Java. 00:19:11
Ese algo es el JRE, Java Runtime Environment, si yo quiero solo ejecutar, o el JDK, el Java Development Kit, si yo quiero además de ejecutar, pues también programar. 00:19:28
Para nosotros que somos desarrolladores, nosotros instalaremos el jdk. 00:19:47
Pero una vez que yo he hecho mi programa, para que se ejecute, 00:19:53
el requisito es que esté instalado un JRE, o sea un Java Runtime Environment, 00:19:57
un entorno de ejecución de Java, en el ordenador donde voy a ejecutar. 00:20:04
Pero ya que escribo mi programa una vez, y lo puedo ejecutar donde me da la gana. 00:20:12
es lo que decíamos antes, el de la compilación 00:20:18
y de la 00:20:20
interpretación, ahora yo quiero 00:20:21
escribirlo una vez, instalaré 00:20:24
si lo quiero ejecutar en este ordenador 00:20:26
lo único que tengo que hacer es instalar en este ordenador 00:20:28
el JRE y ya me funciona 00:20:30
no tengo que compilar nada 00:20:32
para este ordenador, allá donde 00:20:34
haya la posibilidad 00:20:36
de instalar un JRE 00:20:38
mi programa funcionará 00:20:40
pero 00:20:42
Java es un poquito particular 00:20:48
¿Por qué usa las dos cosas? 00:20:50
Usa tanto un compilador como un intérprete. 00:20:55
Java hace dos fases. 00:21:00
Primero hace una compilación y después interpreta esta compilación. 00:21:01
Hemos dicho que el compilador lo que hace es traducir de un idioma, de un lenguaje a otro. 00:21:08
En vez de tener un compilador que traduce de mi lenguaje a código máquina, que es la compilación estándar, Java hace una traducción desde Java, como lo conocemos nosotros, a un lenguaje intermedio que se llama el bytecode. 00:21:14
el bytecode es un lenguaje raro que nosotros no vemos 00:21:33
que no es lenguaje máquina 00:21:38
pero está a mitad entre lenguaje de alto nivel 00:21:40
que es el Java que conocemos nosotros 00:21:45
y el lenguaje máquina que está por abajo 00:21:46
el intérprete, el Java Virtual Machine 00:21:49
no interpreta líneas de códigos de Java 00:21:52
sino que interpreta líneas de códigos de bytecode 00:21:55
Es decir, que si yo tengo un programa en Java, esto se compila en un programa en bytecode, 00:21:58
y luego por algún lado estará la Java Virtual Machine, que recibirá línea por línea estos comandos y los ejecutará en el ordenador que está por debajo. 00:22:18
¿Por qué esto? Por lo que decíamos antes. Porque en esta fase de compilación, yo puedo meter un poquito de optimización. 00:22:38
Yo he escrito mi programa y cuando lo voy a compilar, el bytecode que sale ya está un poquito más optimizado, 00:22:48
está un poquito más organizado respecto al Java que he escrito yo. 00:22:55
Y aquí puedo meter también todas las cosas positivas de la compilación, como por ejemplo, 00:22:59
oye, si hay algún error 00:23:06
o cosa por el estilo, detectalo y dime 00:23:08
que error es, entonces lo puedo 00:23:10
contar, por ejemplo, errores sintáticos 00:23:12
¿vale? una vez que tengo 00:23:14
compilado esto, sé que el bytecode 00:23:16
a nivel sintático está bien 00:23:18
no hay errores sintáticos 00:23:20
ya no puedo a un cierto momento ejecutar 00:23:21
un programa y decir, ah, falta un punto y coma 00:23:24
o no sé qué hacer, pues esto 00:23:26
ya se ha comprobado en esta fase 00:23:28
¿vale? claramente 00:23:30
los errores semánticos, eso 00:23:31
no lo puedes detectar, ni esto, ni esto 00:23:34
que yo lo que decíamos antes 00:23:36
si el área del triángulo la he calculado como base 00:23:38
por altura y ya está, pues el error es 00:23:40
mío, he fallado yo en el 00:23:42
algoritmo, no él 00:23:44
¿sí? ¿dudas? 00:23:45
vale 00:23:54
compilación en Java 00:23:54
entonces tengo el editor, el editor 00:23:57
en Java es un texto plano, o sea un editor 00:23:59
de texto plano, puedo yo, de hecho 00:24:01
nuestro primer programa que lo vamos a hacer en breve 00:24:03
será con Notepad 00:24:05
¿vale? o sea cualquier 00:24:07
editor de texto plano es 00:24:09
un editor de Java, no me importa. 00:24:11
No se puede programar en Word, 00:24:13
pero sí en blocnotas. 00:24:16
¿Vale? Sabéis que Word añade 00:24:17
cosas detrás que nosotros no vemos 00:24:19
y que son lenguajes de marcas 00:24:21
raros suyos propietarios 00:24:23
que nosotros no queremos ver. Y si yo 00:24:25
luego intento interpretar eso, pues hay 00:24:27
todas estas datos que no sé qué son. 00:24:29
En vez de blocnotas, lo que yo he escrito 00:24:31
allí y que se vea es lo que se ha escrito en el fichero. 00:24:33
Con eso, puedo editar 00:24:35
un lenguaje. Lo que hago 00:24:37
es obtener un programa fuente a través del editor hago una compilación con un programa que se llama 00:24:39
java java compiler vale esto me crea un programa punto clas vale mientras el programa fuente está 00:24:45
en un punto ya el bytecode está en un punto clas y esto es el fichero interpretable por la java 00:24:53
virtual machine. Entonces ahora yo tendré instalada la 00:25:03
virtual machine, la enciendo y le voy a pasar el bytecode como input. La 00:25:07
virtual machine leerá línea por línea el bytecode y lo traducirá al código 00:25:14
máquina y lo ejecutará. La cosa interesante es que yo esto lo he escrito una vez 00:25:19
en cada ordenador distinto, Linux, Windows o no sé qué, está instalado en la virtual machine 00:25:25
yo esto lo compilo una vez 00:25:30
y obtengo el bytecode 00:25:33
este bytecode ya se ejecuta 00:25:34
en cualquier dispositivo 00:25:37
que tenga la Java Virtual Machine 00:25:38
el bytecode es independiente 00:25:40
del hardware y del sistema operativo 00:25:47
que está preparado, esta es la parte interesante 00:25:48
entonces es muy 00:25:50
portable 00:25:53
tengo el programa fuente 00:25:54
lo compilo en bytecode 00:25:56
y ahora la Java Virtual Machine 00:25:58
para la máquina 1 que es un Windows 00:26:01
se ejecutará con el código máquina 00:26:02
de la máquina 1, esto que es un Linux 00:26:04
tendrá una Java Vector Machine distinta 00:26:06
pero pillará el mismo bytecode 00:26:08
para ejecutarse, la Java Vector Machine está aquí 00:26:10
que es de Mac, será una Java Vector Machine 00:26:12
distinta, pero no la hago yo 00:26:14
no la programo yo la Java Vector Machine 00:26:16
habré instalado el 00:26:17
JRE, el Java Runtime 00:26:20
Environment, para 00:26:22
ese sistema operativo 00:26:24
y el bytecode es el mismo y se ejecutará 00:26:26
en la tercera máquina 00:26:28
Vamos a hacer una pequeña pausa ahora 00:26:29
y luego seguimos con el concepto de la política 00:26:47
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
16 de septiembre de 2025 - 13:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
226.60 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid