Esta sección es introductoria a la programación en Java, por lo que escribiremos programas en los que empleamos los tipos primitivos (declaración e inicialización) como los enteros y los booleanos
(int y boolean), operaciones lógicas (&&, !, ||) y
aritméticas (+, %, *...), de asignación y estructuras básicas de Java como la
instrucción if / else y los bucles while y for.
Para la entrada y salida (I/O) a través del terminal usaremos la directiva import java.util.Scanner; y algunos métodos como
-
System.out.printf() para escribir en la misma línea.
-
System.out.println() para escribir en la línea siguiente.
-
new Scanner ( System.in ) para tomar la entrada.
-
.nextInt() para tomar el siguiente entero en la línea (devuelve un entero). También existe .nextDouble().
-
.hasNextInt() para saber si el siguiente elemento es un entero (devuelve un boolean).
-
.nextLine() para tomar la siguiente línea (devuelve un String).
En cada código se realizan observaciones indicando el procedimiento del programa y las cuestiones que
se consideran importantes.
PROBLEMA 1
Escribir un programa que pide un año (número entero) e indica si el año es o no bisiesto.
Usar las estructuras y métodos if/else, .nextInt(), printfln, %.
Ver código
1 import java.util.Scanner;
2 public class bisiesto
3 {
4 public static void main(String [] args )
5 {
6 System.out.println("Año: ");
7 Scanner in=new Scanner( System.in );
8 int x=in.nextInt();
9
10 boolean bis;
11
12 bis = ( x % 100) == 0 ? true : false;
13 if (bis)
14 bis = ( x % 400) == 0 ? true : false;
15 else
16 bis = ( x % 4 ) == 0 ? true : false;
17 System.out.println(bis);
18 }
19 }
Observaciones:
Año bisiesto: si no es secular (terminado en 00), es divisible entre 4. Si es secular, es divisible entre 400.
Entradas: entero de cuatro dígitos (año).
Salida: se imprime un boolean (true si el año es bisiesto; false, si no).
Las instrucciones del if / else no están cerradas entre llaves ya que sólo tienen una
instrucción.
a % b devuelve el resto de la división a / b.
-
En la línea 8 usamos .nextInt() para tomar el siguiente entero
de la entrada (tenga los dígitos que tenga). El programa no comprueba si la entrada tiene el formato adecuado.
En la línea 12 tenemos un ?, con lo que asignamos a
bis el valor boolean de la expresión lógica
( x % 100) == 0
(true si x es divisible entre 100).
PROBLEMA 2
Escribir un programa que genere la tabla de multiplicar de un entero (0, -1, 1,-2, 2, -3, 3, ...) proporcionado
por el usuario.
Usar bucles for/while.
Ver código
1 import java.util.Scanner;
2 public class tablaX
3 {
4 public static void main( String [] args)
5 {
6 System.out.println("Entero: ");
7 Scanner in = new Scanner( System.in );
8 int i = in.nextInt();
9 System.out.println("Tabla del " + i);
10
11 for (int k=0; k<11; k++)
12 System.out.println(i+" x "+k+" = "+ i*k);
13 }
14 }
Observaciones:
PROBLEMA 3
Sobrecarga de nombres: Java permite que haya varios métodos con el mismo nombre y el mismo tipo
de clase siempre que sus signaturas (número y tipo de parámetros) sean distintas.
Escribir un programa con dos métodos estáticos con el mismo nombre pero diferente número de
argumentos (4 y 5).
El programa pide números enteros y calcula el máximo de ellos. Nosotros introducimos 4 ó 5 enteros (separados
por espacios), que serán guardados en un vector de 4 ó 5 elementos.
Ver código
1 import java.util.Scanner;
2 public class maximo0
3 {
4 public static void main ( String [] args)
5 {
6 System.out.println("Enteros: ");
7 Scanner in = new Scanner( System.in );
8
9 int maxi;
10 int [] x = new int[4];
11 for (int i=0; i<4; i++)
12 x[i]=in.nextInt();
13
14 if (in.hasNextInt())
15 {
16 int [] original;
17 original = x;
18 x = new int[5];
19 for( int i=0; i<4; i++)
20 x[i]=original[i];
21 original = null;
22 x[4]=in.nextInt();
23 maxi = maximo(x[0],x[1],x[2],x[3],x[4]);
24 }
25 else
26 maxi = maximo(x[0],x[1],x[2],x[3]);
27 System.out.println("Máximo: " + maxi);
28 }
29
30 public static int maximo (int a, int b, int c, int d)
31 {
32 int max, max1, max2;
33 max1 = Math.max(a,b);
34 max2 = Math.max(c,d);
35 max = Math.max(max1,max2);
36 return max;
37 }
38 public static int maximo (int a, int b, int c, int d, int e)
39 {
40 int max, max1, max2;
41 max1 = maximo(a,b,c,d);
42 max=Math.max(max1, e);
43 return max;
44 }
45 }
Observaciones:
Entradas:4 ó 5 enteros
Salida: un entero
El programa sabrá que hemos introducido 4 enteros cuando el quinto elemento no sea un entero ni un espacio
(por ejemplo una letra).
-
Se utiliza un vector de dimensión variable (expansión dinámica), x. Cuando se define, necesitamos indicar cuántos
elementos tendrá (4, que es el mínimo). En el caso de que haya un entero más, hay que ampliar el vector: guardamos el vector
en una nueva referencia, original, (al ser nueva, no es una referencia a x); después, creamos un nuevo vector de dimensión 5
cuyos 4 primeros elementos son los guardados en original.
Este procedimiento puede hacer de una manera más rápida con el tipo ArrayList que proporciona
la libreria Java. En el
Tema 2 lo usaremos en algunos problemas.
El método de 5 argumentos usa el de 4.
-
.hasNextInt(), en la línea 14, devuelve true si el
siguiente elemento es un entero. Es por ello que el usuario debe introducir un no entero para que
.hasNextInt() devuelva false en el caso de 4 enteros. Si no, el programa se queda esperando.
PROBLEMA 4
Escribir un programa que imprime números entre corchetes con el siguiente formato:
[1][2][3][4]
Utilizar un método que admite dos parámetros: howMany, que indica cuántos números hay que
escribir; y lineLength, que indica la longitud máxima de cada línea.
Cuando se alcanza la longitud máxima, se escribe en la línea siguiente.
Los números deben ir entre corchetes, por lo que si un elemento (de la forma [x]) no cabe en una
línea, se pasa a la línea siguiente.
Por ejemplo, para howMany = 6 y lineLength = 7, se imprime:
[1][2]
[3][4]
[4][5]
[6]
Ver código
1 import java.util.Scanner;
2 public class numeros
3 {
4 public static void main( String [] args)
5 {
6 System.out.println("howMany y lineLength?: ");
7 Scanner in = new Scanner( System.in );
8 int i = in.nextInt();
9 int j = in.nextInt();
10
11 if (i>0 && j>=3)
12 imprimir(i,j);
13 else
14 System.out.println("Error");
15 }
16
17 public static void imprimir (int howMany, int lineLength)
18 {
19 int actualLength=0;
20 int actualNumber=1;
21 while (actualNumber <= howMany)
22 {
23 String add="["+actualNumber+"]";
24 actualLength+=add.length();
25
26 if(actualLength<=lineLength)
27 System.out.printf(add);
28
29 else
30 {
31 System.out.println('\n');
32 if( add.length() >lineLength)
33 System.out.printf("error");
34 else
35 {
36 System.out.printf(add);
37 actualLength=add.length();
38 }
39 }
40 actualNumber++;
41 }
42 }
43 }
Observaciones:
El mayor problema de este ejercicio es que el número de dígitos cuenta en la longitud de la línea.
En el caso de los números entre 1 y 9, los elementos [x] tienen .length()= 3. Pero en cada decenena
la longitud irá aumentando.
Lo que hemos hecho es introducir una variable entera que cuenta la longitud de la línea en
qué vamos a escirbir ( actualLength ).
El algoritmo es:
La variable actualNumber es el siguiente número a escribir, por lo que lo iniciamos en 1.
Asimismo, la longitud inicial de la primera línea es actualLength = 0.
En la linea 23 creamos el número elemento a añadir. En la siguiente, contamos el número
de caracteres que tendrá la línea en la consola. Si esta longitud no supera a lineLength, introducimos el
elemento y volvemos al inicio del bucle while tras actualizar actualNumber en la línea 40.
Si por el contrario, al añadir el elmento en la línea actual se supera la permitida, escribimos un
salto de línea.
- Además, en el if de la línea 32 se comprueba si el elemento a añadir es más largo que
lineLength, en cuyo caso el programa escribirá "error" en las líneas siguientes. Esto puedo ocurrir
cuando howMany es un número grande. Por ejemplo, el elemento [100] dará error si lineLength = 4.
PROBLEMA 5
Escribir un programa que proporcione todos los pares de enteros (a,b) que cumplen
$$ a < b < 500$$
y cuyo cociente
$$\frac{a^2 + b^2 + 1 }{ab}$$
es un número natural.
Ver código
1 import java.util.Scanner;
2 public class enteros
3 {
4 public static void main( String [] args)
5 {
6 int a=1;
7 String S=" ";
8 System.out.println("(a,b)"+S+"(a^2+b^2+1)/(ab)");
9
10 while ( a<499 )
11 {
12 for ( int b=a+1; b<500; b++)
13 {
14 int num= a*a + b*b +1;
15 int dem= a*b;
16 if ( (num % dem)==0)
17 System.out.println("( "+a+" , "+b+" )"+S+num/dem);
18 }
19 a++;
20 }
21 }
22 }
Observaciones:
-
Entradas: ninguna
-
Salida: se imprimen los números a y b que cumplen las condiciones del enunciado, así como el resultado del cociente.
-
En el bucle while de la línea 10 tenemos que a < 499, por tanto, como mucho
a puede valer 498. Por tanto, en el siguiente bucle for de la línea 10 tenemos que
b = 499, con lo que no llegará a valer 500.
