diff --git a/008_java_oo/README.md b/008_java_oo/README.md index c61a8ea..8262f9d 100644 --- a/008_java_oo/README.md +++ b/008_java_oo/README.md @@ -2,350 +2,7 @@ Tablero en [trello](https://trello.com/b/dSotNCw1/g5-formaci%C3%B3n-java) -## Java [primeros pasos](https://app.aluracursos.com/course/java-primeros-pasos) - -### ¿Que es Java? - -Algunas [estadisticas](https://www.jetbrains.com/es-es/lp/devecosystem-2022/java/) -de jetbrains (2022). - -![img](./devstats.png) - -#### Máquina Virtual Java - JVM - - - -```mermaid -graph TD - A(Código Java)-->B(Ejecutable JAR) - B-->C(Máquina Virtual JVM) - C--> E(Linux) - C--> F(Windows) - C--> G(Mac) -``` - -ej. código Java - -```java -package com.alura.java; - -public class Persona { - - String nombre; - String apellido, - int edad; - - void datosDefault() { - this.nombre = "Diego"; - this.apellido = "Arguelles"; - this.edad = 28; - } - -} -``` - -ej. bytecode - -```java -{ - java.lang.String nombre; - descriptor: Ljava/lang/String; - flags: (0x0000) - - java.lang.String apellido; - descriptor: Ljava/lang/String; - flags: (0x0000) - - int edad; - descriptor: I - flags: (0x0000) - - public com.alura.java.Persona(); - descriptor: ()V - flags: (0x0001) ACC_PUBLIC - Code: - stack=1, locals=1, args_size=1 - 0: aload_0 - 1: invokespecial #1 // Method java/lang/Object."":()V - 4: return - LineNumberTable: - line 3: 0 - - void datosDefault(); - descriptor: ()V - flags: (0x0000) - Code: - stack=2, locals=1, args_size=1 - 0: aload_0 - 1: ldc #7 // String Diego - 3: putfield #9 // Field nombre:Ljava/lang/String; - 6: aload_0 - 7: ldc #15 // String Arguelles - 9: putfield #17 // Field apellido:Ljava/lang/String; - 12: aload_0 - 13: bipush 28 - 15: putfield #20 // Field edad:I - 18: return - LineNumberTable: - line 10: 0 - line 11: 6 - line 12: 12 - line 13: 18 -} -``` - -#### Características de JVM - -- Administración de memoria -- Multiplataforma -- Seguridad -- Optimización -- Librerías - -Otros lenguajes soportados por la máquina virtual de Java son: -***Ruby, Scala, Python, Groovy, Clojure*** - -Principales características de Java: - -- Orientado a objetos -- Parecido a C++ -- Muchas librerías y una gran comunidad -- Para ejecutar el Bytecode necesitamos tener la máquina virtual de Java -- El Bytecode es independiente del sistema operativo - -Principales componentes de la plataforma Java: - -- Java Virtual Machine (JVM) -- Lenguaje Java -- Librerias Java (API) - -#### Youtube alura [JVM](https://youtu.be/GrEO8nZzyZM) - -Archivo [`HolaMundo.java`](./yt_alura_jvm/HolaMundo.java) - -```java -public class HolaMundo { - public static void main(String[] args) { - System.out.println("Hola Mundo!"); - } -} -``` - -- Compilar: `javac HolaMundo.java` -- Correr: `java HolaMundo` -- Salida: `Hola Mundo!` - -Archivo [`HolaMundo.class`](./yt_alura_jvm/HolaMundo.class) en formato hexadecimal -con `:%!xxd` en **vim** - -```hex -00000000: cafe babe 0000 0040 001d 0a00 0200 0307 .......@........ -00000010: 0004 0c00 0500 0601 0010 6a61 7661 2f6c ..........java/l -00000020: 616e 672f 4f62 6a65 6374 0100 063c 696e ang/Object......()V....... -00000040: 0a0c 000b 000c 0100 106a 6176 612f 6c61 .........java/la -00000050: 6e67 2f53 7973 7465 6d01 0003 6f75 7401 ng/System...out. -00000060: 0015 4c6a 6176 612f 696f 2f50 7269 6e74 ..Ljava/io/Print -00000070: 5374 7265 616d 3b08 000e 0100 0b48 6f6c Stream;......Hol -00000080: 6120 4d75 6e64 6f21 0a00 1000 1107 0012 a Mundo!........ -00000090: 0c00 1300 1401 0013 6a61 7661 2f69 6f2f ........java/io/ -000000a0: 5072 696e 7453 7472 6561 6d01 0007 7072 PrintStream...pr -000000b0: 696e 746c 6e01 0015 284c 6a61 7661 2f6c intln...(Ljava/l -000000c0: 616e 672f 5374 7269 6e67 3b29 5607 0016 ang/String;)V... -000000d0: 0100 0948 6f6c 614d 756e 646f 0100 0443 ...HolaMundo...C -000000e0: 6f64 6501 000f 4c69 6e65 4e75 6d62 6572 ode...LineNumber -000000f0: 5461 626c 6501 0004 6d61 696e 0100 1628 Table...main...( -00000100: 5b4c 6a61 7661 2f6c 616e 672f 5374 7269 [Ljava/lang/Stri -00000110: 6e67 3b29 5601 000a 536f 7572 6365 4669 ng;)V...SourceFi -00000120: 6c65 0100 0e48 6f6c 614d 756e 646f 2e6a le...HolaMundo.j -00000130: 6176 6100 2100 1500 0200 0000 0000 0200 ava.!........... -00000140: 0100 0500 0600 0100 1700 0000 1d00 0100 ................ -00000150: 0100 0000 052a b700 01b1 0000 0001 0018 .....*.......... -00000160: 0000 0006 0001 0000 0001 0009 0019 001a ................ -00000170: 0001 0017 0000 0025 0002 0001 0000 0009 .......%........ -00000180: b200 0712 0db6 000f b100 0000 0100 1800 ................ -00000190: 0000 0a00 0200 0000 0300 0800 0400 0100 ................ -000001a0: 1b00 0000 0200 1c0a ........ -``` - -Oracle Docs [Opcode Mnemonics](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-7.html) - -`javap -c HolaMundo` - -```java -Compiled from "HolaMundo.java" -public class HolaMundo { - public HolaMundo(); - Code: - 0: aload_0 - 1: invokespecial #1 // Method java/lang/Object."":()V - 4: return - - public static void main(java.lang.String[]); - Code: - 0: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream; - 3: ldc #13 // String Hola Mundo! - 5: invokevirtual #15 // Method java/io/PrintStream.println:(Ljava/lang/String;)V - 8: return -``` - -### Primeros Pasos - -```mermaid -flowchart LR -subgraph JDK -subgraph JRE - c(JVM) - style c fill:#f9f,stroke:#333,stroke-width:2px - d(Librerías) - style d fill:#f9f,stroke:#333,stroke-width:2px -end - a(Tools) -end -``` - -#### Instalación - -##### Archlinux - -```sh -# última versión -sudo pacman -S jdk-openjdk - -# Versiones LTS -# jdk8-openjdk -# jdk11-openjdk -# jdk17-openjdk -``` - -Cambiar la versión de Java a utlizar - -``` -# listar verisones instaladas -sudo archlinux-java status - -# establecer versión a utilizar -sudo archlinux-java set java-20-openjdk -``` - -##### Ubuntu - -```sh -sudo apt install openjdk-17-jdk - -# headless -# sudo apt install openjdk-17-jdk-headless -``` - -Exportar variable `JAVA_HOME` - -```sh -# Buscar ruta de instalación -sudo update-alternatives --config java - -# o -whereis java - -# agregar en .bashrc -export JAVA_HOME= -``` - -##### Comprobar instalación - -```sh -javac --version -javac 20.0.1 -``` - -```sh -java --version -openjdk 20.0.1 2023-04-18 -OpenJDK Runtime Environment (build 20.0.1+9) -OpenJDK 64-Bit Server VM (build 20.0.1+9, mixed mode, sharing) -``` - -**Java** es un lenguaje de programación que se actualiza periódicamente por **Oracle**, -la empresa responsable de su desarrollo. Cada nueva versión de Java trae consigo -nuevas características, mejoras de rendimiento, correcciones de errores y -actualizaciones de seguridad. Estas versiones se numeran, siguiendo un patrón -específico. - -Cuando se lanza una nueva versión, puede incluir nuevas bibliotecas, clases, -métodos y otros recursos que los desarrolladores pueden utilizar para crear -aplicaciones Java más eficientes y con menos errores. - -Aquí hay algunos ejemplos de algunas de las principales versiones de Java y sus -características: - -- [Java **8**](https://www.java.com/es/download/help/java8_es.html#:~:text=Una%20de%20las%20funciones%20destacables,el%20lenguaje%20de%20programaci%C3%B3n%20Java.&text=Esta%20nueva%20API%20permitir%C3%A1%20a,natural%20y%20f%C3%A1cil%20de%20comprender) - Introdujo la programación funcional, incluyendo la **interfaz** `java.util.function`, - que permite el uso de expresiones lambda. Además, se agregó una nueva API de - fecha y hora que proporciona una forma más simple y segura de manejar fechas y horas. - -- Java **11** - Introdujo el sistema de módulos de Java, que ayuda a simplificar la creación y - mantenimiento de aplicaciones complejas. Además, se agregó la **clase** `HttpClient`, - que admite comunicaciones HTTP/2. - -- Java **15** - Agregó características como la palabra clave `sealed`, que permite que las - clases restrinjan qué otras clases pueden extenderlas o implementarlas, - y también agregó mejoras a la API Records, que ayuda a simplificar la creación - de clases de datos inmutables. - -- [Java **17**](https://www.oracle.com/cl/news/announcement/oracle-releases-java-17-2021-09-14/) - Introduce nuevas características y mejoras, como patrones de coincidencia que - mejoran la sintaxis al trabajar con estructuras de datos complejas. Además, - se mejoran el rendimiento del recolector de basura para reducir la latencia en - las aplicaciones Java. - También se agregan funcionalidades a los registros, que - son clases inmutables y compactas utilizadas para representar datos, incluyendo - la capacidad de definir registros locales dentro de métodos. - Otra adición importante son las nuevas clases y métodos en el paquete - `java.util` para trabajar con estructuras de datos persistentes, lo que permite - realizar cambios en los datos sin modificar las estructuras originales. - Por último, se agrega soporte para **CGroups** en la API de Java, lo que permite - una mejor administración de recursos en entornos de contenedores. - -Al actualizar a una nueva versión de Java, es importante tener en cuenta la -compatibilidad con versiones anteriores. A veces, se eliminan o modifican -características o funcionalidades en una nueva versión, lo que puede afectar el -código existente. Por esta razón, es importante probar su código al actualizar -a una nueva versión de Java. - -Además, es posible que coexistan diferentes versiones de Java en un sistema, -lo que permite que las aplicaciones se ejecuten en versiones específicas de la JVM -(Java Virtual Machine) para garantizar la compatibilidad con el código existente. - -Otras características de las -[diferentes versiones de Java](https://www.aluracursos.com/blog/caracteristica-destacables-java8-delante). - -### IDE - -#### Eclipse - -Instalación desde AUR, o descarga desde -[eclipse.org](https://www.eclipse.org/downloads/packages/) - -#### IntelliJ IDEA - -```sh -sudo pacman -S intellij-idea-community-edition -``` - -Al crear projectos con IDEs estos crean la estrucutura principal del proyecto y al -compilar guardan los bytecodes en un directorio distinto de donde esta el codigo -fuente. - -Para correr un archivo bytecode en otra ruta se puede usar el flag `--clas-path`. - -ej. [proyecto](./intellij_idea/java_primeros_pasos/) creado con IntelliJ IDEA - -```sh -java --class-path ./intellij_idea/java_primeros_pasos/out/production/java_primeros_pasos/ Ejemplo -``` - -### Tipos y Variables - -#### Tipo entero - +- [Curso](https://app.aluracursos.com/course/java-primeros-pasos) +Java [primeros pasos](./primeros_pasos.md) +- [Curso](https://app.aluracursos.com/course/java-parte2-introduccion-orientada-objetos) +Java [orientación a objetos](./orientacion_obj.md) diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/Ambito.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/Ambito.java new file mode 100644 index 0000000..0fc4953 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/Ambito.java @@ -0,0 +1,12 @@ +public class Ambito { + public static void main(String[] args) { + int personas = 2; + boolean pareja; + + if (personas > 1) { + pareja = true; + } else { + pareja = false; + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloFor.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloFor.java new file mode 100644 index 0000000..914a9d0 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloFor.java @@ -0,0 +1,7 @@ +public class CicloFor { + public static void main(String[] args) { + for (int i=0; i<10; i++){ + System.out.println(i+1); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloWhile.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloWhile.java new file mode 100644 index 0000000..1776266 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/CicloWhile.java @@ -0,0 +1,9 @@ +public class CicloWhile { + public static void main(String[] args) { + int contador = 0; + while (contador < 10){ + contador++; + System.out.println(contador); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/CiclosWhile2.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/CiclosWhile2.java new file mode 100644 index 0000000..2c28640 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/CiclosWhile2.java @@ -0,0 +1,11 @@ +public class CiclosWhile2 { + public static void main(String[] args) { + int contador = 0; + int sumatoria = 0; + while (contador < 10){ + contador++; + sumatoria+=contador; + System.out.println("Ciclo "+contador+" : "+sumatoria); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales.java new file mode 100644 index 0000000..fa2be9b --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales.java @@ -0,0 +1,20 @@ +public class Condicionales { + public static void main(String[] args) { + int edad = 15; + String mensaje = ""; + if (edad > 18) { + mensaje = "Eres mayor de edad"; + } else { + mensaje = "Eres menor de edad"; + if (edad >= 16){ + mensaje += " pero puedes pasar"; + } else { + mensaje += " y no puedes pasar"; + } + } + System.out.println(mensaje); + + // Sintaxis relajada para una linea sgte. al if + if (edad > 18) System.out.println("la edad es " + edad); + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales2.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales2.java new file mode 100644 index 0000000..22fbcff --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/Condicionales2.java @@ -0,0 +1,16 @@ +public class Condicionales2 { + public static void main(String[] args) { + int edad = 18; + int personas = 2; + boolean pareja = personas > 1; + boolean permitido = edad >= 18 && pareja; + String mensaje; + + if (permitido) { + mensaje = "Puedes pasar"; + } else { + mensaje = "No puedes pasar"; + } + System.out.println(mensaje); + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioFactorial.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioFactorial.java new file mode 100644 index 0000000..51111d3 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioFactorial.java @@ -0,0 +1,15 @@ +public class DesafioFactorial { + public static void main(String[] args) { + for (int num = 1; num <= 10; num++) { + System.out.println("El factorial de "+num+" es "+calculoFactorial(num)); + } + } + static int calculoFactorial(int num){ + int resultado = 1; + while (num > 1){ + resultado = resultado * num; + num--; + } + return resultado; + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioMultiplos.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioMultiplos.java new file mode 100644 index 0000000..fc27ddc --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/DesafioMultiplos.java @@ -0,0 +1,9 @@ +public class DesafioMultiplos { + public static void main(String[] args) { + for (int i=1; i<100; i++){ + if (i % 3 == 0){ + System.out.println(i); + } + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/EjemploCaracteres.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/EjemploCaracteres.java new file mode 100644 index 0000000..973f93f --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/EjemploCaracteres.java @@ -0,0 +1,18 @@ +public class EjemploCaracteres { + public static void main(String[] args) { + char caracter = 'F'; + System.out.println(caracter); + + caracter = 65; + System.out.println(caracter); + + caracter = 65 + 1; + char segundo_caracter = (char)(caracter + 1); + System.out.println(segundo_caracter); + + String cadena = "Alura Latam"; + System.out.println(cadena); + cadena = cadena + " + Oracle Next Education " + 2023; + System.out.println(cadena); + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/EjercicioMatriz.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/EjercicioMatriz.java new file mode 100644 index 0000000..607b2d2 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/EjercicioMatriz.java @@ -0,0 +1,10 @@ +public class EjercicioMatriz { + public static void main(String[] args) { + for (int col = 0; col <= 10; col++){ + for (int fila = 0; fila < col; fila++){ + System.out.print("* "); + } + System.out.println(); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/SolucionFactorial.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/SolucionFactorial.java new file mode 100644 index 0000000..0179d4e --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/SolucionFactorial.java @@ -0,0 +1,9 @@ +public class SolucionFactorial { + public static void main(String[] args) { + int factorial = 1; + for (int i = 1; i < 11; i++) { + factorial *= i; + System.out.println("Factorial de " + i + " = " + factorial); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/TablaMultiplicacion.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/TablaMultiplicacion.java new file mode 100644 index 0000000..afded61 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/TablaMultiplicacion.java @@ -0,0 +1,11 @@ +public class TablaMultiplicacion { + public static void main(String[] args) { + for (int i=1; i<=10; i++){ + System.out.println("Tabla Nro "+i); + for (int mult = 0; mult <= 10; mult++){ + System.out.println(i+" x "+mult+" = "+(mult*i)); + } + System.out.println(); + } + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/TestDescuento.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/TestDescuento.java new file mode 100644 index 0000000..c0cc9ef --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/TestDescuento.java @@ -0,0 +1,22 @@ +public class TestDescuento { + + public static void main(String[] args) { + + double valorCompra = 250.0; + int dscto; + if (valorCompra >= 100.0 && valorCompra <= 199.99){ + dscto = 10; + } else if (valorCompra >= 200.0 && valorCompra <= 299.99) { + dscto = 15; + } else if (valorCompra >= 300.0) { + dscto = 20; + } else { + dscto = 0; + } + double valorDescuento = valorCompra * (dscto / 100.00 ); + double totalCompra = valorCompra - valorDescuento; + System.out.println("Total compra : $"+valorCompra+"\n"+ + "Descuento : "+dscto+"%\n"+ + " Total Final : $"+totalCompra); + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/TipoVariable.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/TipoVariable.java new file mode 100644 index 0000000..5892d22 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/TipoVariable.java @@ -0,0 +1,39 @@ +public class TipoVariable { + public static void main(String[] args) { + // Entero + int edad = 16*2; + System.out.println("La edad es " + edad); + + // Double + double salario = 1250.58; + System.out.println("El salario es de " + salario + " centavos" ); + + // División de enteros devuelve enteros - 32/5 = 6.4 --> 6 + System.out.println( edad / 5); + + // División de decimales devuelve decimales - 4.0 / 2 = 2.0 + System.out.println( 4.0 / 2 ); + + // CONVERSIONES + int salario_int = (int)salario; + System.out.println("Salario convertido a entero : " + salario_int); + + //long numero_largo = 9_223_372_036_854_775_807L; + long numero_largo = Long.MAX_VALUE; + //int numero = 1_999_999_999; + int numero = Integer.MAX_VALUE; + //short numero_corto = 19_999; + short numero_corto = Short.MAX_VALUE; + //byte clasico_byte = 127; + byte clasico_byte = Byte.MAX_VALUE; + //float decimal_bajo = 16.5F; + float decimal_bajo = Float.MAX_VALUE; + + System.out.println( + "long : " + numero_largo + "\n"+ + "int : " + numero + "\n"+ + "short : " + numero_corto + "\n" + + "byte : " + clasico_byte + "\n" + + "float : " + decimal_bajo); + } +} diff --git a/008_java_oo/intellij_idea/java_primeros_pasos/src/VariablesMemoria.java b/008_java_oo/intellij_idea/java_primeros_pasos/src/VariablesMemoria.java new file mode 100644 index 0000000..6809774 --- /dev/null +++ b/008_java_oo/intellij_idea/java_primeros_pasos/src/VariablesMemoria.java @@ -0,0 +1,13 @@ +public class VariablesMemoria { + public static void main(String[] args) { + int var1 = 10; + int var2 = 6; + + var1 = var2; + var2 = 20; + + // var1 tima el VALOR de la variable var1 al momento de la asignación + // java no asinga punteros de variables, solo valores + System.out.println(var1); + } +} diff --git a/008_java_oo/orientacion_obj.md b/008_java_oo/orientacion_obj.md new file mode 100644 index 0000000..e69de29 diff --git a/008_java_oo/primeros_pasos.md b/008_java_oo/primeros_pasos.md new file mode 100644 index 0000000..e45e06a --- /dev/null +++ b/008_java_oo/primeros_pasos.md @@ -0,0 +1,790 @@ +# Java [primeros pasos](https://app.aluracursos.com/course/java-primeros-pasos) + +## ¿Que es Java? + +Algunas [estadisticas](https://www.jetbrains.com/es-es/lp/devecosystem-2022/java/) +de jetbrains (2022). + +![img](./devstats.png) + +### Máquina Virtual Java - JVM + + + +```mermaid +graph TD + A(Código Java)-->B(Ejecutable JAR) + B-->C(Máquina Virtual JVM) + C--> E(Linux) + C--> F(Windows) + C--> G(Mac) +``` + +ej. código Java + +```java +package com.alura.java; + +public class Persona { + + String nombre; + String apellido, + int edad; + + void datosDefault() { + this.nombre = "Diego"; + this.apellido = "Arguelles"; + this.edad = 28; + } + +} +``` + +ej. bytecode + +```java +{ + java.lang.String nombre; + descriptor: Ljava/lang/String; + flags: (0x0000) + + java.lang.String apellido; + descriptor: Ljava/lang/String; + flags: (0x0000) + + int edad; + descriptor: I + flags: (0x0000) + + public com.alura.java.Persona(); + descriptor: ()V + flags: (0x0001) ACC_PUBLIC + Code: + stack=1, locals=1, args_size=1 + 0: aload_0 + 1: invokespecial #1 // Method java/lang/Object."":()V + 4: return + LineNumberTable: + line 3: 0 + + void datosDefault(); + descriptor: ()V + flags: (0x0000) + Code: + stack=2, locals=1, args_size=1 + 0: aload_0 + 1: ldc #7 // String Diego + 3: putfield #9 // Field nombre:Ljava/lang/String; + 6: aload_0 + 7: ldc #15 // String Arguelles + 9: putfield #17 // Field apellido:Ljava/lang/String; + 12: aload_0 + 13: bipush 28 + 15: putfield #20 // Field edad:I + 18: return + LineNumberTable: + line 10: 0 + line 11: 6 + line 12: 12 + line 13: 18 +} +``` + +### Características de JVM + +- Administración de memoria +- Multiplataforma +- Seguridad +- Optimización +- Librerías + +Otros lenguajes soportados por la máquina virtual de Java son: +***Ruby, Scala, Python, Groovy, Clojure*** + +Principales características de Java: + +- Orientado a objetos +- Parecido a C++ +- Muchas librerías y una gran comunidad +- Para ejecutar el Bytecode necesitamos tener la máquina virtual de Java +- El Bytecode es independiente del sistema operativo + +Principales componentes de la plataforma Java: + +- Java Virtual Machine (JVM) +- Lenguaje Java +- Librerias Java (API) + +### Youtube alura [JVM](https://youtu.be/GrEO8nZzyZM) + +Archivo [`HolaMundo.java`](./yt_alura_jvm/HolaMundo.java) + +```java +public class HolaMundo { + public static void main(String[] args) { + System.out.println("Hola Mundo!"); + } +} +``` + +- Compilar: `javac HolaMundo.java` +- Correr: `java HolaMundo` +- Salida: `Hola Mundo!` + +Archivo `HolaMundo.class` en formato hexadecimal con `:%!xxd` en **vim** + +```hex +00000000: cafe babe 0000 0040 001d 0a00 0200 0307 .......@........ +00000010: 0004 0c00 0500 0601 0010 6a61 7661 2f6c ..........java/l +00000020: 616e 672f 4f62 6a65 6374 0100 063c 696e ang/Object......()V....... +00000040: 0a0c 000b 000c 0100 106a 6176 612f 6c61 .........java/la +00000050: 6e67 2f53 7973 7465 6d01 0003 6f75 7401 ng/System...out. +00000060: 0015 4c6a 6176 612f 696f 2f50 7269 6e74 ..Ljava/io/Print +00000070: 5374 7265 616d 3b08 000e 0100 0b48 6f6c Stream;......Hol +00000080: 6120 4d75 6e64 6f21 0a00 1000 1107 0012 a Mundo!........ +00000090: 0c00 1300 1401 0013 6a61 7661 2f69 6f2f ........java/io/ +000000a0: 5072 696e 7453 7472 6561 6d01 0007 7072 PrintStream...pr +000000b0: 696e 746c 6e01 0015 284c 6a61 7661 2f6c intln...(Ljava/l +000000c0: 616e 672f 5374 7269 6e67 3b29 5607 0016 ang/String;)V... +000000d0: 0100 0948 6f6c 614d 756e 646f 0100 0443 ...HolaMundo...C +000000e0: 6f64 6501 000f 4c69 6e65 4e75 6d62 6572 ode...LineNumber +000000f0: 5461 626c 6501 0004 6d61 696e 0100 1628 Table...main...( +00000100: 5b4c 6a61 7661 2f6c 616e 672f 5374 7269 [Ljava/lang/Stri +00000110: 6e67 3b29 5601 000a 536f 7572 6365 4669 ng;)V...SourceFi +00000120: 6c65 0100 0e48 6f6c 614d 756e 646f 2e6a le...HolaMundo.j +00000130: 6176 6100 2100 1500 0200 0000 0000 0200 ava.!........... +00000140: 0100 0500 0600 0100 1700 0000 1d00 0100 ................ +00000150: 0100 0000 052a b700 01b1 0000 0001 0018 .....*.......... +00000160: 0000 0006 0001 0000 0001 0009 0019 001a ................ +00000170: 0001 0017 0000 0025 0002 0001 0000 0009 .......%........ +00000180: b200 0712 0db6 000f b100 0000 0100 1800 ................ +00000190: 0000 0a00 0200 0000 0300 0800 0400 0100 ................ +000001a0: 1b00 0000 0200 1c0a ........ +``` + +Oracle Docs [Opcode Mnemonics](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-7.html) + +`javap -c HolaMundo` + +```java +Compiled from "HolaMundo.java" +public class HolaMundo { + public HolaMundo(); + Code: + 0: aload_0 + 1: invokespecial #1 // Method java/lang/Object."":()V + 4: return + + public static void main(java.lang.String[]); + Code: + 0: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream; + 3: ldc #13 // String Hola Mundo! + 5: invokevirtual #15 // Method java/io/PrintStream.println:(Ljava/lang/String;)V + 8: return +``` + +## Primeros Pasos + +```mermaid +flowchart LR +subgraph JDK +subgraph JRE + c(JVM) + style c fill:#f9f,stroke:#333,stroke-width:2px + d(Librerías) + style d fill:#f9f,stroke:#333,stroke-width:2px +end + a(Tools) +end +``` + +### Instalación + +#### Archlinux + +```sh +# última versión +sudo pacman -S jdk-openjdk + +# Versiones LTS +# jdk8-openjdk +# jdk11-openjdk +# jdk17-openjdk +``` + +Cambiar la versión de Java a utlizar + +``` +# listar verisones instaladas +sudo archlinux-java status + +# establecer versión a utilizar +sudo archlinux-java set java-20-openjdk +``` + +#### Ubuntu + +```sh +sudo apt install openjdk-17-jdk + +# headless +# sudo apt install openjdk-17-jdk-headless +``` + +Exportar variable `JAVA_HOME` + +```sh +# Buscar ruta de instalación +sudo update-alternatives --config java + +# o +whereis java + +# agregar en .bashrc +export JAVA_HOME= +``` + +#### Comprobar instalación + +```sh +javac --version +javac 20.0.1 +``` + +```sh +java --version +openjdk 20.0.1 2023-04-18 +OpenJDK Runtime Environment (build 20.0.1+9) +OpenJDK 64-Bit Server VM (build 20.0.1+9, mixed mode, sharing) +``` + +**Java** es un lenguaje de programación que se actualiza periódicamente por **Oracle**, +la empresa responsable de su desarrollo. Cada nueva versión de Java trae consigo +nuevas características, mejoras de rendimiento, correcciones de errores y +actualizaciones de seguridad. Estas versiones se numeran, siguiendo un patrón +específico. + +Cuando se lanza una nueva versión, puede incluir nuevas bibliotecas, clases, +métodos y otros recursos que los desarrolladores pueden utilizar para crear +aplicaciones Java más eficientes y con menos errores. + +Aquí hay algunos ejemplos de algunas de las principales versiones de Java y sus +características: + +- [Java **8**](https://www.java.com/es/download/help/java8_es.html#:~:text=Una%20de%20las%20funciones%20destacables,el%20lenguaje%20de%20programaci%C3%B3n%20Java.&text=Esta%20nueva%20API%20permitir%C3%A1%20a,natural%20y%20f%C3%A1cil%20de%20comprender) + Introdujo la programación funcional, incluyendo la **interfaz** `java.util.function`, + que permite el uso de expresiones lambda. Además, se agregó una nueva API de + fecha y hora que proporciona una forma más simple y segura de manejar fechas y horas. + +- Java **11** + Introdujo el sistema de módulos de Java, que ayuda a simplificar la creación y + mantenimiento de aplicaciones complejas. Además, se agregó la **clase** `HttpClient`, + que admite comunicaciones HTTP/2. + +- Java **15** + Agregó características como la palabra clave `sealed`, que permite que las + clases restrinjan qué otras clases pueden extenderlas o implementarlas, + y también agregó mejoras a la API Records, que ayuda a simplificar la creación + de clases de datos inmutables. + +- [Java **17**](https://www.oracle.com/cl/news/announcement/oracle-releases-java-17-2021-09-14/) + Introduce nuevas características y mejoras, como patrones de coincidencia que + mejoran la sintaxis al trabajar con estructuras de datos complejas. Además, + se mejoran el rendimiento del recolector de basura para reducir la latencia en + las aplicaciones Java. + También se agregan funcionalidades a los registros, que + son clases inmutables y compactas utilizadas para representar datos, incluyendo + la capacidad de definir registros locales dentro de métodos. + Otra adición importante son las nuevas clases y métodos en el paquete + `java.util` para trabajar con estructuras de datos persistentes, lo que permite + realizar cambios en los datos sin modificar las estructuras originales. + Por último, se agrega soporte para **CGroups** en la API de Java, lo que permite + una mejor administración de recursos en entornos de contenedores. + +Al actualizar a una nueva versión de Java, es importante tener en cuenta la +compatibilidad con versiones anteriores. A veces, se eliminan o modifican +características o funcionalidades en una nueva versión, lo que puede afectar el +código existente. Por esta razón, es importante probar su código al actualizar +a una nueva versión de Java. + +Además, es posible que coexistan diferentes versiones de Java en un sistema, +lo que permite que las aplicaciones se ejecuten en versiones específicas de la JVM +(Java Virtual Machine) para garantizar la compatibilidad con el código existente. + +Otras características de las +[diferentes versiones de Java](https://www.aluracursos.com/blog/caracteristica-destacables-java8-delante). + +## IDE + +### Eclipse + +Instalación desde AUR, o descarga desde +[eclipse.org](https://www.eclipse.org/downloads/packages/) + +### IntelliJ IDEA + +```sh +sudo pacman -S intellij-idea-community-edition +``` + +Al crear projectos con IDEs estos crean la estrucutura principal del proyecto y al +compilar guardan los bytecodes en un directorio distinto de donde esta el codigo +fuente. + +Para correr un archivo bytecode en otra ruta se puede usar el flag `--clas-path`. + +ej. [proyecto](./intellij_idea/java_primeros_pasos/) creado con IntelliJ IDEA + +```tree +📂️ intellij_idea +└── 📂️ java_primeros_pasos + ├── 📂️ out + │ └── 📂️ production + │ └── 📂️ java_primeros_pasos + │ └──  Ejemplo.class + ├── 📂️ src + │ └── ☕️ Ejemplo.java + └── 📄️ java_primeros_pasos.iml +``` + +```sh +java --class-path ./intellij_idea/java_primeros_pasos/out/production/java_primeros_pasos/ Ejemplo +``` + +## Tipos y Variables + +[TipoVariable.java](./intellij_idea/java_primeros_pasos/src/TipoVariable.java) + +```java +public class TipoVariable { + public static void main(String[] args) { + // Entero + int edad = 16*2; + System.out.println("La edad es " + edad); + + // Double + double salario = 1250.58; + System.out.println("El salario es de " + salario + " centavos" ); + + // División de enteros devuelve enteros - 32/5 = 6.4 --> 6 + System.out.println( edad / 5); + + // Divisin de decimales devuelve decimales - 4.0 / 2 = 2.0 + System.out.println( 4.0 / 2 ); + + // CONVERSIONES + int salario_int = (int)salario; + System.out.println("Salario convertido a entero : " + salario_int); + + long numero_largo = 9_223_372_036_854_775_807L; + int numero = 1_999_999_999; + short numero_corto = 19_999; + byte clasico_byte = 127; + float decimal_bajo = 16.5F; + + System.out.println( + "long : " + numero_largo + "\n"+ + "int : " + numero + "\n"+ + "short : " + numero_corto + "\n" + + "byte : " + clasico_byte + "\n" + + "float : " + decimal_bajo); + } +} +``` + +Como se ve en los videos, cuando intentamos poner un valor entero en una variable +de tipo double, Java no muestra un error. Sin embargo, cuando intentamos poner +un doble en una variable del tipo entero, tenemos un error de compilación. + +Esta propiedad se produce porque Java convierte implícitamente de un tipo más +pequeño a tipos "más grandes". De entero a double, por ejemplo. + +Lo contrario no es cierto porque hay pérdida de datos cuando se realiza la +conversión. Resultando en un " type mismatch" que muestra que esta instrucción +es de tipos incompatibles. + +Para realizar una conversión donde puede haber pérdida de información, es +necesario hacer un type casting. Vea las instrucciones a continuación. + +```java +int edad = (int)30.0; +``` + +En el caso anterior, es **explícito** que se realizará la conversión de +*double* a *entero*. + +Funcionamiento del cast implícito y explícito en la sgte. tabla. + +| DE/HACIA | `byte` | `short` | `char` | `int` | `long` | `float` | `double` | +| - | - | - | - | - | - | - | - | +| **`byte`** | - | Impl. | (char) | Impl. | Impl. | Impl. | Impl. | +| **`short`** | (byte) | - | (char) | Impl. | Impl. | Impl. | Impl. | +| **`char`** | (byte) | (short) | - | Impl. | Impl. | Impl. | Impl. | +| **`int`** | (byte) | (short) | (char) | - | Impl. | Impl. | Impl. | +| **`long`** | (byte) | (short) | (char) | (int) | - | Impl. | Impl. | +| **`float`** | (byte) | (short) | (char) | (int) | (long) | - | Impl. | +| **`double`** | (byte) | (short) | (char) | (int) | (long) | (float) | - | + +### Tamaño de Variables + +| Tipo | Tamaño | +| - | - | +| `boolean` | 1 bit | +| `byte` | 1 byte | +| `short` | 2 bytes | +| `char` | 2 bytes | +| `int` | 4 bytes | +| `float` | 4 bytes | +| `long` | 8 bytes | +| `double` | 8 bytes | + +### Char y String + +[EjemploCaracteres.java](./intellij_idea/java_primeros_pasos/src/EjemploCaracteres.java) + +```java +public class EjemploCaracteres { + public static void main(String[] args) { + char caracter = 'F'; + System.out.println(caracter); + + caracter = 65; + System.out.println(caracter); + + caracter = 65 + 1; + char segundo_caracter = (char)(caracter + 1); + System.out.println(segundo_caracter); + + String cadena = "Alura Latam"; + System.out.println(cadena); + cadena = cadena + " + Oracle Next Education " + 2023; + System.out.println(cadena); + } +} +``` + +### Variables y Memoria + +[VariablesMemoria.java](./intellij_idea/java_primeros_pasos/src/VariablesMemoria.java) + +```java +public class VariablesMemoria { + public static void main(String[] args) { + int var1 = 10; + int var2 = 6; + + var1 = var2; + var2 = 20; + + // var1 tima el VALOR de la variable var1 al momento de la asignación + // java no asinga punteros de variables, solo valores + System.out.println(var1); + } +} +``` + +### Condicional if + +[Condicionales.java](./intellij_idea/java_primeros_pasos/src/Condicionales.java) + +```java +public class Condicionales { + public static void main(String[] args) { + int edad = 15; + String mensaje = ""; + if (edad > 18) { + mensaje = "Eres mayor de edad"; + } else { + mensaje = "Eres menor de edad"; + if (edad >= 16){ + mensaje += " pero puedes pasar"; + } else { + mensaje += " y no puedes pasar"; + } + } + System.out.println(mensaje); + + // Sintaxis relajada para una linea sgte. al if + if (edad > 18) System.out.println("la edad es " + edad); + } +} +``` + +### Boolean + +[Condicionales2.java](./intellij_idea/java_primeros_pasos/src/Condicionales2.java) + +```java +public class Condicionales2 { + public static void main(String[] args) { + int edad = 18; + int personas = 2; + boolean pareja = personas > 1; + boolean permitido = edad >= 18 && pareja; + String mensaje; + + if (permitido) { + mensaje = "Puedes pasar"; + } else { + mensaje = "No puedes pasar"; + } + System.out.println(mensaje); + } +} +``` + +### Scope + +[Ambito.java](./intellij_idea/java_primeros_pasos/src/Ambito.java) + +```java +public class Ambito { + public static void main(String[] args) { + int personas = 2; + boolean pareja; + + if (personas > 1) { + pareja = true; + } else { + pareja = false; + } + } +} +``` + +### Ejercicio + +María es propietaria de una tienda de ropa y le gustaría crear un programa que +calcule el valor final del producto después de aplicar un descuento que ofrecería +a sus clientes. + +- Si el valor de la compra está entre $100.0 y $199.99, el descuento es del 10%. +- Si el valor de la compra está entre $200.0 y $299.99, el descuento es del 15%. +- Para compras superiores a $300.0, el descuento es del 20%. + + +[TestDescuento.java](./intellij_idea/java_primeros_pasos/src/TestDescuento.java) + +```java +public class TestDescuento { + + public static void main(String[] args) { + + double valorCompra = 250.0; + int dscto; + if (valorCompra >= 100.0 && valorCompra <= 199.99){ + dscto = 10; + } else if (valorCompra >= 200.0 && valorCompra <= 299.99) { + dscto = 15; + } else if (valorCompra >= 300.0) { + dscto = 20; + } else { + dscto = 0; + } + double valorDescuento = valorCompra * (dscto / 100.00 ); + double totalCompra = valorCompra - valorDescuento; + System.out.println("Total compra : $"+valorCompra+"\n"+ + "Descuento : "+dscto+"%\n"+ + " Total Final : $"+totalCompra); + } +} +``` + +```txt + Total compra : $250.0 + Descuento : 15% + Total Final : $212.5 +``` + +### Switch + +Si tenemos una variable `mes`, y necesitamos probar su número e imprimir su +mes correspondiente. Entonces, *¿vamos a hacer 12 if?* + +Una alternativa al `if/else` es el `switch`, de cambio, que es una estructura +de control de flujo que permite ejecutar diferentes acciones basadas en el valor +de una expresión. Es una forma más simplificada y legible de escribir varios +bloques if/else encadenados. + +Funciona de la siguiente manera (sintaxe del switch): + +```java + switch (variable) { + case opción1: + // instrucción(es) si coincide con la opción 1 + break; + case option2: + // intrucción(es) si coincide con la opción 2 + break; + case option3: + // instrucción(es) si coincide con la opción 3 + break; + default: + // instrucción(es) si no hay coincidencia + } +``` + +### Ciclo While + +[CiclosWhile.java](./intellij_idea/java_primeros_pasos/src/CicloWhile.java) +Nros. del 1 al 10 + +```java +public class CiclosWhile { + public static void main(String[] args) { + int contador = 0; + while (contador < 10){ + contador++; + System.out.println(contador); + } + } +} +``` + +[CicloWhile2.java](./intellij_idea/java_primeros_pasos/src/CiclosWhile2.java) +Suma de los nros. del 1 al 10 + +```java +public class CiclosWhile2 { + public static void main(String[] args) { + int contador = 0; + int sumatoria = 0; + while (contador < 10){ + contador++; + sumatoria+=contador; + System.out.println("Ciclo "+contador+" : "+sumatoria); + } + } +} +``` + +### Ciclo For + +[CicloFor.java](./intellij_idea/java_primeros_pasos/src/CicloFor.java) +Nros. del 1 al 10 + +```java +public class CicloFor { + public static void main(String[] args) { + for (int i=0; i<10; i++){ + System.out.println(i+1); + } + } +} +``` + +[TablaMultiplicacion.java](./intellij_idea/java_primeros_pasos/src/TablaMultiplicacion.java) +Tablas de multiplicar + +```java +public class TablaMultiplicacion { + public static void main(String[] args) { + for (int i=1; i<=10; i++){ + System.out.println("Tabla Nro "+i); + for (int mult = 0; mult <= 10; mult++){ + System.out.println(i+" x "+mult+" = "+(mult*i)); + } + System.out.println(); + } + } +} +``` + +[EjercicioMatriz.java](./intellij_idea/java_primeros_pasos/src/EjercicioMatriz.java) + +```java +public class EjercicioMatriz { + public static void main(String[] args) { + for (int col = 0; col <= 10; col++){ + for (int fila = 0; fila < col; fila++){ + System.out.print("* "); + } + System.out.println(); + } + } +} +``` + +### Desafios + +[DesafioMultiplos.java](./intellij_idea/java_primeros_pasos/src/DesafioMultiplos.java) +Multiplos de 3 de 1 al 100 + +```java +public class DesafioMultiplos { + public static void main(String[] args) { + for (int i=1; i<100; i++){ + if (i % 3 == 0){ + System.out.println(i); + } + } + } +} +``` + +En este ejercicio opcional, tu desafío es imprimir los factoriales del 1 al 10. + +¿Recuerdas el factorial? ¿No? No hay problema, sigue las reglas: + +El factorial de `0` es `1` +El factorial de `1` es `(0!) * 1 = 1` +El factorial de `2` es `(1!) * 2 = 2` +El factorial de `3` es `(2!) * 3 = 6` +El factorial de `4` es `(3!) * 4 = 24` +El factorial de un número `n` es `n * n-1 * n-2 ... hasta n = 1` + +Es decir, el factorial de `4!` = `1 x 2 x 3 x 4` = `24` +El factorial de `6!` = `1 x 2 x 3 x 4 x 5 x 6` = `720` + +Ahora crea una nueva clase, escribe un for que comience una variable `n` (nro actual) +como 1 y factorial (resultado total) como 1. + +¡Haz su ciclo entre 1 y 10 y calcula el resultado! + +[DesafioFactorial.java](./intellij_idea/java_primeros_pasos/src/DesafioFactorial.java) + +```java +public class DesafioFactorial { + public static void main(String[] args) { + for (int num = 1; num <= 10; num++) { + System.out.println("El factorial de "+num+" es "+calculoFactorial(num)); + } + } + static int calculoFactorial(int num){ + int resultado = 1; + while (num > 1){ + resultado = resultado * num; + num--; + } + return resultado; + } +} +``` + +```txt +El factorial de 1 es 1 +El factorial de 2 es 2 +El factorial de 3 es 6 +El factorial de 4 es 24 +El factorial de 5 es 120 +El factorial de 6 es 720 +El factorial de 7 es 5040 +El factorial de 8 es 40320 +El factorial de 9 es 362880 +El factorial de 10 es 3628800 +``` + +[SolucionFactorial.java](./intellij_idea/java_primeros_pasos/src/SolucionFactorial.java) + +```java +class Factorial { + public static void main(String[] args) { + int factorial = 1; + for (int i = 1; i < 11; i++) { + factorial *= i; + System.out.println("Factorial de " + i + " = " + factorial); + } + } +} +``` diff --git a/README.md b/README.md index 0a2f885..c29deb9 100644 --- a/README.md +++ b/README.md @@ -29,3 +29,5 @@ primoridiales en programación con Javascript. - [Business Agility](./007_business_agility/README.md) - [Java](./008_java_oo/README.md) Orientado a Objetos + - [Primeros pasos](./008_java_oo/primeros_pasos.md) + - [Orientación a objetos](./008_java_oo/orientacion_obj.md)