Nombre de Unidad Didáctica

NOMBRE DEL TEMA DE LA SEMANA

Semana 2

OBJETO DE LA EXPERIENCIA
Reconoce conceptos básicos del Lenguaje de Programación Java a través de casos prácticos
MARCO TEÓRICO
¿Qué es Java?
Java es uno de los lenguajes de programación más populares del mundo. Es un lenguaje orientado a objetos, potente, versátil y
mutiplataforma (corre en cualquier sistema operativo moderno). Además puedes obtener Java y gran cantidad de herramientas para trabajar
con él de forma gratuita, siendo la mayor parte de su código libre y abierto.

¿Qué relación tiene con Android?

Java fue elegido como el lenguaje para el entorno de desarrollo de Android, el sistema operativo móvil líder en smartphones y tablets.
Android es por tanto el sistema operativo (es una versión de Linux) y Java el lenguaje utilizado para crear apps en él.

¿Qué necesito conocer de Java para aprender a crear Apps para Android?
Con la tecnología Java puedes desarrollar sencillas aplicaciones para PC, applets para ejecutar en un navegador o potentes aplicaciones web,
con acceso a bases de datos y grandes prestaciones, orientadas al mundo empresarial. Pero no necesitas dominar todas las tecnologías Java si
quieres aprender a crear Apps para Android
MATERIALES

Según la experiencia a realizar, de acuerdo al catálogo de equipamiento del taller.

a) EQUIPOS
b) HERRAMIENTAS

c) CONSUMIBLES
PROCEDIMIENTO

If, If….. else, Switch

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

For, While, Do…. While, Break, Continue

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 . Definición: el factorial de un número n es el resultado del producto 1*2*3*……… *(n-
1)*n.
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 procesamiento 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.

Entradas y Salidas en Java

La entrada y salida en Java se lee y se escribe en flujos (stream) donde las fuentes básicas de entrada y salida son el teclado y la
pantalla.

Un flujo: es una corriente de datos entre una fuente y un destino

Salida:

En Java el objeto System.out está asociado con el flujo de salida que dirige los datos a la consola o pantalla, y tiene los siguientes
métodos:

print( ) Transfiere una cadena al buffer de la pantalla

para visualizarlo cuando termine el programa.
println( Transfiere una cadena al buffer de la pantalla con el
) carácter \n para visualizarlo cuando termine el programa.
flush( ) La cadena que se encuentra en el buffer pantalla se d salida d l
escribe en ese momento y e espera e a
termine el programa n q
o a u
e

Con estos métodos se puede escribir cualquier cadena o dato de los tipos básicos.
 System.out.println(“El valor es” + “una virtud”);

Con el operador + se concatenan las dos cadenas y la cadena resultante se envía al buffer de la pantalla para se visualizada cuando el
programa termine. También podemos enviar constantes o variables de los tipos básicos, el método se encarga de convertir a cadena
esos datos, por ejemplo:

int p = 60;
System.out.print(“Valor de i es: “ + i);

El contenido de la variable i se convierte a cadena y se concatena con la constante de cadena.

Java utiliza secuencias de escape tales como \n (salto de línea) y \t (tabulador) con los métodos print y println.

Entrada:

En Java el objeto System.in esta asociado al flujo estándar de entrada (teclado) el elemento básico de este flujo son caracteres y no
cadenas como ocurre con out. El método read( ) retorna el carácter actual en el buffer de entrada:

char c;
c = (char) System.in.read( );

Esto resulta impráctico cuando es una línea de caracteres lo que queremos leer desde teclado, para ello se utiliza la clase
InputStreamReader, de la que se crea un objeto inicializado con System.in:

InputStreamReader en = new InputStreamReader(System.in);

Una vez creado el en este se utiliza a su vez como argumento para inicializar otro objeto de la clase BufferedReader, el cual permite
la entrada de líneas de caracteres desde el teclado con el método readLine( ):

BufferReader entrada = new BufferedReader (en); String cd;

System.out.print(“Introdusca una cadena por el teclado: “);
System.out.flush( );
cd = entrada.readLine( );

el método readLine( ) retorna un objeto cadena con la linea de caracteres leida desde el teclado; la referencia a ese objeto se asigna a
cd, que es una variable de tipo String. readLine( ) lanza la excepción IOException. Para evitar error en tiempo de compilación, en
main( ) se añade throws IOException

