1) Declara dos variables numricas (con el valor que desees), muestra por consola la suma, resta,

multiplicacin, divisin y mdulo (resto de la divisin).

Esconder

public class OperacionesApp {

public static void main(String[] args) {
//Declaramos las variables
int num1=10;
int num2=5;
/*Realizamos las operaciones.
* Tambien lo podemos guardar el resultado en variables. */
System.out.println("El resultado de la suma es "+(num1+num2));
System.out.println("El resultado de la resta es "+(num1-num2));
System.out.println("El resultado de la multiplicacin es "+(num1*num2));
System.out.println("El resultado de la divisin es "+(num1/num2));
}

2) Declara 2 variables numricas (con el valor que desees), he indica cual es mayor de los dos. Si son
iguales indicarlo tambin. Ves cambiando los valores para comprobar que funciona.
Esconder

public class NumeroMayorApp {

public static void main(String[] args) {
//Declaramos las variables
int num1=30;
int num2=15;
//Hacemos la comprobacin
if (num1>=num2){
//If anidado
if(num1==num2){
System.out.println("Los numeros "+num1+" y "+num2+" son iguales");
}else{
System.out.println("El nmero "+num1+" es mayor que el nmero
"+num2);
}
}else{
System.out.println("El nmero "+num2+" es mayor que el nmero "+num1);
}
}

3) Declara un String que contenga tu nombre, despus muestra un mensaje de bienvenida por consola. Por
ejemplo: si introduzco Fernando, me aparezca Bienvenido Fernando.
Esconder

public class SaludoApp {

public static void main(String[] args) {
String nombre="Fernando";
System.out.println("Bienvenido "+nombre);
}
4) Modifica la aplicacin anterior, para que nos pida el nombre que queremos introducir (recuerda usar
JOptionPane).
Esconder

import javax.swing.JOptionPane;
public class SaludoPersonalizadoApp {
public static void main(String[] args) {
//Nos aparece un cuadro de dialogo
String nombre=JOptionPane.showInputDialog("Introduce tu nombre");
System.out.println("Bienvenido "+nombre);
}

5) Haz una aplicacin que calcule el rea de un cuadrado (pi*R 2). El radio se pedir por teclado (recuerda
pasar de String a double con Double.parseDouble). Usa la constante PI y el mtodo pow de Math.
Esconder

import javax.swing.JOptionPane;
public class AreaCirculoApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce un radio");
//Pasamos el String a double
double radio=Double.parseDouble(texto);
//Formula area circulo, usamos algunos de los metodos de Math
double area=Math.PI*Math.pow(radio, 2);
System.out.println("El area del circulo es "+area);
}

6) Lee un nmero por teclado e indica si es divisible entre 2 (resto = 0). Si no lo es, tambin debemos
indicarlo.

Esconder

import javax.swing.JOptionPane;
public class DivisibleApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce un numero");
//Pasamos el String a int
int numero=Integer.parseInt(texto);
//Comprobamos si es divisible entre 2, es decir, si el resto de la division
if (numero%2==0){
System.out.println("El numero "+numero+" es divisible entre 2");
}else{
System.out.println("El numero "+numero+" no es divisible entre 2");
}
}

7) Lee un nmero por teclado y muestra por consola, el carcter al que pertenece en la tabla ASCII. Por
ejemplo: si introduzco un 97, me muestre una a.
Esconder

import javax.swing.JOptionPane;
public class CodigoASCIIApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce un codigo de la tabla

ASCII");

//Pasamos el String a int

int codigo=Integer.parseInt(texto);
//Pasamos el codigo a caracter
char caracter=(char)codigo;
System.out.println(caracter);
}

8) Modifica el ejercicio anterior, para que en lugar de pedir un nmero, pida un carcter (char) y muestre su
cdigo en la tabla ASCII.
Esconder

import javax.swing.JOptionPane;
public class CaracterASCIIApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce un caracter ASCII");
//Pasamos el String a char con el metodo charAt
char caracter=texto.charAt(0);
//Pasamos el caracter a codigo
int codigo=(int)caracter;
System.out.println(codigo);
}

9) Lee un nmero por teclado que pida el precio de un producto (puede tener decimales) y calcule el precio
final con IVA. El IVA sera una constante que sera del 21%.
Esconder

