├── 01_introduccion
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ └── modules.xml
├── 01_introduccion.iml
├── README.md
└── src
│ ├── Casting.java
│ ├── OperadorDecrementoIncremento.java
│ ├── OperadorMath.java
│ ├── OperadoresAritmeticos.java
│ ├── OperadoresAsignacion.java
│ ├── OperadoresComparacion.java
│ ├── OperadoresLogicos.java
│ ├── PalabraReservadaVar.java
│ ├── TiposDatos.java
│ └── Variables.java
├── 02_estructura_de_control
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ ├── modules.xml
│ ├── uiDesigner.xml
│ └── vcs.xml
├── Estructura_control.iml
├── README.md
└── src
│ ├── Arrays
│ └── Example.java
│ ├── CicloDoWhile
│ ├── DoWhileExample.java
│ └── DoWhileNumber.java
│ ├── CicloFor
│ ├── CalcularSuma.java
│ ├── Example.java
│ ├── RecorridoArrays.java
│ └── VerificarElemento.java
│ ├── CicloWhile
│ ├── Example.java
│ ├── LecturaEntrada.java
│ └── SumaNumeros.java
│ ├── Condicional
│ ├── IfElseExample.java
│ ├── IfElseGenero.java
│ ├── IfElseUniversitario.java
│ └── RangoEdad.java
│ └── Switch
│ ├── DiaSemana.java
│ └── DiasSemana.java
├── 03_clases_wrapper
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ ├── modules.xml
│ ├── uiDesigner.xml
│ └── vcs.xml
├── 03_clases_wrapper.iml
├── README.md
└── src
│ ├── BooleanWrapper.java
│ ├── CharacteWrapper.java
│ ├── DoubleWrapper.java
│ └── IntegerWrapper.java
├── 04_funciones_metodos
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ ├── modules.xml
│ └── vcs.xml
├── Funciones metodos.iml
├── README.md
└── src
│ ├── ExampleMetodo.java
│ ├── PasarPorReferencia.java
│ ├── PasarPorReferencia2.java
│ └── PasarPorValor.java
├── 05_arreglos
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ ├── modules.xml
│ └── vcs.xml
├── Arreglos.iml
└── src
│ ├── EjemploArregloNumMayor.java
│ ├── EjemploArreglos.java
│ ├── EjemploArreglosCombinados.java
│ ├── EjemploArreglosFor.java
│ ├── EjemploArreglosForIOrdenamientoBurbuja.java
│ ├── EjemploArreglosForInverso.java
│ └── EjemploArreglosForInversoMutable.java
├── 06_matrices
├── .gitignore
├── .idea
│ ├── .gitignore
│ ├── misc.xml
│ ├── modules.xml
│ └── vcs.xml
├── matrices.iml
└── src
│ ├── EjemploMatrices.java
│ ├── EjemploMatricesColumnas.java
│ ├── EjemploMatricesStringFor.java
│ ├── EjemploMatricesStringFor2.java
│ └── EjemploMatricesSumar.java
├── README.md
└── assets
├── portada.png
└── social-media
├── discord.svg
├── facebook.svg
├── gmail.svg
├── linkedin.svg
├── reddit.svg
└── twitter.svg
/01_introduccion/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/01_introduccion/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/01_introduccion/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/01_introduccion/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/01_introduccion/01_introduccion.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/01_introduccion/README.md:
--------------------------------------------------------------------------------
1 | # Variable
2 |
3 | - Una variable es un espacio de memoria (RAM) que contiene un dato de tipo numérico, booleano, de texto u otros tipos de datos un poco más complejos.
4 |
5 | - Las variables en Java se componen de un nombre único y un valor que puede cambiar a lo largo de la ejecución del programa. Al declarar las variables debemos definir el tipo de dato que vamos a usar y un punto y coma al final:
6 |
7 |
8 | ## Categorías de Tipos en Java
9 |
10 | En Java, los tipos se pueden clasificar en las siguientes categorías:
11 |
12 | 1. **Tipos primitivos:**
13 | - `boolean`: representa un valor booleano (`true` o `false`).
14 | - `byte`: representa un número entero de 8 bits.
15 | - `short`: representa un número entero de 16 bits.
16 | - `int`: representa un número entero de 32 bits.
17 | - `long`: representa un número entero de 64 bits.
18 | - `float`: representa un número de punto flotante de 32 bits.
19 | - `double`: representa un número de punto flotante de 64 bits.
20 | - `char`: representa un carácter Unicode de 16 bits.
21 |
22 | 2. **Clases Wrapper:**
23 | - `Boolean`: wrapper para `boolean`.
24 | - `Byte`: wrapper para `byte`.
25 | - `Short`: wrapper para `short`.
26 | - `Integer`: wrapper para `int`.
27 | - `Long`: wrapper para `long`.
28 | - `Float`: wrapper para `float`.
29 | - `Double`: wrapper para `double`.
30 | - `Character`: wrapper para `char`.
31 |
32 | 3. **Tipos de referencia:**
33 | - `String`: representa una secuencia de caracteres.
34 | - `Object`: es la clase base de todas las clases en Java.
35 | - `Array`: representa un arreglo de elementos.
36 | - `Class`: representa la información de una clase en tiempo de ejecución.
37 | - `Interface`: representa una interfaz.
38 |
39 | 4. **Tipos enumerados (Enums):** Son un tipo especial de clase que representa un conjunto fijo de constantes.
40 |
41 | Además de estas categorías, Java también ofrece otras estructuras y tipos de datos para almacenar y manipular colecciones de elementos, como `List`, `Set`, `Map`, entre otros. Estos tipos están definidos en el paquete `java.util`.
42 |
43 | Es importante tener en cuenta que Java es un lenguaje de tipado estático, lo que significa que los tipos de las variables deben ser declarados explícitamente antes de usarlas. Cada variable tiene un tipo específico y solo puede almacenar valores compatibles con ese tipo.
44 |
45 |
46 |
47 | ```java
48 | // Variables.java
49 |
50 | public class Variables {
51 | public static void main(String[] args) {
52 | // Declarar la variable edad de tipo int (números enteros)
53 | int edad;
54 |
55 | // Actualizar el contenido de la variable edad:
56 | edad = 10; // si ya habías declarado la variable
57 |
58 | // Declarar una variable y asignarle un valor al mismo tiempo:
59 | int salario = 1000;
60 |
61 | // Crear una variable de tipo String:
62 | String nombre = "Gustavo";
63 | }
64 | }
65 | ```
66 |
67 | - Java nos permite actualizar nuestras variables reutilizando los valores que tenían anteriormente, de esta forma evitamos errores o inconsistencias en nuestro código:
68 |
69 | ```java
70 | public class Example {
71 | public static void main(String[] args) {
72 | // Actualizar datos numéricos:
73 | int salario = 1000;
74 | salario = salario + 200;
75 | System.out.println(salario); // 1200
76 |
77 | salario += 300;
78 | System.out.println(salario); // 1500
79 |
80 | // Actualizar variables de tipo String:
81 | String nombre = "Santiago";
82 | nombre = nombre + " Castillo";
83 | System.out.println(nombre); // Santiago Castillo
84 |
85 | nombre += " De León";
86 | System.out.println(nombre); // Santiago Castillo De León
87 |
88 | nombre = "Alex" + nombre;
89 | System.out.println(nombre); // Alex Santiago Castillo De León
90 | }
91 | }
92 |
93 | ```
94 |
95 | ## Reglas para Definir Nombres de Variables en Java
96 |
97 | Aquí tienes algunas reglas para definir nombres de variables en Java:
98 |
99 | 1. Los nombres de variables en Java son sensibles a mayúsculas y minúsculas, lo que significa que `miVariable` y `mivariable` se considerarán como dos variables diferentes.
100 |
101 | 2. Los nombres de variables deben comenzar con una letra, un guion bajo (`_`) o un símbolo de dólar (`$`). No pueden comenzar con un número.
102 |
103 | 3. Después del primer carácter, los nombres de variables pueden contener letras, dígitos, guiones bajos y símbolos de dólar.
104 |
105 | 4. Los nombres de variables no pueden ser palabras reservadas de Java, como `int`, `boolean`, `if`, `for`, entre otras. Puedes encontrar una lista completa de palabras reservadas en la documentación oficial de Java.
106 |
107 | 5. Es una buena práctica utilizar nombres descriptivos para las variables, que indiquen su propósito o contenido. Por ejemplo, en lugar de usar nombres como `a`, `x` o `temp`, es preferible utilizar nombres como `edad`, `nombreUsuario` o `totalVentas`.
108 |
109 | 6. Se recomienda seguir una convención de nomenclatura llamada CamelCase, donde la primera letra de la variable comienza en minúscula y las primeras letras de las palabras subsiguientes se capitalizan. Por ejemplo: `nombreUsuario`, `totalVentas`, `saldoCuenta`.
110 |
111 | 7. Evita utilizar nombres de variables demasiado largos y complicados, ya que esto puede dificultar la legibilidad del código. Busca un equilibrio entre nombres descriptivos y concisos.
112 |
113 | Recuerda seguir estas convenciones al nombrar tus variables en Java para mantener un código legible y comprensible.
114 |
115 | ## Convenciones de Nomenclatura para Clases y Métodos en Java
116 |
117 | A continuación, se presentan las convenciones de nomenclatura recomendadas para clases y métodos en Java:
118 |
119 | ### Clases
120 |
121 | - Los nombres de las clases deben comenzar con una letra mayúscula y seguir el estilo CamelCase.
122 | - Utiliza nombres descriptivos que reflejen el propósito y la responsabilidad de la clase.
123 | - Evita nombres de clases demasiado genéricos o ambiguos.
124 |
125 | Ejemplo:
126 | ```java
127 | public class MiClase {
128 | // código de la clase
129 | }
130 | ```
131 |
132 |
133 | ### Métodos
134 |
135 | - Los nombres de los métodos deben comenzar con una letra minúscula y seguir el estilo camelCase.
136 | - Utiliza nombres descriptivos que indiquen la acción realizada por el método.
137 | - Los nombres de los métodos deben ser verbos o frases verbales.
138 |
139 | ```java
140 | public void calcularPromedio() {
141 | // código del método
142 | }
143 | ```
144 |
145 | ### Métodos de Acceso (Getters y Setters)
146 |
147 | - Los métodos de acceso deben seguir la convención de los métodos normales.
148 | - Utiliza el prefijo "get" para los métodos que devuelven el valor de una propiedad.
149 | - Utiliza el prefijo "set" para los métodos que establecen el valor de una propiedad.
150 |
151 | ```java
152 | public int getEdad() {
153 | return edad;
154 | }
155 |
156 | public void setEdad(int edad) {
157 | this.edad = edad;
158 | }
159 | ```
160 |
161 | Recuerda seguir estas convenciones de nomenclatura al escribir tus clases y métodos en Java para mantener un código consistente y legible.
162 |
163 |
164 | # Tipos de Datos Numéricos en Java
165 |
166 | En Java, existen varios tipos de datos numéricos que se utilizan para representar diferentes rangos y precisiones de valores numéricos. A continuación, se presentan algunos ejemplos de estos tipos de datos numéricos:
167 |
168 | - `byte`: Representa números enteros de 8 bits con signo. Su rango va desde -128 hasta 127.
169 |
170 | ```java
171 | byte myByte = 10;
172 | ```
173 | - `short`: Representa números enteros de 16 bits con signo. Su rango va desde -32,768 hasta 32,767.
174 | ```java
175 | short myShort = 1000;
176 | ```
177 |
178 | - `int`: Representa números enteros de 32 bits con signo. Es el tipo de dato numérico más común en Java. Su rango va desde -2,147,483,648 hasta 2,147,483,647.
179 | ```java
180 | int myInt = 100000;
181 | ```
182 |
183 | - `long`: Representa números enteros de 64 bits con signo. Debes agregar una "L" al final del valor para indicar que es un tipo long. Su rango va desde -9,223,372,036,854,775,808 hasta 9,223,372,036,854,775,807.
184 | ```java
185 | long myLong = 10000000000L;
186 | ```
187 |
188 | - `float`: Representa números de punto flotante de 32 bits. Debes agregar una "f" o "F" al final del valor para indicar que es un tipo float.
189 | ```java
190 | float myFloat = 3.14f;
191 | ```
192 |
193 | - `double`: Representa números de punto flotante de 64 bits. Es el tipo de dato numérico decimal más común en Java. No es necesario agregar nada al final del valor para indicar que es un tipo double.
194 | ```java
195 | double myDouble = 3.14159;
196 |
197 | ```
198 |
199 | Estos son solo algunos ejemplos de los tipos de datos numéricos en Java. Puedes utilizar estos tipos de datos para almacenar y manipular diferentes valores numéricos en tus programas Java.
200 |
201 |
202 | ```java
203 | public class Main {
204 | public static void main(String[] args) {
205 |
206 | //byte, short, int, long
207 | System.out.println("bits tipo byte:" + Byte.SIZE);
208 | System.out.println("bytes tipo byte:" + Byte.BYTES);
209 | System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
210 | System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
211 |
212 | System.out.println();
213 |
214 | System.out.println("bits tipo short:" + Short.SIZE);
215 | System.out.println("bytes tipo short:" + Short.BYTES);
216 | System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
217 | System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
218 |
219 | System.out.println();
220 |
221 | System.out.println("bits tipo int:" + Integer.SIZE);
222 | System.out.println("bytes tipo int:" + Integer.BYTES);
223 | System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
224 | System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
225 |
226 | System.out.println();
227 |
228 | System.out.println("bits tipo long:" + Long.SIZE);
229 | System.out.println("bytes tipo long:" + Long.BYTES);
230 | System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
231 | System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);
232 |
233 | System.out.println();
234 |
235 | System.out.println("bits tipo float:" + Float.SIZE);
236 | System.out.println("bytes tipo float:" + Float.BYTES);
237 | System.out.println("valor minimo tipo float:" + Float.MIN_VALUE);
238 | System.out.println("valor maximo tipo float:" + Float.MAX_VALUE);
239 |
240 | System.out.println();
241 |
242 | System.out.println("bits tipo Double:" + Double.SIZE);
243 | System.out.println("bytes tipo Double:" + Double.BYTES);
244 | System.out.println("valor minimo tipo Double:" + Double.MIN_VALUE);
245 | System.out.println("valor maximo tipo Double:" + Double.MAX_VALUE);
246 |
247 | System.out.println();
248 |
249 | System.out.println("bits tipo char:" + Character.SIZE);
250 | System.out.println("bytes tipo char:" + Character.BYTES);
251 | }
252 | }
253 |
254 | ```
255 | # Tipos de Datos en Java
256 |
257 | En Java, además de los tipos de datos numéricos, existen otros tipos de datos que se utilizan para diferentes propósitos. A continuación se presentan algunos de estos tipos de datos:
258 |
259 | - `boolean`: Representa un valor de verdad, que puede ser `true` (verdadero) o `false` (falso). Se utiliza principalmente en estructuras de control condicionales.
260 |
261 | - `char`: Representa un solo carácter Unicode. Se declara utilizando comillas simples (' '). Por ejemplo, `char myChar = 'A';`.
262 |
263 | - `String`: Representa una secuencia de caracteres. Aunque técnicamente no es un tipo de dato primitivo, se utiliza ampliamente en Java para representar texto y se trata de manera especial en el lenguaje.
264 |
265 | - Arreglo (`array`): Representa una colección de elementos del mismo tipo. Permite almacenar múltiples valores en una única variable. Se declara utilizando corchetes []. Por ejemplo, `int[] myArray = {1, 2, 3};`.
266 |
267 | - Enumerado (`enum`): Representa un conjunto de constantes predefinidas. Se utiliza para definir un conjunto de valores permitidos para una variable. Por ejemplo, `enum Day {MONDAY, TUESDAY, WEDNESDAY};`.
268 |
269 |
270 | # Palabra reservada `var` en Java
271 |
272 | la palabra reservada var se introdujo en la versión 10 del lenguaje y se utiliza para declarar variables con inferencia de tipos. Con `var`, el tipo de dato de la variable se infiere automáticamente a partir del valor que se le asigna en el momento de la declaración.
273 |
274 | Algunas consideraciones sobre el uso de `var` en Java:
275 |
276 | - **Inferencia de tipos**: Al utilizar `var`, el compilador deduce automáticamente el tipo de dato de la variable basándose en el valor asignado.
277 |
278 | - **Uso local**: `var` solo se puede utilizar para declarar variables locales dentro de métodos o bloques de código.
279 |
280 | - **Tipo estático**: Aunque el tipo de dato se infiere automáticamente, la variable sigue siendo fuertemente tipada.
281 |
282 | - **Inicialización requerida**: Es obligatorio inicializar la variable al momento de la declaración.
283 |
284 | Aquí tienes un ejemplo de cómo se utiliza `var` en Java:
285 |
286 | ```java
287 | var message = "Hola, mundo!"; // El tipo de dato de 'message' se infiere como String
288 | var number = 10; // El tipo de dato de 'number' se infiere como int
289 | var pi = 3.14; // El tipo de dato de 'pi' se infiere como double
290 |
291 | System.out.println(message);
292 | System.out.println(number);
293 | System.out.println(pi);
294 | ```
295 |
296 |
297 |
298 | | Tipo de dato | Bits | bytes | Rango |
299 | | ------------- | ---- | ----- | ----- |
300 | | `byte` | 8 | 1 | -128 hasta 127
301 | | `short` | 16 | 2 | -32768 hasta 32767
302 | | `int` | 32 | 4 | -2147483648 hasta 2147483647 |
303 | | `long` | 64 | 8 | -9223372036854775808 hasta 9223372036854775807 |
304 | | `float` | 32 | 4 | 1.4E-45 hasta 3.4028235E38 |
305 | | `double` | 64 | 8 | 4.9E-324 hasta 1.7976931348623157E308 |
306 | | `char` | 16 | 2 | solo puede almacenar 1 dígito o un carácter |
307 | | `boolean` | 16 | 2 | Son un tipo de dato lógico, solo aceptan los valores `true` o `false` |
308 |
309 | **[⬆ Volver a índice](#índice)**
310 |
311 | ---
312 |
313 | ## Comentarios en Java
314 |
315 | En Java, los comentarios se utilizan para agregar notas o explicaciones en el código fuente. Los comentarios no se ejecutan como parte del programa y son ignorados por el compilador. Son útiles para hacer el código más legible y comprensible para otros programadores o para tu futuro yo.
316 |
317 | Java admite tres tipos de comentarios:
318 |
319 | - **Comentarios de una línea**: Estos comentarios se utilizan para agregar notas breves en una sola línea.
320 | ```java
321 | // Esto es un comentario de una línea
322 | int x = 5; // También se pueden agregar comentarios después del código en la misma línea
323 | ```
324 |
325 | - **Comentarios de múltiples líneas**: Estos comentarios se utilizan para agregar notas o explicaciones más extensas que abarcan varias líneas.
326 | ```java
327 | /*
328 | Este es un comentario
329 | de múltiples líneas.
330 | Puedo escribir aquí varias líneas de texto
331 | sin afectar el código.
332 | */
333 | ```
334 |
335 | - **Comentarios de documentación**: Estos comentarios se utilizan para generar documentación automática utilizando la herramienta Javadoc. Los comentarios de documentación siguen una estructura específica y se utilizan para describir clases, métodos, parámetros y valores de retorno.
336 | ```java
337 | /**
338 | * Esta clase representa un objeto de tipo Persona.
339 | * Contiene atributos y métodos relacionados con una persona.
340 | */
341 | public class Persona {
342 | /**
343 | * Este método devuelve el nombre de la persona.
344 | * @return El nombre de la persona.
345 | */
346 | public String getNombre() {
347 | // ...
348 | }
349 | }
350 | ```
351 |
352 | Los comentarios son una buena práctica de programación y te ayudan a mantener tu código organizado y comprensible. Utilízalos para explicar la lógica detrás de tu código, documentar decisiones importantes o proporcionar instrucciones a otros programadores que puedan trabajar en el mismo código en el futuro.
353 |
354 | ---
355 |
356 | ## Operadores Aritméticos:
357 | ```java
358 | int a = 10;
359 | int b = 5;
360 |
361 | int suma = a + b; // suma = 15
362 | int resta = a - b; // resta = 5
363 | int multiplicacion = a * b; // multiplicacion = 50
364 | int division = a / b; // division = 2
365 | int modulo = a % b; // modulo = 0
366 | ```
367 |
368 | ## Operadores de Asignación:
369 | ```java
370 | int x = 10;
371 |
372 | x += 5; // equivalente a x = x + 5;
373 | x -= 3; // equivalente a x = x - 3;
374 | x *= 2; // equivalente a x = x * 2;
375 | x /= 4; // equivalente a x = x / 4;
376 | x %= 3; // equivalente a x = x % 3;
377 | ```
378 |
379 | ## Operadores de Comparación:
380 | ```java
381 | int a = 10;
382 | int b = 5;
383 |
384 | boolean igual = (a == b); // false
385 | boolean diferente = (a != b); // true
386 | boolean mayor = (a > b); // true
387 | boolean menor = (a < b); // false
388 | boolean mayorIgual = (a >= b); // true
389 | boolean menorIgual = (a <= b); // false
390 | ```
391 |
392 | ## Operadores de Incremento y Decremento:
393 | ```java
394 | int x = 5;
395 |
396 | x++; // incremento en 1, x = 6
397 | x--; // decremento en 1, x = 5
398 |
399 | int y = 10;
400 | int z = ++y; // incremento antes de asignar, z = 11, y = 11
401 |
402 | int w = 10;
403 | int v = w++; // incremento después de asignar, v = 10, w = 11
404 | ```
405 |
406 | ## Operadores Lógicos:
407 | ```java
408 | boolean a = true;
409 | boolean b = false;
410 |
411 | boolean and = (a && b); // false
412 | boolean or = (a || b); // true
413 | boolean not = !a; // false
414 | ```
415 |
416 | # Operaciones matemáticas con la clase Math en Java
417 |
418 | En Java, puedes realizar operaciones matemáticas comunes utilizando la clase `Math`. Esta clase proporciona métodos estáticos para realizar cálculos matemáticos sin tener que implementar las operaciones desde cero.
419 |
420 | ## Ejemplos de uso
421 |
422 | Aquí tienes algunos ejemplos de cómo utilizar la clase `Math` en Java:
423 |
424 | ### Operaciones básicas:
425 |
426 | ```java
427 | double x = 4.3;
428 | double y = 2.5;
429 |
430 | double max = Math.max(x, y); // Obtiene el valor máximo entre x e y (max = 4.3)
431 | double min = Math.min(x, y); // Obtiene el valor mínimo entre x e y (min = 2.5)
432 | double abs = Math.abs(-5.6); // Obtiene el valor absoluto de -5.6 (abs = 5.6)
433 | double sqrt = Math.sqrt(25); // Obtiene la raíz cuadrada de 25 (sqrt = 5.0)
434 | ```
435 | ### Funciones trigonométricas:
436 | ```java
437 | double angle = 45.0;
438 | double radians = Math.toRadians(angle); // Convierte el ángulo a radianes
439 | double sin = Math.sin(radians); // Calcula el seno del ángulo (sin = 0.7071)
440 | double cos = Math.cos(radians); // Calcula el coseno del ángulo (cos = 0.7071)
441 | double tan = Math.tan(radians); // Calcula la tangente del ángulo (tan = 1.0)
442 |
443 | ```
444 |
445 | ### Funciones exponenciales y logarítmicas:
446 | ```java
447 | double power = Math.pow(2, 3); // Calcula 2 elevado a la potencia de 3 (power = 8.0)
448 | double exp = Math.exp(1.0); // Calcula el exponencial de 1.0 (exp = 2.7183)
449 | double log = Math.log(10.0); // Calcula el logaritmo natural de 10.0 (log = 2.3026)
450 | double log10 = Math.log10(100.0); // Calcula el logaritmo base 10 de 100.0 (log10 = 2.0)
451 |
452 | ```
453 |
454 | ### Generación de números aleatorios:
455 | ```java
456 | double random = Math.random(); // Genera un número aleatorio entre 0.0 y 1.0
457 | int randomInt = (int) (Math.random() * 10); // Genera un número aleatorio entre 0 y 9
458 |
459 | ```
460 |
461 | Estos son solo algunos ejemplos de cómo puedes utilizar el operador Math en Java. La clase Math proporciona muchos más métodos para realizar operaciones matemáticas más complejas. Puedes consultar la documentación oficial de Java para obtener más información sobre los métodos disponibles en la clase `Math`.
462 |
463 | ## Casting en Java
464 |
465 | ### Casting de ampliación (upcasting):
466 | ```java
467 | int x = 5;
468 | double y = x; // Casting implícito de int a double (upcasting)
469 | System.out.println(y); // Resultado: 5.0
470 | ```
471 |
472 | ### Casting de reducción (downcasting):
473 | ```java
474 | double x = 3.14;
475 | int y = (int) x; // Casting explícito de double a int (downcasting)
476 | System.out.println(y); // Resultado: 3 (parte decimal truncada)
477 | ```
478 |
479 | ### Casting entre tipos numéricos:
480 | ```java
481 | int a = 10;
482 | byte b = (byte) a; // Casting explícito de int a byte
483 | System.out.println(b); // Resultado: 10 (sin pérdida de información)
484 |
485 | double c = 3.75;
486 | int d = (int) c; // Casting explícito de double a int
487 | System.out.println(d); // Resultado: 3 (parte decimal truncada)
488 |
489 | long e = 2147483643534547l;
490 | int f = (int) e; // Casting explícito de long a int
491 | System.out.println(f); // Resultado: -4465453 (pérdida de información, fuera del rango de int)
492 | ```
493 | ### Casting con tipos de datos booleanos:
494 | ```java
495 | int x = 1;
496 | boolean y = (x != 0); // Casting implícito de int a boolean
497 | System.out.println(y); // Resultado: true
498 |
499 | boolean z = true;
500 | int w = (z) ? 1 : 0; // Casting implícito de boolean a int
501 | System.out.println(w); // Resultado: 1
502 |
503 | ```
504 |
--------------------------------------------------------------------------------
/01_introduccion/src/Casting.java:
--------------------------------------------------------------------------------
1 | public class Casting {
2 | public static void main(String[] args) {
3 | // Casting de ampliación (upcasting):
4 |
5 | // int x = 5;
6 | // double y = x; // Casting implícito de int a double (upcasting)
7 | // System.out.println(y); // Resultado: 5.0
8 |
9 | // Casting de reducción (downcasting):
10 | // double x = 3.14;
11 | // int y = (int) x; // Casting explícito de double a int (downcasting)
12 | // System.out.println(y); // Resultado: 3 (parte decimal truncada)
13 |
14 | // Casting entre tipos numéricos:
15 | int a = 10;
16 | byte b = (byte) a; // Casting explícito de int a byte
17 | System.out.println(b); // Resultado: 10 (sin pérdida de información)
18 |
19 | double c = 3.75;
20 | int d = (int) c; // Casting explícito de double a int
21 | System.out.println(d); // Resultado: 3 (parte decimal truncada)
22 |
23 | long e = 2147483643534547l;
24 | int f = (int) e; // Casting explícito de long a int
25 | System.out.println(f); // Resultado: -4465453 (pérdida de información, fuera del rango de int)
26 |
27 | //Casting con tipos de datos booleanos:
28 | int x = 1;
29 | boolean y = (x != 0); // Casting implícito de int a boolean
30 | System.out.println(y); // Resultado: true
31 |
32 | boolean z = true;
33 | int w = (z) ? 1 : 0; // Casting implícito de boolean a int
34 | System.out.println(w); // Resultado: 1
35 |
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadorDecrementoIncremento.java:
--------------------------------------------------------------------------------
1 | public class OperadorDecrementoIncremento {
2 | public static void main(String[] args) {
3 | int x = 5;
4 |
5 | x++; // incremento en 1, x = 6
6 | x--; // decremento en 1, x = 5
7 |
8 | int y = 10;
9 | int z = ++y; // incremento antes de asignar, z = 11, y = 11
10 |
11 | int w = 10;
12 | int v = w++; // incremento después de asignar, v = 10, w = 11
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadorMath.java:
--------------------------------------------------------------------------------
1 | public class OperadorMath {
2 | public static void main(String[] args) {
3 | double x = 4.3;
4 | double y = 2.5;
5 |
6 | //Operaciones básicas:
7 | double max = Math.max(x, y); // Obtiene el valor máximo entre x e y (max = 4.3)
8 | double min = Math.min(x, y); // Obtiene el valor mínimo entre x e y (min = 2.5)
9 | double abs = Math.abs(-5.6); // Obtiene el valor absoluto de -5.6 (abs = 5.6)
10 | double sqrt = Math.sqrt(25); // Obtiene la raíz cuadrada de 25 (sqrt = 5.0)
11 |
12 |
13 | // Funciones trigonométricas:
14 | double angle = 45.0;
15 | double radians = Math.toRadians(angle); // Convierte el ángulo a radianes
16 | double sin = Math.sin(radians); // Calcula el seno del ángulo (sin = 0.7071)
17 | double cos = Math.cos(radians); // Calcula el coseno del ángulo (cos = 0.7071)
18 | double tan = Math.tan(radians); // Calcula la tangente del ángulo (tan = 1.0)
19 |
20 | // Funciones exponenciales y logarítmicas:
21 | double power = Math.pow(2, 3); // Calcula 2 elevado a la potencia de 3 (power = 8.0)
22 | double exp = Math.exp(1.0); // Calcula el exponencial de 1.0 (exp = 2.7183)
23 | double log = Math.log(10.0); // Calcula el logaritmo natural de 10.0 (log = 2.3026)
24 | double log10 = Math.log10(100.0); // Calcula el logaritmo base 10 de 100.0 (log10 = 2.0)
25 |
26 | // Generación de números aleatorios:
27 |
28 | double random = Math.random(); // Genera un número aleatorio entre 0.0 y 1.0
29 | int randomInt = (int) (Math.random() * 10); // Genera un número aleatorio entre 0 y 9
30 |
31 |
32 |
33 |
34 |
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadoresAritmeticos.java:
--------------------------------------------------------------------------------
1 | public class OperadoresAritmeticos {
2 | public static void main(String[] args) {
3 | int a = 10;
4 | int b = 5;
5 |
6 | int suma = a + b; // suma = 15
7 | int resta = a - b; // resta = 5
8 | int multiplicacion = a * b; // multiplicacion = 50
9 | int division = a / b; // division = 2
10 | int modulo = a % b; // modulo = 0
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadoresAsignacion.java:
--------------------------------------------------------------------------------
1 | public class OperadoresAsignacion {
2 | public static void main(String[] args) {
3 | int x = 10;
4 |
5 | x += 5; // equivalente a x = x + 5;
6 | x -= 3; // equivalente a x = x - 3;
7 | x *= 2; // equivalente a x = x * 2;
8 | x /= 4; // equivalente a x = x / 4;
9 | x %= 3; // equivalente a x = x % 3;
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadoresComparacion.java:
--------------------------------------------------------------------------------
1 | public class OperadoresComparacion {
2 | public static void main(String[] args) {
3 | int a = 10;
4 | int b = 5;
5 |
6 | boolean igual = (a == b); // false
7 | boolean diferente = (a != b); // true
8 | boolean mayor = (a > b); // true
9 | boolean menor = (a < b); // false
10 | boolean mayorIgual = (a >= b); // true
11 | boolean menorIgual = (a <= b); // false
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/01_introduccion/src/OperadoresLogicos.java:
--------------------------------------------------------------------------------
1 | public class OperadoresLogicos {
2 | public static void main(String[] args) {
3 | boolean a = true;
4 | boolean b = false;
5 |
6 | boolean and = (a && b); // false
7 | System.out.println(and);
8 |
9 | boolean or = (a || b); // true
10 | System.out.println(or);
11 |
12 | boolean not = !a; // false
13 | System.out.println(not);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/01_introduccion/src/PalabraReservadaVar.java:
--------------------------------------------------------------------------------
1 | public class PalabraReservadaVar {
2 | public static void main(String[] args) {
3 | var message = "Hola, mundo!"; // El tipo de dato de 'message' se infiere como String
4 | var number = 10; // El tipo de dato de 'number' se infiere como int
5 | var pi = 3.14; // El tipo de dato de 'pi' se infiere como double
6 |
7 | System.out.println(message);
8 | System.out.println(number);
9 | System.out.println(pi);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/01_introduccion/src/TiposDatos.java:
--------------------------------------------------------------------------------
1 | public class TiposDatos {
2 | public static void main(String[] args) {
3 | //byte, short, int, long
4 | System.out.println("bits tipo byte:" + Byte.SIZE);
5 | System.out.println("bytes tipo byte:" + Byte.BYTES);
6 | System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
7 | System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
8 |
9 | System.out.println();
10 |
11 | System.out.println("bits tipo short:" + Short.SIZE);
12 | System.out.println("bytes tipo short:" + Short.BYTES);
13 | System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
14 | System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
15 |
16 | System.out.println();
17 |
18 | System.out.println("bits tipo int:" + Integer.SIZE);
19 | System.out.println("bytes tipo int:" + Integer.BYTES);
20 | System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
21 | System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
22 |
23 | System.out.println();
24 |
25 | System.out.println("bits tipo long:" + Long.SIZE);
26 | System.out.println("bytes tipo long:" + Long.BYTES);
27 | System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
28 | System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);
29 |
30 | System.out.println();
31 |
32 | System.out.println("bits tipo float:" + Float.SIZE);
33 | System.out.println("bytes tipo float:" + Float.BYTES);
34 | System.out.println("valor minimo tipo float:" + Float.MIN_VALUE);
35 | System.out.println("valor maximo tipo float:" + Float.MAX_VALUE);
36 |
37 | System.out.println();
38 |
39 | System.out.println("bits tipo Double:" + Double.SIZE);
40 | System.out.println("bytes tipo Double:" + Double.BYTES);
41 | System.out.println("valor minimo tipo Double:" + Double.MIN_VALUE);
42 | System.out.println("valor maximo tipo Double:" + Double.MAX_VALUE);
43 |
44 | System.out.println();
45 |
46 | System.out.println("bits tipo char:" + Character.SIZE);
47 | System.out.println("bytes tipo char:" + Character.BYTES);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/01_introduccion/src/Variables.java:
--------------------------------------------------------------------------------
1 | // Variables.java
2 |
3 | public class Variables {
4 | public static void main(String[] args) {
5 | // Declarar la variable edad de tipo int (números enteros)
6 | int edad;
7 |
8 | // Actualizar el contenido de la variable edad:
9 | edad = 10; // si ya habías declarado la variable
10 |
11 | // Declarar una variable y asignarle un valor al mismo tiempo:
12 | //int salario = 1000;
13 |
14 | // Crear una variable de tipo String:
15 | // String nombre = "Gustavo";
16 |
17 |
18 |
19 | // Actualizar datos numéricos:
20 | int salario = 1000;
21 | salario = salario + 200;
22 | System.out.println(salario); // 1200
23 |
24 | salario += 300;
25 | System.out.println(salario); // 1500
26 |
27 | // Actualizar variables de tipo String:
28 | String nombre = "Santiago";
29 | nombre = nombre + " Castillo";
30 | System.out.println(nombre); // Santiago Castillo
31 |
32 | nombre += " De León";
33 | System.out.println(nombre); // Santiago Castillo De León
34 |
35 | nombre = "Alex" + nombre;
36 | System.out.println(nombre); // Alex Santiago Castillo De León
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/02_estructura_de_control/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/02_estructura_de_control/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/02_estructura_de_control/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/02_estructura_de_control/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/02_estructura_de_control/.idea/uiDesigner.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
--------------------------------------------------------------------------------
/02_estructura_de_control/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/02_estructura_de_control/Estructura_control.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/02_estructura_de_control/README.md:
--------------------------------------------------------------------------------
1 |
2 | # Estructuras de Control en Java
3 |
4 | En Java, las estructuras de control son bloques de código que permiten controlar el flujo de ejecución de un programa. Estas estructuras permiten tomar decisiones y repetir bloques de código según sea necesario
5 |
6 | Este repositorio contiene ejemplos de código en Java relacionados con los diferentes flujos de control disponibles en el lenguaje. Los flujos de control son estructuras que permiten tomar decisiones y repetir acciones en función de ciertas condiciones. Los flujos de control disponibles en Java incluyen:
7 |
8 | 1. **Estructura "if-else":** Permite ejecutar un bloque de código si se cumple una condición, y otro bloque de código si no se cumple. Se pueden utilizar operadores lógicos y de comparación para definir las condiciones.
9 |
10 | 2. **Estructura "switch":** Permite evaluar diferentes casos y ejecutar un bloque de código correspondiente al caso que coincide con una expresión. Es una alternativa a la estructura "if-else" cuando se tienen múltiples condiciones.
11 |
12 | 3. **Estructura "while":** Permite repetir un bloque de código mientras se cumpla una condición especificada. La condición se verifica antes de cada iteración.
13 |
14 | 4. **Estructura "do-while":** Similar a la estructura "while", pero la condición se verifica después de cada iteración. Esto garantiza que el bloque de código se ejecute al menos una vez, incluso si la condición inicialmente es falsa.
15 |
16 | 5. **Estructura "for":** Permite ejecutar un bloque de código un número específico de veces. Se utiliza para iterar sobre un rango de valores, como elementos de una lista o índices de un arreglo.
17 |
18 |
19 |
20 | ## Condicionales
21 |
22 | ### if-else
23 |
24 | La estructura de control if-else permite ejecutar un bloque de código si se cumple una condición y otro bloque de código si la condición no se cumple.
25 |
26 | Ejemplo:
27 | ```java
28 | if (condicion) {
29 | // Código a ejecutar si la condición es verdadera
30 | } else {
31 | // Código a ejecutar si la condición es falsa
32 | }
33 | ```
34 |
35 | ### Ejemplos:
36 |
37 | ```java
38 | import java.util.Scanner;
39 |
40 | public class IfElseExample {
41 | public static void main(String[] args) {
42 | Scanner scanner = new Scanner(System.in);
43 |
44 | System.out.print("Ingresa tu edad: ");
45 | int edad = scanner.nextInt();
46 |
47 | if (edad >= 18) {
48 | System.out.println("Eres mayor de edad");
49 | } else {
50 | System.out.println("Eres menor de edad");
51 | }
52 |
53 | scanner.close();
54 | }
55 | }
56 |
57 | ```
58 |
59 | ```java
60 | int edad = 25;
61 |
62 | if (edad < 18) {
63 | System.out.println("Eres menor de edad");
64 | } else if (edad >= 18 && edad <= 65) {
65 | System.out.println("Eres adulto");
66 | } else {
67 | System.out.println("Eres mayor de edad");
68 | }
69 |
70 | ```
71 |
72 | ```java
73 | import java.util.Scanner;
74 |
75 | public class IfElseExample {
76 | public static void main(String[] args) {
77 | Scanner scanner = new Scanner(System.in);
78 |
79 | System.out.print("Ingresa tu género (Hombre/Mujer): ");
80 | String genero = scanner.nextLine();
81 |
82 | if (genero.equalsIgnoreCase("Hombre")) {
83 | System.out.println("Bienvenido");
84 | } else if (genero.equalsIgnoreCase("Mujer")) {
85 | System.out.println("Bienvenida");
86 | } else {
87 | System.out.println("Género no reconocido");
88 | }
89 |
90 | scanner.close();
91 | }
92 | }
93 |
94 | ```
95 |
96 |
97 | ```java
98 | import java.util.Scanner;
99 |
100 | public class IfElseExample {
101 | public static void main(String[] args) {
102 | Scanner scanner = new Scanner(System.in);
103 |
104 | System.out.print("Ingresa tu edad: ");
105 | int edad = scanner.nextInt();
106 | scanner.nextLine();
107 |
108 | System.out.print("¿Tienes un título universitario? (Sí/No): ");
109 | String titulo = scanner.nextLine();
110 |
111 | System.out.print("¿Tienes experiencia laboral? (Sí/No): ");
112 | String experiencia = scanner.nextLine();
113 |
114 | if (edad >= 22 && titulo.equalsIgnoreCase("Sí") && experiencia.equalsIgnoreCase("Sí")) {
115 | System.out.println("Eres elegible para este empleo de nivel avanzado");
116 | } else if (edad >= 18 && titulo.equalsIgnoreCase("Sí")) {
117 | System.out.println("Eres elegible para este empleo de nivel intermedio");
118 | } else {
119 | System.out.println("No eres elegible para este empleo");
120 | }
121 |
122 | scanner.close();
123 | }
124 | }
125 |
126 | ```
127 |
128 |
129 | ```java
130 | import java.util.Scanner;
131 |
132 | public class IfElseExample {
133 | public static void main(String[] args) {
134 | Scanner scanner = new Scanner(System.in);
135 |
136 | System.out.print("Ingresa un número del 1 al 7: ");
137 | int numero = scanner.nextInt();
138 |
139 | if (numero >= 1 && numero <= 7) {
140 | if (numero == 1) {
141 | System.out.println("Lunes");
142 | } else if (numero == 2) {
143 | System.out.println("Martes");
144 | } else if (numero == 3) {
145 | System.out.println("Miércoles");
146 | } else if (numero == 4) {
147 | System.out.println("Jueves");
148 | } else if (numero == 5) {
149 | System.out.println("Viernes");
150 | } else if (numero == 6) {
151 | System.out.println("Sábado");
152 | } else {
153 | System.out.println("Domingo");
154 | }
155 | } else {
156 | System.out.println("Número inválido. Debe estar entre 1 y 7");
157 | }
158 |
159 | scanner.close();
160 | }
161 | }
162 |
163 |
164 | ```
165 |
166 |
167 | #### 1. `Ejercicio de adivinar un número`: Escribe un programa que genere un número aleatorio entre 1 y 100. Luego, solicita al usuario que adivine el número generado. Utilizando la estructura condicional if-else, muestra un mensaje indicando si el número ingresado por el usuario es mayor o menor que el número generado, y continúa solicitando al usuario que adivine hasta que lo haga correctamente.
168 |
169 | Solución
170 |
171 | ```java
172 | import java.util.Scanner;
173 | import java.util.Random;
174 |
175 | public class AdivinarNumero {
176 |
177 | public static void main(String[] args) {
178 | Scanner scanner = new Scanner(System.in);
179 | Random random = new Random();
180 |
181 | int numeroAleatorio = random.nextInt(100) + 1;
182 | int intentos = 0;
183 | int numeroIngresado;
184 |
185 | System.out.println("Adivina el número generado (entre 1 y 100)");
186 |
187 | do {
188 | System.out.print("Ingresa un número: ");
189 | numeroIngresado = scanner.nextInt();
190 | intentos++;
191 |
192 | if (numeroIngresado < numeroAleatorio) {
193 | System.out.println("El número ingresado es menor que el número generado.");
194 | } else if (numeroIngresado > numeroAleatorio) {
195 | System.out.println("El número ingresado es mayor que el número generado.");
196 | } else {
197 | System.out.println("¡Felicidades! Adivinaste el número en " + intentos + " intentos.");
198 | }
199 | } while (numeroIngresado != numeroAleatorio);
200 |
201 | scanner.close();
202 | }
203 | }
204 | ```
205 |
206 | En este programa, se genera un número aleatorio utilizando la clase `Random` y se almacena en la variable numeroAleatorio. Luego, se solicita al usuario que adivine el número y se utiliza un bucle do-while para continuar solicitando el número hasta que se adivine correctamente.
207 |
208 | Dentro del bucle, se compara el número ingresado por el usuario con el número aleatorio utilizando la estructura condicional if-else. Se muestra un mensaje indicando si el número es mayor o menor que el número generado. Si el número ingresado es igual al número generado, se muestra un mensaje de felicitaciones y se termina el bucle.
209 |
210 | El programa también lleva un contador de intentos para mostrar cuántos intentos tomó al usuario adivinar el número.
211 |
212 |
213 |
214 | ---
215 |
216 |
217 | #### 2. `Ejercicio de determinar el día de la semana:` Escribe un programa que solicite al usuario ingresar un número del 1 al 7 que represente un día de la semana. Utilizando la estructura condicional if-else, muestra el nombre del día correspondiente (por ejemplo, 1 para "Lunes", 2 para "Martes", etc.).
218 |
219 | Solución
220 |
221 | ```java
222 | import java.util.Scanner;
223 |
224 | public class DiaSemana {
225 |
226 | public static void main(String[] args) {
227 | Scanner scanner = new Scanner(System.in);
228 |
229 | System.out.print("Ingrese un número del 1 al 7: ");
230 | int numero = scanner.nextInt();
231 |
232 | if (numero == 1) {
233 | System.out.println("Lunes");
234 | } else if (numero == 2) {
235 | System.out.println("Martes");
236 | } else if (numero == 3) {
237 | System.out.println("Miércoles");
238 | } else if (numero == 4) {
239 | System.out.println("Jueves");
240 | } else if (numero == 5) {
241 | System.out.println("Viernes");
242 | } else if (numero == 6) {
243 | System.out.println("Sábado");
244 | } else if (numero == 7) {
245 | System.out.println("Domingo");
246 | } else {
247 | System.out.println("Número inválido");
248 | }
249 |
250 | scanner.close();
251 | }
252 | }
253 | ```
254 |
255 |
256 | ---
257 |
258 | #### 3. `Ejercicio de cálculo de descuento`: Escribe un programa que solicite al usuario ingresar el precio de un producto. Si el precio supera los $100, aplica un descuento del 10% y muestra el precio final; de lo contrario, muestra el precio sin descuento.
259 |
260 | Solución
261 |
262 | ```java
263 | import java.util.Scanner;
264 |
265 | public class Descuento {
266 |
267 | public static void main(String[] args) {
268 | Scanner scanner = new Scanner(System.in);
269 |
270 | System.out.print("Ingrese el precio del producto: ");
271 | double precio = scanner.nextDouble();
272 |
273 | if (precio > 100) {
274 | double descuento = precio * 0.1;
275 | double precioFinal = precio - descuento;
276 | System.out.println("Precio con descuento: $" + precioFinal);
277 | } else {
278 | System.out.println("Precio sin descuento: $" + precio);
279 | }
280 |
281 | scanner.close();
282 | }
283 | }
284 |
285 | ```
286 |
287 |
288 | ---
289 |
290 | #### 4. `Ejercicio de verificación de un triángulo`: Escribe un programa que solicite al usuario ingresar las longitudes de tres lados de un triángulo. Utilizando la estructura condicional if-else, verifica si es posible formar un triángulo con esas longitudes y muestra un mensaje correspondiente.
291 |
292 | Solución
293 |
294 | ```java
295 | import java.util.Scanner;
296 |
297 | public class VerificarTriangulo {
298 |
299 | public static void main(String[] args) {
300 | Scanner scanner = new Scanner(System.in);
301 |
302 | System.out.print("Ingrese la longitud del primer lado: ");
303 | double lado1 = scanner.nextDouble();
304 |
305 | System.out.print("Ingrese la longitud del segundo lado: ");
306 | double lado2 = scanner.nextDouble();
307 |
308 | System.out.print("Ingrese la longitud del tercer lado: ");
309 | double lado3 = scanner.nextDouble();
310 |
311 | if (lado1 + lado2 > lado3 && lado1 + lado3 > lado2 && lado2 + lado3 > lado1) {
312 | System.out.println("Se puede formar un triángulo con esas longitudes");
313 | } else {
314 | System.out.println("No se puede formar un triángulo con esas longitudes");
315 | }
316 |
317 | scanner.close();
318 | }
319 | }
320 |
321 | ```
322 |
323 |
324 | ---
325 |
326 |
327 | #### 5. `Ejercicio de conversión de temperaturas`: Escribe un programa que solicite al usuario ingresar una temperatura en grados Celsius. Utilizando la estructura condicional if-else, convierte la temperatura a grados Fahrenheit si es mayor o igual a 0, o a grados Kelvin si es menor a 0, y muestra el resultado.
328 |
329 | Solución
330 |
331 | ```java
332 | import java.util.Scanner;
333 |
334 | public class ConversionTemperatura {
335 |
336 | public static void main(String[] args) {
337 | Scanner scanner = new Scanner(System.in);
338 |
339 | System.out.print("Ingrese una temperatura en grados Celsius: ");
340 | double celsius = scanner.nextDouble();
341 |
342 | if (celsius >= 0) {
343 | double fahrenheit = celsius * 9 / 5 + 32;
344 | System.out.println("Temperatura en grados Fahrenheit: " + fahrenheit);
345 | } else {
346 | double kelvin = celsius + 273.15;
347 | System.out.println("Temperatura en grados Kelvin: " + kelvin);
348 | }
349 |
350 | scanner.close();
351 | }
352 | }
353 |
354 | ```
355 |
356 |
357 | ---
358 |
359 | # Ejercicios de Estructuras de Control en Java
360 |
361 | Este repositorio contiene una serie de ejercicios prácticos para practicar y reforzar los conceptos de estructuras de control en Java. Cada ejercicio se enfoca en un aspecto específico de las estructuras de control y tiene como objetivo mejorar tus habilidades de programación en Java.
362 |
363 |
364 | ## Ejercicio 1: Estructuras de control anidadas
365 |
366 | **Descripción**: Este ejercicio solicita al usuario que ingrese su edad y género. Utilizando estructuras de control anidadas, el programa verifica si la edad ingresada es mayor o igual a 18 y luego verifica el género para mostrar un mensaje de bienvenida adecuado.
367 |
368 | **Objetivo**: Practicar el uso de estructuras de control anidadas y tomar decisiones basadas en múltiples condiciones.
369 |
370 | Solución
371 |
372 | ```java
373 | import java.util.Scanner;
374 |
375 | public class EstructurasAnidadas {
376 | public static void main(String[] args) {
377 | Scanner scanner = new Scanner(System.in);
378 |
379 | System.out.print("Ingrese su edad: ");
380 | int edad = scanner.nextInt();
381 |
382 | System.out.print("Ingrese su género (M/F): ");
383 | char genero = scanner.next().charAt(0);
384 |
385 | if (edad >= 18) {
386 | if (genero == 'M') {
387 | System.out.println("Bienvenido, caballero");
388 | } else {
389 | System.out.println("Bienvenida, señorita");
390 | }
391 | } else {
392 | System.out.println("Lo siento, eres menor de edad");
393 | }
394 | }
395 | }
396 |
397 | ```
398 |
399 |
400 | ---
401 |
402 |
403 | ## Ejercicio 2: Estructuras de control avanzadas
404 |
405 | **Descripción**: En este ejercicio, se solicita al usuario que ingrese la cantidad de números que desea ingresar. Luego, se utiliza un bucle "enhanced" for para permitir que el usuario ingrese los números uno por uno. Finalmente, se muestra en pantalla la lista de números ingresados.
406 |
407 | **Objetivo**: Practicar el uso del bucle "enhanced" for y la interacción con el usuario para ingresar datos.
408 |
409 | Solución
410 |
411 | ```java
412 | import java.util.Scanner;
413 |
414 | public class EnhancedForLoop {
415 | public static void main(String[] args) {
416 | Scanner scanner = new Scanner(System.in);
417 |
418 | System.out.print("Ingrese la cantidad de números: ");
419 | int cantidad = scanner.nextInt();
420 |
421 | int[] numeros = new int[cantidad];
422 |
423 | System.out.println("Ingrese los números:");
424 | for (int i = 0; i < cantidad; i++) {
425 | numeros[i] = scanner.nextInt();
426 | }
427 |
428 | System.out.println("Los números ingresados son:");
429 | for (int numero : numeros) {
430 | System.out.println(numero);
431 | }
432 | }
433 | }
434 |
435 | ```
436 |
437 |
438 | ---
439 |
440 | ## Ejercicio 3: Uso de operadores lógicos
441 |
442 | **Descripción**: En este ejercicio, se pide al usuario que ingrese su edad y si es estudiante o no. Utilizando operadores lógicos (AND, OR, NOT), el programa evalúa diferentes condiciones y muestra mensajes en función de las respuestas ingresadas.
443 |
444 | **Objetivo**: Practicar el uso de operadores lógicos en combinación con las estructuras de control para evaluar múltiples condiciones.
445 |
446 | Solución
447 |
448 | ```java
449 | import java.util.Scanner;
450 |
451 | public class OperadoresLogicos {
452 | public static void main(String[] args) {
453 | Scanner scanner = new Scanner(System.in);
454 |
455 | System.out.print("Ingrese su edad: ");
456 | int edad = scanner.nextInt();
457 |
458 | System.out.print("¿Es estudiante? (S/N): ");
459 | char respuesta = scanner.next().charAt(0);
460 | boolean esEstudiante = respuesta == 'S' || respuesta == 's';
461 |
462 | if (edad >= 18 && esEstudiante) {
463 | System.out.println("Eres mayor de edad y eres estudiante");
464 | }
465 |
466 | if (edad < 18 || esEstudiante) {
467 | System.out.println("Eres menor de edad o eres estudiante");
468 | }
469 |
470 | if (!esEstudiante) {
471 | System.out.println("No eres estudiante");
472 | }
473 | }
474 | }
475 |
476 | ```
477 |
478 |
479 | ---
480 |
481 | ## Ejercicio 4: Manejo de excepciones
482 |
483 | **Descripción**: En este ejercicio, se solicita al usuario que ingrese un numerador y un denominador. El programa intenta realizar la división y muestra el resultado. Sin embargo, si el denominador es cero, se captura la excepción "ArithmeticException" y se muestra un mensaje de error en su lugar.
484 |
485 | **Objetivo**: Practicar el manejo de excepciones y cómo utilizar la estructura try-catch para evitar que el programa se detenga abruptamente por errores.
486 |
487 |
488 | Solución
489 |
490 | ```java
491 | import java.util.Scanner;
492 |
493 | public class ManejoExcepciones {
494 | public static void main(String[] args) {
495 | Scanner scanner = new Scanner(System.in);
496 |
497 | System.out.print("Ingrese el numerador: ");
498 | int numerador = scanner.nextInt();
499 |
500 | System.out.print("Ingrese el denominador: ");
501 | int denominador = scanner.nextInt();
502 |
503 | try {
504 | int resultado = numerador / denominador;
505 | System.out.println("El resultado es: " + resultado);
506 | } catch (ArithmeticException e) {
507 | System.out.println("Error: División por cero");
508 | }
509 | }
510 | }
511 |
512 | ```
513 |
514 |
515 | ---
516 |
517 | Estos ejercicios están diseñados para ayudarte a practicar diferentes aspectos de las estructuras de control en Java, como la anidación de estructuras, el uso de bucles, la evaluación de condiciones y el manejo de excepciones. Espero que te sean útiles para fortalecer tus habilidades de programación en Java.
518 |
519 | ¡Diviértete aprendiendo y mejorando tus habilidades de programación! 😎
520 |
521 |
522 | Este es un breve tutorial que te introduce a la estructura de control switch en el lenguaje de programación Java. El switch es una forma eficiente de evaluar múltiples casos y ejecutar bloques de código según los resultados.
523 |
524 | **[⬆ Volver a índice](#índice)**
525 |
526 | ## ¿Qué es el switch?
527 |
528 | El switch es una estructura de control que te permite realizar diferentes acciones según el valor de una expresión o variable. Puedes considerarlo como una serie de comparaciones que dirigen el flujo de ejecución hacia diferentes bloques de código.
529 |
530 | ## Sintaxis básica
531 |
532 | ```java
533 | switch (expresion) {
534 | case valor1:
535 | // Bloque de código para valor1
536 | break;
537 | case valor2:
538 | // Bloque de código para valor2
539 | break;
540 | ...
541 | default:
542 | // Bloque de código por defecto
543 | }
544 | ```
545 | - La expresión es evaluada y su resultado se compara con los casos definidos.
546 | - Cada caso representa un valor o conjunto de valores que se comparan con la expresión.
547 | - Si hay coincidencia entre la expresión y un caso, se ejecuta el bloque de código correspondiente.
548 | - La palabra clave `break` se utiliza para salir del switch después de ejecutar el bloque de código correspondiente.
549 | - El bloque `default` se ejecuta si no hay coincidencia con ninguno de los casos anteriores.
550 |
551 | ```java
552 | String mes = "Enero";
553 |
554 | switch (mes) {
555 | case "Enero":
556 | System.out.println("Es el primer mes del año");
557 | break;
558 | case "Febrero":
559 | System.out.println("Es el segundo mes del año");
560 | break;
561 | case "Marzo":
562 | System.out.println("Es el tercer mes del año");
563 | break;
564 | default:
565 | System.out.println("Mes desconocido");
566 | }
567 | ```
568 |
569 | ## Ejercicios:
570 |
571 | #### 1. `Ejercicio de días de la semana`: Escribe un programa que solicite al usuario un número del 1 al 7 y muestre el día de la semana correspondiente.
572 |
573 | Solución
574 |
575 | ```java
576 | import java.util.Scanner;
577 |
578 | public class DiasSemana {
579 | public static void main(String[] args) {
580 | Scanner scanner = new Scanner(System.in);
581 | System.out.print("Ingrese un número del 1 al 7: ");
582 | int numero = scanner.nextInt();
583 |
584 | String diaSemana;
585 | switch (numero) {
586 | case 1:
587 | diaSemana = "Lunes";
588 | break;
589 | case 2:
590 | diaSemana = "Martes";
591 | break;
592 | case 3:
593 | diaSemana = "Miércoles";
594 | break;
595 | case 4:
596 | diaSemana = "Jueves";
597 | break;
598 | case 5:
599 | diaSemana = "Viernes";
600 | break;
601 | case 6:
602 | diaSemana = "Sábado";
603 | break;
604 | case 7:
605 | diaSemana = "Domingo";
606 | break;
607 | default:
608 | diaSemana = "Número inválido";
609 | }
610 | System.out.println("El día de la semana correspondiente es: " + diaSemana);
611 | }
612 | }
613 |
614 | ```
615 |
616 |
617 | ---
618 |
619 | #### 2. **Ejercicio de categorías de edad:**: Crea un programa que pida al usuario ingresar su edad y muestre un mensaje indicando en qué categoría de edad se encuentra (por ejemplo, "niño", "adolescente", "adulto").
620 |
621 | Solución
622 |
623 | ```java
624 | import java.util.Scanner;
625 |
626 | public class CategoriasEdad {
627 | public static void main(String[] args) {
628 | Scanner scanner = new Scanner(System.in);
629 | System.out.print("Ingrese su edad: ");
630 | int edad = scanner.nextInt();
631 |
632 | String categoria;
633 | switch (edad) {
634 | case 0:
635 | case 1:
636 | case 2:
637 | case 3:
638 | case 4:
639 | case 5:
640 | case 6:
641 | case 7:
642 | case 8:
643 | case 9:
644 | case 10:
645 | categoria = "Niño";
646 | break;
647 | case 11:
648 | case 12:
649 | case 13:
650 | case 14:
651 | case 15:
652 | case 16:
653 | case 17:
654 | categoria = "Adolescente";
655 | break;
656 | default:
657 | categoria = "Adulto";
658 | }
659 | System.out.println("Usted se encuentra en la categoría: " + categoria);
660 | }
661 | }
662 |
663 | ```
664 |
665 |
666 | ---
667 |
668 |
669 | #### 3. **Ejercicio de conversión de unidades:**: Desarrolla un programa que convierta una temperatura ingresada por el usuario en grados Celsius a una escala seleccionada (por ejemplo, Celsius a Fahrenheit o Celsius a Kelvin). Utiliza una estructura de control switch para manejar las diferentes opciones de conversión.
670 |
671 | Solución
672 |
673 | ```java
674 | import java.util.Scanner;
675 |
676 | public class ConversionTemperatura {
677 | public static void main(String[] args) {
678 | Scanner scanner = new Scanner(System.in);
679 |
680 | System.out.print("Ingresa la temperatura en grados Celsius: ");
681 | double celsius = scanner.nextDouble();
682 |
683 | System.out.println("Elige la opción de conversión:");
684 | System.out.println("1. Celsius a Fahrenheit");
685 | System.out.println("2. Celsius a Kelvin");
686 |
687 | int option = scanner.nextInt();
688 |
689 | switch (option) {
690 | case 1:
691 | double fahrenheit = (celsius * 9/5) + 32;
692 | System.out.printf("%.2f grados Celsius equivalen a %.2f grados Fahrenheit.", celsius, fahrenheit);
693 | break;
694 | case 2:
695 | double kelvin = celsius + 273.15;
696 | System.out.printf("%.2f grados Celsius equivalen a %.2f grados Kelvin.", celsius, kelvin);
697 | break;
698 | default:
699 | System.out.println("Opción inválida. Por favor, selecciona 1 o 2.");
700 | }
701 |
702 | scanner.close();
703 | }
704 | }
705 |
706 | ```
707 |
708 |
709 | ---
710 |
711 | **[⬆ Volver a índice](#índice)**
712 |
713 | # Ciclo `while` en Java
714 |
715 | El ciclo `while` es una estructura de control en Java que permite repetir un bloque de código mientras se cumpla una condición específica. En cada iteración del ciclo, se evalúa la condición y si es verdadera, se ejecuta el bloque de código. Si la condición es falsa, se sale del ciclo y se continúa con la ejecución del programa.
716 |
717 | ## Sintaxis
718 |
719 | La sintaxis básica del ciclo `while` es la siguiente:
720 |
721 | ```java
722 | while (condicion) {
723 | // Bloque de código a repetir
724 | }
725 | ```
726 |
727 | La condicion es una expresión booleana que se evalúa antes de cada iteración. Si la condición es true, el bloque de código se ejecuta. Si la condición es false, se sale del ciclo.
728 |
729 | Es importante tener en cuenta que si la condición inicialmente es false, el bloque de código no se ejecutará nunca.
730 |
731 | ### Contador ascendente:
732 | Este código imprimirá los números del 1 al 10 en orden ascendente.
733 |
734 | ```java
735 | int contador = 1;
736 | while (contador <= 10) {
737 | System.out.println(contador);
738 | contador++;
739 | }
740 |
741 | ```
742 | ### Contador descendente:
743 | Este código imprimirá los números del 10 al 1 en orden descendente.
744 |
745 | ```java
746 | int contador = 10;
747 | while (contador >= 1) {
748 | System.out.println(contador);
749 | contador--;
750 | }
751 |
752 | ```
753 |
754 | ### Suma de números
755 | Este código calcula la suma de los números del 1 al 10 utilizando el ciclo `while`.
756 | ```java
757 | int numero = 1;
758 | int suma = 0;
759 | while (numero <= 10) {
760 | suma += numero;
761 | numero++;
762 | }
763 | System.out.println("La suma de los números del 1 al 10 es: " + suma);
764 |
765 | ```
766 | ### Lectura de entrada hasta que se ingrese un valor específico:
767 | Este código calcula la suma de los números del 1 al 10 utilizando el ciclo `while`.
768 | ```java
769 | Scanner scanner = new Scanner(System.in);
770 | String input = "";
771 | while (!input.equalsIgnoreCase("salir")) {
772 | System.out.print("Ingresa un valor (escribe 'salir' para terminar): ");
773 | input = scanner.nextLine();
774 | System.out.println("Ingresaste: " + input);
775 | }
776 | scanner.close();
777 |
778 | ```
779 |
780 | Este código solicita al usuario ingresar valores y muestra cada valor ingresado. El ciclo `while` continúa hasta que se ingresa la palabra "salir".
781 |
782 | Recuerda que la condición en el ciclo while debe ser evaluada cuidadosamente para evitar bucles infinitos. Asegúrate de que la condición eventualmente se vuelva falsa para que el ciclo se detenga.
783 |
784 |
785 | ## Bucle Do-While
786 |
787 | El bucle do-while es una estructura de control utilizada en muchos lenguajes de programación. A diferencia del bucle while tradicional, el bucle do-while garantiza que se ejecute al menos una vez, ya que la condición se evalúa al final del bucle.
788 |
789 | ## Sintaxis
790 |
791 | La sintaxis general del bucle do-while es la siguiente:
792 |
793 | ```java
794 | do {
795 | // Código a ejecutar
796 | } while (condición);
797 | ```
798 |
799 | ### ejemplo
800 |
801 | ```java
802 | public class DoWhileExample {
803 | public static void main(String[] args) {
804 | int contador = 1;
805 |
806 | do {
807 | System.out.println("El valor del contador es: " + contador);
808 | contador++;
809 | } while (contador <= 5);
810 | }
811 | }
812 | ```
813 |
814 | En este ejemplo, el bucle "do-while" imprimirá el valor del contador mientras sea menor o igual a 5. La condición se verifica al final del bucle, lo que significa que el bucle se ejecutará al menos una vez antes de comprobar la condición.
815 |
816 | ---
817 |
818 | En este ejemplo, el programa solicita al usuario que ingrese números hasta que se ingrese el número 0 para salir. Luego, calcula la suma de los números ingresados utilizando el bucle "do-while".
819 |
820 | ```java
821 | import java.util.Scanner;
822 |
823 | public class DoWhileExample {
824 | public static void main(String[] args) {
825 | int suma = 0;
826 | int numero;
827 | Scanner scanner = new Scanner(System.in);
828 |
829 | do {
830 | System.out.print("Ingresa un número (ingresa 0 para salir): ");
831 | numero = scanner.nextInt();
832 | suma += numero;
833 | } while (numero != 0);
834 |
835 | System.out.println("La suma de los números ingresados es: " + suma);
836 | }
837 | }
838 |
839 |
840 | ```
841 | ---
842 |
843 | # Arrays en Java
844 |
845 | Este es un archivo README que explica los arrays en el lenguaje de programación Java. Los arrays son estructuras de datos que permiten almacenar un conjunto de elementos del mismo tipo en una sola variable.
846 |
847 | ## Declaración y asignación
848 |
849 | En Java, se pueden declarar y asignar arrays de la siguiente manera:
850 |
851 | ```java
852 | // Declaración y asignación directa
853 | int[] numeros = {1, 2, 3, 4, 5};
854 |
855 | // Declaración y asignación por separado
856 | int[] numeros;
857 | numeros = new int[]{1, 2, 3, 4, 5};
858 | ```
859 |
860 | ### Acceso a elementos
861 | Los elementos de un array se acceden utilizando el índice del elemento, que comienza en 0. Por ejemplo:
862 |
863 | ```java
864 | int[] numeros = {1, 2, 3, 4, 5};
865 |
866 | System.out.println(numeros[0]); // Imprime el primer elemento (1)
867 | numeros[2] = 10; // Modifica el tercer elemento a 10
868 |
869 | ```
870 |
871 | ### Longitud de un array
872 | Se puede obtener la longitud de un array utilizando la propiedad `length`. Por ejemplo:
873 |
874 | ```java
875 | int[] numeros = {1, 2, 3, 4, 5};
876 |
877 | int longitud = numeros.length;
878 | System.out.println("La longitud del array es: " + longitud);
879 |
880 | ```
881 |
882 |
883 |
884 |
885 |
886 |
887 |
888 | ---
889 |
890 | # Ciclo `for` en Java
891 |
892 | El ciclo `for` es una estructura de control utilizada para repetir un bloque de código un número específico de veces.
893 |
894 | ## Sintaxis
895 |
896 | La sintaxis básica del ciclo `for` en Java es la siguiente:
897 |
898 | ```java
899 | for (inicialización; condición; actualización) {
900 | // bloque de código a ejecutar
901 | }
902 | ```
903 |
904 |
905 | - `inicialización`: Se utiliza para declarar e inicializar la variable de control del ciclo. Generalmente, se establece un valor inicial para la variable de control.
906 |
907 | - `condición`: Es una expresión booleana que se evalúa antes de cada iteración. Si la condición es `true`, el bloque de código dentro del ciclo se ejecuta. Si es `false`, el ciclo se detiene.
908 |
909 | - `actualización`: Se utiliza para actualizar o modificar la variable de control después de cada iteración. Generalmente, se incrementa o decrementa el valor de la variable de control.
910 |
911 | ## Ejemplo
912 |
913 | Aquí hay un ejemplo que muestra cómo se utiliza el ciclo `for` en Java para imprimir los números del 1 al 5:
914 |
915 | ```java
916 | for (int i = 1; i <= 5; i++) {
917 | System.out.println(i);
918 | }
919 | ```
920 |
921 |
922 | En este ejemplo:
923 |
924 | - `int i = 1` inicializa la variable `i` con el valor 1.
925 | - `i <= 5` verifica si `i` es menor o igual a 5. Si es verdadero, el ciclo continúa; de lo contrario, se detiene.
926 | - `i++` incrementa el valor de `i` en 1 después de cada iteración.
927 | - `System.out.println(i)` imprime el valor de `i` en la consola.
928 |
929 | El resultado de este código sería:
930 |
931 | ```java
932 | 1
933 | 2
934 | 3
935 | 4
936 | 5
937 | ```
938 |
939 | #### Recorrido de un array
940 | Se puede recorrer un array utilizando un bucle `for` o un bucle "for-each". Por ejemplo:
941 |
942 | ```java
943 | int[] numeros = {1, 2, 3, 4, 5};
944 |
945 | // Recorrido con bucle for
946 | for (int i = 0; i < numeros.length; i++) {
947 | System.out.println(numeros[i]);
948 | }
949 |
950 | // Recorrido con bucle for-each
951 | for (int numero : numeros) {
952 | System.out.println(numero);
953 | }
954 |
955 | ```
956 |
957 | #### Calcular la suma de los elementos de un arreglo de doubles:
958 | ```java
959 | double[] valores = {1.5, 2.3, 4.1, 3.7};
960 | double suma = 0;
961 | for (double valor : valores) {
962 | suma += valor;
963 | }
964 | System.out.println("La suma de los elementos es: " + suma);
965 |
966 | ```
967 |
968 | #### Imprimir los caracteres de una cadena utilizando un arreglo de caracteres:
969 | ```java
970 | String palabra = "Hola";
971 | char[] caracteres = palabra.toCharArray();
972 | for (char c : caracteres) {
973 | System.out.println(c);
974 | }
975 |
976 | ```
977 |
978 | #### Verificar si un elemento existe en un arreglo de strings:
979 | ```java
980 | String[] nombres = {"Juan", "María", "Pedro", "Ana"};
981 | String nombreBuscado = "Pedro";
982 | boolean encontrado = false;
983 | for (String nombre : nombres) {
984 | if (nombre.equals(nombreBuscado)) {
985 | encontrado = true;
986 | break;
987 | }
988 | }
989 | if (encontrado) {
990 | System.out.println(nombreBuscado + " se encuentra en el arreglo.");
991 | } else {
992 | System.out.println(nombreBuscado + " no se encuentra en el arreglo.");
993 | }
994 |
995 | ```
996 |
997 | ## Usos comunes
998 |
999 | El ciclo `for` se utiliza ampliamente en Java y en muchos otros lenguajes de programación. Algunos usos comunes del ciclo `for` incluyen:
1000 |
1001 | - Recorrer una matriz o una colección de elementos.
1002 | - Realizar una serie de operaciones un número específico de veces.
1003 | - Iterar sobre una secuencia de números.
1004 |
1005 | ## Conclusiones
1006 |
1007 | El ciclo `for` en Java es una estructura de control poderosa que permite repetir un bloque de código varias veces. Su sintaxis clara y concisa lo convierte en una opción popular para muchas tareas de programación. Espero que este README te haya proporcionado una introducción útil al ciclo `for` en Java. ¡Diviértete programando!
1008 |
1009 |
1010 |
1011 |
1012 | ---
1013 |
1014 |
1015 |
1016 | ## Ejercicios ciclo `while`
1017 |
1018 | #### 1. **Validación de contraseña**: Escribe un programa que solicite al usuario ingresar una contraseña y valide que cumpla con ciertos criterios, como tener al menos 8 caracteres, incluir letras mayúsculas, minúsculas y números.
1019 |
1020 | Solución
1021 |
1022 | ```java
1023 | import java.util.Scanner;
1024 |
1025 | public class ValidacionContrasena {
1026 | public static void main(String[] args) {
1027 | Scanner scanner = new Scanner(System.in);
1028 |
1029 | boolean contraseñaValida = false;
1030 |
1031 | while (!contraseñaValida) {
1032 | System.out.print("Ingresa una contraseña: ");
1033 | String contraseña = scanner.nextLine();
1034 |
1035 | if (contraseña.length() >= 8 && contraseña.matches(".*[A-Z].*") && contraseña.matches(".*[a-z].*") && contraseña.matches(".*\\d.*")) {
1036 | System.out.println("Contraseña válida");
1037 | contraseñaValida = true;
1038 | } else {
1039 | System.out.println("La contraseña no cumple los requisitos. Intenta nuevamente.");
1040 | }
1041 | }
1042 |
1043 | scanner.close();
1044 | }
1045 | }
1046 |
1047 | ```
1048 |
1049 |
1050 | ---
1051 |
1052 | #### 2. **Calculadora avanzada**: Crea una calculadora que realice operaciones matemáticas avanzadas, como potenciación, raíz cuadrada y logaritmo. Permite al usuario elegir la operación y solicita los valores de entrada.
1053 |
1054 | Solución
1055 |
1056 | ```java
1057 | import java.util.Scanner;
1058 |
1059 | public class CalculadoraAvanzada {
1060 | public static void main(String[] args) {
1061 | Scanner scanner = new Scanner(System.in);
1062 |
1063 | boolean salir = false;
1064 |
1065 | while (!salir) {
1066 | System.out.println("Calculadora Avanzada");
1067 | System.out.println("1. Potenciación");
1068 | System.out.println("2. Raíz cuadrada");
1069 | System.out.println("3. Logaritmo");
1070 | System.out.println("4. Salir");
1071 | System.out.print("Elige una opción: ");
1072 | int opcion = scanner.nextInt();
1073 |
1074 | switch (opcion) {
1075 | case 1:
1076 | System.out.print("Ingresa la base: ");
1077 | double base = scanner.nextDouble();
1078 | System.out.print("Ingresa el exponente: ");
1079 | double exponente = scanner.nextDouble();
1080 | double resultadoPotencia = Math.pow(base, exponente);
1081 | System.out.println("El resultado de la potencia es: " + resultadoPotencia);
1082 | break;
1083 | case 2:
1084 | System.out.print("Ingresa un número: ");
1085 | double numeroRaiz = scanner.nextDouble();
1086 | double resultadoRaiz = Math.sqrt(numeroRaiz);
1087 | System.out.println("El resultado de la raíz cuadrada es: " + resultadoRaiz);
1088 | break;
1089 | case 3:
1090 | System.out.print("Ingresa un número: ");
1091 | double numeroLogaritmo = scanner.nextDouble();
1092 | double resultadoLogaritmo = Math.log(numeroLogaritmo);
1093 | System.out.println("El resultado del logaritmo es: " + resultadoLogaritmo);
1094 | break;
1095 | case 4:
1096 | salir = true;
1097 | break;
1098 | default:
1099 | System.out.println("Opción inválida. Intenta nuevamente.");
1100 | break;
1101 | }
1102 | }
1103 |
1104 | scanner.close();
1105 | }
1106 | }
1107 |
1108 | ```
1109 |
1110 |
1111 | ---
1112 |
1113 | #### 3. **Generación de contraseñas aleatorias**: Escribe un programa que genere contraseñas aleatorias de cierta longitud y complejidad. Permite al usuario elegir la longitud y los tipos de caracteres permitidos (letras mayúsculas, minúsculas, números y caracteres especiales).
1114 |
1115 | Solución
1116 |
1117 | ```java
1118 | import java.util.Scanner;
1119 | import java.util.Random;
1120 |
1121 | public class GeneracionContrasena {
1122 | public static void main(String[] args) {
1123 | Scanner scanner = new Scanner(System.in);
1124 | Random random = new Random();
1125 |
1126 | System.out.print("Ingresa la longitud de la contraseña: ");
1127 | int longitud = scanner.nextInt();
1128 | scanner.nextLine(); // Consumir el salto de línea
1129 |
1130 | System.out.println("Elige los tipos de caracteres permitidos:");
1131 | System.out.println("1. Letras mayúsculas");
1132 | System.out.println("2. Letras minúsculas");
1133 | System.out.println("3. Números");
1134 | System.out.println("4. Caracteres especiales");
1135 | System.out.println("5. Todos los anteriores");
1136 | System.out.print("Elige una opción: ");
1137 | int opcion = scanner.nextInt();
1138 | scanner.nextLine(); // Consumir el salto de línea
1139 |
1140 | String caracteresPermitidos = "";
1141 |
1142 | switch (opcion) {
1143 | case 1:
1144 | caracteresPermitidos = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1145 | break;
1146 | case 2:
1147 | caracteresPermitidos = "abcdefghijklmnopqrstuvwxyz";
1148 | break;
1149 | case 3:
1150 | caracteresPermitidos = "0123456789";
1151 | break;
1152 | case 4:
1153 | caracteresPermitidos = "!@#$%^&*()";
1154 | break;
1155 | case 5:
1156 | caracteresPermitidos = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
1157 | break;
1158 | default:
1159 | System.out.println("Opción inválida. Se generará una contraseña con letras mayúsculas y números.");
1160 | caracteresPermitidos = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1161 | break;
1162 | }
1163 |
1164 | String contraseñaGenerada = generarContraseña(longitud, caracteresPermitidos);
1165 | System.out.println("Contraseña generada: " + contraseñaGenerada);
1166 |
1167 | scanner.close();
1168 | }
1169 |
1170 | public static String generarContraseña(int longitud, String caracteresPermitidos) {
1171 | Random random = new Random();
1172 | StringBuilder contraseña = new StringBuilder();
1173 |
1174 | for (int i = 0; i < longitud; i++) {
1175 | int indice = random.nextInt(caracteresPermitidos.length());
1176 | contraseña.append(caracteresPermitidos.charAt(indice));
1177 | }
1178 |
1179 | return contraseña.toString();
1180 | }
1181 | }
1182 |
1183 | ```
1184 |
1185 |
1186 | ---
1187 |
1188 | #### 4. **Cálculo del factorial**: Pide al usuario que ingrese un número y calcula su factorial utilizando un ciclo while. Asegúrate de manejar los casos de números negativos y cero.
1189 |
1190 | Solución
1191 |
1192 | ```java
1193 | import java.util.Scanner;
1194 |
1195 | public class CalculoFactorial {
1196 | public static void main(String[] args) {
1197 | Scanner scanner = new Scanner(System.in);
1198 |
1199 | System.out.print("Ingresa un número entero: ");
1200 | int numero = scanner.nextInt();
1201 |
1202 | if (numero < 0) {
1203 | System.out.println("El factorial solo se puede calcular para números no negativos.");
1204 | } else {
1205 | int factorial = 1;
1206 | int contador = 1;
1207 |
1208 | while (contador <= numero) {
1209 | factorial *= contador;
1210 | contador++;
1211 | }
1212 |
1213 | System.out.println("El factorial de " + numero + " es: " + factorial);
1214 | }
1215 |
1216 | scanner.close();
1217 | }
1218 | }
1219 |
1220 | ```
1221 |
1222 |
1223 | ---
1224 |
1225 | #### 5. **Juego de adivinar palabras**: Crea un juego en el que el programa elige una palabra al azar de una lista predefinida y el usuario debe adivinarla ingresando letras. Lleva un registro de los intentos y muestra las letras correctas a medida que se adivinan.
1226 |
1227 | Solución
1228 |
1229 | ```java
1230 | import java.util.Scanner;
1231 | import java.util.Random;
1232 |
1233 | public class JuegoAdivinarPalabras {
1234 | public static void main(String[] args) {
1235 | Scanner scanner = new Scanner(System.in);
1236 | Random random = new Random();
1237 |
1238 | String[] palabras = { "manzana", "pera", "banana", "naranja", "uva" };
1239 | String palabraAleatoria = palabras[random.nextInt(palabras.length)];
1240 | int intentos = 0;
1241 | boolean adivinado = false;
1242 | StringBuilder palabraAdivinada = new StringBuilder();
1243 |
1244 | for (int i = 0; i < palabraAleatoria.length(); i++) {
1245 | palabraAdivinada.append("_");
1246 | }
1247 |
1248 | System.out.println("¡Adivina la palabra!");
1249 |
1250 | while (!adivinado) {
1251 | System.out.println("Palabra: " + palabraAdivinada);
1252 | System.out.print("Ingresa una letra: ");
1253 | char letra = scanner.nextLine().charAt(0);
1254 | intentos++;
1255 |
1256 | for (int i = 0; i < palabraAleatoria.length(); i++) {
1257 | if (palabraAleatoria.charAt(i) == letra) {
1258 | palabraAdivinada.setCharAt(i, letra);
1259 | }
1260 | }
1261 |
1262 | if (palabraAdivinada.toString().equals(palabraAleatoria)) {
1263 | adivinado = true;
1264 | }
1265 | }
1266 |
1267 | System.out.println("¡Felicidades! Adivinaste la palabra '" + palabraAleatoria + "' en " + intentos + " intentos.");
1268 |
1269 | scanner.close();
1270 | }
1271 | }
1272 |
1273 |
1274 | ```
1275 |
1276 |
1277 | ---
1278 |
1279 | #### 6. **Ordenamiento de números**: Solicita al usuario que ingrese una serie de números y luego ordénalos en forma ascendente utilizando el algoritmo de ordenamiento de burbuja.
1280 |
1281 | Solución
1282 |
1283 | ```java
1284 | import java.util.Scanner;
1285 |
1286 | public class OrdenamientoNumeros {
1287 | public static void main(String[] args) {
1288 | Scanner scanner = new Scanner(System.in);
1289 |
1290 | System.out.print("Ingresa el número de elementos: ");
1291 | int n = scanner.nextInt();
1292 |
1293 | int[] numeros = new int[n];
1294 |
1295 | for (int i = 0; i < n; i++) {
1296 | System.out.print("Ingresa el elemento " + (i + 1) + ": ");
1297 | numeros[i] = scanner.nextInt();
1298 | }
1299 |
1300 | boolean intercambio = true;
1301 |
1302 | while (intercambio) {
1303 | intercambio = false;
1304 |
1305 | for (int i = 0; i < n - 1; i++) {
1306 | if (numeros[i] > numeros[i + 1]) {
1307 | int temp = numeros[i];
1308 | numeros[i] = numeros[i + 1];
1309 | numeros[i + 1] = temp;
1310 | intercambio = true;
1311 | }
1312 | }
1313 | }
1314 |
1315 | System.out.println("Números ordenados:");
1316 |
1317 | for (int i = 0; i < n; i++) {
1318 | System.out.println(numeros[i]);
1319 | }
1320 |
1321 | scanner.close();
1322 | }
1323 | }
1324 |
1325 | ```
1326 |
1327 |
1328 | ---
1329 |
1330 | #### 7. **Conversión de números decimales a binarios**: Pide al usuario que ingrese un número decimal y conviértelo a su representación binaria utilizando un ciclo while.
1331 |
1332 | Solución
1333 |
1334 | ```java
1335 | import java.util.Scanner;
1336 |
1337 | public class ConversionDecimalBinario {
1338 | public static void main(String[] args) {
1339 | Scanner scanner = new Scanner(System.in);
1340 |
1341 | System.out.print("Ingresa un número decimal: ");
1342 | int numeroDecimal = scanner.nextInt();
1343 |
1344 | StringBuilder numeroBinario = new StringBuilder();
1345 |
1346 | while (numeroDecimal > 0) {
1347 | int residuo = numeroDecimal % 2;
1348 | numeroBinario.insert(0, residuo);
1349 | numeroDecimal /= 2;
1350 | }
1351 |
1352 | System.out.println("El número en binario es: " + numeroBinario);
1353 |
1354 | scanner.close();
1355 | }
1356 | }
1357 |
1358 | ```
1359 |
1360 |
1361 | ---
1362 |
1363 | #### 8. **Validación de entrada numérica**: Escribe un programa que solicite al usuario que ingrese una serie de números y valide que sean enteros positivos. Continúa solicitando números hasta que se ingrese un número negativo.
1364 | Solución
1365 |
1366 | ```java
1367 | import java.util.Scanner;
1368 |
1369 | public class ValidacionEntradaNumerica {
1370 | public static void main(String[] args) {
1371 | Scanner scanner = new Scanner(System.in);
1372 |
1373 | int numero;
1374 | boolean salir = false;
1375 |
1376 | while (!salir) {
1377 | System.out.print("Ingresa un número entero positivo: ");
1378 |
1379 | if (scanner.hasNextInt()) {
1380 | numero = scanner.nextInt();
1381 |
1382 | if (numero >= 0) {
1383 | salir = true;
1384 | System.out.println("Número válido: " + numero);
1385 | } else {
1386 | System.out.println("El número debe ser positivo. Intenta nuevamente.");
1387 | }
1388 | } else {
1389 | System.out.println("Entrada inválida. Debe ser un número entero. Intenta nuevamente.");
1390 | scanner.next(); // Consumir la entrada inválida
1391 | }
1392 | }
1393 |
1394 | scanner.close();
1395 | }
1396 | }
1397 |
1398 |
1399 | ```
1400 |
1401 |
1402 | ---
1403 |
1404 | #### 9. **Generación de un patrón de asteriscos**: Solicita al usuario que ingrese un número y muestra un patrón de asteriscos en forma de triángulo, utilizando un ciclo while para generar cada línea.
1405 |
1406 | Solución
1407 |
1408 | ```java
1409 | import java.util.Scanner;
1410 |
1411 | public class SumaDigitos {
1412 | public static void main(String[] args) {
1413 | Scanner scanner = new Scanner(System.in);
1414 |
1415 | System.out.print("Ingresa un número entero positivo: ");
1416 | int numero = scanner.nextInt();
1417 |
1418 | int sumaDigitos = 0;
1419 |
1420 | while (numero > 0) {
1421 | int digito = numero % 10;
1422 | sumaDigitos += digito;
1423 | numero /= 10;
1424 | }
1425 |
1426 | System.out.println("La suma de los dígitos es: " + sumaDigitos);
1427 |
1428 | scanner.close();
1429 | }
1430 | }
1431 |
1432 |
1433 | ```
1434 |
1435 |
1436 | ---
1437 |
1438 |
1439 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Arrays/Example.java:
--------------------------------------------------------------------------------
1 | package Arrays;
2 |
3 | public class Example {
4 | public static void main(String[] args) {
5 | // Declaración y asignación directa
6 | // int[] numeros = {1, 2, 3, 4, 5, 50, 100, 85};
7 |
8 | double[] decimal = {25.25, 30.25, 15.45};
9 |
10 | String[] nombre = {"Juan", "Jose", "Gustavo"};
11 |
12 | char[] caracter = {'a', 'e', 'i', 'o', 'u'};
13 |
14 | // Declaración y asignación por separado
15 | int[] numeros2;
16 | numeros2 = new int[]{1, 2, 3, 4, 5};
17 |
18 |
19 | //Acceso a elementos
20 | // posicion 0, 1, 2, 3, 4, 5, 6, 7
21 | int[] numeros = {1, 2, 3, 4, 5, 50, 100, 85};
22 | // System.out.println(numeros[0]); // Imprime el primer elemento (1)
23 |
24 | // Longitud de un array
25 | int longitud = numeros.length;
26 | System.out.println("La longitud del array es: " + longitud);
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloDoWhile/DoWhileExample.java:
--------------------------------------------------------------------------------
1 | package CicloDoWhile;
2 |
3 | public class DoWhileExample {
4 | public static void main(String[] args) {
5 | int contador = 6;
6 |
7 | // do {
8 | // System.out.println("El valor del contador es: " + contador);
9 | // contador++;
10 | // } while (contador <=5);
11 |
12 |
13 | while (contador <=5) {
14 | System.out.println("El valor del contador es: " + contador);
15 | contador++;
16 | }
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloDoWhile/DoWhileNumber.java:
--------------------------------------------------------------------------------
1 | package CicloDoWhile;
2 |
3 | import java.util.Scanner;
4 | public class DoWhileNumber {
5 | public static void main(String[] args) {
6 | int suma = 0;
7 | int numero;
8 | Scanner scanner = new Scanner(System.in);
9 |
10 | do {
11 | System.out.print("Ingresa un número (ingresa 0 para salir): ");
12 | numero = scanner.nextInt();
13 | suma += numero;
14 | } while (numero != 0);
15 |
16 | System.out.println("La suma de los números ingresados es: " + suma);
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloFor/CalcularSuma.java:
--------------------------------------------------------------------------------
1 | package CicloFor;
2 |
3 | public class CalcularSuma {
4 | public static void main(String[] args) {
5 | double[] valores = {1.5, 2.3, 4.1, 3.7};
6 | double suma = 0;
7 |
8 | for (double valor : valores) {
9 | suma += valor;
10 | }
11 | // System.out.println("La suma de los elementos es: " + suma);
12 |
13 | // Imprimir los caracteres de una cadena utilizando un arreglo de caracteres:
14 | String palabra = "Hola";
15 | char[] letras = {'H', 'o', 'l', 'a'};
16 | // char[] caracteres = palabra.toCharArray();
17 |
18 | for (char c : palabra.toCharArray()) {
19 | System.out.println(c);
20 | }
21 |
22 |
23 |
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloFor/Example.java:
--------------------------------------------------------------------------------
1 | package CicloFor;
2 |
3 | public class Example {
4 | public static void main(String[] args) {
5 | int contador = 1;
6 |
7 | for (int i = 1; i <= 5; i++) {
8 | System.out.println(i);
9 | }
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloFor/RecorridoArrays.java:
--------------------------------------------------------------------------------
1 | package CicloFor;
2 |
3 | public class RecorridoArrays {
4 | public static void main(String[] args) {
5 | // posicion 0, 1, 2, 3, 4
6 | int[] numeros = {1, 2, 3, 4, 5, 100, 200, 350 , 500};
7 |
8 | // Recorrido con bucle for
9 | // numero.length = 5
10 | // for (int i = 0; i < numeros.length; i++) {
11 | // System.out.println(numeros[i]);
12 | // }
13 |
14 | // Recorrido con bucle for-each
15 |
16 | for (int numero : numeros) {
17 | System.out.println(numero);
18 | }
19 |
20 |
21 |
22 |
23 |
24 |
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloFor/VerificarElemento.java:
--------------------------------------------------------------------------------
1 | package CicloFor;
2 |
3 | public class VerificarElemento {
4 | public static void main(String[] args) {
5 | // Verificar si un elemento existe en un arreglo de strings:
6 |
7 | String[] nombres = {"Juan", "María", "Manuel", "Ana"};
8 |
9 | String nombreBuscado = "Pedro";
10 |
11 | boolean encontrado = false;
12 |
13 | for (String nombre : nombres) {
14 | if (nombre.equals(nombreBuscado)) {
15 | encontrado = true;
16 | break;
17 | }
18 | }
19 |
20 | if (encontrado) {
21 | System.out.println(nombreBuscado + " se encuentra en el arreglo.");
22 | } else {
23 | System.out.println(nombreBuscado + " no se encuentra en el arreglo.");
24 | }
25 |
26 |
27 |
28 |
29 |
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloWhile/Example.java:
--------------------------------------------------------------------------------
1 | package CicloWhile;
2 |
3 | public class Example {
4 | public static void main(String[] args) {
5 | // // Contador ascendente:
6 | // int contador = 1;
7 | //
8 | // while (contador <= 10) { // contador = 1, 2, 3, 4, 5, 6,7,8,9,10
9 | // System.out.println(contador); // 1, 2, 3, 4, 5,6,7,8,9,10
10 | // contador++; // 1, 2, 3, 4, 5, 6,7,8,9, 10, 11
11 | // }
12 | int contador = 10;
13 | while (contador >= 1) {
14 | System.out.println(contador);
15 | contador--;
16 | }
17 |
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloWhile/LecturaEntrada.java:
--------------------------------------------------------------------------------
1 | package CicloWhile;
2 |
3 | import java.util.Scanner;
4 |
5 | public class LecturaEntrada {
6 | public static void main(String[] args) {
7 | Scanner scanner = new Scanner(System.in);
8 | String input = "salir";
9 | boolean contraseñaValida = false;
10 |
11 | while (!input.equalsIgnoreCase("salir")){
12 | System.out.print("Ingresa un valor (escribe 'salir' para terminar): ");
13 | input = scanner.nextLine();
14 | System.out.println("Ingresaste: " + input);
15 | }
16 |
17 | scanner.close();
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/CicloWhile/SumaNumeros.java:
--------------------------------------------------------------------------------
1 | package CicloWhile;
2 |
3 | public class SumaNumeros {
4 | public static void main(String[] args) {
5 | int numero = 1;
6 | int suma = 0;
7 | while (numero <= 10) { // numero = 1, 2, 3
8 | suma += numero; // suma = 1 , 3, 6,
9 | numero++; // numero = 2, 3 , 4
10 | System.out.println(suma);
11 | }
12 | System.out.println("La suma de los números del 1 al 10 es: " + suma);
13 |
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Condicional/IfElseExample.java:
--------------------------------------------------------------------------------
1 | package Condicional;
2 |
3 | import java.util.Scanner;
4 |
5 | public class IfElseExample {
6 | public static void main(String[] args) {
7 | Scanner scanner = new Scanner(System.in);
8 |
9 | System.out.println("Ingresa tu edad: ");
10 | int edad = scanner.nextInt();
11 |
12 | if (edad >= 18) {
13 | System.out.println("Eres mayor de edad");
14 | } else {
15 | System.out.println("Eres menor de edad");
16 | }
17 | scanner.close();
18 | }
19 | }
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Condicional/IfElseGenero.java:
--------------------------------------------------------------------------------
1 | package Condicional;
2 |
3 | import java.util.Scanner;
4 |
5 | public class IfElseGenero {
6 | public static void main(String[] args) {
7 | Scanner scanner = new Scanner(System.in);
8 |
9 | System.out.print("Ingresa tu género (Hombre/Mujer): ");
10 | String genero = scanner.nextLine();
11 |
12 | if (genero.equalsIgnoreCase("Hombre")){
13 | System.out.println("Bienvenido");
14 | } else if (genero.equalsIgnoreCase("Mujer")) {
15 | System.out.println("Bienvenida");
16 | } else {
17 | System.out.println("Género no reconocido");
18 | }
19 | scanner.close();
20 |
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Condicional/IfElseUniversitario.java:
--------------------------------------------------------------------------------
1 | package Condicional;
2 |
3 | import java.util.Scanner;
4 |
5 | public class IfElseUniversitario {
6 | public static void main(String[] args) {
7 | Scanner scanner = new Scanner(System.in);
8 |
9 | System.out.print("Ingresa tu edad: ");
10 | int edad = scanner.nextInt();
11 |
12 | System.out.print("¿Tienes un título universitario? (Si/No): ");
13 | String titulo = scanner.next();
14 | scanner.nextLine();
15 |
16 | System.out.print("¿Tienes experiencia laboral? (Si/No): ");
17 | String experiencia = scanner.nextLine();
18 |
19 | if (edad >= 22 && titulo.equalsIgnoreCase("Si") && experiencia.equalsIgnoreCase("Si")) {
20 | System.out.println("Eres elegible para este empleo de nivel avanzado");
21 | } else if (edad >= 18 && titulo.equalsIgnoreCase("Si")) {
22 | System.out.println("Eres elegible para este empleo de nivel intermedio");
23 | } else {
24 | System.out.println("No eres elegible para este empleo");
25 | }
26 |
27 | scanner.close();
28 |
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Condicional/RangoEdad.java:
--------------------------------------------------------------------------------
1 | package Condicional;
2 |
3 | public class RangoEdad {
4 | public static void main(String[] args) {
5 | int edad = 15;
6 |
7 | if (edad < 18) {
8 | System.out.println("Eres menor de edad");
9 | } else if (edad >= 18 && edad <=65) {
10 | System.out.println("Eres adulto");
11 | } else {
12 | System.out.println("Eres mayor de edad");
13 | }
14 |
15 |
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Switch/DiaSemana.java:
--------------------------------------------------------------------------------
1 | package Switch;
2 |
3 | public class DiaSemana {
4 | public static void main(String[] args) {
5 | String mes = "CASA";
6 |
7 | switch (mes) {
8 | case "Enero":
9 | System.out.println("Es el primer mes del año");
10 | break;
11 | case "Febrero":
12 | System.out.println("Es el segundo mes del año");
13 | break;
14 | case "Marzo":
15 | System.out.println("Es el tercer mes del año");
16 | break;
17 | default:
18 | System.out.println("Mes desconocido");
19 | }
20 |
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/02_estructura_de_control/src/Switch/DiasSemana.java:
--------------------------------------------------------------------------------
1 | package Switch;
2 | import java.util.Scanner;
3 | public class DiasSemana {
4 | public static void main(String[] args) {
5 | Scanner scanner = new Scanner(System.in);
6 | System.out.print("Ingrese un número del 1 al 7: ");
7 | int numero = scanner.nextInt();
8 |
9 | String diaSemana;
10 | switch (numero) {
11 | case 1:
12 | diaSemana = "Lunes";
13 | break;
14 | case 2:
15 | diaSemana = "Martes";
16 | break;
17 | case 3:
18 | diaSemana = "Miércoles";
19 | break;
20 | case 4:
21 | diaSemana = "Jueves";
22 | break;
23 | case 5:
24 | diaSemana = "Viernes";
25 | break;
26 | case 6:
27 | diaSemana = "Sábado";
28 | break;
29 | case 7:
30 | diaSemana = "Domingo";
31 | break;
32 | default:
33 | diaSemana = "Número inválido";
34 | }
35 | System.out.println("El día de la semana correspondiente es: " + diaSemana);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/03_clases_wrapper/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/03_clases_wrapper/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/03_clases_wrapper/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/03_clases_wrapper/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/03_clases_wrapper/.idea/uiDesigner.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
--------------------------------------------------------------------------------
/03_clases_wrapper/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/03_clases_wrapper/03_clases_wrapper.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/03_clases_wrapper/README.md:
--------------------------------------------------------------------------------
1 | # Clases Wrapper en Java
2 |
3 | Las clases wrapper en Java son clases que proporcionan un envoltorio para tipos primitivos, permitiendo tratarlos como objetos. Cada tipo primitivo tiene su correspondiente clase wrapper en Java, que proporciona métodos útiles para manipular y convertir los valores primitivos.
4 |
5 | | Tipo Primitivo | Clase Wrapper |
6 | | ------------- | ------------- |
7 | | int | Integer |
8 | | double | Double |
9 | | boolean | Boolean |
10 | | char | Character |
11 | | byte | Byte |
12 | | short | Short |
13 | | long | Long |
14 | | float | Float |
15 |
16 | Estas clases proporcionan métodos para realizar conversiones entre los tipos primitivos y sus correspondientes clases wrapper. Por ejemplo, puedes convertir un valor entero a un objeto Integer usando el método estático `valueOf()`:
17 |
18 | ```java
19 | int num = 42;
20 | Integer obj = Integer.valueOf(num);
21 | ```
22 |
23 | Las clases wrapper en Java son un conjunto de clases que proporcionan un envoltorio para los tipos de datos primitivos en Java. Estas clases permiten tratar los tipos primitivos como objetos al proporcionar métodos y funcionalidades adicionales.
24 |
25 | Cada tipo primitivo tiene su propia clase wrapper correspondiente en Java, y estas clases se utilizan para realizar operaciones más avanzadas y manipular los valores primitivos de manera más flexible. A continuación se describen las principales clases wrapper disponibles en Java:
26 |
27 | - **Integer**: La clase Integer envuelve un valor entero de 32 bits. Proporciona métodos para convertir enteros en diferentes formatos (binario, octal, hexadecimal), realizar operaciones aritméticas y manipular valores enteros.
28 |
29 | - **Double**: La clase Double envuelve un valor de punto flotante de doble precisión de 64 bits. Proporciona métodos para realizar operaciones aritméticas, comparaciones, obtener valores especiales como infinito y NaN (Not a Number), y convertir números en diferentes formatos.
30 |
31 | - **Boolean**: La clase Boolean envuelve un valor booleano (true o false). Proporciona métodos para realizar operaciones lógicas, comparaciones y conversiones entre booleanos y otros tipos de datos.
32 |
33 | - **Character**: La clase Character envuelve un único carácter Unicode. Proporciona métodos para comprobar la categoría de un carácter, convertir caracteres en diferentes formatos, realizar operaciones de comparación y manipular valores de caracteres.
34 |
35 | - **Byte**: La clase Byte envuelve un valor de 8 bits que representa un número entero. Proporciona métodos para realizar operaciones aritméticas, comparaciones y convertir bytes en diferentes formatos.
36 |
37 | - **Short**: La clase Short envuelve un valor de 16 bits que representa un número entero. Proporciona métodos para realizar operaciones aritméticas, comparaciones y convertir números cortos en diferentes formatos.
38 |
39 | - **Long**: La clase Long envuelve un valor de 64 bits que representa un número entero largo. Proporciona métodos para realizar operaciones aritméticas, comparaciones y convertir números largos en diferentes formatos.
40 |
41 | - **Float**: La clase Float envuelve un valor de punto flotante de precisión simple de 32 bits. Proporciona métodos para realizar operaciones aritméticas, comparaciones, obtener valores especiales como infinito y NaN, y convertir números en diferentes formatos.
42 |
43 | Estas clases wrapper son útiles en situaciones en las que necesitas trabajar con tipos de datos primitivos en contextos que requieren objetos, como al utilizar estructuras de datos genéricas, APIs específicas que trabajan con objetos o al aprovechar funcionalidades específicas de cada clase wrapper.
44 |
45 |
46 | ### Ejemplo con la clase Integer:
47 | ```java
48 | // Declaración de una variable entera primitiva
49 | int num = 42;
50 |
51 | // Envoltura de la variable entera en un objeto Integer
52 | Integer obj = Integer.valueOf(num);
53 |
54 | // Utilizando métodos de la clase Integer
55 | System.out.println("Valor del objeto Integer: " + obj.toString());
56 | System.out.println("Valor en binario: " + Integer.toBinaryString(obj));
57 | System.out.println("Valor en hexadecimal: " + Integer.toHexString(obj));
58 | System.out.println("Suma con otro entero: " + obj + 10);
59 |
60 | ```
61 | ```java
62 | Integer num = Integer.valueOf(42); // Crear un objeto Integer con el valor 42 forma explicita
63 |
64 | // Métodos disponibles en la clase Integer
65 | int value = num.intValue(); // Obtener el valor entero del objeto Integer
66 | String str = num.toString(); // Convertir el objeto Integer a una cadena de texto
67 | int parsedInt = Integer.parseInt("123"); // Convertir una cadena de texto a un valor entero
68 |
69 | ```
70 |
71 | ```java
72 | int sum = Integer.sum(10, 20); // Sumar dos enteros
73 | int compareResult = Integer.compare(10, 20); // Comparar dos enteros
74 |
75 | ```
76 |
77 | ```java
78 | int intValue = Integer.parseInt("42"); // Convertir una cadena de texto a un valor entero
79 | String binaryString = Integer.toBinaryString(42); // Convertir un entero a una cadena binaria
80 | int maxValue = Integer.max(10, 20); // Obtener el valor máximo entre dos enteros
81 | int minValue = Integer.min(10, 20); // Obtener el valor mínimo entre dos enteros
82 |
83 | ```
84 | ### Ejemplo con la clase Double:
85 |
86 | ```java
87 | double doubleValue = Double.parseDouble("3.14"); // Convertir una cadena de texto a un valor de punto flotante
88 | String hexString = Double.toHexString(3.14); // Convertir un valor de punto flotante a una cadena hexadecimal
89 | double maxValue = Double.max(1.23, 4.56); // Obtener el valor máximo entre dos números de punto flotante
90 | double minValue = Double.min(1.23, 4.56); // Obtener el valor mínimo entre dos números de punto flotante
91 |
92 | ```
93 |
94 | ### Ejemplo con la clase Character:
95 |
96 | ```java
97 | boolean isDigit = Character.isDigit('9'); // Verificar si un carácter es un dígito
98 | boolean isLetter = Character.isLetter('A'); // Verificar si un carácter es una letra
99 | boolean isWhitespace = Character.isWhitespace(' '); // Verificar si un carácter es un espacio en blanco
100 | char toUpperCase = Character.toUpperCase('a'); // Convertir un carácter a mayúscula
101 |
102 |
103 | ```
104 |
105 | ### Ejemplo con la clase Boolean:
106 |
107 | ```java
108 | boolean parsedBoolean = Boolean.parseBoolean("true"); // Convertir una cadena de texto a un valor booleano
109 | String toString = Boolean.toString(true); // Convertir un valor booleano a una cadena de texto
110 | boolean logicalAnd = Boolean.logicalAnd(true, false); // Realizar una operación lógica AND entre dos valores booleanos
111 | boolean logicalOr = Boolean.logicalOr(true, false); // Realizar una operación lógica OR entre dos valores booleanos
112 |
113 | ```
114 |
115 |
116 |
117 |
--------------------------------------------------------------------------------
/03_clases_wrapper/src/BooleanWrapper.java:
--------------------------------------------------------------------------------
1 | public class BooleanWrapper {
2 | public static void main(String[] args) {
3 | boolean parsedBoolean = Boolean.parseBoolean("true"); // Convertir una cadena de texto a un valor booleano
4 |
5 | System.out.println("parsedBoolean = " + parsedBoolean);
6 |
7 | String toString = Boolean.toString(true); // Convertir un valor booleano a una cadena de texto
8 |
9 | // System.out.println("toString = " + toString);
10 |
11 | boolean logicalAnd = Boolean.logicalAnd(true, true); // Realizar una operación lógica AND entre dos valores booleanos
12 |
13 | System.out.println("logicalAnd = " + logicalAnd);
14 |
15 |
16 | boolean logicalOr = Boolean.logicalOr(true, false); // Realizar una operación lógica OR entre dos valores booleanos
17 | System.out.println("logicalOr = " + logicalOr);
18 |
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/03_clases_wrapper/src/CharacteWrapper.java:
--------------------------------------------------------------------------------
1 | public class CharacteWrapper {
2 | public static void main(String[] args) {
3 | boolean isDigit = Character.isDigit('9'); // Verificar si un carácter es un dígito
4 | System.out.println("isDigit = " + isDigit);
5 |
6 | boolean isLetter = Character.isLetter('2'); // Verificar si un carácter es una letra
7 | System.out.println("isLetter = " + isLetter);
8 |
9 | boolean isWhitespace = Character.isWhitespace(' '); // Verificar si un carácter es un espacio en blanco
10 | System.out.println("isWhitespace = " + isWhitespace);
11 |
12 | char toUpperCase = Character.toUpperCase('a'); // Convertir un carácter a mayúscula
13 | System.out.println("toUpperCase = " + toUpperCase);
14 |
15 |
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/03_clases_wrapper/src/DoubleWrapper.java:
--------------------------------------------------------------------------------
1 | public class DoubleWrapper {
2 | public static void main(String[] args) {
3 | // double doubleValue = Double.parseDouble("3.14"); // Convertir una cadena de texto a un valor de punto flotante
4 | //
5 | // double suma = doubleValue + 25.36;
6 | //
7 | // System.out.println("suma = " + suma);
8 |
9 | double doubleValue = Double.parseDouble("3.14"); // Convertir una cadena de texto a un valor de punto flotante
10 |
11 | System.out.println("doubleValue = " + doubleValue);
12 |
13 | String hexString = Double.toHexString(3.14); // Convertir un valor de punto flotante a una cadena hexadecimal
14 | System.out.println("hexString = " + hexString);
15 |
16 | double maxValue = Double.max(1.23, 4.56); // Obtener el valor máximo entre dos números de punto flotante
17 | System.out.println("maxValue = " + maxValue);
18 |
19 | double minValue = Double.min(1.23, 4.56); // Obtener el valor mínimo entre dos números de punto flotante
20 | System.out.println("minValue = " + minValue);
21 |
22 | int intPrimitivo = 127;
23 | Integer intObjeto = intPrimitivo;
24 |
25 | // -32768 hasta 32767
26 | Short shortObjeto = intObjeto.shortValue();
27 |
28 | // -128 hasta 127
29 | Byte byteObjeto = intObjeto.byteValue();
30 | System.out.println("byteObjeto = " + byteObjeto);
31 |
32 | System.out.println("shortObjeto = " + shortObjeto);
33 |
34 |
35 |
36 |
37 | Integer num1 = Integer.valueOf(1000);
38 | Integer num2 = num1;
39 |
40 | System.out.println("num1 = " + num1);
41 | System.out.println("num2 = " + num2);
42 |
43 | System.out.println("Son el mismo objeto ? " + (num1 == num2));
44 |
45 |
46 | System.out.println("-------------------------------------------------");
47 | num2 = 5000;
48 |
49 |
50 | System.out.println("num1 = " + num1);
51 | System.out.println("num2 = " + num2);
52 |
53 | System.out.println("Son el mismo objeto ? " + (num1 == num2));
54 |
55 |
56 | System.out.println("condicion " + (num1.intValue() < num2.intValue()));
57 |
58 |
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/03_clases_wrapper/src/IntegerWrapper.java:
--------------------------------------------------------------------------------
1 | public class IntegerWrapper {
2 | public static void main(String[] args) {
3 |
4 | // Ejemplo con la clase Integer:
5 |
6 | int num = 42; // tipo primitivo
7 | Integer obj = Integer.valueOf(num); // clase wrapper forma explicita
8 | Integer obj3 = num; // forma implicita
9 | System.out.println("obj = " + obj);
10 |
11 | // Utilizando métodos de la clase Integer
12 | System.out.println("Valor del objeto Integer: " + obj.toString());
13 |
14 | // String obj2 = obj.toString();
15 |
16 | System.out.println("Valor en binario: " + Integer.toBinaryString(obj));
17 |
18 | System.out.println("Valor en hexadecimal: " + Integer.toHexString(obj));
19 | System.out.println("Suma con otro entero: " + (num + 10));
20 |
21 | int parsedInt = Integer.parseInt(obj.toString()); // Convertir una cadena de texto a un valor entero
22 |
23 | int compareResult = Integer.compare(21, 50); // Comparar dos enteros
24 |
25 | if (compareResult == 0) {
26 | System.out.println("Ambos numeros son iguales");
27 | } else if (compareResult == 1) {
28 | System.out.println("El primer valor es mayor");
29 | } else if (compareResult == -1) {
30 | System.out.println("El segundo valor es mayor");
31 | }
32 |
33 | System.out.println("compareResult = " + compareResult);
34 |
35 | int maxValue = Integer.max(50, 20); // Obtener el valor máximo entre dos enteros
36 | System.out.println("maxValue = " + maxValue);
37 |
38 | int minValue = Integer.min(10, 20); // Obtener el valor mínimo entre dos enteros
39 | System.out.println("minValue = " + minValue);
40 |
41 |
42 | int value = obj;
43 | System.out.println("obj.intValue() = " + obj.intValue());
44 |
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/04_funciones_metodos/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/04_funciones_metodos/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/04_funciones_metodos/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/04_funciones_metodos/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/04_funciones_metodos/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/04_funciones_metodos/Funciones metodos.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/04_funciones_metodos/README.md:
--------------------------------------------------------------------------------
1 | # Curso de Java: Funciones y Métodos
2 |
3 | Este repositorio contiene el material del curso de Java donde se aborda el tema de funciones y métodos. Este módulo es fundamental para aprender a organizar y reutilizar el código de manera efectiva.
4 |
5 | ## Contenido
6 |
7 | - [Introducción a las funciones](#introducción-a-las-funciones)
8 | - [Paso de parámetros](#paso-de-parámetros)
9 | - [Sobrecarga de métodos](#sobrecarga-de-métodos)
10 | - [Métodos con valor de retorno](#métodos-con-valor-de-retorno)
11 | - [Métodos con modificadores de acceso](#métodos-con-modificadores-de-acceso)
12 |
13 | Por supuesto, aquí tienes la descripción en formato Markdown:
14 |
15 | ## Métodos en Java
16 |
17 | En Java, los métodos son bloques de código que encapsulan una serie de instrucciones para realizar una tarea específica. Proporcionan modularidad y reutilización de código al dividir un programa en partes más pequeñas y manejables.
18 |
19 | Un método consta de una firma que incluye el tipo de retorno, el nombre del método y los parámetros (si los tiene). El tipo de retorno indica el tipo de dato que el método devuelve después de su ejecución, y los parámetros son variables opcionales que se pueden pasar para proporcionar valores de entrada.
20 |
21 | Los beneficios de utilizar métodos en Java incluyen:
22 |
23 | - **Reutilización de código**: Permite escribir un conjunto de instrucciones una vez y reutilizarlo en diferentes partes del programa, evitando la duplicación de código.
24 |
25 | - **Modularidad**: Facilita la división de un programa en partes más pequeñas y manejables, lo que mejora la legibilidad y el mantenimiento del código.
26 |
27 | - **Abstracción**: Los métodos permiten ocultar los detalles de implementación y proporcionar una interfaz clara para interactuar con otras partes del programa.
28 |
29 | - **Organización**: Ayudan a organizar el código de manera estructurada y lógica, lo que facilita la comprensión y el seguimiento del flujo del programa.
30 |
31 | En resumen, los métodos en Java son bloques de código que realizan tareas específicas y se utilizan para dividir un programa en partes más pequeñas y reutilizables. Proporcionan estructura, modularidad y abstracción al código, lo que facilita su mantenimiento y comprensión.
32 |
33 | ## Introducción a las funciones
34 |
35 | En esta sección, exploraremos la importancia de las funciones en la programación y cómo nos ayudan a dividir el código en bloques más pequeños y reutilizables. Además, aprenderemos la sintaxis básica de una función en Java y cómo podemos utilizarla para realizar operaciones simples.
36 |
37 | ## Paso de parámetros
38 |
39 | El paso de parámetros es una parte fundamental de las funciones en Java. En este apartado, aprenderemos los diferentes tipos de parámetros (valor y referencia) y cómo se pasan a una función. También veremos ejemplos prácticos de funciones que toman diferentes tipos de parámetros.
40 |
41 | ## Sobrecarga de métodos
42 |
43 | La sobrecarga de métodos nos permite tener múltiples métodos con el mismo nombre pero con diferentes parámetros. En esta sección, exploraremos este concepto y veremos cómo podemos utilizarlo para crear métodos que realicen operaciones similares pero con diferentes tipos de datos o número de parámetros.
44 |
45 | ## Métodos con valor de retorno
46 |
47 | A veces, necesitamos que una función nos devuelva un valor calculado. En este apartado, aprenderemos cómo especificar el tipo de retorno en una función y cómo podemos utilizarlo para obtener resultados. Veremos ejemplos de funciones que realizan cálculos y devuelven el resultado.
48 |
49 | ## Métodos con modificadores de acceso
50 |
51 | En Java, podemos utilizar modificadores de acceso (public, private, protected) para controlar el acceso a los métodos. En esta sección, exploraremos los diferentes modificadores de acceso y cómo afectan la visibilidad y el acceso a los métodos desde otras partes del programa.
52 |
53 | ¡Claro! Aquí tienes algunos ejemplos de métodos en Java para diferentes situaciones:
54 |
55 | 1. Método sin retorno y sin parámetros:
56 | ```java
57 | public void saludar() {
58 | System.out.println("¡Hola, bienvenido!");
59 | }
60 | ```
61 |
62 | 2. Método con retorno y parámetros:
63 | ```java
64 | public int sumar(int a, int b) {
65 | int resultado = a + b;
66 | return resultado;
67 | }
68 | ```
69 |
70 | 3. Método estático:
71 | ```java
72 | public static void imprimirMensaje(String mensaje) {
73 | System.out.println(mensaje);
74 | }
75 | ```
76 |
77 | 4. Método recursivo:
78 | ```java
79 | public int calcularFactorial(int n) {
80 | if (n == 0 || n == 1) {
81 | return 1;
82 | } else {
83 | return n * calcularFactorial(n - 1);
84 | }
85 | }
86 | ```
87 |
88 | 5. Método con argumentos variables:
89 | ```java
90 | public int sumarNumeros(int... numeros) {
91 | int suma = 0;
92 | for (int numero : numeros) {
93 | suma += numero;
94 | }
95 | return suma;
96 | }
97 | ```
98 |
99 |
--------------------------------------------------------------------------------
/04_funciones_metodos/src/ExampleMetodo.java:
--------------------------------------------------------------------------------
1 | public class ExampleMetodo {
2 | public static void main(String[] args) {
3 | // saludar();
4 | int resul = sumar(2,5);
5 | System.out.println("sumar(2,5) = " + sumar(2,5));
6 |
7 |
8 | System.out.println("Factorial = " + calcularFactorial(5));
9 |
10 | System.out.println("--------------------------");
11 |
12 | saludar();
13 | }
14 |
15 | public static void saludar() {
16 | System.out.println("¡Hola, bienvenido!");
17 | System.out.println("Factorial = " + calcularFactorial(5));
18 | }
19 |
20 | public static int sumar(int a, int b) {
21 | int resultado = a + b;
22 | return resultado;
23 | }
24 |
25 | public static int calcularFactorial(int n) {
26 | if (n == 0 || n == 1) {
27 | return 1;
28 | } else {
29 | return n * calcularFactorial(n - 1);
30 | }
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/04_funciones_metodos/src/PasarPorReferencia.java:
--------------------------------------------------------------------------------
1 | public class PasarPorReferencia {
2 | public static void main(String[] args) {
3 | int [] edad = {10, 20, 30};
4 |
5 | System.out.println("Iniciamo el metodo main ");
6 | for (int i =0; i < edad.length; i++) {
7 | System.out.println("edad[i] = " + edad[i]);
8 | }
9 |
10 | System.out.println("Antes de llamar el metodo test");
11 |
12 | test(edad);
13 |
14 | System.out.println("Despues de llamar al metodo test");
15 |
16 | for (int i =0; i < edad.length; i++) {
17 | System.out.println("edad[i] = " + edad[i]);
18 | }
19 |
20 | System.out.println("Finaliza el metodo main con los datos del arreglo modificados!");
21 |
22 | }
23 |
24 | public static void test(int [] edadArray) {
25 | System.out.println("Iniciamos el metodo test");
26 | for (int i =0; i < edadArray.length; i++) {
27 | edadArray[i] = edadArray[i] + 10 ;
28 | }
29 |
30 | System.out.println("Finaliza el metodo test");
31 |
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/04_funciones_metodos/src/PasarPorReferencia2.java:
--------------------------------------------------------------------------------
1 | class Persona {
2 | private String nombre;
3 | public void modificarNombre(String nuevoNombre) {
4 | nombre = nuevoNombre;
5 | }
6 | public String leerNombre() {
7 | return this.nombre;
8 | }
9 | }
10 | public class PasarPorReferencia2 {
11 | public static void main(String[] args) {
12 | Persona persona = new Persona();
13 | persona.modificarNombre("Gustavo");
14 |
15 | System.out.println("Iniciamo el metodo main");
16 |
17 | System.out.println("Persona.nombre = " + persona.leerNombre());
18 | System.out.println("Antes de llamar al metodo test");
19 | test(persona);
20 | System.out.println("Despues de llamar al metodo test");
21 |
22 | System.out.println("Persona.nombre = " + persona.leerNombre());
23 |
24 | System.out.println("Finaliza el metodo main con los datos de la persona modificados!");
25 |
26 | }
27 |
28 | public static void test(Persona persona) {
29 | System.out.println("Iniciamos el metodo test");
30 | persona.modificarNombre("Juan");
31 | System.out.println("Finaliza el metodo test");
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/04_funciones_metodos/src/PasarPorValor.java:
--------------------------------------------------------------------------------
1 | public class PasarPorValor {
2 | public static void main(String[] args) {
3 | Integer i = 10;
4 |
5 | System.out.println("Iniciamo el metodo main con i = " + i);
6 | test(i);
7 | System.out.println("Finaliza el metodo main con el valor de i =" + i);
8 |
9 | }
10 |
11 | public static void test(int i) {
12 | System.out.println("Iniciamor el metodo test con i = " + i);
13 | i = 50;
14 | System.out.println("Finaliza el metodo test con i = " + i);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/05_arreglos/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/05_arreglos/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/05_arreglos/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/05_arreglos/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/05_arreglos/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/05_arreglos/Arreglos.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArregloNumMayor.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class EjemploArregloNumMayor {
4 | public static void main(String[] args) {
5 | Scanner scanner = new Scanner(System.in);
6 |
7 | System.out.println("Ingrese la cantidad de elementos");
8 | int total = scanner.nextInt();
9 |
10 | int[] a = new int[total];
11 |
12 | System.out.println("Ingrese " + total + " valores");
13 | for (int i=0; i < a.length; i++){
14 | a[i] = scanner.nextInt();
15 | }
16 |
17 | int max = 0;
18 |
19 | for (int i = 1; i < a.length; i++) {
20 | max = (a[max] > a[i]) ? max: i ;
21 | }
22 |
23 | System.out.println("max = " + a[max]);
24 |
25 |
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglos.java:
--------------------------------------------------------------------------------
1 |
2 | import java.util.Arrays;
3 |
4 | public class EjemploArreglos {
5 |
6 | public static void main(String[] args) {
7 | int [] numeros = new int[4];
8 |
9 | numeros[0] = 50;
10 | numeros[1] = Integer.valueOf("8");
11 | // numeros[2] = 8;
12 | numeros[3] = 45;
13 |
14 | Arrays.sort(numeros);
15 |
16 | int i = numeros[0];
17 | int j = numeros[1];
18 | int k = numeros[2];
19 | int l = numeros[numeros.length - 1]; // obtener el ultimo valor del array
20 |
21 | System.out.println("i = " + i);
22 | System.out.println("j = " + j);
23 | System.out.println("k = " + k);
24 | System.out.println("l = " + l);
25 |
26 | String[] productos = {"Televisor", "Computadora", "Silla", "Libro", "Reloj"}; // tamaño del array 5
27 |
28 | System.out.println("productos[0] = " + productos[0]);
29 | System.out.println("productos[1] = " + productos[1]);
30 | System.out.println("productos[2] = " + productos[2]);
31 | System.out.println("productos[3] = " + productos[3]);
32 | System.out.println("productos[4] = " + productos[4]);
33 |
34 | Arrays.sort(productos);
35 |
36 | System.out.println("Despues de ordenarlos");
37 |
38 | System.out.println("productos[0] = " + productos[0]);
39 | System.out.println("productos[1] = " + productos[1]);
40 | System.out.println("productos[2] = " + productos[2]);
41 | System.out.println("productos[3] = " + productos[3]);
42 | System.out.println("productos[4] = " + productos[4]);
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 | }
58 |
59 | }
60 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglosCombinados.java:
--------------------------------------------------------------------------------
1 | public class EjemploArreglosCombinados {
2 | public static void main(String[] args) {
3 | int[] a,b,c ;
4 | a = new int[12];
5 | b = new int[12];
6 | c = new int[a.length + b.length];
7 |
8 | System.out.println("Asignacion de valores del arreglo a");
9 | for (int i = 0; i < a.length; i++){
10 | a[i] = i + 1;
11 | }
12 |
13 | System.out.println("Asignacion de valores del arreglo b");
14 | for (int i = 0; i < b.length; i++){
15 | b[i] = (i + 1) * 5 ;
16 | }
17 |
18 | for (int x: a) {
19 | System.out.println(x);
20 | }
21 |
22 | System.out.println(" -------------- ----- ");
23 |
24 | for (int x: b) {
25 | System.out.println(x);
26 | }
27 |
28 | System.out.println(" --------------------------------- ");
29 | int aux = 0;
30 | for (int i =0; i < b.length; i+= 3) {
31 | for (int j = 0; j < 3; j++) {
32 | c[aux++] = a [i+j];
33 | }
34 | for (int j=0; j < 3; j++) {
35 | c[aux++] = b[i+j];
36 | }
37 | }
38 |
39 | for (int i=0; i < c.length; i++) {
40 | System.out.println(i + " : " + c[i]);
41 | }
42 |
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglosFor.java:
--------------------------------------------------------------------------------
1 | import java.util.Arrays;
2 |
3 | public class EjemploArreglosFor {
4 | public static void main(String[] args) {
5 | String[] productos = {"Televisor", "Computadora", "Silla", "Libro", "Reloj"}; // tamaño del array 5
6 | int total = productos.length;
7 |
8 | System.out.println("total = " + total);
9 |
10 | // Arrays.sort(productos);
11 |
12 | System.out.println(" ------ Usando el ciclo for ---------");
13 | for (int i = 0; i < total; i++) {
14 | System.out.println("Para el indice " + i + " : " + productos[i]);
15 | }
16 |
17 | System.out.println("------- Usando el foreach -------------");
18 | for (String prod: productos) {
19 | System.out.println("prod = " + prod);
20 | }
21 |
22 | System.out.println("------- Usando el ciclo while ----------");
23 | int i = 0;
24 | while (i < total) {
25 | System.out.println("Para el indice " + i + " : " + productos[i]);
26 | i++;
27 | }
28 |
29 | System.out.println("------- Usando el ciclo do while ----------");
30 | int j = 0;
31 |
32 | do {
33 | System.out.println("Para el indice " + j + " : " + productos[j]);
34 | j++;
35 | } while (j < total);
36 |
37 |
38 | int [] numeros = new int[10];
39 |
40 | int totalNumeros = numeros.length;
41 | for (int k = 0; k < totalNumeros; k++) {
42 | numeros[k] = k*3;
43 | }
44 |
45 | for (int k = 0; k < totalNumeros; k++) {
46 | System.out.println("numeros = " + numeros[k]);
47 | }
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglosForIOrdenamientoBurbuja.java:
--------------------------------------------------------------------------------
1 | import java.util.Arrays;
2 | import java.util.Collections;
3 |
4 | public class EjemploArreglosForIOrdenamientoBurbuja {
5 |
6 | public static void arregloInverso(String [] arreglo) {
7 | int total2 = arreglo.length;
8 | int total = arreglo.length;
9 |
10 | for (int i = 0; i < total2; i++) {
11 | String actual = arreglo[i];
12 | String inverso = arreglo[total-1-i];
13 | arreglo[i] = inverso;
14 | arreglo[total-1-i] = actual;
15 | total2--;
16 | }
17 | }
18 | public static void main(String[] args) {
19 | String[] productos = {"Televisor", "Computadora", "Silla", "Libro", "Reloj", "Mesa"}; // tamaño del array 5
20 | int total = productos.length;
21 |
22 | // arregloInverso(productos);
23 |
24 | Collections.reverse(Arrays.asList(productos));
25 |
26 | System.out.println(" usando el ciclo for ");
27 |
28 | for ( int i =0; i < total; i++) {
29 | System.out.println("Para el indice " + i + " : " + productos[i]);
30 |
31 | }
32 |
33 | System.out.println("------------- Metodo de ordenamiento Burbuja --------------");
34 |
35 | Integer [] numeros = new Integer[5];
36 |
37 |
38 | numeros[0] = 10;
39 | numeros[1] = Integer.valueOf("8");
40 | numeros[2] = 45;
41 | numeros[3] = -5;
42 | numeros[4] = 7;
43 |
44 | sortBurbuja(numeros);
45 |
46 | for (int i = 0; i < numeros.length; i++) {
47 | System.out.println("i = " + i + " : " + numeros[i]);
48 | }
49 |
50 | }
51 |
52 | public static void sortBurbuja (Object [] arreglo) {
53 | int total = arreglo.length;
54 | int contador = 0;
55 |
56 | for (int i=0; i < total -1; i++) {
57 | for (int j =0; j < total -1; j++) {
58 | if (((Comparable) arreglo[j+1]).compareTo(arreglo[j]) > 0 ) {
59 | Object auxiliar = arreglo[j];
60 | arreglo[j] = arreglo[j+1];
61 | arreglo[j+1] = auxiliar;
62 | }
63 | contador++;
64 | }
65 | }
66 |
67 | System.out.println("contador = " + contador);
68 | }
69 |
70 |
71 | }
72 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglosForInverso.java:
--------------------------------------------------------------------------------
1 | public class EjemploArreglosForInverso {
2 | public static void main(String[] args) {
3 | String[] productos = {"Televisor", "Computadora", "Silla", "Libro", "Reloj"}; // tamaño del array 5
4 | int total = productos.length;
5 |
6 | System.out.println("total = " + total);
7 |
8 | System.out.println("------------ Usando for -----------");
9 |
10 | for (int i =0; i < total; i++) {
11 | System.out.println("Para el i = " + i + " : " + productos[i]);
12 | }
13 |
14 | System.out.println("------------ Usando for inverso -----------");
15 | for (int i = 0; i = 0; i-- ) {
21 | System.out.println("Para i = " + " valor " + productos[i]);
22 | }
23 |
24 |
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/05_arreglos/src/EjemploArreglosForInversoMutable.java:
--------------------------------------------------------------------------------
1 | import java.util.Arrays;
2 | import java.util.Collection;
3 | import java.util.Collections;
4 |
5 | public class EjemploArreglosForInversoMutable {
6 |
7 | public static void arregloInverso(String [] arreglo) {
8 | int total2 = arreglo.length;
9 | int total = arreglo.length;
10 |
11 | for (int i = 0; i < total2; i++) {
12 | String actual = arreglo[i];
13 | String inverso = arreglo[total-1-i];
14 | arreglo[i] = inverso;
15 | arreglo[total-1-i] = actual;
16 | total2--;
17 | }
18 | }
19 | public static void main(String[] args) {
20 | String[] productos = {"Televisor", "Computadora", "Silla", "Libro", "Reloj", "Mesa"}; // tamaño del array 5
21 | int total = productos.length;
22 |
23 | // arregloInverso(productos);
24 |
25 | Collections.reverse(Arrays.asList(productos));
26 |
27 | System.out.println(" usando el ciclo for ");
28 |
29 | for ( int i =0; i < total; i++) {
30 | System.out.println("Para el indice " + i + " : " + productos[i]);
31 |
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/06_matrices/.gitignore:
--------------------------------------------------------------------------------
1 | ### IntelliJ IDEA ###
2 | out/
3 | !**/src/main/**/out/
4 | !**/src/test/**/out/
5 |
6 | ### Eclipse ###
7 | .apt_generated
8 | .classpath
9 | .factorypath
10 | .project
11 | .settings
12 | .springBeans
13 | .sts4-cache
14 | bin/
15 | !**/src/main/**/bin/
16 | !**/src/test/**/bin/
17 |
18 | ### NetBeans ###
19 | /nbproject/private/
20 | /nbbuild/
21 | /dist/
22 | /nbdist/
23 | /.nb-gradle/
24 |
25 | ### VS Code ###
26 | .vscode/
27 |
28 | ### Mac OS ###
29 | .DS_Store
--------------------------------------------------------------------------------
/06_matrices/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/06_matrices/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/06_matrices/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/06_matrices/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/06_matrices/matrices.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/06_matrices/src/EjemploMatrices.java:
--------------------------------------------------------------------------------
1 | public class EjemploMatrices {
2 | public static void main(String[] args) {
3 | int [][] numeros = new int[2][4];
4 |
5 | // llenar primera fila
6 | numeros[0][0] = 1;
7 | numeros[0][1] = 2;
8 | numeros[0][2] = 3;
9 | numeros[0][3] = 4;
10 |
11 | // llenar segunda fila
12 |
13 | numeros[1][0] = 11;
14 | numeros[1][1] = 12;
15 | numeros[1][2] = 13;
16 | numeros[1][3] = 14;
17 |
18 | System.out.println("Numeros de filas: " + numeros.length);
19 | System.out.println("Numeros de columnas: " + numeros[0].length);
20 |
21 | System.out.println("Primer elemento de la matriz: " + numeros[0][0]);
22 | System.out.println("Ultimo elemento: " + numeros[numeros.length - 1][numeros[1].length - 1]);
23 |
24 | int num1 = numeros[0][0];
25 | int num2 = numeros[0][1];
26 | int num3 = numeros[0][2];
27 | int num4 = numeros[0][3];
28 | int num5 = numeros[1][0];
29 | int num6 = numeros[1][1];
30 | int num7 = numeros[1][2];
31 | int num8 = numeros[1][3];
32 |
33 | System.out.println("num1 = " + num1);
34 | System.out.println("num2 = " + num2);
35 | System.out.println("num3 = " + num3);
36 | System.out.println("num4 = " + num4);
37 | System.out.println("num5 = " + num5);
38 | System.out.println("num6 = " + num6);
39 | System.out.println("num7 = " + num7);
40 | System.out.println("num8 = " + num8);
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/06_matrices/src/EjemploMatricesColumnas.java:
--------------------------------------------------------------------------------
1 | public class EjemploMatricesColumnas {
2 | public static void main(String[] args) {
3 | int [][] matriz = new int[3][];
4 |
5 | matriz[0] = new int[2];
6 | matriz[1] = new int[3];
7 | matriz[2] = new int[4];
8 |
9 | System.out.println("Matriz length: " + matriz.length);
10 | System.out.println("fila 0 length: " + matriz[0].length + " numero de columnas");
11 | System.out.println("fila 1 length: " + matriz[1].length + " numero de columnas");
12 | System.out.println("fila 2 length: " + matriz[2].length + " numero de columnas");
13 |
14 | for (int i =0; i < matriz.length; i++) {
15 | for (int j =0; j
3 |
4 |
5 | De cero a experto
6 |
7 | Deja tu :star: si te gusta el proyecto.
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 | ---
19 |
20 | #### Puedes apoyar mi trabajo haciendo "☆ Star" en el repo o nominarme a "GitHub Star". ¡Gracias!
21 |
22 | [](https://stars.github.com/nominate/)
23 |
24 | Si quieres unirte a nuestra comunidad de desarrollo, aprender programación de Apps, mejorar tus habilidades y ayudar a la continuidad del proyecto, puedes encontrarnos en:
25 |
26 | [](https://youtube.com/@tavcode?sub_confirmation=1)
27 | [](https://twitch.com/gustavo_dev_)
28 | [](https://discord.gg/2Qnhu8cQaD)
29 | [](https://twitter.com/gustavo_dev_)
30 | 
31 | 
32 |
33 | ## Índice
34 |
35 | - [Índice](#índice)
36 | - [Introducción](https://github.com/elmergustavo/java-fullStack/tree/master/01_introduccion)
37 | - [Estructuras de control](https://github.com/elmergustavo/java-fullStack/tree/master/02_estructura_de_control)
38 |
39 |
40 | ---
41 |
42 | - [Instalar IntelliJ IDEA](https://www.youtube.com/watch?v=aoW2gsmYBHQ&t=10s)
43 |
44 | **[⬆ Volver a índice](#índice)**
45 |
46 | ---
47 |
48 |
49 | ## Algunos vídeos en YouTube:
50 |
51 |
4 |
5 | De cero a experto
6 |
7 | Deja tu :star: si te gusta el proyecto.
8 | 
10 | 
11 | 
12 | 
13 | 
14 | 
56 |
57 | 
61 |
62 |