Las líneas de código:

InputStreamReader en = new InputStreamReader(System.in); BufferReader entrada = new BufferedReader (en);

Se simplifican en una sola sentencia, no teniendo que crear el objeto en, es la forma usual en que aparece en los programas.
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));

a) Para capturar una cadena de caracteres se haría el siguiente programa: Class ImpNombre {
Public static void main( String[ ] arg ) throws IOException {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); String nombre;
System.out.print(“Introdusca su nombre por el teclado: “);
System.out.flush( );
nombre = entrada.readLine( );
System.out.println(“Hola: “ + nombre);
}
}

b) Para capturar valores enteros se haría el siguiente programa:

Class SumaEnteros {
Public static void main( String[ ] arg ) throws IOException {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); int dato1, dato2,suma;

System.out.print(“Introdusca un entero por el teclado: “);

System.out.flush( );
dato1 = Integer.parseInt(entrada.readLine( ));

System.out.print(“Introdusca otro entero por el teclado: “);

System.out.flush( );
dato2 = Integer.parseInt(entrada.readLine( ));

suma = dato1 + dato2 ;

System.out.println(“Suma = “ + suma );
}
}
Con Integer.parseInt( ) se convierte una cadena a un int.

c) Para capturar valores float se haría el siguiente programa:

Class AreaTriangulo {
Public static void main( String[ ] arg ) throws IOException {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); Float dato;
float base, altura;

System.out.print(“Introdusca la base por el teclado: “);

System.out.flush( );
dato = Float.ValueOf(entrada.readLine( )); base = dato.floatValue( );

System.out.print(“Introdusca la altura por el teclado: “);

System.out.flush( );
dato = Float.ValueOf(entrada.readLine( )); altura = dato.floatValue( );

System.out.println(“Area =“ + base * altura/2 );

}
}
d) Para capturar valores double se haría el siguiente programa: Class AreaTriangulo {
Public static void main( String[ ] arg ) throws IOException {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in)); Double dato;
double base, altura;

System.out.print(“Introdusca la base por el teclado: “);

System.out.flush( );
dato = Double.ValueOf(entrada.readLine( )); base =
dato.doubleValue( );

System.out.print(“Introdusca la altura por el teclado: “);

System.out.flush( );
dato = Double.ValueOf(entrada.readLine( )); altura =
dato.doubleValue( );

System.out.println(“Area = “ + base * altura/2 );

}
}

Nota:
double d;
float f;
otra forma de realizar la captura de información de manera eficiente seria usando lo siguiente:

d = Double.parseDouble(entrada.readLine( )); // para el caso de

un double. f = Float.parseFloat(entrada.readLine( )); // para el
caso de un float.

Estas dos formas simplifican la forma en que se efectuaron las entradas en los ejemplos anteriores

En la librería java.util disponemos de otra forma de realizar la entrada de datos, la clase Sccaner proporciona métodos para leer
datos de la entrada estándar (teclado), referenciada por el método System.in, estos métodos son:

Scanner(System.in): construye un lector para obtener valore por la entrada estándar ejemplo:

Sccaner leer = new Sccaner(System.in)

Asociados al objeto leer tenemos los siguientes metodos:

next( ): retorna una cadena, el fin de la cadena se delimita por un espacio en blanco o un Enter, ejemplo:

String dato = leer.next();

nextLine( ): retorna una cadena, pero a diferencia del anterior, lee del teclado los caracteres introducidos, inclusive los espacios en
blanco, hasta encontrar el Enter. Ejemplo:

String dato = leer.nextLine( ):

También existen métodos de lectura para cada uno de los tipos de datos como son:
Metodo Acció
n
nextBoolean( Lee un elemento de tipo lógico
) (true o false).
nextInt( ) Lee un valor entero.
nextFloat( ) Lee un valor real en simple
precisión.
nextDouble( Lee un valor real en
) doble precisión.

Si el tipo de dato introducido no es del tipo solicitado no se acepta la entrada y se lanza una excepción, por ejemplo:
Leer.nextBolean ( );

Salida con formato

Mediante el método printf de la clase java.util podemos especificar cómo va a ser la salida de la siguiente manera:

System.out.printf(“Formato”, lista variables o valores);

En donde en el formato se especifica cómo será la salida, es una cadena de caracteres formada por caracteres ordinarios,
especificaciones de formato y secuencias de escape, el formato se lee de izquierda a derecha.
Lista de variables: representa datos a escribir, cada variable debe tener su correspondiente especificación de formato y en el mismo
orden.

