Java - Lectura 1

Computación 2 Profesor – Hernán Silva V. Primavera, 2013

Computación 2 Hernán Silva V.

Primavera, 2013

Java - Lectura 1 1

Java

1. Fundamentals

1.1. Introducción

Java es un lenguaje de propósito general, de orientación a objeto. Muy popular por estos días y de amplio uso en Internet. Pertenece a Sun Microsystems y Oracle.

1.1.1. Sabores de Java1

Java 2 EE Enterprise Edition. Es la plataforma de desarrollo de aplicaciones para servidores utilizados en un entorno empresarial. IncluyeEnterprise JavaBeans (EJB), JavaServer Pages (JSP), Servlets, JDBC, JNDI y especificaciones para interactuar con sistemas de Administración ya implantadas en empresas.

Java 2 SE Standard Edition. Es la plataforma de desarrollo de aplicaciones en clientes, fundamentalmente orientadas a ordenadores de sobremesa o pequeños grupos de servidores. Incluye el API básico de Java con applets, red, RMI, Servlets, JDBC, Swing, AWT, JFC 2D, Java Media (Java 3D, Java Sound, JAI, JMF), JavaBeans (no Enterprise JavaBeans) y algunos más.

Java 2 ME Micro Edition. Es la plataforma de desarrollo de aplicaciones en dispositivos de capacidades limitadas, por ejemplo, teléfonos móviles, asistentes digitales personales (PDA), dispositivos WAP, sistemas de navegación para coches, etc

1 http://www.fismat.umich.mx/computacion/notas/introduccion/introduccion.html

Java - Lectura 1 2

1.2. Sintaxis Básica

1.2.1. Primer programa: Hola Mundo

// // Aplicación HolaMundo de ejemplo // class HolaMundoApp { public static void main( String args[] ) { System.out.println( "¡Hola Mundo!" ); } }

Aquí podemos ya observar algunos elementos importantes:

• El programa corresponde a una única clase, de nombre “HolaMundoApp”, la que contiene un único método, de nombre “main”.

• El texto del programa debe estar contenido en un archivo del mismo nombre de la clase, y con extensión “java”, es decir, en este caso el archivo se debe llamar “HolaMundoApp.java”.

• El método “main” recibe como parámetro de entrada un arreglo de nombre “args” y no entrega resultados en la salida (lo que se indica por la palabra “void”)

• El arreglo “args” es de tipo “String” y de largo indeterminado (pues args[] no indica la cantidad de elementos del arreglo)

• El modificador “static” lo explicaremos más adelante, en el contexto de los objetos. Un adelanto: Significa que si se crea otro objeto de la clase “HolaMundoApp”, el método “main” no se duplicará para este nuevo objeto, sino que seguirá siendo único y asociado a la clase.

• La clase “System” posee un objeto “out”, que es de tipo o clase PrintStream, y representa la salida estándar del medioambiente donde se está ejecutando la aplicación (típicamente, la salida por pantalla).

• El objeto “out” tiene un método de nombre “println”, que recibe como parámetro un string, y cuya función es desplegar dicho string en la salida estándar del sistema.

Java - Lectura 1 3

1.2.2. Ciclos y cálculos simples

// // Aplicación ejemplo // class SampleApp { public static void main( String args[] ) { int suma = 0; for ( int i=1; i<=10; ++i ) { suma = suma + i; } System.out.println( "valor es: " + suma ); } }

1.2.3. Lo mismo con un while

// // Aplicación ejemplo // class SampleApp { public static void main( String args[] ) { int suma = 0; i = 1; while ( i<=10 ) { suma = suma + i; i = i+1; } System.out.println( "valor es: " + suma ); } }

Este programa tiene un pequeño error en la línea “i = 1;”

¿ Cuál es el error ?

Java - Lectura 1 4

1.2.4. Leer desde teclado

// // Ejemplo de IO desde teclado // class IOBasico { public static void main( String args[] ) { // create Scanner to obtain input from command window Scanner input = new Scanner( System.in ); System.out.println( "hi" ); System.out.print( "Enter first integer:" ); // prompt int number1 = input.nextInt(); // read first number from user System.out.print( "Enter second integer:" ); // prompt int number2 = input.nextInt(); // read second number int sum = number1 + number2; // add numbers System.out.println("Sum is " + sum); // display sum } }