import javax.swing.JOptionPane;
public class PrecioProductoApp {
public static void main(String[] args) {
//Declaramos una constante
final double IVA=0.21;
String texto=JOptionPane.showInputDialog("Introduce el precio de un
producto");
//Pasamos el String a double
double precio=Double.parseDouble(texto);
//Obtenemos el precio final (precio+(precio*IVA))
double precioFinal=precio+(precio*IVA);
System.out.println(precioFinal);
}

10) Muestra los nmeros del 1 al 100 (ambos incluidos). Usa un bucle while.
Esconder

public class MuestraNumWhileApp {

public static void main(String[] args) {
int num=1;
//Definimos el bucle, incluye el 100
while (num<=100){
System.out.println(num);
//Incrementamos num
num++;
}
}

11) Haz el mismo ejercicio anterior con un bucle for.

Esconder

public class MuestraNumForApp {

public static void main(String[] args) {
//Definimos el bucle, incluye el 100
for (int num=1;num<=100;num++){
System.out.println(num);
}
}

12) Muestra los nmeros del 1 al 100 (ambos incluidos) divisibles entre 2 y 3. Utiliza el bucle que desees.
Esconder
Con While

public class DivisiblesWhileApp {

public static void main(String[] args) {
int num=1;
//Definimos el bucle, incluye el 100
while (num<=100){
if (num%2==0 || num%3==0){
System.out.println(num);
}
//Incrementamos num
num++;
}
}

 Con For

public class DivisiblesForApp {

public static void main(String[] args) {
//Definimos el bucle, incluye el 100
for (int num=1;num<=100;num++){
//Comprobamos si es divisible entre 2 o 3
if (num%2==0 || num%3==0){
System.out.println(num);
}
}
}

13) Realiza una aplicacin que nos pida un nmero de ventas a introducir, despus nos pedir tantas ventas
por teclado como nmero de ventas se hayan indicado. Al final mostrara la suma de todas las ventas. Piensa
que es lo que se repite y lo que no.
Esconder

import javax.swing.JOptionPane;
public class VentasApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce el nmero de ventas");
//Pasamos el String a int
int numVentas=Integer.parseInt(texto);

(i+1));

/*Declaramos una variable para sumar las ventas,

* si lo declaramos dentro del bucle, no podriamos
* acceder fuera del bucle a la suma de las ventas.
* Esto es por el mbito.
*/
int sumaVentas=0;
for (int i=0;i<numVentas;i++){
//indico el numero de venta
texto=JOptionPane.showInputDialog("Introduce el precio de la venta"+
int venta=Integer.parseInt(texto);
//Acumulamos el valor de la venta
sumaVentas=sumaVentas+venta;
}
System.out.println(sumaVentas);

14) Realiza una aplicacin que nos calcule una ecuacin de segundo grado. Debes pedir las variables a,
b y c por teclado y comprobar antes que el discriminante (operacin en la raz cuadrada). Para la raz
cuadrada usa el mtodo sqlrt de Math. Te recomiendo que uses mensajes de traza.
Esconder

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

import javax.swing.JOptionPane;
public class Ecuacion2GradoApp {
public static void main(String[] args) {
String textoA=JOptionPane.showInputDialog("Introduce el valor de a");
int a=Integer.parseInt(textoA);
String textoB=JOptionPane.showInputDialog("Introduce el valor de b");
int b=Integer.parseInt(textoB);
String textoC=JOptionPane.showInputDialog("Introduce el valor de c");
int c=Integer.parseInt(textoC);
double discriminante=Math.pow(b, 2)-(4*a*c);
//Mensaje de traza
System.out.println(">>"+discriminante);
if (discriminante>0){
//Tambien se puede hacer por parte si lo ves ms facil
//recuerda que debes tener en cuenta la prioridad de elementos
double x1=((b*(-1))+Math.sqrt(discriminante))/(2*a);
double x2=((b*(-1))-Math.sqrt(discriminante))/(2*a);
System.out.println("El valor de x1 es "+x1+" y el valor de x2 es
"+x2);
}else{
System.out.println("El discriminante es negativo");
}
}
}

15) Lee un nmero por teclado y comprueba que este numero es mayor o igual que cero, si no lo es
lo volver a pedir (do while), despus muestra ese nmero por consola.
Esconder

1
2
3
4
5
6
7
8
9
10
11
12

import javax.swing.JOptionPane;
public class ComprobacionApp {
public static void main(String[] args) {
/* Declaramos la varible ya que sino no podemos usarla
* en el while por el tema de mbito
*/
int codigo;
do{
String texto=JOptionPane.showInputDialog("Introduce un numero mayor

que 0");

codigo=Integer.parseInt(texto);
}while(codigo<=0);

13
14
15
16
17

System.out.println(codigo);
}
}

16) Escribe una aplicacin con un String que contenga una contrasea cualquiera. Despus se te
pedir que introduzcas la contrasea, con 3 intentos. Cuando aciertes ya no pedir mas la
contrasea y mostrara un mensaje diciendo Enhorabuena. Piensa bien en la condicin de salida
(3 intentos y si acierta sale, aunque le queden intentos).
Mostrar
17) Crea una aplicacin que nos pida un da de la semana y que nos diga si es un dia laboral o no.
Usa un switch para ello.
Esconder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import javax.swing.JOptionPane;
public class DiaApp {
public static void main(String[] args) {
String dia=JOptionPane.showInputDialog("Introduce un dia de la
semana");
switch(dia){
case "lunes":
case "martes":
case "miercoles":
case "jueves":
case "viernes":
System.out.println("Es un dia laboral");
break;
case "sabado":
case "domingo":
System.out.println("Es un dia festivo");
default:
System.out.println("Introduce un dia de la semana");
}
}
}

18) Pide por teclado dos nmeros y genera 10 nmeros aleatorios entre esos nmeros. Usa el
mtodoMath.random para generar un nmero entero aleatorio (recuerda el casting de double a int).
Esconder