La siguiente tabla muestra los formatos utilizados y ejemplos:

Carácter Descripción Ejempl Salida

o
c Carácter printf(“%c”, ‘A’); A
printf(“%c A 65
%d”,’A’,(int)’A’);
d Enteros printf(“%05”,45); 00045
printf(“%5d”,45) 45
Fof Reales printf(“%.2f”,45.00); 45.00
printf(“%.0f”,45.00); 45
printf(“%8.2f”,145.30); 145.30
printf(“%8.2f”,45.00) 45.00
s Cadenas printf(“%8s”,”abc”); a
printf(“%8s”,”abcde”); bc
printf(“%-8s”,”abc”); abcde
printf(“%-8s”,”abcde”); abc
abcde
Nota: % indica una especificación de formato, el signo – después del % indica que el dato se alineara a la izquierda del campo de
impresión de no aparecer a la derecha (ver ejemplos en la tabla), en el caso de los valores numéricos si se indica %05, es que se usara
un campo de impresión de 5 caracteres en caso de no haber el carácter se imprimirá un cero, un formato como este %8.2 indica
que se usara un campo de impresión de 8 caracteres de los cuales 2 se usaran para la parte decimal, el \n indica un salto de línea.

Métodos (Funciones):

Bloque de código que tiene un nombre, un tipo y una lista de argumentos o parámetros, esto es lo que en otros lenguajes de
programación recibe el nombre de función.

Sintaxis:

tipo nombre_método (lista_de_argumento) {

cuerpo del método

tipo: especifica el tipo de dato devuelto por el método.

nombre_método: nombre que identifica al método (usar identificador valido). lista_de_parámetros: es un secuencia de parejas,
formadas por el tipo y el identificador del parámetro separados por comas, son variables que reciben el valor del argumento pasadas
al método cuando este es llamado, si el método no tiene parámetros entonces la lista será vacía.
Los métodos que retornan algún valor deben utilizar return con la siguiente sintaxis:

return valor;
return; (si no retorna ningún valor)

donde valor es una expresión con el valor que se devuelve, los métodos en Java siempre se deben declarar dentro de una clase.

Cuando un programa llama a un método, el control del programa se transfiere al método llamado. Un método llamado devuelve el
control al llamador cuando ejecuta la sentencia return o cuando se alcanza la llave derecha (}) al final del método.

El siguiente ejemplo crea un programa en el cual se define un método llamado máximo que será llamado desde la función main( ),
este método determinara el mayor de dos números.

import java.io.*; class

prueba_max {
public static void main( String [ ] ar) throws IOException {
BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in));
int num1, num2, res; System.out.print(“De el
numero 1: “); System.out.flush( );
num1 = Integer.parseInt(entrada.readLine( )); System.out.print(“De el
numero 2: “); System.out.flush( );
num2 = Integer.parseInt(entrada.readLine( )); res = maximo(num1,
num2);
System.out.println(“El máximo valor es: “ + res);
}

static void máximo(int a, int b) { if(a > b) return a;

else return b;
}

} // fin clase prueba_max

La clase prueba_max contiene el método principal main( ) y el método máximo( ). El método main( ) se diferencia de otros métodos
en que este es llamado por la maquina virtual Java, mientras que el método máximo( ) será invocado por main( ). Java exige que desde
un método estático solo se pueden llamar otros métodos estáticos por esa razón máximo( ) también tiene el modificador static, además
este método retorna un valor entero y recibe dos parámetros enteros.
Paso de los argumentos a los métodos:

Los argumentos se pasan a los métodos en Java por valor, esto significa que se hace una copia del tipo de dato recibido, en otras
palabras, tomemos como ejemplo el programa anterior, al leer los valores a num1 se le asigna el valor de 10 ya num2 el valor de 21
cuando se llama al método máximo( ), res = máximo( num1, num2), se pasan estos dos valores al mismo, este crea dos posiciones en
memoria donde se almacenan los valores suministrados por num1 y num2, dichas posiciones son a y b, de tal manera que si en el
método se modificara la información de a o b esto no alteraria los valores de num1 y num2. hagamos el siguiente ejemplo para
demostrar lo anterior:

