Archivos para la categoría ‘Java Básico’

Hoy os mostramos cómo formatear una fecha de forma simple para poder mostrar simplemente el texto mediante programación en java, eliminando la complejidad de los objetos GregorianCalendar o Date, mediante la clase SimpleDateFormat

    SimpleDateFormat sdf = new SimpleDateFormat("dd - MM - yyyy");
    Calendar cal = Calendar.getInstance(); // hoy
    System.out.println("Hoy es " + sdf.format(cal.getTime()));

La clase SimpleDateFormat es muy sencilla de utilizar en java. Simplemente al constructor hay que pasarle cómo se deben formatear las fechas. dd es el día, MM es el mes y yyyy es el año. Se puede ver una lista de los posibles valores que admite en la API de SimpleDateFormat.

Una vez inicializada la clase, el método format devuelve un StringBuffer con la fecha debidamente formateada.  Se le debe pasar un objeto de tipo Date, que se puede extraer del GregorianCalendar mediante el método getTime()…y ya está este sencilla rutina de programación en java.

Las excepciones de tipo NullPointer son las causas de excepción en tiempo de ejecución más comunes.

Todos los valores en Java, excepto las primitivas, son referencias a objetos y todos tienen un valor por defecto, el valor null, que indica que el objeto no tiene asignado ningún valor. A un objeto con valor null, no inicializado, que no referencia ningún objeto, no se le puede aplicar ningún método, siendo el resultado el lanzamiento de una excepción de tipo NullPointerException

Una excepción de tipo NullPointerException lleva asociada la información de la línea de código donde se produjo el error. El mecanismo para detectar y corregir el error es directamente ir a esta línea de código y averiguar cuál de los objetos involucrados en la operación es el que no ha sido inicializado. Una vez detectado, será necesario inicializar el valor del objeto, pero siempre teniendo cuidado de no hacerlo para simplemente eliminar el error, sino que se le debe asignar un valor acorde con la lógica propia del programa.

class Casa{
private long precio;
 
public Casa (long precio){
this.precio = precio;
}
 
public long getPrecio(){
return precio;
}
 
public class Vender {
 
private Casa casa;
 
public static void main(String[] args){
 
Vender vender = new Vender();
System.out.println(vender.casa.getPrecio());
}
}

Obviamente al ejecutar este ejemplo, se producirá un error indicando la línea concreta del error, y revisando esta línea se puede ver que la casa no está inicializada, y al no tener una referencia de la misma no se puede operar sobre el objeto y se lanzará la excepción NullPointerException.

Por ejemplo, el error se podría corregir inicializando el objeto casa incluido en el objeto Vender.

private Casa casa = new Casa(100000);

Los métodos list y listFiles, aplicables a un objeto de tipo File, no aseguran el orden en el que se devuelven los contenidos de un directorio.

Si se desea que el listado de ficheros tenga un orden determinado, es necesario realizar una ordenación posteriormente.

A continuación presentamos dos tipos de ordenación. La primera devuelve los resultados en orden por fecha de modificación. La segunda es un tanto especial, ya que devuelve siempre en primer lugar, si existe, un fichero del que se conoce previamente el nombre, y el resto de resultados los ordena alfabéticamente.

File[] filesPorFecha = directory.listFiles();
 
Arrays.sort(filesPorFecha, new Comparator<File>(){
	public int compare(File f1, File f2){
        return Long.valueOf(f1.lastModified()).compareTo(f2.lastModified());
} });

String[] filesPorNombre = directory.list();
 
Arrays.sort(filesPorNombre, new Comparator<String>(){
         public int compare(String f1, String f2){
		if (!f1.equals(f2) && f1.equals("nombredelfichero")){
			return -1;
		}else if (!f1.equals(f2) && f2.equals("nombredelfichero")){
			return 1;
		}else{
			return f1.compareTo(f2);
		}
         }
 });

El siguiente extracto de código recorre todas las claves y valores de un Map. En primer lugar se construye y rellena el Map para posteriormente sacar por la salida estándar todas las claves y valores del mismo.

