Fundamentos
De JAVA
Palabras
reservadas
En el siguiente cuadro se listan las palabras reservadas, aquellas que
emplea el lenguaje Java, y que el programador no puede utilizar como identificadores.
Algunas de estas palabras le resultarán familiares al programador del lenguaje
C/C++. Las palabras reservadas señaladas con un arterisco (*) no se utilizan.
abstract
|
boolean
|
break
|
byte
|
byvalue*
|
case
|
cast*
|
catch
|
char
|
class
|
const*
|
continue
|
default
|
do
|
double
|
else
|
extends
|
false
|
final
|
finally
|
float
|
for
|
future*
|
generic*
|
goto*
|
if
|
implements
|
import
|
inner*
|
instanceof
|
int
|
interface
|
long
|
native
|
new
|
null
|
operator*
|
outer*
|
package
|
private
|
protected
|
public
|
rest*
|
return
|
short
|
satatic
|
super
|
switch
|
synchronized
|
this
|
throw
|
transient
|
true
|
try
|
var*
|
void
|
volatile
|
while
|
|
|
Todos los
lenguajes de programación permiten realizar operaciones entre los tipos de
datos básicos: suma, resta, producto, cociente, etc., de dos números. Otros
lenguajes como el BASIC y Java permiten "sumar", concatenar cadenas
de caracteres.
Java tiene cinco operadores
aritméticos cuyo significado se muestra en la tabla adjunta
Operador
|
Nombre
|
Ejemplo
|
+
|
Suma
|
3+4
|
-
|
Diferencia
|
3-4
|
*
|
Producto
|
3*4
|
/
|
Cociente
|
20/7
|
%
|
Módulo
|
20%7
|
El cociente
entre dos enteros da como resultado un entero. Por ejemplo, al dividir 20 entre
7 nos da como resultado 2.
El operador
módulo da como resultado el resto de la división entera. Por ejemplo 20%7 da
como resultado 6 que es el resto de la división entre 20 y 7.
El operador
módulo también se puede emplear con números reales. Por ejemplo, el cociente
entre 7.5 y 3.0 es 2.5 y el resto es cero, es decir, 7.5=3.0 x 2.5+ 0. El
operador módulo, funciona de la siguiente forma 7.5=3.0 x 2+1.5, calcula la
diferencia entre el dividendo (7.5) y el producto del divisor (3.0) por
la parte entera (2) del cociente, devolviendo 1.5. Así pues, la operación
7.5%3.0 da como resultado 1.5.
Operadores de relación o de comparación
Permiten
evaluar la igualdad y la magnitud. El resultado de una operación de relacion es
un valor booleano true o false. Los operadores de relacion son los siguientes:
Operador
|
Operación
|
<
|
¿Primer operando menor que el segundo?
|
>
|
¿Primer operando mayor que el segundo?
|
<=
|
¿Primer operando menor o igual que el segundo?
|
>=
|
¿Primer operando mayor o igual que el segundo?
|
!=
|
¿Primer operando didtinto que el segundo?
|
==
|
¿Primer operando igual que el segundo?
|
Operadores lógicos
El
resultado de una operación logica (AND, OR, XOR y NOT) es un valor booleano
verdadero o falso (true o false). Las expresiones que dan como resultado
valores booleanos pueden combinarse para formar expresiones booleanas
utilizando los operadores logicos indicados a continuación. Los operandos deben
ser expresiones que den un resultado booleano.
Operador
|
Operación
|
&& o &
|
AND. Da como resultado true si al evaluar cada uno
de los operandos el resultado es true. Si uno de ellos es false, el resultado
es false. Si se utiliza && (no &) y el primer operando es false,
el segundo operando no es evaluado.
|
| | o |
|
OR. El resultado es false si al evaluar cada uno
de los operandos el resultado es false. Si uno de ellos es true, el resultado
es true. Si se utiliza | | (no |) y el primer operando es true, el segundo
operando no es evaluado (el carácter | es ASCII 124).
|
!
|
NOT. El resultado de
aplicar este operador es false si al evaluar su operando el resultado es
true, y true en caso contrario.
|
^
|
XOR. Da como resultado true si al evaluar cada uno
de los operandos el resultado de uno es true y el del otro false, en otro caso
el resultado es false.
|
El operador asignación
Nos
habremos dado cuenta que el operador más importante y más frecuentemente usado
es el operador asignación =, que hemos empleado para la inicialización
de las variables. Así,
int numero;
numero=20;
la primera
sentencia declara una variable entera de tipo int y le da un
nombre (numero). La segunda sentencia usa el operador asignación para
inicializar la variable con el número 20.
Consideremos ahora, la siguiente sentencia: a=b;
que asigna
a a el valor de b. A la izquierda siempre tendremos una variable
tal como a, que recibe valores, a la derecha otra variable b, o
expresión que tiene un valor. Por tanto, tienen sentido las expresiones
a=1234;
double area=calculaArea(radio);
superficie=ancho*alto;
Sin
embargo, no tienen sentido las expresiones
1234=a;
calculaArea(radio)=area;
Las
asignaciones múltiples son también posibles. Por ejemplo, es válida la
sentencia
c=a=b; //equivalente a c=(a=b);
la cual
puede ser empleada para inicializar en la misma línea varias variables
c=a=b=321; //asigna 321 a a, b y c
El operador
asignación se puede combinar con los operadores aritméticos
Expresión
|
Significado
|
x+=y
|
x=x+y
|
x-=y
|
x=x-y
|
x*=y
|
x=x*y
|
x/=y
|
x=x/y
|
Así, la
sentencia
x=x+23;
evalúa la
expresión x+23, que es asignada de nuevo a x. El compilador lee
primero el contenido de la porción de memoria nombrada x, realiza la
suma, y guarda el resultado en la misma porción de memoria. Se puede escribir
la sentencia anterior de una forma equivalente más simple
x+=23;
En Java se
usa el operador + para concatenar cadenas de carcateres o strings. Veremos en
el siguiente apartado una sentencia como la siguiente:
System.out.println("la temperatura centígrada es "+tC);
El operador
+ cuando se utiliza con strings y otros objetos, crea un solo string que
contiene la concatenación de todos sus operandos. Si alguno de los operandos no
es una cadena, se convierte automáticamente en una cadena. Por ejemplo, en la
sentencia anterior el número del tipo double que guarda la
variable tC se convierte en un string que se añade al string "la
temperatura centígrada es ".
Como
veremos más adelante, un objeto se convierte automáticamente en un string si su
clase redefine la función miembro toString
de la clase base Object.
Como vemos
en el listado, para mostrar un resultado de una operación, por ejemplo, la suma
de dos números enteros, escribimos
iSuma=ia+ib;
System.out.println("El resultado de la suma es "+iSuma);
Concatena
una cadena de caracteres con un tipo básico de dato, que convierte
automáticamente en un string.
El operador
+= también funciona con cadenas.
String nombre="Juan ";
nombre+="García";
System.out.println(nombre);
public class OperadorAp {
public static void main(String[] args) {
System.out.println("Operaciones con enteros");
int ia=7, ib=3;
int iSuma, iResto;
iSuma=ia+ib;
System.out.println("El resultado de la suma es "+iSuma);
int iProducto=ia*ib;
System.out.println("El resultado del producto es "+iProducto);
System.out.println("El resultado del cociente es "+(ia/ib));
iResto=ia%ib;
System.out.println("El resto de la división entera es "+iResto);
System.out.println("**********************************");
System.out.println("Operaciones con números decimales");
double da=7.5, db=3.0;
double dSuma=da+db;
System.out.println("El resultado de la suma es "+dSuma);
double dProducto=da*db;
System.out.println("El resultado del producto es "+dProducto);
double dCociente=da/db;
System.out.println("El resultado del cociente es "+dCociente);
double dResto=da%db;
System.out.println("El resto de la división es "+dResto);
}
}
|
Los operadores aritméticos tienen
distinta precedencia, así la expresión a+b*c es equivalente a a+(b*c)
ya que el producto y el cociente
tienen mayor precedencia que la suma o la resta. Por tanto, en la segunda
expresión el paréntesis no es necesario. Sin embargo, si queremos que se
efectúe antes la suma que la multiplicación tenemos que emplear los paréntesis
(a+b)*c
Para
realizar la operación 
escribiremos a/(b*c); o bien,
a/b/c;
En la mayoría de los casos, la
precedencia de las operaciones es evidente, sin embargo, en otros que no lo son
tanto, se aconseja emplear paréntesis. Como ejemplo, estudiemos un programa que
nos permite convertir una temperatura en grados Fahrenheit en su equivalente en
la escala Celsius. La fórmula de conversión es
cuya codificación es: tC=(tF-32)*5/9;
Las
operaciones se realizan como suponemos, ya que si primero se realizase el
cociente 5/9, el resultado de la división entera sería cero, y el producto por
el resultado de evaluar el paréntesis sería también cero. Si tenemos dudas
sobre la precedencia de operadores podemos escribir:
public class PrecedeApp {
public static void main(String[] args) {
int tF=80;
System.out.println("la temperatura Fahrenheit es "+tF);
int tC=(tF-32)*5/9;
System.out.println("la temperatura centígrada es "+tC);
}
}
|
Cuando se
realiza una operación, si un operando es entero (int) y el
otro es de coma flotante (double) el resultado es en coma
flotante (double).
int a=5;
double b=3.2;
double suma=a+b;
Cuando se
declaran dos variables una de tipo int y otra de tipo double.
int entero;
double real=3.20567;
¿qué
ocurrirá cuando asignamos a la variable entero el número guardado en la
variable real?. Como hemos visto se trata de dos tipos de variables
distintos cuyo tamaño en memoria es de 32 y 64 bits respectivamente. Por tanto,
la sentencia
entero=real;
convierte
el número real en un número entero eliminando los decimales. La variable entero
guardará el número 3.
Se ha de
tener cuidado, ya que la conversión de un tipo de dato en otro es una fuente
frecuente de error entre los programadores principiantes. Ahora bien,
supongamos que deseamos calcular la división 7/3, como hemos visto, el
resultado de la división entera es 2, aún en el caso de que tratemos de guardar
el resultado en una variable del tipo double, como lo prueba la siguiente
porción de código.
int ia=7;
int ib=3;
double dc=ia/ib;
Si queremos
obtener una aproximación decimal del número 7/3, hemos de promocionar el entero
ia a un número en coma flotante, mediante un procedimiento denominado
promoción o casting.
int ia=7;
int ib=3;
double dc=(double)ia/ib;
Como
aplicación, consideremos el cálculo del valor medio de dos o más números
enteros
int edad1=10;
int edad2=15;
double media=(double)(edad1+edad2)/2;
El valor
medio de 10 y 15 es 12.5, sin la promoción se obtendría el valor erróneo 12.
Imaginemos
ahora, una función que devuelve un entero int y queremos
guardarlo en una variable de tipo float. Escribiremos
float resultado=(float)retornaInt();
Existen también conversiones
implícitas realizadas por el compilador, por ejemplo cuando pasamos un entero int a una función
cuyo único parámetro es de tipo long.
Operadores unarios
·
++
Incremento
·
--
Decremento
actúan sobre un único operando. Se
trata de uno de los aspecto más confusos para el programador, ya que el
resultado de la operación depende de que el operador esté a la derecha i++
o a la izquierda ++i.
Conoceremos, primero el significado de
estos dos operadores a partir de las sentencias equivalentes:
i=i+1; //añadir 1 a i
i++;
Del mismo modo, lo son
i=i-1; //restar 1 a i
i--;
Examinemos ahora, la posición del
operador respecto del operando. Consideremos en primer lugar que el operador
unario ++ está a la derecha del operando. La sentencia j=i++;
asigna a j, el valor que tenía
i. Por ejemplo, si i valía 3, después de ejecutar la sentencia, j
toma el valor de 3 e i el valor de 4. Lo que es equivalente a las dos
sentencias
j=i;
i++;
Un resultado distinto se obtiene si el
operador ++ está a la izquierda del operando
j=++i;
asigna a j el valor
incrementado de i. Por ejemplo, si i valía 3, después de ejecutar
la sentencia j e i toman el valor de 4. Lo que es equivalente a
las dos sentencias
++i;
j=i;
public class UnarioApp {
public static void main(String[] args) {
int i=8;
int a, b, c;
System.out.println("\tantes\tdurante\tdespués");
i=8; a=i; b=i++; c=i;
System.out.println("i++\t"+a+'\t'+b+'\t'+c);
i=8; a=i; b=i--; c=i;
System.out.println("i--\t"+a+'\t'+b+'\t'+c);
i=8; a=i; b=++i; c=i;
System.out.println("++i\t"+a+'\t'+b+'\t'+c);
i=8; a=i; b=--i; c=i;
System.out.println("--i\t"+a+'\t'+b+'\t'+c);
}
}
|
La salida del
programa es, la siguiente
antes durante después
i++ 8 8 9
i-- 8 8 7
++i 8 9 9
--i 8 7 7
|
ESTRUCTURAS DE CONTROL
CONDICIONALES
Del mismo modo que en la vida diaria, en un programa es
necesario tomar decisiones basadas en ciertos hechos y actuar en consecuencia.
El lenguaje Java tiene una sentencia básica denominada if (si
condicional) que realiza un test y permite responder de acuerdo al
resultado.
La sentencia if
La sentencia if, actúa como cabría esperar. Si la
condición es verdadera, la sentencia se ejecuta, de otro modo, se salta dicha
sentencia, continuando la ejecución del programa con otras sentencias a
continuación de ésta. La forma general de la sentencia if es:
if (condición)
sentencia;
Si el resultado del test es verdadero (true) se ejecuta la
sentencia que sigue a continuación de if, en caso contrario, falso (false), se salta dicha
sentencia, tal como se indica en la figura. La sentencia puede consistir a su
vez, en un conjunto de sentencias agrupadas en un bloque.
if (condición){
sentencia1;
sentencia2;
}
En el
siguiente ejemplo, si el número del boleto que hemos adquirido coincide con el
número aparecido en el sorteo, nos dicen que hemos obtenido un premio.
if(numeroBoleto==numeroSorteo)
System.out.println("has obtenido un premio");
La
sentencia if...else completa la sentencia if, para realizar una
acción alternativa
if (condición)
sentencia1;
else
sentencia2
Las dos
primeras líneas indican que si la condición es verdadera se ejecuta la
sentencia 1. La palabra clave else, significa que si la condición no es
verdadera se ejecuta la sentencia 2, tal como se ve en la figura..
Dado que
las sentencias pueden ser simples o compuestas la forma general de if...else
es
if (condición){
sentencia1;
sentencia2;
}else{
sentencia3
sentencia4;
sentencia5;
}
Existe
una forma abreviada de escribir una sentencia condicional if...else como
la siguiente:
if (numeroBoleto==numeroSoreteo)
premio=1000;
else
premio=0;
en una
sola línea
premio=(numeroBoleto==numeroSoreteo) ? 1000 : 0;
Un ejemplo
significativo es el siguiente: el signo de un número elevado a una potencia par
es positivo, y es negativo cuando está elevado a una potencia impar.
int signo=(exponente%2==0)?1:-1;
La
condición entre parántesis es la siguiente: un número es par, cuando el resto
de la división entera de dicho número entre dos vale cero.
Como podemos ver en la figura del apartado anterior, la
sentencia if...else tiene dos ramas, el programa va por una u otra rama
dependiendo del valor verdadero o falso de la expresión evaluada. A veces, es
necesario, elegir entre varias alternativas, como se muestra en la siguiente
figura
Por
ejemplo, considérese las siguientes series de sentencias if...else
if(expresion==valor1)
sentencia1;
else if(expresion==valor2)
sentencia2;
else if(expresion==valor3)
sentencia3;
else
sentencia4;
El código
resultante puede ser difícil de seguir y confuso incluso para el programador
avanzado. El lenguaje Java proporciona una solución elegante a este problema
mediante la sentencia condicional switch para agrupar a un conjunto de
sentencias if...else.
switch(expresion){
case valor1:
sentencia1;
break; //sale de switch
case valor2:
sentencia2;
break; //sale switch
case valor3:
sentencia3;
break; //sale de switch
default:
sentencia4;
}
En la sentencia switch, se compara el valor de una
variable o el resultado de evaluar una expresión, con un conjunto de números
enteros valor1, valor2, valor3, .. o con un conjunto de
caracteres, cuando coinciden se ejecuta el bloque de sentencias que están
asociadas con dicho número o carácter constante. Dicho bloque de sentencias no
está entre llaves sino que empieza en la palabra reservada case y
termina en su asociado break. Si el compilador no encuentra
coincidencia, se ejecuta la sentencia default, si es que está presente
en el código.
Veamos ahora un ejemplo sencillo: dado el número que
identifica al mes (del 1 al 12) imprimir el nombre del mes.
public class SwitchApp1 {
public static void main(String[] args) {
int mes=3;
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
default: System.out.println("Este mes no existe"); break;
}
}
}
|
Ahora un ejemplo más complicado, escribir un programa que
calcule el número de días de un mes determinado cuando se da el año. Anotar primero, los meses que tienen 31 días
y los que tienen 30 días. El mes de Febrero (2º mes) es el más complicado ya
que tiene 28 días excepto en los años que son bisiestos que tiene 29. Son
bisiestos los años múltiplos de cuatro, que no sean múltiplos de 100, pero si
son bisiestos los múltiplos de 400.
public class SwitchApp2 {
public static void main(String[] args) {
int mes=2;
int año=1992;
int numDias=30;
switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDias = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDias = 30;
break;
case 2:
if ( ((año % 4 == 0) && !(año % 100 == 0)) || (año % 400 == 0) )
numDias = 29;
else
numDias = 28;
break;
default:
System.out.println("Este mes no existe");
break;
}
System.out.println("El mes "+mes+" del año "+año+" tiene "+numDias+" días");
}
}
|
ESTRUCTURAS DE CONTROL
CONDICIONALES
Tan importantes como las
sentencias condiciones son las sentencias iterativas o repetitivas.
Normalmente, las sentencias de un programa son ejecutadas en el orden en el que
aparecen. Cada sentencia es ejecutada una y solamente una vez. El lenguaje
Java, como la mayoría de los lenguajes, proporciona sentencias que permiten
realizar una tarea una y otra vez hasta que se cumpla una determinada
condición, dicha tarea viene definida por un conjunto de sentencias agrupadas
en un bloque. Las sentencias iterativas son for, while y do...while
Esta sentencia se encuentra en la mayoría de los lenguajes de
programación. El bucle for se empleará cuando conocemos el número de
veces que se ejecutará una sentencia o un bloque de sentencias, tal como se
indica en la figura. La forma general que adopta la sentencia for es
for(inicialización; condición; incremento)
sentencia;
El primer término
inicialización, se usa para inicializar una variable índice, que controla
el número de veces que se ejecutará el bucle. La condición representa la
condición que ha de ser satisfecha para que el bucle continúe su ejecución. El incremento
representa la cantidad que se incrementa la variable índice en cada repetición.
Ejemplo: Escribir
un programa que imprima los primeros 10 primeros números enteros empezando por
el cero
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
El resultado será:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
La variable índice i
se declara y se inicializa en el término inicialización, la condición
se expresa de modo que i se debe mantener estrictamente menor que 10; la
variable i se incrementa una unidad en cada repetición del bucle. La
variable i es local al bucle, por lo que deja de existir una vez que se
sale del bucle.
Ejemplo: Escribir
un programa que imprima los números pares positivos menores o iguales que 20
for (int i=2; i
<=20; i += 2) {
System.out.println(i);
}
Ejemplo: Escribir
un programa que imprima los números pares positivos menores o iguales que 20 en
orden decreciente
for (int i=20;
i >= 2; i -= 2) {
System.out.println(i);
}
Ejemplo: Escribir
un programa que calcule el factorial de un número empleando la sentencia
iterativa for. Guardar el resultado en un número entero de tipo long
.
public
class FactorialApp {
public static void main(String[] args) {
int numero=4;
long resultado=1;
for(int i=1; i<=numero; i++){
resultado*=i;
}
System.out.println("El factorial
es "+resultado);
}
}
|
La sentencia while
A la
palabra reservada while le sigue una condición encerrada entre
paréntesis. El bloque de sentencias que le siguen se ejecuta siempre que la
condición sea verdadera tal como se ve en la figura. La forma general que
adopta la sentencia while es:
while (condición)
sentencia;
Ejemplo: Escribir
un programa que imprima los primeros 10 primeros números enteros empezando por
el cero, empleando la sentencia iterativa while.
int i=0;
while (i<10)
{
System.out.println(i);
i++;
}
El valor inicial de
i es cero, se comprueba la condición (i<10), la cual resulta
verdadera. Dentro del bucle, se imprime i, y se incrementa la variable
contador i, en una unidad. Cuando i vale 10, la condición (i<10)
resulta falsa y el bucle ya no se ejecuta. Si el valor inicial de i
fuese 10, no se ejecutaría el bucle. Por tanto, el bucle while no se
ejecuta si la condición es falsa.
Ejemplo:
escribir un programa que calcule el factorial de un número empleando la
sentencia iterativa while
public
class FactorialApp1 {
public static void main(String[] args) {
int numero=4;
long resultado=1;
while(numero>0){
resultado*=numero;
numero--;
}
System.out.println("El factorial
es "+resultado);
}
}
|
Como hemos
podido apreciar las sentencias for y while la condición está al
principio del bucle, sin embargo, do...while la condición está al final
del bucle, por lo que el bucle se ejecuta por lo menos una vez tal como se ve
en la figura. do marca el comienzo del bucle y while el final del
mismo. La forma general es:
do{
sentencia;
}while(condición);
Ejemplo:
Escribir un programa que imprima los primeros 10 primeros números enteros
empezando por el cero, empleando la sentencia iterativa do..while.
int i=0;
do{
System.out.println(i);
i++;
}while(i < 10);
El bucle do...while,
se usa menos que el bucle while, ya que habitualmente evaluamos la
expresión que controla el bucle al comienzo, no al final.
A veces es
necesario interrumpir la ejecución de un bucle for, while, o do...while.
for(int i = 0; i < 10; i++){
if (i == 8) break;
System.out.println(i);
}
Consideremos
de nuevo el ejemplo del bucle for,
que imprime los 10 primeros números enteros, se interrumpe la ejecución del
bucle cuando se cumple la condición de que la variable contador i valga
8. El código se leerá: "salir del bucle cuando la variable contador i,
sea igual a 8".
Como
podemos apreciar, la ejecución del bucle finaliza prematuramente. Quizás el
lector pueda pensar que esto no es de gran utilidad pues, el código anterior es
equivalente a
for(int i = 0; i <=8; i++)
System.out.println(i);
Sin
embargo, podemos salir fuera del bucle prematuramente si se cumple alguna
condición de finalización.
while(true){
if (condicionFinal) break;
//...otras sentencias
}
Como
podemos apreciar en esta porción de código, la expresión en el bucle while
es siempre verdadera, por tanto, tiene que haber algún mecanismo que nos
permita salir del bucle. Si la condicion de finalización es verdadera, es decir
la variable condicionFinal
del tipo boolean
toma el valor true,
se sale del bucle, en caso contrario se continua el procesmiento de los datos.
La
sentencia continue, fuerza al bucle a comenzar la siguiente iteración
desde el principio. En la siguiente porción de código, se imprimen todos los
números del 0 al 9 excepto el número 8.
for(int i = 0; i < 10; i++){
if (i == 8) continue;
System.out.println(i);
}
Tanto break como continue pueden tener una etiqueta
opcional que indica a Java hacia donde dirigirse cuando se cumple una
determinada condición.
salida:
for(int i=0; i<20; i++){
while(j<70){
if(i*j==500) break salida;
//...
}
//...
}
La etiqueta en este ejemplo se denomina salida, y se añade
antes de la parte inicial del ciclo. La etiqueta debe terminar con el carácter
dos puntos :. Si no disponemos de etiqueta, al cumplirse la
condición i*j==500, se saldría del bucle interno while,
pero el proceso de cálculo continuaría en el bucle externo for.
Escribir un programa que calcule los números
primos comprendidos entre 3 y 100.
Los
números primos tienen la siguiente característica: un número primo es solamente
divisible por sí mismo y por la unidad, por tanto, un número primo no puede ser
par excepto el 2. Para saber si un número impar es primo, dividimos dicho
número por todos los números impares comprendidos entre 3 y la mitad de dicho
número. Por ejemplo, para saber si 13 es un número primo basta dividirlo por 3,
y 5. Para saber si 25 es número primo se divide entre 3, 5, 7, 9, y 11. Si el
resto de la división (operación módulo %) es cero, el número no es primo.
public
class PrimosApp {
public static void main(String[] args) {
boolean bPrimo;
System.out.println("Números
primos comprendidos entre 3 y 100");
for(int numero=3; numero<100;
numero+=2){
bPrimo=true;
for(int i=3; i<numero/2;
i+=2){
if(numero%i==0){
bPrimo=false;
break;
}
}
if(bPrimo){
System.out.print(numero+" - ");
}
}
}
}
|
En
primer lugar, hacemos un bucle for para examinar los números impares
comprendidos entre 3 y 100.
Hacemos
la suposición de que numero es primo, es decir, de que la variable de
control bPrimo toma el valor true. Para confirmarlo, se halla el
resto de la división entera entre numero, y los números i impares
comprendidos entre 3 y numero/2. (Se recordará que todo número es
divisible por la unidad). Si el número numero es divisible por algún
número i (el resto de la división entera numero%i es cero),
entonces el número numero no es primo, se abandona el bucle (break)
con la variable de control bPrimo tomando el valor false. En el
caso de que numero sea un número primo, se completa el bucle interno,
tomando la variable de control bPrimo el valor inicial true.
Por
último, si el número es primo, bPrimo es true, se imprime en la
ventana, uno a continuación del otro separados por un guión.
En
este programa podemos observar la diferencia entre print y println.
El sufijo ln en la segunda función indica que se imprime el argumento y
a continuación se pasa a la línea siguiente.
ARREGLOS
(ARRAYS)
Al
igual que otros lenguajes de programación, java permite juntar y manejar
múltiples valores a través de un objeto array ( matriz ).
Como otras
variables, antes de poder utilizar un array primero se debe declarar.
Al igual que
otras variables, la declaración de un array tiene dos componentes primarios: el
tipo del array y su nombre.
Un tipo de array
incluye el tipo de dato de los elementos que va contener el array.
Por ejemplo, el
tipo de dato para un array que solo va a contener elementos enteros es un array
de enteros. No puede existir un array de tipo de datos genético en el que el
tipo de sus elementos este indefinido cuando se declara el array.
Aquí tenemos
la declaración de un array de enteros;
int[] arrayDeEnteros
La parte int[] de
la declaración indica que arrayDeEnteros es un arrray de enteros. La
declaración no asigna memoria para contener los elementos del array.
Si se intenta
asignar un valor o acceder a cualquier elemento de arrayDeEnteros antes de
haber asignado la memoria para él , el compilador dará un error como el
siguiente y no compilara el programa:
Testing. Java : 64: Variable arrayDeEnteros may not have been
initialized.
Para asignar
memoria a los elementos de un array, primero se debe ejemplarizar el array. Se
puede hacer esto utilizando el operador new
de java. (Realmente, los pasos que se deben seguir para crear un array son
similares a los se deben seguir para crear un objeto de una clase: declaración,
ejemplarización e inicialización).
La siguiente
sentencia asigna la suficiente memoria para que arrayDeenteros pueda contener
diez enteros
int[
] arrayDeEnteros = new int [ 10 ]
En general, cuando
se crea un array, se utiliza el operador new,
más el tipo de dato de los elementos del array, más el número de elementos
deseados encerrados entre cochetes cuadrados (‘[‘ y ‘]’ )
Sintaxis general:
|
TipodeElemento[] NombredeArray =
new
TipodeElementos[TamañoArray]
|
Ahora que se ha
asignado memoria para un array ya se pueden asignar valores a los elementos y
recuperar esos valores:
for (int j = 0; j < arrayDeEnteros.length; j =j+1 )
{
arrayDeEnyteros[ ] = j;
………
}
Como se puede ver en el ejemplo anterior, para
referirse a un elemento de array, se añade corchetes cuadrados al nombre
del array. Entre los corchetes cuadrados
se indica ( bien con una variable o con una expresión ) el índice del elemento
al que se quiere acceder.
En java, el índice del array empieza en 0 y
termina en la longitud del array menos uno, lo que implica que el primer
elemento de cualquier arreglo es el elemento número cero: NombredeArray[0]
Hay otro elemento
interesante en el pequeño ejemplo anterior. El bucle for itera sobre cada
elemento de arrayDeEnteros asignándole valores e imprimiendo esos valores.
El uso de
arrayDeEnteros.length para obtener el tamaño real del array.lentgh es una
propiedad proporcionada para todos los array de java. La longitud del arreglo
se determina así:
NombredeArray.length
OBSERVACIONES:
Para asignar memoria a los 12 elementos de un arreglo c, usamos: int c[] = new
int[12]
El enunciado anterior también puede realizarse en dos pasos como
sigue:
int
c[]; //
declara el arreglo
c= new int[12]; //
asigna memoria al arreglo
|
Cuando se asigna espacio de almacenamiento a
un arreglo, los elementos se inicializan automáticamente a cero en el caso de
variables de tipos de datos numéricos,
a false en el caso de valores booleanos o a null en el caso de referencias.
|
Podemos reservar memoria para varios arreglos con una sola
declaración. La siguiente declaración reserva 100 elementos para el arreglo
entero b y 27 elementos para el arreglo entero x.
int b[] = new
int[100], x[] = new int[27];
|
EJEMPLO DE RANDOM
(ALEATORIO)
Numero
aleatorio:
Variable_entera=(int)
(Math.random()*intervalo);
|
Devuelve valores entre 0 e intervalo-1
|
public class EjRandom
 {
public static void main(String[] args)
{
int
n[]=new int[12];
for
(int i=0; i<n.length; i=i+1)
{
n[i]=(int) (Math.random()*7);
}
for (int i=0; i<n.length;
i=i+1)
{
System.out.print(" "+n[i]+"\n");
}
}
}
|
public class Lista1
{
public static void main(String[] args)
{
int n[]={32,27,64,18,95,14,90,70,60,37};
for (int i=0; i<n.length; i=i+1)
{
System.out.println("Lista ("+i+"):
"+ n[i]);
}
}
 }
|
public class Lista1
{
public
static void main(String[] args)
{
int
n[]={32,27,64,18,95,14,90,70,60,37};
int
n1[]={54,53,85,83,23,76,32,95,32,65};
for (int i=0; i<n.length;
i=i+1)
{
System.out.println("Listas
("+i+"): "+ n[i]+"
"+n1[i]);
}
}
}
|
public class Lista1
{
public
static void main(String[] args)
{
int
n[]={32,27,64,18,95,14,90,70,60,37};
int
n1[]={54,53,85,83,23,76,32,95,32,65};
int posiciony=15;
for
(int i=0; i<n.length; i=i+1)
{
System.out.print("Listas
("+i+"): "+ n[i]);
System.out.println(" "+n1[i]);
}
}
}
|
public class Lista1
{
public
static void main(String[] args)
{
int
n[]={32,27,64,18,95,14,90,70,60,37};
int
n1[]={54,53,85,83,23,76,32,95,32,65};
int posiciony=15;
for
(int i=0; i<n.length; i=i+1)
{
System.out.print("Listas
("+i+"): "+ n[i]);
System.out.print(" "+n1[i]+"\n");
}
}
}
|
Eficiencia:
precisión y plenitud / recursos empleados