class valor {
public static void main(String [ ] ar) {
int a = 70;
System.out.println(“Valor de a antes de llamar al método: “+ a);
metodo(a);
System.out.println(“Valor de a después de llamar al método: “+ a);
}

static void metodo( int x) { System.out.println(“Dentro del método x = “+ x);

x = 200;
System.out.println(“Cambiamos el valor de x ahora es = “+ x);
}
}

la salida queda así al ejecutar el programa:

Valor de a antes de llamar al método: 70 Dentro del

método x = 70
Cambiamos el valor de x ahora es = 200 Valor de a después
de llamar al método: 70

En la técnica de paso de parámetros por valor, el método que recibe no puede modificar la
variable que recibe el método como argumento (parámetro pasado).

Sobrecarga de métodos:

Técnica mediante la cual dos o mas métodos dentro de la misma clase tienen el mismo nombre y las declaraciones de sus parámetros
son diferentes. La sobrecarga es uno de los procedimientos mediante el cual Java implementa el Polimorfismo.

Cuando Java llama un método sobrecargado el compilador determina cual es el método invocado basándose en el numero o tipo de
argumento pasados; con lo cual los métodos sobrecargados deben tener diferentes tipos o numeraos de parámetro, cuando Java
encuentra una llamada a un método sobrecargado, ejecuta la versión del método cuyos parámetros coincidan con los argumentos
utilizados en la llamada. Ejemplo: se define una clase con
2 métodos sobrecargados, adición( ), diferenciándose uno del otro por el numero/tipo parámetro, el método main( ) llama a los dos
métodos.

class sobrecarga {
public static void main(String [ ] ar ) {
int num1 = 25, num2 = 200;
double nu1 = 125.45, nu2 = 34.25;
System.out.println(“Suma de enteros = “ + adicion(num1, num2)); System.out.println(“Suma de reales = “ +
adicion(nu1, nu2));
}

static int adicion( int x, int y) { return x + y;

}

static double adicion( double z, double w) { return z + w;

}
} // fin clase sobrecarga
Funciones matemáticas

Mediante la clase Math se tiene acceso al conjunto de funciones matemáticas estándar:

Math.abs( x ) para int, long, float y double Valor Absoluto de un Nro

Math.sin( double ) Retorna el seno de un ángulo en radianes
Math.cos( double ) Retorna el coseno de un ángulo en radianes Math.tan( double )
Retorna el tangente de un ángulo en radianes Math.asin( double )
retorna el arcoseno.
Math.acos( double ) retorna el arcocoseno. Math.atan(
double ) retorna el arcotangente.
Math.atan2( double,double ) convierte coodenadas rectangulares a polares Math.exp( double )
retorna ex
Math.log( double ) retorna el logaritmo de un Nro. Math.sqrt( double )
retorna la raiz cuadrada de un Nro.
Math.ceil( double ) retorna el valor más pequeño que es menor o igual al valor dado Math.floor( double ) retorna
el valor más grande que es menor o igual al valor dado Math.rint( double ) retorna el redondeo del valor dado
Math.pow( a,b ) retorna ab
Math.round( x ) para double y float
Math.random() devuelve un double retorna un Nro aleatorio.
Math.max( a,b ) para int, long, float y double retorna el valor máximo entre dos Nros.
Math.min( a,b ) para int, long, float y double retorna el valor mínimo entre dos Nros. Math.E para la base exponencial
Math.PI para PI

class Mates {

public static void main( String args[] ) { int x;

double rand,y,z; float
max;

rand = Math.random(); x =
Math.abs( -123 );
y = Math.round( 123.567 ); z =
Math.pow( 2,4 );
max = Math.max( (float)1e10,(float)3e9 );
 // Se imprimen en consola los números obtenidos de las operaciones
// anteriores para comprobar los resultados de la aplicación de
// los métodos definidos en la clase Math
System.out.println( rand ); System.out.println( x );
System.out.println( y ); System.out.println( z );
System.out.println( max );
} }

Vectores y matrices

Un vector (arreglo) es una manera de agrupar valores de un mismo tipo bajo un mismo nombre. Para acceder a los valores
individuales se asigna a cada uno de ellos un número denominado índice, el cual comienza en cero. En Java podemos declarar
vectores de dos maneras:

char c[], a; (tipo nombre_arreglo [ ];) char [] p, d, f;

(tipo [ ] nombre_arreglo;)