1
2
3
4
5
6
7
8
9

import javax.swing.JOptionPane;
public class GeneraNumApp {
public static void main(String[] args) {
String texto1=JOptionPane.showInputDialog("Introduce el primero
numero");
int num1=Integer.parseInt(texto1);
String texto2=JOptionPane.showInputDialog("Introduce el segundo

10
11
12
13
14
15
16
17
18

numero");
int num2=Integer.parseInt(texto2);
for (int i=0;i<10;i++){
//Generamos un numero aleatorio
int numAleatorio=(int)Math.floor(Math.random()*(num1num2)+num2);
System.out.println(numAleatorio);
}
}
}

19) Pide por teclado un nmero entero positivo (debemos controlarlo) y muestra el nmero de cifras
que tiene. Por ejemplo: si introducimos 1250, nos muestre que tiene 4 cifras. Tendremos que
controlar si tiene una o mas cifras, al mostrar el mensaje.
Esconder

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

import javax.swing.JOptionPane;
public class CuentaCifrasApp {
public static void main(String[] args) {
int numero=0;
do{
String texto=JOptionPane.showInputDialog("Introduce un numero");
numero=Integer.parseInt(texto);
}while(numero<0);
int contador=0;
for (int i=numero;i>0;i/=10){
//Incrementamos el contador
contador++;
}
//Controlamos en el caso de que haya una cifra o mas
if (contador==1){
System.out.println("El numero "+numero+ " tiene "+contador+"

cifra");

}else{
System.out.println("El numero "+numero+ " tiene "+contador+"
cifras");
}
}
}

20) Pide un nmero por teclado e indica si es un nmero primo o no. Un nmero primo es aquel solo
puede dividirse entre 1 y si mismo. Por ejemplo: 25 no es primo, ya que 25 es divisible entre 5, sin
embargo, 17 si es primo.
Un buen truco para calcular la raz cuadrada del numero e ir comprobando que si es divisible desde
ese numero hasta 1.
NOTA: Si se introduce un numero menor o igual que 1, directamente es no primo.
Esconder

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

import javax.swing.JOptionPane;
public class PrimoApp {
public static void main(String[] args) {
String texto=JOptionPane.showInputDialog("Introduce un numero");
int numero=Integer.parseInt(texto);
//Un numero negativo, el 0 y el 1, son directamente no

primos.

if (numero<=1){
System.out.println("El numero "+numero+" no es
primo");
}else{
//Hacemos un casting para que nos devuelva un numero
entero
int raiz=(int)Math.sqrt(numero);
int contador=0;
//Contamos el numero de divisibles
for (int i=raiz;i>1;i--){
if (numero%i==0){
contador++;
}
}
/*Segun el numero de divisibles, sabemos si es primo o

no

* Si es primo el contador sera 0

*/
//Mensaje de traza
System.out.println(">>"+contador);
if (contador<1){
System.out.println("El numero "+numero+" es primo");
}else{
System.out.println("El numero "+numero+" no es
primo");
}
}
}
}

21) Muestra los nmeros primos entre 1 y 100.

Esconder

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

public class MuestraPrimosApp {

public static void main(String[] args) {

entero

for (int i=1;i<=100;i++){

//Hacemos un casting para que nos devuelva un numero
int raiz=(int)Math.sqrt(i);
int contador=0;
//Hacemos otro bucle para contar los divisibles
for (int j=raiz;j>1;j--){
if (i%j==0){
contador++;
}
}
/*Segun el numero de divisibles, sabemos si es primo o no
* Si es primo el contador sera 0
*/
if (contador<1){
System.out.println(i);
}
}

}
}

22) Del siguiente String La lluvia en Sevilla es una maravilla cuenta cuantas vocales hay en total
(recorre el String con charAt).
Esconder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class CuentaVocalesApp {

public static void main(String[] args) {
String cadena="La lluvia en Sevilla es una maravilla";
int contador=0;
for (int i=0;i<cadena.length();i++){
//Comprobamos si el caracter es una vocal
if(cadena.charAt(i)=='a' || cadena.charAt(i)=='e' ||
cadena.charAt(i)=='i' || cadena.charAt(i)=='o' || cadena.charAt(i)=='u'){
contador++;
}
}
System.out.println("Hay "+contador+" vocales");
}
}

17
23) Reemplaza todas las a del String anterior por una e.
Esconder

1
2
3
4
5
6
7
8
9
10
11

public class CambioLetrasApp {

public static void main(String[] args) {
String cadena="La lluvia en Sevilla es una maravilla";
//Aviso, de esta forma no modifica el String original
System.out.print(cadena.replace('a', 'e'));
}
}

24) Recorre el String del ejercicio 22 y transforma cada carcter a su cdigo ASCII. Muestralos en
linea recta, separados por un espacio entre cada carcter.
Esconder