	HashMap  map = new HashMap();
	map.put("clave1","valor1");
	map.put("clave2","valor2");
	Iterator itr = map.entrySet().iterator();
	while (itr.hasNext()) {
		Map.Entry e = (Map.Entry)itr.next();
		System.out.println("clave: "+e.getKey()+"valor:"+e.getValue());
	}

Un paquete es un espacio de nombres que organiza un conjunto de clases e interfaces relacionadas. Puede pensar en los paquetes como algo similar a las diferentes carpetas de su ordenador. Puede tener guardadas páginas HTML en una carpeta, imágenes en otra y scripts y aplicaciones en otra distinta. Puesto que un software escrito en el lenguaje de programación Java puede llegar a consistir de cientos o miles de clases individuales, tiene sentido que se organicen las clases e interfaces relacionadas en paquetes.

La plataforma Java proporciona una enorme biblioteca de clases (un conjunto de paquetes) adecuado para usar en sus propias aplicaciones. A esta biblioteca se la conoce como la Interfaz de Programación de Aplicaciones (Application Programming Interface en inglés) o por su abreviatura API. Sus paquetes representan las tareas más comunes asociadas a la programación en general. Por ejemplo, un objeto String contiene estado y comportamiento para cadenas de caracteres («character strings»); un objeto File permite a un programador crear, eliminar, inspeccionar, comparar o modificar un archivo en un sistema de archivos; un objeto Socket permite la creación y uso de sockets de red; otros objetos de interfaz gráfica («GUI») controlan botones, cajas de selección y cualquier otra cosa relacionada con las interfaces gráficas de usuario. Literalmente hay miles de clases de las que elegir. Esto le permite al programador enfocar sus esfuerzos en el diseño de la aplicación, más que en la infraestructura requerida para hacerla funcionar.

La Java Platform API Specification contiene el listado completo de todos los paquetes, interfaces, clases, campos y métodos proporcionados por la Plataforma Java 6, edición estándar (Java Platform 6, Standard Edition). Cargue esta página en su navegador y añádala a sus marcadores o favoritos. Siendo programador se convertirá en su documentación de referencia más importante.

 

Como ya ha aprendido, los objetos definen su interacción con el mundo exterior a través de los métodos de que exponen. Los métodos forman la interfaz del objeto con el mundo exterior; por ejemplo, los botones que hay en la parte frontal de su televisor forman la interfaz entre usted y el cableado eléctrico al otro lado de la caja de plástico. Debe pulsar un botón para encender y apagar el televisor.
En su forma más común, una interfaz es un grupo de métodos relacionados con cuerpos vacíos. El comportamiento de una bicicleta, si se especifica como una interfaz, podría aparecer así:

interface Bicycle {
 
       void changeCadence(int newValue);
 
       void changeGear(int newValue);
 
       void speedUp(int increment);
 
       void applyBrakes(int decrement);
}

Para implementar esta interfaz el nombre de su clase debería cambiar (a ACMEBicycle, por ejemplo), y usaría la palabra clave implements en la declaración de clase:

class ACMEBicycle implements Bicycle {
 
   // remainder of this class implemented as before
 
}

Implementar una interfaz permite a una clase ser más formal acerca del comportamiento que promete proporcionar. Las interfaces forman un contrato entre la clase y el mundo exterior, y este contrato se hace cumplir en el momento de la compilación. Si su clase afirma implementar una interfaz, todos los métodos definidos por esa interfaz deben aparecer en su código fuente para que se compile con éxito.

A menudo diferentes tipos de objetos tienen algunas cosas en común. Por ejemplo, las bicicletas de montaña, las de carretera y los tándems todos comparten las características de las bicicletas (velocidad actual, cadencia de pedal, marcha). Aún así cada una de ellas también define características adicionales que las hacen diferentes: los tándems tienen dos asientos y dos manillares, las bicicletas de carretera tienen un manillar con cuernos, algunas bicicletas de montaña tienen más piñones que les proporcionan marchas más cortas.

La programación orientada a objetos permite que las clases hereden estados y comportamientos de uso común de otras clases. En este ejemplo, Bicycle se convierte en la superclase de MountainBike, RoadBike y TandemBike. En el lenguaje de programación Java se permite que cada clase tenga una superclase directa y que cada superclase tenga el potencial para una cantidad ilimitada de subclases.

La sintaxis para crear subclases en sencilla. Utilice la palabra clave extends seguida del nombre de la clase de la que desea heredar al inicio de su declaración de clase:

class MountainBike extends Bicycle {
 
