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

Los operadores aritméticos

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;

Concatenación de strings

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);

La precedencia de operadores

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);

La conversión automática y promoción (casting)

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

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.

La sentencia switch

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

La sentencia for

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);

}

La sentencia do...while

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.

La sentencia break

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

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);

Etiquetas

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.

Ejemplo: los números primos

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");

}

Informática y Educación

miércoles, 25 de febrero de 2015

Mapas Conceptuales Java

sábado, 21 de febrero de 2015

POO con JAVA

1. POO con JAVA

2. PROCESO DE EJECUCIÓN

3. EVALUACIÓN

viernes, 20 de febrero de 2015

Fundamentos del Lenguaje

Los operadores aritméticos

El operador asignación

Concatenación de strings

La precedencia de operadores

La conversión automática y promoción (casting)

La sentencia if

La sentencia if...else

La sentencia switch

La sentencia for

La sentencia while

La sentencia do...while

La sentencia break

La sentencia continue

Etiquetas

Ejemplo: los números primos

EJEMPLO DE RANDOM (ALEATORIO)

Datos personales