Podemos clasificar los lenguajes de programación atendiendo a distintos criterios
Ejemplo de código máquina:
0010 0000 1001 1001 1000 1110
Ejemplo de lenguaje ensamblador:
MOV R1, DPL CJNE R1, #78H, T05SEG RET
Hay una serie de elementos que están presentes en casi todo lenguaje de programación:
Java es un lenguaje de programación de alto nivel, de propósito general y con una sintaxis ampliamente derivada de C/C++. Fue creado originalmente por Sun Microsystems (actualmente propiedad de Oracle) en 1995.
Entre sus pilares fundamentales destacan:
.java) a un código intermedio universal llamado bytecode (archivos .class).Java es un lenguaje de tipado estático y fuertemente tipado (aunque realiza pequeñas conversiones implícitas seguras, como concatenar números a cadenas de texto).
public class Tipado {
static void main() {
int a = 5;
// a = "Hola"; // ERROR de compilación: No se puede asignar un String a una variable int.
String b = "Texto: ";
IO.println(b + a); // Concatenación implícita: convierte 'a' a String ("Texto: 5").
}
}
Los archivos de código fuente en Java tienen la extensión .java y su nombre debe coincidir exactamente con la clase principal que contienen.
public class HolaMundo {
static void main() {
IO.println("Hola Mundo");
}
}
Existen dos formas de ejecutar este programa desde la consola:
1. Ejecución directa en un solo paso: Ideal para pruebas rápidas. Compila en memoria y ejecuta el resultado de forma transparente:
java HolaMundo.java
2. Proceso tradicional en dos pasos (entornos de producción):
1. Compilar el código fuente a bytecode (genera el archivo HolaMundo.class):
javac HolaMundo.java
2. Ejecutar el bytecode compilado en la JVM:
java HolaMundo
java un archivo ya compilado, no debemos poner la extensión .class, solo el nombre de la clase. Esta ejecución es más rápida porque no requiere recompilar el código.
El compilador de Java genera un archivo .class por cada clase definida en nuestro código fuente, independientemente de si están en el mismo archivo .java o en archivos separados.
public class HolaMundo2 {
static void main() {
IO.println("Hola Mundo 2");
}
}
class HolaMundo3 {
static void main() {
IO.println("Hola Mundo 3");
}
}
Al ejecutar javac HolaMundo2.java, se generarán dos archivos independientes: HolaMundo2.class y HolaMundo3.class.
.java solo puede contener una clase pública (public) como máximo, y el nombre del archivo debe coincidir exactamente con el nombre de dicha clase.
Vamos a ver la estructura del ejemplo anterior HolaMundo.java:
public class HolaMundo {
static void main() {
IO.println("Hola Mundo");
}
}
public class HolaMundo: Define la clase. Todo código en Java debe residir dentro de una clase.{ }): Delimitan los bloques de código (clases, métodos, bucles, etc.).static void main(): Es el método de entrada (punto de inicio) de la aplicación. La JVM busca y ejecuta automáticamente este método al arrancar el programa.IO.println(…): Instrucción que imprime el texto indicado por pantalla y añade un salto de línea.
Las instrucciones se ejecutan secuencialmente (de arriba a abajo) y deben terminar obligatoriamente con punto y coma (;).
static void main() {
IO.println("Primera instrucción");
IO.println("Segunda instrucción");
}
Aunque Java no obliga a sangrar el código para que compile (a diferencia de Python), la indentación es fundamental para garantizar la legibilidad del proyecto. Se recomienda usar 4 espacios por cada nivel de anidamiento.
Ejemplo con correcta indentación:
public class HolaMundo {
static void main() {
IO.println("Código fácil de leer");
}
}
Los comentarios son anotaciones dentro del código fuente que el compilador ignora por completo. Su objetivo es explicar la lógica del programa, añadir notas aclaratorias o generar documentación técnica.
En Java podemos escribir comentarios de tres formas:
//)./* y */./** y */ para generar documentación técnica en HTML.
/**
* Comentario de documentación (JavaDoc).
* Muestra información sobre la clase o el autor.
*/
public class HolaMundo {
static void main() {
/*
* Comentario de bloque o multilínea.
* Útil para detallar algoritmos o bloques
* de código complejos.
*/
// Comentario de una línea: explica la instrucción siguiente
IO.println("Hola mundo");
}
}
Una variable es una posición de memoria con un nombre simbólico asignado donde se almacena un valor susceptible de cambiar a lo largo del programa. Una constante, por el contrario, mantiene un valor fijo e inmutable durante toda la ejecución.
Para utilizar una variable en Java debemos especificar su tipo de dato seguido de su nombre (identificador). Podemos reservar el espacio en memoria (declarar) y asignarle un valor (inicializar) en pasos separados o en una sola línea:
static void main() {
// 1. Declaración (reserva espacio en memoria, sin valor inicial)
int edad;
// 2. Inicialización (asignación del primer valor)
edad = 25;
// 3. Declaración e inicialización simultánea (lo más habitual)
double precio = 19.99;
boolean activo = true;
}
Java maneja 8 tipos de datos primitivos que representan valores simples (enteros, decimales, caracteres o booleanos).
| Tipo | Tamaño (bits) | Descripción | Valor por defecto |
|---|---|---|---|
byte | 8 | Entero muy pequeño con signo $[-128, 127]$ | $0$ |
short | 16 | Entero corto con signo $[-32768, 32767]$ | $0$ |
int | 32 | Entero estándar $[-2^{31}, 2^{31}-1]$ | $0$ |
long | 64 | Entero largo $[-2^{63}, 2^{63}-1]$ | $0L$ |
float | 32 | Decimal en coma flotante de precisión simple | $0.0f$ |
double | 64 | Decimal en coma flotante de precisión doble | $0.0d$ |
char | 16 | Carácter individual en formato Unicode | $'\u0000'$ |
boolean | 1 | Valor lógico (true o false) | false |
Desde Java 10, es posible omitir la declaración explícita del tipo en variables locales utilizando la palabra reservada var. El compilador deducirá el tipo basándose en el valor asignado:
var edad = 25; // Compila como int var sueldo = 1250.50; // Compila como double var texto = "Hola"; // Compila como String
int y los decimales como double. Si necesitas asignar un valor de tipo float o long, debes añadir un sufijo al literal:
float pi = 3.1416f; // Requiere 'f' para no ser tratado como double long distancia = 3000000000L; // Requiere 'L'
Cuando necesitamos convertir el valor de un tipo primitivo a otro, utilizamos la conversión explícita mediante el operador de cast: (tipo) expresion.
public class Cast {
static void main() {
// Cast directo (truncamiento)
double precioDouble = 19.99;
int precioEntero = (int) precioDouble; // Pierde los decimales -> 19
// Evitar división entera no deseada
int a = 9;
int b = 2;
float resultadoIncorrecto = (float) (a / b); // Divide como int (4) y lo convierte a float -> 4.0f
float resultadoCorrecto = (float) a / b; // Convierte 'a' a float (9.0f) y divide -> 4.5f
}
}
(tipo) solo funciona entre tipos primitivos compatibles. Para convertir de String a un tipo numérico, debemos usar los métodos parse de sus respectivas clases envoltorio (wrapper classes):
String textoNumero = "42";
int numero = Integer.parseInt(textoNumero);
double decimal = Double.parseDouble("3.14");
_) y el símbolo de dólar ($)._ o $. Nunca por un número.int, class, final, public, if, etc.).distanciaKilometros antes que d.alturaEdificio).
Las constantes almacenan información que no debe cambiar durante la ejecución. Se definen anteponiendo la palabra reservada final. Por convención, sus nombres se escriben en MAYÚSCULAS_CON_GUION_BAJO.
public class Constantes {
static void main() {
final double VELOCIDAD_LUZ = 299792.458; // en km/s
final float PI = 3.1416f;
// VELOCIDAD_LUZ = 300000.0; // ERROR de compilación: No se puede reasignar una variable final
}
}
El operador principal de asignación es el signo igual (=). Según el tipo de dato asignado, debemos considerar ciertas reglas sintácticas:
char utilizan comillas simples ('a').String utilizan comillas dobles ("Hola").String, se utiliza la barra invertida (\) como carácter de escape.
static void main() {
char letra = 'A';
boolean activo = true;
String frase = "Dijo: \"Hola mundo\""; // Carácter de escape \"
}
Java ofrece operadores aritméticos básicos: suma (+), resta (-), multiplicación (*), división (/) y módulo o resto entero (%). Pueden combinarse con el operador de asignación para acortar instrucciones:
| Operador | Ejemplo | Equivalencia |
|---|---|---|
+= | a += b; | a = a + b; |
-= | a -= b; | a = a - b; |
*= | a *= b; | a = a * b; |
/= | a /= b; | a = a / b; |
%= | a %= b; | a = a % b; |
Operan sobre un único valor para modificar su signo, incrementarlo, decrementarlo o negarlo:
+, -): Cambia o mantiene el signo del valor evaluado.++, –):a++): Utiliza el valor actual de la variable en la expresión y después la incrementa en 1.++a): Incrementa la variable en 1 antes de evaluar la expresión.!): Invierte un valor booleano (!true es false).
public class OperadoresUnarios {
static void main() {
int a = 3;
IO.println("Post-incremento (a++): " + a++); // Muestra 3, 'a' pasa a ser 4
IO.println("Valor tras a++: " + a); // Muestra 4
a = 3;
IO.println("Pre-incremento (++a): " + ++a); // 'a' pasa a ser 4, Muestra 4
}
}
Comparan dos operandos y devuelven un valor booleano (true o false): == (igual a), != (distinto de), < (menor que), > (mayor que), ⇐ (menor o igual) y >= (mayor o igual).
=) con la comparación de igualdad (==):
int a = 5; int b = 2; // IO.println(a = b); // Asigna 2 a 'a' e imprime 2. ¡Sobrescribe la variable! IO.println(a == b); // Compara si 'a' es igual a 'b' e imprime false.
Permiten combinar múltiples condiciones booleanas:
&& (AND): Devuelve true solo si ambas condiciones son verdaderas.|| (OR): Devuelve true si al menos una de las condiciones es verdadera.! (NOT): Niega la condición evaluada.
static void main() {
int edad = 20;
boolean tieneCarnet = true;
boolean puedeConducir = edad >= 18 && tieneCarnet; // true
}
A partir de Java 25 utilizamos la clase IO para interactuar con la consola sin necesidad de realizar importaciones adicionales.
IO.println(…): Imprime el mensaje introducido y añade un salto de línea final.IO.print(…): Imprime el mensaje manteniendo el cursor en la misma línea.
El método IO.readln() pausa la ejecución hasta que el usuario escribe un texto y pulsa Intro. Siempre retorna los datos en forma de cadena (String). Si se requiere un valor numérico, debemos realizar el parseo correspondiente:
public class EntradaSalida {
static void main() {
String nombre = IO.readln("Introduce tu nombre: ");
int edad = Integer.parseInt(IO.readln("Introduce tu edad: "));
IO.println("Hola " + nombre + ", tienes " + edad + " años.");
}
}
Permiten ejecutar un conjunto de instrucciones u otro en función del resultado de evaluar una condición lógica que devuelve un valor booleano (true o false). En Java existen tres estructuras de selección: if-else, switch y el operador ternario.
La sentencia if evalúa una condición. Si esta resulta verdadera (true), se ejecuta el bloque de código delimitado entre llaves {}. En caso contrario, el bloque se omite.
public class SentenciaIf {
static void main() {
int number = 3;
if (number < 5) {
IO.println("El número es menor que 5");
}
IO.println("Fin del programa");
}
}
<) no es lo mismo que evaluar si es menor o igual (⇐). Para number = 5, la condición number < 5 devolverá false. Un porcentaje elevado de los errores en programación principiante proviene de un mal ajuste en los operadores de comparación.
Podemos combinar varias expresiones lógicas en una sola condición utilizando los operadores lógicos && (AND) y || (OR):
if (number > 2 && number < 5) {
IO.println("El número está estrictamente entre 2 y 5");
}
Para ejecutar una alternativa cuando la condición resulte falsa, añadimos el bloque else. Esto evita tener que evaluar condiciones mutuamente excluyentes dos veces de forma ineficiente.
if (number < 5) {
IO.println("El número es menor que 5");
} else {
IO.println("El número es mayor o igual que 5");
}
Si necesitamos evaluar múltiples alternativas en cadena, utilizamos else if:
if (number < 5) {
IO.println("El número es menor que 5");
} else if (number < 8) {
IO.println("El número está en el rango [5, 8)");
} else if (number < 10) {
IO.println("El número está en el rango [8, 10)");
} else {
IO.println("El número es mayor o igual que 10");
}
if independientes en lugar de usar else if obliga a la CPU a evaluar todas las condiciones, reduciendo el rendimiento en programas de gran escala.
Cuando debemos comparar una misma variable contra múltiples valores constantes, la sentencia switch ofrece una alternativa mucho más limpia, estructurada y legible que encadenar múltiples bloques else if.
En el Java moderno, switch no solo funciona como una instrucción de control de flujo, sino también como una expresión capaz de devolver un valor directamente a una variable.
La forma estándar de escribir un switch utiliza el operador flecha (→). Esta sintaxis tiene dos ventajas clave:
int day = 3;
switch (day) {
case 1, 2, 3, 4, 5 -> IO.println("Entre semana / Laborable");
case 6, 7 -> IO.println("Fin de semana");
default -> IO.println("Día no válido");
}
Si un caso requiere ejecutar más de una instrucción, se delimita mediante un bloque de llaves {}:
int option = 1;
switch (option) {
case 1 -> {
IO.println("Iniciando el proceso de copia...");
IO.println("Copia realizada con éxito.");
}
case 2 -> IO.println("Mostrando configuración...");
default -> IO.println("Opción no reconocida.");
}
Un switch puede utilizarse directamente a la derecha de una asignación para calcular y retornar un valor que se guarda en una variable:
int month = 2;
String season = switch (month) {
case 12, 1, 2 -> "Invierno";
case 3, 4, 5 -> "Primavera";
case 6, 7, 8 -> "Verano";
case 9, 10, 11 -> "Otoño";
default -> "Mes no válido";
}; // Recuerda incluir el punto y coma final por ser una asignación de variable
switch se utiliza como expresión para devolver un valor, debe garantizarse que todos los casos posibles estén cubiertos. Por este motivo, la cláusula default es casi siempre obligatoria.
Cuando utilizamos un switch como expresión y uno de los casos necesita ejecutar varias líneas dentro de un bloque {}, no podemos devolver el valor directamente tras la flecha. En su lugar, utilizamos la palabra clave yield para indicar qué valor retorna ese bloque:
int code = 404;
String statusText = switch (code) {
case 200 -> "OK";
case 404 -> {
IO.println("Registrando alerta: recurso no encontrado en el servidor.");
yield "Not Found"; // Devuelve este resultado para el caso 404
}
case 500 -> "Internal Server Error";
default -> "Unknown Code";
};
En Java, no todos los tipos de datos pueden ser evaluados dentro de un switch. Los tipos permitidos son:
byte, short, char, int (y sus clases envoltorio/wrapper como Integer).String.enum.
String role = "ADMIN";
switch (role) {
case "ADMIN", "SUPERUSER" -> IO.println("Acceso total otorgado");
case "USER" -> IO.println("Acceso limitado a lectura");
default -> IO.println("Acceso denegado");
}
El operador ternario (?:) es una forma compacta de representar una estructura if-else simple en una sola línea de código.
| Sintaxis |
|---|
variable = (condicion) ? valor_si_verdadero : valor_si_falso; |
Por ejemplo, este bloque condicional:
String message;
if (age >= 18) {
message = "Mayor de edad";
} else {
message = "Menor de edad";
}
Se simplifica a:
String message = (age >= 18) ? "Mayor de edad" : "Menor de edad";
Las iteraciones o bucles permiten repetir un bloque de código mientras una determinada condición sea verdadera. Java proporciona tres estructuras iterativas principales: while, do-while y for.
Evalúa la condición antes de cada iteración. Si es true, ejecuta el bloque de código; si es false, el bucle finaliza.
public class BucleWhile {
static void main() {
int counter = 1;
while (counter < 10) {
IO.println(counter);
counter++; // Incremento obligatorio para evitar bucle infinito
}
}
}
counter++), la condición siempre será true y el programa quedará atrapado consumiendo recursos.
A diferencia del bucle while, el bucle do-while evalúa la condición al final de la iteración. Esto garantiza que el bloque de código se ejecutará al menos una vez, independientemente de si la condición es verdadera o falsa desde el inicio.
int number = 10;
// Se ejecuta 1 vez aunque 10 no es menor que 10
do {
IO.println("Bucle do-while: " + number);
number++;
} while (number < 10);
number = 10;
// No se ejecuta ninguna vez
while (number < 10) {
IO.println("Bucle while: " + number);
number++;
}
Se utiliza principalmente cuando conocemos de antemano el número exacto de iteraciones que debemos realizar. Agrupa en una sola línea la inicialización, la condición de parada y el paso de actualización.
| Estructura de la cabecera for |
|---|
for (inicialización; condición; actualización) |
public class BucleFor {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
IO.println(i);
}
}
}
Las sentencias break y continue permiten alterarle el flujo normal de ejecución dentro de cualquier tipo de bucle:
break: Interrumpe y finaliza inmediatamente la ejecución del bucle, saltando a la primera línea fuera de él.continue: Salta el resto del código de la iteración actual y pasa inmediatamente a evaluar la siguiente iteración.
for (int i = 0; i < 10; i++) {
if (i > 4) {
break; // Detiene el bucle cuando i llega a 5
}
IO.println(i);
}
for (int i = 0; i < 10; i++) {
if (i == 4) {
continue; // Omite imprimir el valor 4 y continúa con i = 5
}
IO.println(i);
}
Un bucle anidado es un bucle colocado dentro del cuerpo de otro bucle. Por cada iteración del bucle exterior, el bucle interior ejecutará completas todas sus iteraciones.
Un ejemplo clásico es la generación de las tablas de multiplicar del 1 al 9:
for (int i = 1; i <= 9; i++) {
IO.println("--- Tabla del " + i + " ---");
for (int j = 1; j <= 10; j++) {
IO.println(i + " x " + j + " = " + (i * j));
}
}
| Escenario | Bucle recomendado |
| Refleja un número conocido de iteraciones | for |
| El número de iteraciones es indefinido, pero debe ejecutarse al menos una vez | do-while |
| El número de iteraciones es indefinido y puede que nunca deba ejecutarse | while |
Un String representa una cadena de caracteres (texto). Aunque en Java es un objeto, conceptualmente se comporta como una secuencia de caracteres inmutable y de tamaño fijo.
// Inicialización directa (literal)
String nombre = "Ana";
// Mediante la palabra clave new (crea un objeto explícito en memoria)
String apellido = new String("García");
Una propiedad fundamental de los String es que son inmutables: una vez creada la cadena en memoria, su contenido no se puede modificar.
Cualquier método que apliquemos sobre un String (convertir a mayúsculas, reemplazar letras, etc.) no modifica el texto original, sino que devuelve un nuevo String con la transformación.
String texto = "hola"; texto.toUpperCase(); // NO modifica la variable 'texto' IO.println(texto); // Muestra "hola" // Para conservar el resultado, debemos reasignarlo a la variable: texto = texto.toUpperCase(); IO.println(texto); // Muestra "HOLA"
A diferencia de los arrays donde usamos corchetes [] y la propiedad .length, en los String utilizamos métodos:
cadena.length() (devuelve el número de caracteres).cadena.charAt(posición) (las posiciones van desde 0 hasta length() - 1).
String mensaje = "Java";
IO.println("Longitud: " + mensaje.length()); // Muestra 4
IO.println("Primer carácter: " + mensaje.charAt(0)); // Muestra 'J'
IO.println("Último carácter: " + mensaje.charAt(mensaje.length() - 1)); // Muestra 'a'
En Java NUNCA debemos usar el operador == para comparar el contenido de dos cadenas. El operador == comprueba si ambas variables apuntan a la misma posición de memoria, no si contienen las mismas letras.
Para comparar texto debemos usar el método .equals() o .equalsIgnoreCase() (para ignorar mayúsculas y minúsculas):
String texto1 = IO.readln("Introduce una palabra: "); // Ejemplo: "hola"
String texto2 = "hola";
// INCORRECTO: Compara referencias de memoria (daría false casi siempre)
if (texto1 == texto2) {
IO.println("Apuntan al mismo objeto en memoria");
}
// CORRECTO: Compara el contenido de las cadenas
if (texto1.equals(texto2)) {
IO.println("El texto es exactamente igual");
}
// Compara ignorando mayúsculas y minúsculas
if (texto1.equalsIgnoreCase("HOLA")) {
IO.println("Coinciden sin importar mayúsculas/minúsculas");
}
La clase String dispone de multitud de métodos para manipular texto de forma sencilla:
| Método | Descripción | Ejemplo | Resultado |
|---|---|---|---|
contains(texto) | Comprueba si contiene una subcadena | “Programación”.contains(“grama”) | true |
indexOf(texto) | Devuelve la posición de la primera aparición (o -1 si no existe) | “Java”.indexOf(“v”) | 2 |
substring(inicio, fin) | Extrae el texto desde inicio hasta fin - 1 | “Elefante”.substring(0, 3) | “Ele” |
toLowerCase() / toUpperCase() | Convierte todo el texto a minúsculas / mayúsculas | “Java”.toLowerCase() | “java” |
replace(viejo, nuevo) | Reemplaza un texto por otro | “Casa”.replace(“a”, “o”) | “Coso” |
trim() | Elimina espacios en blanco al inicio y al final | “ Hola ”.trim() | “Hola” |
Podemos recorrer un String carácter a carácter utilizando un bucle for con charAt(), o convirtiéndolo directamente a un array de caracteres (char[]):
String palabra = "Algoritmo";
// Opción 1: Recorrido con bucle for tradicional y charAt()
for (int i = 0; i < palabra.length(); i++) {
char letra = palabra.charAt(i);
IO.println("Posición " + i + ": " + letra);
}
// Opción 2: Convertir a char[] y recorrer con for-each
char[] letras = palabra.toCharArray();
for (char letra : letras) {
IO.print(letra + " ");
}
IO.println("");
Los array permiten almacenar un conjunto finito de elementos del mismo tipo con un tamaño fijo asignado desde su creación.
tipo[] nombre;nombre = new tipo[tamaño];
Las posiciones se numeran desde la 0 hasta tamaño - 1. Para acceder o modificar un valor usamos los corchetes [].
int[] numbers;
numbers = new int[10];
//int[] numbers = new int[10];
Para almacenar valores en cada una de las posiciones del array, usamos corchetes ([]) indicando en su interior la posición en la que queremos leer o escribir.
numbers[3] = 10;
Para acceder a los datos de un array accedemos mediante nombre[posicion].
int number;
number = numbers[3];
La propiedad length nos devuelve el número total de elementos. Podemos recorrer el array mediante un bucle for convencional o con un bucle for-each:
// Recorrido con for tradicional
for (int i = 0; i < numbers.length; i++) {
IO.println("Índice " + i + ": " + numbers[i]);
}
// Recorrido con for-each (más limpio para lectura)
for (int number : numbers) {
IO.println(number);
}
Inicializar array:
int[] numbers = new int[5];
for(int i=0; i<numbers.length; i++) {
numbers[i] = Integer.parseInt(IO.readln("Introduce un número entero: "));
}
Otra forma de inicializar un array es definiendo sus valores como una lista separada por comas encerrada entre llaves. Ésto lo debemos hacer a la hora de la declaración del array, y no hace falta indicarle la longitud, ya que se lo indicamos con el número de elementos que le pasemos:
int[] numbers = {1, 3, 312, 15, 69, 7, 8, 9, 0, 1};
Podemos declarar un array de más de una dimensión (como tablas o matrices):
// Inicialización directa
int[][] table = {
{3, 5, 6},
{2, 4, 9}
};
// Recorrido con bucles anidados
for (int[] row : table) {
for (int cell : row) {
IO.print(cell + " ");
}
IO.println("");
}
Crea un programa que calcule el área de un triángulo con base $5$ y altura $10$ ($\text{Área} = \frac{\text{base} \cdot \text{altura}}{2}$). La base y la altura deben ser constantes de tipo entero (int) y el área una variable del mismo tipo.
Modifica el tipo de la variable área a float y la altura a $9$. Comprueba si el resultado coincide con el cálculo manual. Haz las modificaciones necesarias en la operación sin cambiar el tipo de las constantes para obtener el resultado decimal exacto.
Modifica las constantes del Ejercicio 1.a a tipo decimal (float o double) para obtener la solución exacta directamente.
Haz que la base y la altura sean introducidas dinámicamente por el usuario a través de teclado mediante IO.readln().
Escribe un programa que solicite dos números decimales (float) al usuario e imprima su suma, resta, multiplicación, división y módulo (resto).
Modifica el programa anterior para que los resultados de las operaciones se muestren convertidos a entero (int) mediante *casting*, sin cambiar el tipo original de las variables de entrada.
Utiliza el método de formateo String.format(“%.2f”, valor) para mostrar el resultado de la división con exactamente dos decimales.
Crea un programa que solicite un número al usuario y calcule su raíz cuadrada empleando el método adecuado de la clase Math.
Aplica formato a la salida del ejercicio anterior para presentar la raíz cuadrada con tres decimales.
Escribe un programa que solicite por teclado una base y un exponente (números enteros) y muestre por pantalla el resultado de elevar la base a dicho exponente empleando la clase Math. Muestra el resultado formateado a 2 decimales.
Dado el siguiente literal de cadena con espacios superfluos: String mensaje = “ hola mundo ”;, crea un programa que imprima dicho mensaje completamente en mayúsculas y habiendo eliminado los espacios sobrantes de los extremos.
Utiliza la clase java.util.Random o Math.random() para generar y mostrar por pantalla un número entero aleatorio entre $0$ y $9$.
Modifica el ejercicio anterior para que el usuario introduzca por teclado el límite mínimo y máximo entre los cuales se generará el entero aleatorio.
Escribe un programa que pregunte la edad por teclado y muestre el mensaje “Puedes pasar” si es mayor o igual a 18 años, o “No puedes pasar” en caso contrario. Usa if-else.
Modifica el ejercicio anterior para resolverlo utilizando únicamente una sentencia if (sin cláusula else).
Reescribe la lógica del ejercicio 1.a utilizando el operador ternario.
Crea un programa que solicite dos números por teclado y determine cuál de los dos es el mayor.
Resuelve el cálculo del mayor de dos números del ejercicio anterior utilizando el operador ternario.
Escribe un programa que determine si un número entero introducido por teclado es par o impar utilizando if-else.
Modifica el programa anterior para asignar el resultado (true si es par, false si es impar) a una variable booleana llamada isEven mediante el operador ternario.
Escribe un programa que pida un color por teclado:
Modifica el programa anterior para que la comparación no sea sensible a mayúsculas o minúsculas (ej. “Rojo” o “ROJO” funcionarán igual que “rojo”).
Añade al programa anterior la limpieza de espacios en blanco al inicio y al final del texto introducido por el usuario (ej. “ rojo ” debe funcionar correctamente).
Escribe un programa que calcule el factorial de un número entero positivo introducido por el usuario utilizando un bucle while.
Reescribe el programa del cálculo del factorial utilizando un bucle for.
Crea un programa que pida un número entero positivo $N$ por pantalla y muestre todos los números pares comprendidos entre $1$ y $N$ utilizando un bucle while.
Reescribe el ejercicio anterior utilizando un bucle for.
Modifica el ejercicio anterior utilizando la sentencia continue dentro del bucle para filtrar los números impares.
Formatea la salida del ejercicio anterior para que muestre los números en una sola línea separados por comas:
Escribe un número: 17 2, 4, 6, 8, 10, 12, 14, 16
Escribe un programa que encuentre el primer múltiplo de un número dado en un rango (excluyendo el propio número). No utilices la sentencia break.
Modifica el programa anterior para detener la búsqueda del múltiplo mediante el uso de la sentencia break.
Muestra la tabla de multiplicar de un número introducido por el usuario.
Amplía el ejercicio anterior para que, tras cada multiplicación, calcule y muestre el sumatorio acumulado desde 1 hasta el resultado obtenido:
Escribe un número: 3 3 * 1 = 3 -> Suma (1..3): 6 3 * 2 = 6 -> Suma (1..6): 21 3 * 3 = 9 -> Suma (1..9): 45 ...
Crea un programa que muestre un menú interactivo con 3 opciones y muestre la opción elegida:
1.- Opción A 2.- Opción B 3.- Opción C -------------------- Opción: 2 Ha elegido la Opción B
Modifica el menú anterior para añadir la opción “0.- Salir”. El programa debe ejecutarse repetidamente y no finalizará hasta que el usuario introduzca el número $0$.