1
2
3
4
5
6
7
8
9
10
11
12

public class ListaCaracteresApp {

public static void main(String[] args) {
String cadena="La lluvia en Sevilla es una maravilla";
for (int i=0;i<cadena.length();i++){
//Hacemos un casting para convertir el char a int
System.out.print((int)cadena.charAt(i)+" ");
}
}
}

25) Crea una aplicacin llamada CalculadoraPolacaInversaApp, nos pedir 2 operandos (int) y un
signo aritmtico (String), segn este ltimo se realizara la operacin correspondiente. Al final
mostrara el resultado en un cuadro de dialogo.
Los signos aritmticos disponibles son:

+: suma los dos operandos.

-: resta los operandos.

*: multiplica los operandos.

/: divide los operandos, este debe dar un resultado con decimales (double)

^: 1 operando como base y 2 como exponente.

%: mdulo, resto de la divisin entre operando1 y operando2.

Esconder

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

import javax.swing.JOptionPane;
public class CalculadoraPolacaInversaApp {
public static void main(String[] args) {
//no importa que sean int o double
double operando1;
double operando2;
double resultado=0;
//Nos pide los operandos y el signo de operacion
String texto=JOptionPane.showInputDialog("Escribe el operando 1");
operando1=Integer.parseInt(texto);
String operacion=JOptionPane.showInputDialog("Escribe el codigo de
operacion");
String texto2=JOptionPane.showInputDialog("Escribe el operando 2");
operando2=Integer.parseInt(texto2);
//segun el codigo de operacion, haremos una u otra accion
switch (operacion){
case "+":
resultado=operando1+operando2;
break;
case "-":
resultado=operando1-operando2;
break;
case "*":
resultado=operando1*operando2;
break;
case "/":
resultado=operando1/operando2;
break;
case "^":
resultado=(int)Math.pow(operando1, operando2);
break;
case "%":
resultado=operando1%operando2;
break;
}
JOptionPane.showMessageDialog(null, operando1+" "+operacion+" "
+operando2+" = "+resultado);
}
}