Esta es una primera versión básica de IO desde teclado. Primero analizaremos este programa y luego, en el siguiente ejemplo, veremos una versión más elaborada.

• El programa crea un objeto de nombre “input”, del tipo “Scanner”. Esto se efectúa con la palabra reservada new.

• Los Scanner son objetos que tienen métodos que permiten leer información desde un medio de entrada, y analizar esta entrada para convertirla en datos de algún tipo definido, como son números enteros, strings, etc.

• La creación de este objeto “input” se efectúa a través de un constructor. Un constructor es un método de una clase, cuya función es crear nuevas instancias u objetos de dicha clase.

• La clase “System” posee un objeto de nombre “in”, de tipo o clase “InputStream”, que representa la entrada estándar del medioambiente donde se está ejecutando la aplicación (típicamente, la entrada por teclado).

• En este ejemplo, el constructor de la clase “Scanner” recibe como parámetro de entrada al objeto “System.in”, indicando con esto que la información será leida desde el teclado.

Java - Lectura 1 5

• El objeto creado, “input”, tiene un método de nombre “nextInt”, cuya función es leer desde el dispositivo de entrada, y entregar como resultado un número entero. En nuestro caso, la información ingresada debe precisamente corresponder a un número entero pues, de no ser así, el programa caerá en una condición de error.

1.2.5. Leer desde teclado, versión elaborada

// // Ejemplo de IO desde teclado // class IOBasico { public static void main( String args[] ) { // create Scanner to obtain input from command window Scanner input = new Scanner(System.in); String skipLine; System.out.print("Enter texto: "); String texto = input.nextLine(); System.out.println ("texto : " + texto); System.out.print("Enter integer: "); int number1 = input.nextInt(); skipLine = input.nextLine(); System.out.println ("int : " + number1); System.out.print("Enter double: "); double number2 = input.nextDouble(); skipLine = input.nextLine(); System.out.println ("double : " + number2); System.out.print("Enter texto: "); String texto2 = input.nextLine(); System.out.println ("texto : " + texto2); System.out.print("Enter integer: "); int number3 = input.nextInt(); skipLine = input.nextLine(); System.out.println ("int : " + number3); } }

Java - Lectura 1 6

Esta es una segunda versión de IO desde teclado, que mezcla datos de tipo numérico con datos de tipo String.

• Se agrega la instrucción “input.nextLine()” después de cada lectura de datos de tipo numérico. El objetivo es vaciar el buffer de cada línea de entrada y que las lecturas de los datos numéricos sean limpias (se sugiere probar qué sucede si no se agregan estas líneas).

• Similar al caso anterior, el objeto “input” que es de tipo “Scanner”, tiene métodos para leer números enteros (nexInt), números decimales (nextDouble) y strings de datos (nextLine).

1.2.6. Disgresión. Estándares en Java2. Nombres3.

Clases: Para todo nombre de clase, la primera letra debe de ser Mayúscula, si son varias

palabras se debe de intercalar entre mayúsculas y minúsculas, este mecanismo de nombre es llamado camelCase (Ej: NombreDeClase, Animal, Factura).

Interfaces: Aplica la misma definición de clases, pero se debe colocar la terminación able al

final del nombre de la clases (Por ejemplo Runnable, Serializable).

Métodos: Para los metodos de clases, la primera letra debe ser minúscula, si son varias

palabras se debe de intercalar entre minúsculas y mayúsculas, para el caso de los métodos de clases aplica el mecanismo del camelCase (Por ejemplo getNombre, setEdad,

buscarPorIdPersona).

Variables: Para las variables, se aplica el caso de los métodos, donde la primera letra es

minúscula, y las demás se deben de guiar por el mecanismo de camelCase, lo que es importante de destacar, es que los nombres de las variables, además de cumplir lo anterior, deben ser cortos y descriptivos en si mismo. (Por ejemplo: nombre, edad, idPersona).

2 http://www.oracle.com/technetwork/java/javase/documentation/codeconvtoc-136057.html

3 http://www.elclubdelprogramador.com/2011/08/22/java-nomenclatura-estandar-del-codigo-java/

Java - Lectura 1 7

