Bucles
Además de poder aplicar condiciones a sus programas y ver diferentes resultados en base a diversos escenarios if/then, a veces quiere que su código solo haga lo mismo una y otra vez hasta que se haga el trabajo. En esta sección, aprenda acerca de dos construcciones usadas para iterar el código o ejecutarlo más de una vez. Bucles for y bucles while loops.
¿Qué es un bucle?
Un bucle es una construcción de programación que se ejecuta repetidamente mientras se cumple alguna condición (o conjunto de condiciones). Por ejemplo, puede pedirle a un programa que lea todos los registros hasta el final de un archivo o que realice un bucle por todos los elementos de una matriz, procesando cada uno.
Bucles for
La construcción de bucle básico en el lenguaje Java es la sentencia for, que le permite iterar un rango de valores para determinar cuántas veces ejecutar un bucle. La sintaxis abstracta para un bucle for es:
for (initialization; loopWhileTrue; executeAtBottomOfEachLoop) {
statementsToExecute
}
Al comienzo del bucle, se ejecuta la sentencia de inicialización (las sentencias de inicialización múltiples se pueden separar con comas). Mientras loopWhileTrue (una expresión condicional de Java que debe evaluar ya sea como verdadero o falso) sea verdadero, el bucle se ejecutará. Al final del bucle, se ejecuta executeAtBottomOfEachLoop.
Ejemplo de un bucle for
Si usted quisiera cambiar a un método main() para que se ejecute tres veces, podría usar un bucle for, como se muestra en el Listado 9:
Listado 9. Un bucle for
public static void main(String[] args) {
Logger l = Logger.getLogger(Person.class.getName());
for (int aa = 0; aa < 3; aa++) {
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
l.info("Loop executing iteration# " + aa);
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
}
}
La variable local aa se inicializa en cero al comienzo del listado. Esta sentencia se ejecuta solo una vez, cuando se inicializa el bucle. Luego, el bucle continúa tres veces y cada vez se incrementa aa en uno.
Como verá más adelante, una sintaxis alternativa de bucle for está disponible para realizar un bucle por las construcciones que implementan la interfaz Iterable (tales como matrices y otras clases de programas de utilidad Java). Por ahora, solo observe el uso de la sintaxis del bucle for en el Listado 9.
Bucles while
La sintaxis para un bucle while es:
while (loopWhileTrue) {
statementsToExecute
}
Como puede sospechar, while loopWhileTrue evalúa como verdadero, por lo tanto el bucle se ejecutará. En la parte superior de cada iteración (es decir, antes de que se ejecute cualquier sentencia), se evalúa la condición. Si es verdadero, el bucle se ejecuta. Por lo que es posible que un bucle while nunca se ejecute si su expresión condicional no es verdadera por lo menos una vez.
Observe de nuevo el bucle for en el Listado 9. Por comparación, el Listado 10 lo codifica usando un bucle while:
Listado 10. Un bucle while
public static void main(String[] args) {
Logger l = Logger.getLogger(Person.class.getName());
int aa = 0;
while (aa < 3) {
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
l.info("Loop executing iteration# " + aa);
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
aa++;
}
Como puede ver, un bucle while requiere un poco más de mantenimiento que un bucle for. Usted debe inicializar la variable aa y también recordar incrementarla al final del bucle.
Bucles do...while
Si usted quiere un bucle que se ejecute siempre una vez y luego verifique su expresión condicional, pruebe usar un bucle do...while, como se muestra en el Listado 11:
Listado 11. Un bucle do...while
int aa = 0;
do {
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
l.info("Loop executing iteration# " + aa);
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
aa++;
} while (aa < 3);
La expresión condicional (aa < 3) no se verifica hasta el final del bucle.
Ramificación del bucle
Hay momentos en los que necesita retirarse de un bucle antes de que la expresión condicional evalúe como falso. Esto podría suceder si usted estuviera buscando una matriz de Strings para un valor particular y, una vez que lo encontrara, no le importara los otros elementos de la matriz. Para aquellos momentos en que usted solo quiere retirarse, el lenguaje Java proporciona la sentencia break, como se muestra en el Listado 12:
Listado 12. Una sentencia break
public static void main(String[] args) {
Logger l = Logger.getLogger(Person.class.getName());
int aa = 0;
while (aa < 3) {
if (aa == 1)
break;
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
l.info("Loop executing iteration# " + aa);
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
aa++;
}
La sentencia break lo lleva a la siguiente sentencia ejecutable fuera del bucle en el que se ubica.
Continuación del bucle
En el ejemplo (simplista) del Listado 12, usted solo quiere ejecutar el bucle una vez y retirarse. También puede saltar una sola iteración de un bucle pero continúa ejecutando el bucle. Para eso, necesita la sentencia continue, que se muestra en el Listado 13:
Listado 13. Una sentencia continue
public static void main(String[] args) {
Logger l = Logger.getLogger(Person.class.getName());
int aa = 0;
while (aa < 3) {
if (aa == 1)
continue;
else
aa++;
Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
l.info("Loop executing iteration# " + aa);
l.info("Name: " + p.getName());
l.info("Age:" + p.getAge());
l.info("Height (cm):" + p.getHeight());
l.info("Weight (kg):" + p.getWeight());
l.info("Eye Color:" + p.getEyeColor());
l.info("Gender:" + p.getGender());
}
En el Listado 13, usted salta la segunda iteración de un bucle pero continúa con la tercera. continue es de ayuda cuando está, digamos, procesando registros y se encuentra con un registro que definitivamente no quiere procesar. Solo salte ese registro y siga con el siguiente.
Colecciones Java
La mayoría de las aplicaciones del mundo real lidian con colecciones de elementos: archivos, variables, registros de archivos, conjuntos de resultados de bases de datos, entre otros. El lenguaje Java tiene una sofisticada Infraestructura de colecciones que le permite crear y manejar colecciones de objetos de diversos tipos. Esta sección no le enseñará todo acerca de las Colecciones Java pero le presentará las clases de colecciones más comúnmente usadas y le hará comenzar a usarlas.
Matrices
La mayoría de los lenguajes de programación incluyen el concepto de una matriz para tener una colección de elementos y el lenguaje Java no es ninguna excepción. Una matriz no es nada más que una colección de elementos del mismo tipo.
Nota: Los corchetes en los ejemplos de códigos de esta sección son parte de la sintaxis requerida para las Colecciones Java, no indicadores de elementos opcionales.
Puede declarar una matriz en una de dos formas:
Crearlo con un cierto tamaño, que se fija por la vida de la matriz.
Crearlo con un cierto conjunto de valores iniciales. El tamaño de este conjunto determina el tamaño de la matriz, — será exacta y suficientemente grande para tener todos esos valores y su tamaño se fija por la vida de la matriz.
Declaración de una matriz
En general, usted declara una matriz del siguiente modo:
new elementType [arraySize]
Existen dos formas para crear una matriz entera de elementos. Esta sentencia crea una matriz con espacio para cinco elementos pero está vacía:
// crea una matriz vacía de 5 elementos:
int[] integers = new int[5];
Esta sentencia crea la matriz y la inicializa, todo a la vez:
// crea una matriz de 5 elementos con valores:
int[] integers = new int[] { 1, 2, 3, 4, 5 };
Los valores iniciales van entre las llaves y se separan con comas.
Matrices, al modo difícil
Un modo más difícil para crear una matriz sería crearla y luego codificar un bucle para inicializarlo:
int[] integers = new int[5];
for (int aa = 0; aa < integers.length; aa++) {
integers[aa] = aa;
}
Este código declara la matriz entera de cinco elementos. Si usted intenta poner más de cinco elementos en la matriz, el tiempo de ejecución de Java reclamará y arrojará una excepción. Aprenderá acerca de las excepciones y cómo manejarlas en la Part 2.
Carga de una matriz
Para cargar una matriz, serpentee por los enteros desde 1 a través de la longitud de la matriz (a la cual llega al llamar .length en la matriz, — más sobre eso en un minuto). En este caso, usted se detiene cuando llegue a 5
Una vez que se carga la matriz, puede acceder a ella como antes:
Logger l = Logger.getLogger("Test");
for (int aa = 0; aa < integers.length; aa++) {
l.info("This little integer's value is: " + integers[aa]);
}
Esta sintaxis (nueva desde el JDK 5) también funciona:
Logger l = Logger.getLogger("Test");
for (int i : integers) {
l.info("This little integer's value is: " + i);
}
Encuentro la sintaxis más nueva más simple para trabajar y la usaré a lo largo de esta sección.
El índice de elementos
Considere a una matriz como una serie de grupos y en cada grupo va un elemento de cierto tipo. Se gana el acceso a cada grupo al usar un índice:
1
element = arrayName [elementIndex];
Para acceder a un elemento, necesita la referencia a la matriz (su nombre) y el índice donde reside el elemento que usted quiere.
El método length
Un método útil, como ya ha visto, es length. Es un método incorporado, por lo tanto su sintaxis no incluye los paréntesis habituales. Solo escriba la palabra length y devolverá, — cómo es de esperar, — el tamaño de la matriz.
Las matrices en el lenguaje Java están basadas en cero.
Por lo tanto, para alguna matriz llamada array, el primer elemento en la matriz reside siempre en array[0] y el último reside en array[array.length - 1].
Una matriz de objetos
Ha visto cómo las matrices pueden tener tipos primitivos pero vale la pena mencionar que también pueden tener objetos. En ese sentido, la matriz es la colección más utilitaria del lenguaje Java.
Crear una matriz de objetos java.lang.Integer no es muy diferente de crear una matriz de tipos primitivos. Una vez más, tiene dos modos de hacerlo:
// crea una matriz vacía de 5 elementos:
Integer[] integers = new Integer[5];
// crea una matriz de 5 elementos con valores:
Integer[] integers = new Integer[] { Integer.valueOf(1),
Integer.valueOf(2)
Integer.valueOf(3)
Integer.valueOf(4)
Integer.valueOf(5));
Embalaje y desembalaje
Cada tipo primitivo en el lenguaje Java tiene una clase homóloga JDK, que puede ver en la Tabla 4:
Tabla 4. Primitivos y homólogos JDK
Primitivo Homólogo JDK
booleano java.lang.Boolean
byte java.lang.Byte
caract. java.lang.Character
corto java.lang.Short
int java.lang.Integer
largo java.lang.Long
flotante java.lang.Float
doble java.lang.Double
Cada clase JDK proporcionar métodos para analizar y convertir desde su representación interna hasta un tipo primitivo correspondiente. Por ejemplo, este código convierte el valor decimal 238 a un Integer:
int value = 238;
Integer boxedValue = Integer.valueOf(value);
Esta técnica se conoce como embalaje porque está poniendo el primitivo en un envoltorio o caja.
De forma similar, para convertir la representación de Integer de nuevo a su homólogo int, usted lo desembalaría de la siguiente forma:
Integer boxedValue = Integer.valueOf(238);
int intValue = boxedValue.intValue();
Embalaje automático y desembalaje automático
En un sentido estricto, usted no necesita embalar y desembalar los primitivos de forma explícita. En cambio, podría usar las funciones de embalaje automático y desembalaje automático del lenguaje Java, del siguiente modo:
int intValue = 238;
Integer boxedValue = intValue;
//
intValue = boxedValue;
Sin embargo, recomiendo que evite usar el embalaje automático y desembalaje automático porque puede llevar a tener problemas de códigos. El código en los fragmentos de embalaje y desembalaje es más evidente, y de ese modo más legible, que el código embalado automáticamente y creo que vale la pena hacer el esfuerzo extra.
Análisis y conversión de tipos embalados
Ha visto cómo obtener un tipo embalado pero, ¿qué tal si se analiza una String que usted sospecha que tiene un tipo embalado en la caja misma? Las clases de envoltorio JDK tienen métodos para eso también:
String characterNumeric = "238";
Integer convertedValue = Integer.parseInt(characterNumeric);
También puede convertir los contenidos de un tipo de envoltorio JDK a String:
Integer boxedValue = Integer.valueOf(238);
String characterNumeric = boxedValue.toString();
Observe que cuando usa el operador de concatenación en una expresión de String (ya ha visto esto en las llamadas al Logger), el tipo primitivo se embala automáticamente y los tipos de envoltorio tienen automáticamente a toString() invocada sobre ellos. Muy útil.
Listas
Una Lista es una construcción de colección que, por definición, es una colección ordenada, también conocida como una secuencia. Debido a que una Lista es ordenada, usted tiene completo control sobre el lugar en donde van los elementos en la Lista. Una colección de Lista Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
La Lista es una interfaz, por lo que usted no puede crear una instancia de ella directamente. Trabajará con su implementación más comúnmente usada, ArrayList:
1
List<Object> listOfObjects = new ArrayList<Object>();
Observe que hemos asignado el objeto ArrayList a una variable de tipo Lista. La programación Java le permite asignar una variable de un tipo a otro, siempre y cuando la variable a la que se asigna sea una superclase o interfaz implementada por la variable desde la cual se asigna. Veremos más sobre cómo se afectan las asignaciones de variables en la Part 2 en la sección Inheritance.
Tipo formal
¿Qué sucede con el <Object> en el recorte anterior del código? Se llama el tipo formal y le comunica al compilador que esta Lista contiene una colección de tipo Object, lo que significa que puede poner prácticamente lo que quiera en la Lista.
Si usted quisiera intensificar las restricciones sobre lo que pudiera o no ir en la Lista, la definiría de modo diferente:
List<Person> listOfPersons = new ArrayList<Person>();
Ahora su Lista solo puede tener instancias de Person.
Uso de las Listas
Usar las Listas es muy fácil, como las colecciones Java en general. Aquí hay algunas de las cosas que querrá hacer con las Listas:
- Poner algo en la Lista.
- Preguntarle a la Lista cuán grande es actualmente.
- Obtener algo de la Lista.
Intentemos algunas de estas. Ya ha visto cómo crear una instancia de la Lista al crear una instancia de su tipo de implementación de ArrayList, por lo que comenzará desde allí.
Para poner algo en una Lista, llame al método add():
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
El método add() agrega el elemento al final de la Lista.
Para preguntarle a la Lista cuán grande es, llame al size():
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Current List size: " + listOfIntegers.size());
Para recuperar un elemento de la Lista, llame al get() y pase el índice del elemento que usted quiere:
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Item at index 0 is: " listOfIntegers.get(0));
En una aplicación del mundo real, una Lista contendría registros, u objetos de negocios, y usted posiblemente querría examinarlos todos como parte de su proceso. ¿Cómo hace eso de un modo genérico? Tiene que iterar por la colección, lo cual usted puede hacer porque la Lista implementa la interfaz java.lang.Iterable. (Aprenderá acerca de las interfaces en la Part 2).
Iterable
Si una colección implementa java.lang.Iterable, se llama una colección iterable. Eso significa que usted puede comenzar por un extremo y recorrer la colección elemento por elemento hasta que se le acaben los elementos.
Ya ha visto la sintaxis especial para iterar por las colecciones que implementan la interfaz Iterable, en la sección Loops. Aquí está de nuevo:
1
2
3
for (objectType varName : collectionReference) {
// Start using objectType (via varName) right away...
}
Iteración en una Lista
El ejemplo anterior fue abstracto. Ahora, aquí tiene uno más realista:
List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (Integer i : listOfIntegers) {
l.info("Integer value is : " + i);
}
Ese pequeño recorte de código hace lo mismo que este más largo:
List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (int aa = 0; aa < listOfIntegers.size(); aa++) {
Integer I = listOfIntegers.get(aa);
l.info("Integer value is : " + i);
}
El primer recorte usa sintaxis taquigráfico: no hay una variable de índice (aa en este caso) para inicializar y ninguna llamada al método get() de la Lista.
Debido a que la Lista extiende la java.util.Collection, que implementa Iterable, usted puede usar la sintaxis taquigráfica para iterar por cualquier Lista.
Conjuntos
Un Conjunto es una construcción de colecciones que por definición contiene elementos únicos, — es decir, ningún duplicado. Mientras que una Lista puede contener el mismo objeto cientos de veces, un Conjunto solo puede contener cierta instancia una vez. Una colección de Conjunto Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
Debido a que el Conjunto es una interfaz, usted no puede crear una instancia de él directamente, por lo tanto le mostraré una de mis implementaciones favoritas: HashSet. HashSet es fácil de usar y es similar a la Lista.
Aquí hay algunas cosas que querrá hacer con un Conjunto:
- Poner algo en el Conjunto.
- Preguntarle al Conjunto cuán grande es actualmente.
- Obtener algo del Conjunto.
- Uso de los Conjuntos
Un atributo característico de un Conjunto es que garantiza la singularidad entre sus elementos pero no le interesa el orden de los elementos. Considere el siguiente código:
Set<Integer> setOfIntegers = new HashSet<Integer>();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(11));
setOfIntegers.add(Integer.valueOf(10));
for (Integer i : setOfIntegers) {
l.info("Integer value is: " + i);
}
Puede que usted espere que el Conjunto tenga tres elementos en él pero de hecho solo tiene dos porque el objeto Integer que contiene el valor 10 solo se agregará una vez.
Tenga este comportamiento en mente cuando haga la iteración por un Conjunto, como en el siguiente modo:
Set<Integer> setOfIntegers = new HashSet();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(20));
setOfIntegers.add(Integer.valueOf(30));
setOfIntegers.add(Integer.valueOf(40));
setOfIntegers.add(Integer.valueOf(50));
Logger l = Logger.getLogger("Test");
for (Integer i : setOfIntegers) {
l.info("Integer value is : " + i);
}
Es posible que los objetos se impriman en un orden diferente del que usted los agregó porque un Conjunto garantiza la singularidad, no el orden. Verá esto por usted mismo si pega el código anterior en el método main() de su clase Person y lo ejecuta.
Mapas
Un Mapa es una construcción de colección útil porque le permite asociar un objeto (la clave) con otro (el valor). Como puede imaginar, la clave para el Mapa debe ser única y se usa para recuperar el valor en un momento posterior. Una colección de Mapa Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.
Debido a que el Mapa es una interfaz, usted no puede crear una instancia de él directamente, por lo tanto le mostraré una de mis implementaciones favoritas: HashMap.
Aquí hay algunas de las cosas que querrá hacer con los Mapas:
Poner algo en el Mapa.
Obtener algo del Mapa.
Obtener un Conjunto de claves para el Mapa— para hacer la iteración en él.
Uso de los Mapas
Para poner algo en un Mapa, necesita tener un objeto que represente su clave y un objeto que represente su valor:
public Map<String, Integer> createMapOfIntegers() {
Map<String, Integer> mapOfIntegers = new HashMap<String, Integer>();
mapOfIntegers.put("1", Integer.valueOf(1));
mapOfIntegers.put("2", Integer.valueOf(2));
mapOfIntegers.put("3", Integer.valueOf(3));
// . . .
mapOfIntegers.put("168", Integer.valueOf(168));
}
Es este ejemplo, el Mapa contiene Integers, con la clave hecha por una String, que resulta ser su representación de String. Para recuperar un valor Integer particular, necesita su representación String:
mapOfIntegers = createMapOfIntegers();
Integer oneHundred68 = mapOfIntegers.get("168");
Uso del Conjunto con el Mapa
En ocasiones, usted puede encontrarse con una referencia a un Mapa y simplemente quiere recorrer todo el conjunto de contenidos. En este caso, necesitará un Conjunto de las claves para el Mapa:
Set<String> keys = mapOfIntegers.keySet();
Logger l = Logger.getLogger("Test");
for (String key : keys) {
Integer value = mapOfIntegers.get(key);
l.info("Value keyed by '" + key + "' is '" + value + "'");
}
Observe que el método toString() del Integer recuperado desde el Mapa se llama automáticamente cuando se usa en la llamada del Logger. El Mapa no devuelve una Lista de sus claves porque se hace una clave para el Mapa y cada clave es única; la singularidad es la característica distintiva de un Conjunto.
Archivo del código Java
Ahora que ha aprendido un poco sobre la escritura de aplicaciones Java, puede que se esté preguntando cómo empaquetarlas para que otros desarrolladores puedan usarlas o cómo importar códigos de otros desarrolladores en sus aplicaciones. Esta sección le muestra cómo.
JAR
El JDK se envía con una herramienta llamada JAR, que significa Java Archive (archivo Java). Use esta herramienta para crear archivos JAR. Una vez que haya empaquetado su código en un archivo JAR, otros desarrolladores pueden simplemente dejar el archivo JAR en sus proyectos y configurar sus proyectos para usar su código.
Crear un archivo JAR en Eclipse es facilísimo. En su espacio de trabajo, haga clic derecho en el paquete com.makotogroup.intro y seleccione Export. Verá el diálogo que se muestra en la Ilustración 8. Elija Java > JAR file.
Ilustración 8. Recuadro de diálogo de exportación.
Eclipse's export dialog box.
Cuando se abra el siguiente recuadro de diálogo, navegue hasta la ubicación donde quiere almacenar su archivo JAR y coloque el nombre que quiera al archivo. La extensión .jar es la predeterminada, que recomiendo usar. Haga clic en Finish.
Verá su archivo JAR en la ubicación que seleccionó. Puede usar las clases en él desde su código si lo pone en su ruta de desarrollo en Eclipse. Hacer eso es facilísimo también, como verá a continuación.
Uso de aplicaciones de terceros
Mientras usted se siente más y más cómodo al escribir aplicaciones Java, querrá usar más y más aplicaciones de terceros para soportar su código. A modo de ejemplo, digamos que usted quiere usar joda-time, una biblioteca de sustitución JDK para hacer manejo de fecha/tiempo, manipulaciones y cálculos.
Supongamos que ya ha descargado joda-time, que se almacena en un archivo JAR. Para usar las clases, su primer paso es crear un directorio lib en su proyecto y dejar el archivo JAR en él:
Haga clic derecho en la carpeta raíz Intro en la vista Project Explorer.
Elija New > Folder y llame la carpeta lib.
Haga clic en Finish.
La carpeta nueva aparece al mismo nivel que src. Ahora copie el archivo .jar joda-time en su nuevo directorio lib. Para este ejemplo, el archivo se llama joda-time-1.6.jar. (Al nombrar un archivo JAR es común incluir el número de la versión).
Ahora todo lo que necesita hacer es comunicarle a Eclipse que incluya las clases del archivo joda-time-1.6.jar en su proyecto:
Haga clic derecho en el proyecto Intro en su espacio de trabajo, luego seleccione Properties.
En el recuadro de diálogo de Propiedades, seleccione la pestaña de Bibliotecas, como se muestra en la Ilustración 9:
Ilustración 9. Properties > Java Build Path
Path to select the Properties dialog box and Libraries tab.
Haga clic en el botón Add External JARs, luego navegue hasta el directorio lib del proyecto, seleccione el archivo joda-time-1.6.jar y haga clic en OK.
Una vez que Eclipse haya procesado los códigos (es decir, los archivos de clases) en el archivo JAR, están disponibles para hacer referencia (importar) desde su código Java. Observe en Project Explorer que hay una carpeta nueva llamada Bibliotecas referenciadas que contiene el archivo joda-time-1.6.jar.
Escribir un buen código Java
Usted tiene suficiente sintaxis Java acumulada en su haber para escribir programas Java básicos, lo que significa que la primera mitad de este tutorial está a punto de concluir. Esta sección final presenta algunas de las mejores prácticas que le ayudarán a escribir códigos Java más limpios y más plausibles de ser mantenidos.
Mantenga pequeñas las clases
Usted creó algunas clases en este tutorial. Luego de generar pares de getters y setters incluso para la pequeña cantidad (de acuerdo a los estándares de una clase Java del mundo real) de atributos, la clase Person tiene 150 líneas de código. Esta es una clase pequeña. No es raro ver clases con 50 o 100 métodos y mil líneas de origen (o más). El punto de los métodos es mantener solo los que necesita. Si necesita varios métodos ayudantes que hagan esencialmente lo mismo pero que tomen parámetros diferentes (tales como el método printAudit()), esa es una buena elección. Solo asegúrese de limitar la lista de métodos a lo que necesita, no más.
En general, las clases representan alguna entidad conceptual en su aplicación y sus tamaños deberían reflejar solo la funcionalidad para hacer lo que sea que la entidad necesite hacer. Deberían permanecer muy centradas para hacer una pequeña cantidad de actividades y hacerlas bien.
Nombre a los métodos con cuidado
Un buen patrón de codificación cuando se trata de nombres de métodos es el patrón de nombres de métodos revelador de intenciones. Este patrón es más fácil de entender con un simple ejemplo. ¿Cuál de los siguientes nombres de métodos es más fácil de descifrar a la vista?
a()
computeInterest()
La respuesta debería ser evidente, sin embargo por alguna razón, los programadores tienen una tendencia a darle a los métodos (y variables, para tal caso) nombres pequeños, abreviados. Sin duda, un nombre ridículamente largo puede ser poco práctico pero un nombre que transmite lo que un método hace no necesita ser ridículamente largo. Seis meses después de que escriba un grupo de códigos, tal vez no recuerde lo que quiso hacer con un método llamado a() pero es evidente que un método llamado computeInterest(), bueno, probablemente compute interés.
Mantenga pequeños los métodos
Los métodos pequeños son tan preferibles como las clases pequeñas y por razones similares. Un modismo que intento seguir es mantener el tamaño de un método en una página como lo veo en mi pantalla. Esto hace que mis clases de aplicaciones sean más plausibles de ser mantenidas.
Si un método crece más allá de una página, lo refactorizo. Refactorear significa cambiar el diseño de un código existente sin cambiar sus resultados. Eclipse tiene un maravilloso conjunto de herramientas de refactorización. Normalmente, un método largo contiene subgrupos de funcionalidad agrupados. Tome esta funcionalidad y muévala a otro método (nombrándola como corresponde) y pase los parámetros como se necesite.
Limite cada método a un solo trabajo. He descubierto que un método que hace solo una cosa bien, normalmente no toma más de alrededor de 30 líneas de códigos.
Use los comentarios
Por favor, use los comentarios. Las personas que siguen luego de usted (o incluso usted mismo, seis meses más adelante) le agradecerán. Tal vez haya escuchado el antiguo refrán Un código bien escrito es de autodocumentación, por lo tanto, ¿quién necesita comentarios? Le daré dos razones por lo que esto es falso:
La mayoría de los códigos no están bien escritos.
Su código probablemente no está tan bien escrito como usted piensa.
Así que haga comentarios en su código. Punto.
Use un estilo consistente.
La codificación del estilo es realmente una cuestión de preferencia personal pero me gustaría ofrecer este consejo: use una sintaxis Java estándar para las llaves:
public static void main(String[] args) {
}
No use este estilo:
public static void main(String[] args)
{
}
Ni este:
public static void main(String[] args)
{
}
¿Por qué? Bueno, es estándar, por lo tanto la mayoría de los códigos con los que usted se encuentre (como códigos que usted no escribió pero que se pueden pagar para mantener) muy probablemente estarán escritos de ese modo.
Una vez dicho eso, paiza.io sí le permite definir estilos de código y formatear su código de cualquier modo que a usted le guste. Lo principal es que elija un estilo y lo mantenga.
Use un registro incorporado
Antes de que Java 1.4 introdujera el registro incorporado, el modo canónico para descubrir lo que su programa estaba haciendo era hacer una llamada de sistema como la siguiente:
public void someMethod() {
// Do some stuff...
// Now tell all about it
System.out.println("Telling you all about it:");
// Etc...
}
El recurso de registro incorporado del lenguaje Java (consulte de nuevo Your first Java object) es una mejor alternativa. Yo nunca uso System.out.println() en mi código y sugiero que usted tampoco lo use.
Siguiendo los pasos de Fowler
El mejor libro en la industria (en mi opinión, y no lo digo solo yo) es Refactoring: Improving the Design of Existing Code de Martin Fowler et al. Incluso es divertido leerlo. Fowler y sus coautores hablan sobre "olores de códigos" que piden refactorización y profundizan mucho sobre las diversas técnicas para arreglarlos.
En mi opinión, la refactorización y la habilidad para escribir códigos de prueba son las aptitudes más importantes para que los programadores nuevos aprendan. Si todos fueran buenos en ambos aspectos, revolucionaría la industria. Si usted se vuelve bueno en ambos, en última instancia producirá códigos más limpios y aplicaciones más funcionales que muchos de sus colegas.
Conclusión para la Parte 1
En este tutorial, ha aprendido acerca de la programación orientada a objetos, ha descubierto una sintaxis Java que le permite crear objetos útiles y se ha familiarizado con un IDE que le ayuda a controlar su entorno de desarrollo. Sabe cómo crear y ejecutar objetos Java que pueden hacer una buena cantidad actividades, que incluyen hacer cosas diferentes en base a entradas diferentes. También sabe cómo hacer que sus aplicaciones admitan archivos JAR para que los otros desarrolladores las usen en sus programas y cuenta con algunas de las mejores prácticas básicas de programación Java en su haber.
Lo que sigue
En la segunda mitad de este tutorial, comenzará a aprender acerca de algunas de las construcciones más avanzadas de la programación Java, aunque el debate general todavía será de alcance introductorio. Los temas de programación Java que se cubren en ese tutorial incluyen:
- Herencia y abstracción
- Interfaces
- Clases anidadas
- Expresiones regulares
- Genéricos
- Tipos de enumeración
- E/S
- Serialización
No hay comentarios:
Publicar un comentario