     // Los nuevos campos y métodos que definan una bici de montaña irían aquí
 
}

Esto proporciona a MountainBike los mismos campos y métodos que Bicycle, pero permite a su código encargarse exclusivamente de las características que la hacen única. Esto hace que el código de sus subclases sea fácil de leer. Sin embargo debe encargarse de documentar apropiadamente el estado y comportamiento que cada superclase que define, ya que ese código no aparecerá en el archivo fuente de cada subclase.

Las sentencias de control de flujo determinan el orden en que se ejecutarán las otras sentencias dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo.

• toma de decisiones     if-else, switch-case
• bucles     for, while, do-while
• excepciones     try-catch-finally, throw
• miscelaneas     break, continue, label:, return

Aquí sólo vamos a tratar las sentencias de tomas de decisiones y los bucles, dejando las excepciones para otra ocasión.

Sentencias de toma de decisiones

• La sentencia if-else

La sentencia if-else de java proporciona a los programas la posibilidad de ejecutar selectivamente otras sentencias basándose en algún criterio. Esta es la versión más sencilla de la sentencia if: la sentencia gobernada por if se ejecuta si alguna codición es verdadera. Generalmente, la forma sencilla de if se puede escribir así.

if (expresión)
sentencia;

Pero, ¿y si quieres ejecutar un juego diferente de sentencias si la expresión es falsa? Bien, puedes utilizar la sentencia else, que ejecuta la condición opuesta

if (expresión)
sentencia;
else
otrasentencia;

Este uso particular de la sentencia else es la forma de capturarlo todo.

Existe otra forma de la sentecia else, else if que ejecuta una sentencia basada en otra expresión. Como ejemplo, un programa que asigna notas basadas en la puntuación de un examen, un Sobresaliente para una puntuación del 90% o superior, un Notable para el 80% o superior y demás:

int puntuacion;
String nota;
 
if (puntuacion >= 90) {
nota = "Sobresaliente";
} else if (puntuacion >= 80) {
nota = "Notable";
} else if (puntuacion >= 70) {
nota = "Bien";
} else if (puntuacion >= 60) {
nota = "Suficiente";
} else {
nota = "Insuficiente";
}

Una sentencia if puede tener cualquier número de sentencias de acompañamiento else if.

• La sentencia switch-case

La sentencia switch se utiliza para realizar sentencias condicionalmente basadas en alguna expresión. Por ejemplo, un programa contiene un entero llamado mes cuyo valor indica el mes en alguna fecha, y se quiere mostrar el nombre del mes basándose en su número entero equivalente. Se podría utilizar la sentencia switch de Java para realizar esta tarea.

int mes;
. . .
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("May0"); 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("No es un mes válido");
break;
}

La sentencia switch evalúa su expresión, en este caso el valor de mes, y ejecuta la sentencia case apropiada.

Decidir cuando utilizar las sentencias if o switch dependen del juicio personal. Se puede decidir cual utilizar basándose en la buena lectura del código o en otros factores. Cada sentencia case debe ser única y el valor proporcionado a cada sentencia case debe ser del mismo tipo que el tipo de dato devuelto por la expresión proporcionada a la sentencia switch.

Otro punto de interes en la sentencia switch son las sentencias break después de cada case. La sentencia break hace que el control salga de la sentencia switch y continúe con la siguiente línea. La sentencia break es necesaria porque las sentencias case se siguen ejecutando hacia abajo. Esto es, sin un break explícito, el flujo de control seguiría secuencialmente a través de las sentencias case siguientes.