Constantes: Para la constantes, su nombre debe ser escrito completamente en Mayúsculas, y para la separación de palabras se debe usar el underscore/guión bajo (_). (Por ejemplo MAX_SUMA, VALOR_MULTIPLO).

1.2.7. Disgresión. Estándares en Java. Indentación del código.

• Siempre se indenta 4 espacios el código encerrado entre corchetes '{' y '}'. • El primer corchete está en el mismo renglón que la instrucción. • A partir del último corchete '}' se termina la indentación.

Ejemplos:

void main( int argc, char *argv[] ) { // Código indentado dentro de la función }

for ( int i=1; i<=20; ++i ) { // primera instrucción }

if ( condición ) { // una instrucción indentada }

do { // primera instrucción } while ( condición );

if ( condición ) { // una instrucción indentada } else { // primera instrucción // segunda instrucción bien indentada // tercera instrucción }

switch ( value ) { case 'a': case 'b': // primera instrucción // segunda instrucción break; case 'c': // primera instrucción break; default: // primera instrucción break; }

while ( condición ) { // primera instrucción // segunda instrucción bien indentada }

list::iterator it = L.begin(); for ( ; it != L.end(); ++it ) { int a = it->first; // alineación long b = it->second; // y espaciado c = ( ((long)(a) - b) / 2 ) >> 5; delta = b - c }

Java - Lectura 1 8

1.3. Arreglos

Los arreglos en Java son estructuras lineales que contienen datos de un mismo tipo.

El tipo de datos se refiere a datos elementales (por ejemplo, todos enteros, todos decimales, booleanos, etc), o también objetos (en este caso, todos deben ser de una misma clase).

Un arreglo es identificado con un nombre, y los datos que contiene son accesados a través de un índice.

En Java, la posiciones de un arreglo se cuentan a partir de la posición cero. Eso significa que un arreglo de tamaño “n” posiciones, presenta subíndices desde cero (primera posición del arreglo) hasta n-1 (última posición).

1.3.1. Primer programa de Arreglos

// // Aplicación de Arreglos // class PrimerPgmArreglos { public static void main( String args[] ) { int [] arr = new int [10]; for ( int i=0; i<10; ++i ) { arr[i] = i; } System.out.println( "Primera posicion: " + arr[0] ); System.out.println( "Ultima posicion: " + arr[9] ); } }

Explicación:

• En este ejemplo el programa crea un arreglo de nombre “arr”, de tipo entero, de 10 posiciones. Nótese aquí nuevamente el uso de la palabra “new” (los arreglos también son objetos).

• El programa luego inicia un ciclo para llenar el arreglo con valores (desde las posiciones 0 a 9).

Java - Lectura 1 9

• Finalmente despliega los valores almacenados en la primera y última posición del arreglo.

1.3.2. Recorriendo Arreglos

// // Aplicación de Arreglos // class ArrayApp { public static void main( String args[] ) { int n = 10; int [] arr = new int [n]; for ( int i=0; i<n; ++i ) { arr[i] = i; } for ( int i=0; i<n; ++i ) { System.out.println( "posicion: " + i + “ , valor: “ + arr[i] ); } } }

1.3.3. Otra forma de recorrer Arreglos

// // Aplicación de Arreglos // class ArrayApp { public static void main( String args[] ) { int n = 10; int [] arr = new int [n]; for ( int i=0; i<n; ++i ) { arr[i] = i; } for ( int val: arr ) { System.out.println( “valor: “ + val ); } } }

Java - Lectura 1 10

1.3.4. Cargar un arreglo con datos ingresados por teclado

El siguiente programa solicita una cantidad de datos a almacenar, y luego lee la cantidad de datos indicada, cargándolos en un arreglo. En este caso trabaja con un arreglo de números enteros.

Finalmente, para mostrar el resultado logrado, despliega los datos almacenados en el arreglo.

// // Aplicación de Arreglos // class ArrayApp { public static void main( String args[] ) { // create Scanner to obtain input from command window Scanner input = new Scanner( System.in ); // leer cantidad de datos a almacenar System.out.print("Ingrese cantidad de datos para almacenar: "); int arrSize = input.nextInt(); // leer datos y almacenar en arreglo int[] arr = new int[arrSize]; for ( int i = 0; i < arrSize; ++i ) { System.out.print("Ingrese numero: "); int num = input.nextInt(); arr[i] = num; } // desplegar el arreglo for (int num : arr) { System.out.println(num); } } }

Java - Lectura 1 11

1.4. Funciones y Subrutinas (Métodos4)

1.4.1. Introducción

Las funciones y subrutinas se utilizan como un mecanismo de “factorización” de código. La idea es:

• Trozos de código que se utilizan más de una vez • Mejorar la legibilidad del código

Como Usted sabe, las Funciones/Subrutinas (en general se les llama “rutinas” tanto para referirse a funciones como subrutinas) son trozos de código que “encapsulan” una tarea o funcionalidad. Lo más importante, pueden ser “llamadas” desde otras partes de un programa, así que permiten reutilizar código (para tareas que se necesita ejecutar más de una vez) y facilitan la legibilidad y el orden en su programa. Además, una rutina también puede utilizar o “llamar” a otra rutina (imagine lo poderoso que puede ser esto ...)

// // Ejemplo de uso de Rutinas // class AppEjemplo { public static void main( String args[] ) { for ( int i=0; i<20; ++i ) { System.out.println( "Factorial de " + i + “ es “ + factorial(i) ); } } private static int factorial (int n) { int fact = 1; for (int i = 2; i <= n; ++i) { fact = fact * i; } return fact; } }

4 En Java (y en OOP) las rutinas se conocen como métodos

Java - Lectura 1 12

Explicación:

• La rutina (método) se declara en la línea: private static int factorial (int n)

• Esa declaración corresponde a la firma del método

• La parte “int n” corresponde a los parámetros o argumentos de entrada. En este caso, el método recibe como entrada un valor entero, el que será conocido dentro de la lógica del método como “n”.

• La parte “int” indica que el método retornará como parámetros o argumentos de salida un valor entero. Este “retorno” se materializa en la línea “return fact”.

• El nombre o identificador del método es “factorial”, y con ese nombre es invocado en el cuerpo del “main” (por cierto, “main” también es un método). El cuerpo de un método corresponde al conjunto de instrucciones que conforman al método.

• Los modificadores “static” los veremos más adelante.

• Respecto de los modificadores de visibilidad/accesabilidad “public” y “private” podemos observar lo siguiente: Como “main” está declarado “public” significa que es un método de la clase AppEjemplo, que puede ser invocado, tanto internamente como “desde fuera” de dicha clase. Es decir, en el caso desde “fuera”, para dar inicio a la aplicación, o desde “fuera”, siendo llamado por otra clase de la aplicación, si es que la hubiese. Como el método o función “factorial” está declarado “private”, significa que es un método de la clase AppEjemplo, que sólo puede ser invocado “desde dentro” de dicha clase. Es decir, es un método que es “visible” sólo internamente en la clase AppEjemplo, y sólo puede ser invocado por métodos de la misma clase (en este caso está siendo invocado por el método “main”, que también pertenece a la clase AppEjemplo).

Java - Lectura 1 13

1.4.2. Otro Ejemplo

𝐶𝑜𝑚𝑏𝑖𝑛𝑎𝑡𝑜𝑟𝑖𝑎   𝑛  𝑠𝑜𝑏𝑟𝑒  𝑘 :        𝑛𝑘 =  

𝑛!𝑛 − 𝑘 ! 𝑘!        ,      n ≥ k, n ≥ 0

En este caso, el factorial se utiliza 3 veces. Es una funcionalidad ideal para su “factorización”. Veamos cómo queda en Java:

class AppEjemplo { public static void main( String args[] ) { Scanner input = new Scanner( System.in ); System.out.print("Ingrese n: "); // leer n int n = input.nextInt(); System.out.print("Ingrese k: "); // leer k int k = input.nextInt(); if ( n < k ) { System.out.println (“Error : “ + n + “ es menor que “ + k); System.exit(0); // Termino del programa } int comb = factorial(n) / ( factorial(n-k) * factorial(k) ); System.out.println (“n : “ + n); System.out.println (“k : “ + k); System.out.println (“Combinatoria es : “ + comb); } private static int factorial (int n) { int fact = 1; for (int i = 2; i <= n; ++i) { fact = fact * i; } return fact; } }