El primer formato indica que es arreglo solo el identificador al que siguen los corchetes(c es un arreglo de caracteres y a una variable
de carácter), el segundo formato indica que todos los identificadores son arreglos del tipo (tanto p como d y f serian arreglos de
carácter).

Java no permite en la declaración del arreglo que se indique el tamaño del arreglo, ejemplo: int num[20]; en este caso se especifica que
el arreglo tendrá 20 elementos, esta declaración seria valida en C pero no en Java, el compilador produciría un error.
Para indicar el tamaño del arreglo se usa el operador new de la manera siguiente:

float notas [];

notas = new float [20];

primero se declara el arreglo notas de tipo flota y posteriormente se reserva la memoria suficiente para que le arreglo almacene 20
elementos, esto se podría hacer en una sola sentencia, así:
float notas [ ] = new float [20];

Atributo length: Java considera cada arreglo un objeto, debido a esto podemos conocer el
numero de elementos de un arreglo a través de length, usando el siguiente formato:

nombre_variable = nombre_arreglo.length;

ejemplo:
double p [ ] = new double [20];
System.out.println(“Tamaño del arreglo: “ + p.length);

se mostraría: Tamaño del arreglo: 20.

Inicialización de un arreglo:

Sea int c[ ] = new int [5]; para asignar valores a cada elemento del arreglo c se puede escribir:

c[0] = 6;
c[1] = 3;
c[2] = -2;
c[3] = 40;
c[4] = 16;
la primera sentencia fija el valor de c[0] en 6, la segunda el valor de c[1] en 3 y asi sucesivamente. Otra forma es asignar los valores en el
momento en que se inicializa el arreglo:

int c[ ] = { 6, 3, -2, 40, 16};

el compilador asigna automáticamente 5 elementos a c, sería erróneo hacerlo así:

 int c[ ] = new int[5];

c[ ] = { 6, 3, -2, 40, 16};

También podemos asignar valores a un arreglo mediante un ciclo for o while/do – while, siendo este el método más usado:
BufferedReader entrada = new BufferedReader (new InputStreamReader (System.in)); int c[ ], x;
c[ ] = new int[5]; for(x=0; x < 5;
++x) {
System.out.print(“De el elemento c[“ + x + “]: “);
System.out.flush( );
c[x] = Integer.parseInt(entrada.readLine());
}
El compilador de Java inicializara cualquier arreglo con un valor por defecto, cero, si el arreglo es de tipo real, entero o de carácter.

No es lo mismo un arreglo de caracteres que una cadena de caracteres, la cadena se almacena en objetos String, los arreglos de
caracteres son arreglo de tipo char, una secuencia de caracteres, con las mismas características que los arreglos de otro tipo.

Arreglos multidimensionales:

Los arreglos vistos anteriormente se conocen como arreglos unidimensionales ( una sola dimensión), los multidimensionales son los
que tiene mas de una dimensión, los usuales son los de dos dimensiones.

Como se declaran?:

tipo nombre_areglo[ ] [ ]; o tipo [ ] [ ] nombre_arreglo;

ejemplo:
char tabla [ ][ ];
double [ ][ ] tasa, carga;

estas declaraciones no reservan memoria, para reservar memoria e indicar el numero de filas y columnas usamos new:

tabla [ ][ ] = new char [2][3]; // matriz de 2 filas y 3 columnas

tasa[ ][ ] = new double[5][5]; // matriz cuadrada de 5 filas y 5 columnas esto lo

podemos hacer en una sola sentencia:

char tabla[ ][ ] = new char [2][3];

Inicialización:

1) asignación individual:
tabla[0][0] = tabla[1][0] =
‘a’; ‘j’;
tabla[0][1] = tabla[1][1] =
‘e’; ‘2’;
tabla[0][2] = tabla[1][2] =
‘c’; ‘#’;
 2) asignación el momento en que se declara:

char c[ ][ ] = { {‘a’, ‘e’, ‘c’}, {‘j’, ‘2’, ‘#’}};

3) asignación mediante ciclos:

for(x=0; x<2; ++x)

for(y=0; y < 3; ++y) {
System.out.print(“tabla[“ + x + ”,” + y + ”]: “);
System.out.flush( );
tabla[x][y] = System.in.read( );
}

Uso de arreglos como parámetros:

La manera de pasar parámetros en java es por valor. Cuando se pasa un objeto, realmente lo que se pasa es una
referencia al objeto, la cual no se puede modificar ( ya que pasa por valor); si se pueden modificar los datos
miembros del objeto. Los arreglos en Java se consideran objetos, por lo cual podrán modificarse los elementos del
arreglo, pero no la referencia a este. Ejemplo:

Escribir un método que calcule el mayor de los elementos de un arreglo especificado.

import java.io.*;
class maximo_valor {
public static void main(String [] ar) throws IOException {
BufferedReader en = new BufferedReader ( new InputStreamReader (System.in)); int a[] = new
int[5], x;
for(x=0; x < 5; ++x) { System.out.print(“De
a[“ + x + “]: “); System.out.flush( );
a[x] = Integer.parseInt(en.readLine( ));
}
System.out.println(“El mayor elemento del arreglo es: “ + máximo(a));
}

static int máximo(int x[ ]) {

int y, mx;
mx = x[0];
for(y=0; y< x.length; ++y) mx = Math.max(mx,x[y]);
return mx;
}
}// fin clase máximo_valor

Cadenas

Una cadena es una secuencia de caracteres delimitados por comillas; Java no tiene el tipo cadena como tipo de dato
primitivo sino que declara varias clases para el manejo de cadenas, la más importante es la clase String. Cual cadena
es considerada un objeto String que es diferente de un arreglo de caracteres. Ejemplo:

char a[] = { `c`, ‘a’, ‘r’,’a’, ‘c’, ‘a’, ‘s’}

a es un arreglo de caracteres.

String b = “Caracas”, b es una cadena de caracteres.

Inicialización de variables de cadena:

Nombre de la Carrera – Nombre de la Escuela

 Las variables de cadena se crean bien inicializándolas con una constante o bien con el operador new, ejemplo:

String texto = “La casa esta vacia”; o

String texto;
texto = new String(“La casa esta vacia”);

Captura de cadenas por el teclado:

BufferedReader entrada = new BufferedReader ( new ImputStreamReader ( System.in)); String texto;

texto = entrada.readLine( );el método readLine( ) retorna un objeto cadena con los caracteres leídos desde el
teclado.

Esta clase dispone de diversos métodos para manipular cadenas: Sea a y b dos cadenas

Método Acción
length( ) : a.length retorna el numero de caracteres de la
cadena a
concat( ): a.concat(b) añade la cadena b al final de la
cadena a
charAt( ): a.charAt(2) retorna el carácter que esta en la
posición indicada (2) en la cadena a.
getChar( ): a.getChar(2,6,b,2) a partir de la posición 2 de la cadena a se extraen 6
caracteres los cuales se
almacenan en b a partir de la posición 2.
substring( ): b = a.substring(3,7) retorna todos los caracteres que están
entre la posición 3 y 7 menos uno de la cadena a. Siindicamos
a.substring(3) extrae caracteres desde la
posición hasta el final de la cadena.

compareTo( ): a.c ompareTo(b) compara la cadena con la cadena b y retorna un

valor entero igual a:
 cero; si son iguales a y b alfabéticamente.
 menor que cero; si a es menor
alfabéticamente que b.
 mayor que cero; si a es mayor
alfabéticamente que b.

equals( ): a.equals(b) devuelve true si a y b son iguales alfabéticamente tiene

en cuenta las mayúsculas y
minúsculas.
equalsIgnoreCase( a.equalsIgnoreCase(b) devuelve true si a y b son iguales
): alfabéticamente no toma en cuenta las
mayúsculas y minúsculas.
toUpperCase( ): a = a.toUpperCase(a) devuelve una cadena con
todos los caracteres en mayúscula.
toLowerCase( ): a = a.toLowerCase(a) devuelve una cadena con
todos los caracteres en minúscula.
trim( ): b = a.trim( ) devuelve una cadena sin los espacios en blanco que se
encuentren al principio o al final de la cadena a, ejemplo:
“ El
Corsario “ trim -> “El Corsario”.
replace( ): b = a.replace(‘a’, ‘#’) devuelve una cadena en la
cual se a sustituido el carácter ‘a’ por el carácter ‘#’, ejemplo: “La
venta fue mala”
replace -> “L# vent# fue m#l#”.
toCharArray( ): char [] c = a.toCharArray( ) devuelve un arreglo
con los caracteres de la cadena a.

Escribir un programa que llame a un método que determine cuantas palabras hay en una cadena
leída por el teclado.

Nombre de la Carrera – Nombre de la Escuela

 import java.io.*;
class cuenta_blancos {
public static void main(String [] ar) throws IOException {
BufferedReader en = new BufferedReader ( new InputStreamReader (System.in)); String
cad;
int total;
System.out.print(“Introdusca una cadena de caracteres”);
System.out.fl
ush( ); cad =
en.readLine(
);
total = cuentaBlancos(cad);
System.out.println(“En la cadena leida hay : “ + total + “ palabra(s)”);
}

static int cuentaBlancos( String c ) { int longitud, pal = 0,

x;
longitud = c.length( ); //determina el tamaño de la cadena
for( x = 0; x < longitud – 1; ++x) //cuenta los blancos en la cadena
if( c.charAt(x) = = ‘ ‘) pal ++;
return ++pal;
}

} // fin clase cuenta_blancos

Manejo de excepciones

Uno de los problemas más importantes en el desarrollo de software es la gestión de condiciones de error, por muy
bueno que sea el software siempre aparecen errores por múltiples razones. Una Excepción es, normalmente, una
condición de error imprevista, las cuales suelen terminar el programa del usuario con un mensaje de error
proporcionado por el sistema, los errores típicos entre otros son: agotamiento de memoria, errores de rango en el
manejo de los arreglos, división por cero, archivos inexistentes etc.
El manejo de excepciones es el mecanismo previsto por el lenguaje para el tratamiento de excepciones, permitiendo
al programador intentar la recuperación de estas condiciones y decidir si continuar o no la ejecución del programa.

Procesamiento de excepciones
De forma muy simple el modelo de un mecanismo de excepciones consta de dos palabras reservadas: try y catch.
 try: bloque que contiene el código que puede generar una excepción.
 catch: bloque que procesa una excepción.

Cuando durante la ejecución de un programa se produce un error que impide su ejecución se lanza una excepción
que hace que se visualice un mensaje acerca de lo ocurrido y se detenga la ejecución. Cuando esto ocurre si no
deseamos que la ejecución del programa se detenga habrá que utilizar try para poner en alerta al programa acerca del
código que pueda lanzar una excecion y utilizar catch para capturar y manejar cada excepción que se lance.

Veamos el siguiente ejemplo:

public sttic double leerReal( ) { double datReal = 0.0;

Scanner lector = new
Sccaner(System.in); Try {

datoReal =
Double.parseDouble(lector.nextLine());
return datoReal;
} //Fin del bloque try
catch (NumberFormatException e) {

Nombre de la Carrera – Nombre de la Escuela

 return 0.0;
} //Fin del bloque catch
} //Fin del método leerReal

En el ejemplo anterior vemos que el bloque try intentamos convertir en double la cadena de caracteres devuelta por
nextLine, si se introduce una cadena que nos es convertible aun número real, el sistema lanzara una excepción del
tipo NumberFormatException que será atrapada por el bloque catch lo que dara lugar a que el método leerReal
devuelva un cero. Para probar el método anterior puede escribir en el método main el código siguiente:

double r = 0.0; do {
System.out.print(“De un numero real: “);
r = leerReal( );
} while (r == 0.0);
System.out.println(“El valor leído fue: “ + r);

Excepciones más comunes

Excepción Significado
AritmeticException Desbordamiento de memoria o división por cero.
NumberFormetException Conversión ilegal de una cadena a un tipo numérico.
IndexOutBoundsExeption Acceso a un elemento inexistente en un vector o en una
cadena.
NegativeArraySizeException Intento de creación de un vector de longitud negativa.
NullPointerException Intento de uso de una referencia nula.

ACTIVIDAD VIRTUAL:

a) CUESTIONARIO TÉCNICO

- Indique cuándo utilizar la estructura de control if…else y cuándo la estructura switch

- Desarrolle un caso práctico donde se aplique la sobrecarga de métodos

- Cite un ejemplo práctico de cuándo utilizar arreglos multidimensionales

- Mencione por qué se utiliza un arreglo en vez de utilizar muchas variables para almacenar datos

Nombre de la Carrera – Nombre de la Escuela

 - Es conveniente gestionar las excepciones al desarrollar o sencillamente complejiza el proceso de
implementación ; desarrolle su argumentación

b) CONCLUSIONES DE LA EXPERIENCIA

Nombre de la Carrera – Nombre de la Escuela