Finalmente, puede utilizar la sentencia default al final de la sentencia switch para manejar los valores que no se han manejado explícitamente por una de las sentencias case.

Sentencias de Bucle

• El bucle while

Una sentencia while realiza una acción mientras se cumpla una cierta condición. La sintaxis general de la sentencia while es.

while (expresión)
sentencia;

Esto es, mientras la expresión sea verdadera, ejecutará la sentencia.

sentencia puede ser una sóla sentencia o puede ser un bloque de sentencias. Un bloque de sentencias es un juego de sentencias legales de java contenidas dentro de corchetes(‘{‘y ‘}’).

Además de while Java tiene otros dos constructores de bucles que puedes utilizar en tus programas.

• El bucle for

Puedes utilizar este bucle cuando conozcas los límites del bucle (su instrucción de inicialización, su criterio de terminación y su instrucción de incremento). Por ejemplo, el bucle for se utiliza frecuentemente para iterar sobre los elementos de un array, o los caracteres de una cadena.

 
// a es un array de cualquier tipo
. . .
int i;
int length = a.length;
for (i = 0; i < a.length; i++) {
System.out.println(a[i]);
}

Si sabes cuando estas escribiendo el programa que quieres empezar en el inicio del array, parar al final y utilizar cada uno de los elementos. Entonces la sentencia for es una buena elección. La forma general del bucle for puede expresarse asi.

for (inicialización; terminación; incremento)
sentencias

inicialización es la sentencia que inicializa el bucle. Se ejecuta una vez al iniciar el bucle.

terminación es una sentencia que determina cuando se termina el bucle. Esta expresión se evalúa al principio de cada iteracción en el bucle. Cuando la expreión se evalúa a false el bucle se termina.

Finalmente, incremento es una expresión que se invoca en cada interacción del bucle. Cualquiera (o todos) de estos componentes puden ser una sentencia vacía (un punto y coma).

• el bucle do-while

Java proporciona otro bucle, el bucle do-while,que es similar al bucle while que se vió al principio, excepto en que la expresión se avalú al final del bucle.

do {
sentencias
} while (Expresión Booleana);

La sentencia do-while se usa muy poco en la construcción de bucles pero tiene sus usos. Por ejemplo, es conveniente utilizar la sentencia do-while cuando el bucle debe ejecutarse al menos una vez.

Las clases son los elementos fundamentales de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. El conocimiento de las clases es fundamental para poder entender los programas Java.

Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una clase.

Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos. La palabra clave import puede colocarse al principio de un fichero, fuera del bloque de la clase. Es necesario declarar explícitamente las clases que se van a utilizar (import) que no estén dentro del paquete (package) al que pertenece la clase.

Los tipos de clases que podemos definir son:

• abstract: Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.
• final: Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.
• public: Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.
• synchronizable: Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de controlar la concurrencia. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.

Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para las variables de instancia y los métodos definidos en la clase:

• public (public void CualquieraPuedeAcceder(){}): Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instacia públicos.
• protected (protected void SoloSubClases(){}): Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos de instancia protegidos.
• private (private String NumeroDelCarnetDeIdentidad;) Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases.
• friendly (sin declaración específica, void MetodoDeMiPaquete(){}) Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que protected.

Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código Java; son los separadores simples, que van a definir la forma y función del código. Los separadores admitidos en Java son:

() – paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para definir precedencia en expresiones, contener expresiones para control de flujo y rodear las conversiones de tipo.

{} – llaves. Para contener los valores de matrices inicializadas automáticamente. También se utiliza para definir un bloque de código, para clases, métodos y ámbitos locales.

[] Рcorchetes. Para declarar tipos matriz. Tambi̩n se utiliza cuando se referencian valores de matriz.

; – punto y coma. Separa sentencias.

, – coma. Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar sentencias dentro de una sentencia for.

. Рpunto. Para separar nombres de paquete de subpaquetes y clases. Tambi̩n se utiliza para separar una variable o m̩todo de una variable de referencia.