Datos simples, declaración y conversión

1 comentarios

Todo lenguaje de programación consta de elementos específicos que le permite realizar las operaciones básicas de la programación.
  • Tipos de datos
  • Operadores
  • Instrucciones o sentencias

Categorías de tipos de datos

Los tipos de datos en Java se pueden dividir en tres grupos.

De acuerdo con el tipo de información que representa. Dependiendo del tipo se podrán realizar unas acciones u otras.
  • Datos de tipo primitivo.
  • Variables referencia (variables array, clase/instacia, interface…)
Según se pueda modificar la variable en tiempo de ejecución.
  • Variables: El valor asociado puede ser modificado por el mismo programa durante el tiempo de ejecución
  • Constantes o variables finales: El valor permanecerá inmutable durante toda la ejecución del programa.
Según el lugar de declaración.
  • Variables miembro: Definida dentro de la clase y fuera de los métodos.
  • Variables locales: Se definen dentro de un método.

Tipos de dato  primitivos en Java

En Java prácticamente todo se realiza mediante objetos, de todas maneras, existen algunas excepciones en las que se tiene que trabajar con el mínimo de memoria posible. En estos casos se utilizan datos primitivos tales como int, char, byte, etc… los cuales tienen un tratamiento especial.
A diferencia de sus representaciones como objetos los tipos primitivos no aceptan el estado ‘null’ por lo que siempre se inicializan con un dato por defecto.

A partir de los datos primitivos se puede trabajar con estructuras de tipos de datos compuestos como podrían ser los Arrays, clases e interficies.

Literales

Los literales son la representación escrita en el código fuente de un valor fijo determinado.
Las constantes de tipo booleana son, tal y como hemos visto, ‘false’ por defecto o ‘true’.
Las constantes de tipo carácter (char) se declaran entre comilla simple, de esta manera le estamos indicando al compilador, que nos interesa, literalmente, lo que tenemos dentro de estas comillas, si bien esto nos sirve con la gran mayoría de caracteres alfanuméricos y símbolos de puntuación o especiales, hay un grupo de caracteres que necesitan de un tratamiento especial, para ello se utiliza la denominada secuencia de escape, la contra barra. Por ejemplo, no es lo mismo asignar ‘t’ que asignar \t con el primero mostraríamos una t por consola, con el segundo mostraríamos una tabulación, otra manera de cargar los caracteres seria a través de octales o de códigos Unicode. En la página Unicode-Table.com (Actualmente es (◕‿◕) SYMBL) tenéis todas las combinaciones posibles de códigos Unicode y en la pagina UTF8-CharTable.DE  si seleccionáis “display Octal” podréis ver la comparativa entre Unicode y Octal, esta segunda página es más ligera, pero más compleja de usar si no se sabe lo que se busca. A continuación pongo los caracteres normalmente más usados.

Esto nos lleva a una singularidad, que si bien este no es su momento, viene al caso explicarlo, el caso de los String. Los Strings pueden ser considerados como cadena de caracteres y tal y como se ha explicado hay ciertos caracteres especiales que no se pueden escribir de manera normal. En el caso de los String a la hora de asignar se realiza con las dobles comillas (“”) de tal manera que si queremos escribir una comilla doble tendremos que hacer uso de la secuencia de escape, de esta manera la frase (el “nunca” cogió el coche) quedaría como (“el \”nunca\” cogió el coche”). Basándonos en este principio podemos utilizar cualquier secuencia de escape.
Las constantes enteras se pueden declarar como binarios,  octales, decimales o hexadecimales, si el primer digito del numero que se asigna es un ‘0 ‘ se entiende que se trata de un Octal, en la siguiente tabla vienen explicadas todas las opciones.

Las constantes reales o de coma flotante se expresan con coma decimal y opcionalmente seguidos de un exponente. Por defecto cuando se declaran son doublé, pero lo podemos modificar finalizando la declaración con una ‘f’ o ‘F’.

Desde Java 7 en los numéricos pueden aparecer caracteres de subrayado para facilitar la lectura del número, digamos que queremos declarar de manera constante una tarjeta de crédito , si ponemos todos los dígitos seguidos puede resultar difícil de leer, además las tarjetas de crédito ya tienen una separación lógica, de manera que si queremos podemos declarar un entero long tarjeta = 1234_5678_9012_3456L; y se lee mejor.

Declaración de variables

Una variable es un espacio de memoria correspondiente a un dato cuyo valor se puede modificar en tiempo de ejecución. Toda variable tiene que tener un tipo de dato y un identificador con el que poder referenciarlo. El tipo de dato indicara a Java el espacio de memoria que se tiene que reservar en memoria, los diferentes valores que puede tomar la variable y las operaciones que con ella se puede realizar.
El identificador elegido no puede coincidir con ninguna de las palabras reservadas, además debería seguir las convenciones que todos los programadores intentamos seguir.
·         La variable comienza por minúsculas: mes, clave, nombre…
·         Si el identificador es una palabra compuesta el resto de palabras van juntas y la primera letra en mayúsculas: esDivisible, numeroTarjeta, telefonoMovil
·         El carácter de subrayado puede ser usado en cualquier lugar del identificador, no obstante es aconsejable usarlo únicamente como separador de palabras en las constantes: CARGA_MAXIMA, CARGA_MINIMA,..
En el momento de declaración de las variables podemos declarar primero todas las variables y luego inicializarlas o inicializarlas según las vamos declarando.
Además podemos declarar más de una variable en la misma línea.
int n;
double x = 12.5, y = 2.0;
Pero en el caso de las constantes es aconsejable inicializarlos siempre. Al ser un ‘final’ lo que le estamos indicando es que una vez inicializado no se va a variar nunca, pero no podemos esperar a un método para poner el valor, en el mismo momento en el que se carga la clase contenedora se tiene que cargar el valor de esa variable o nos encontraremos un error en tiempo de ejecución, de esta manera si queremos que este valor se base en una decisión tenemos que ponerlo en el constructor de la clase y recordar que su valor no se va a modificar en toda la ejecución del programa.
La asignación de valor se puede posponer en el código, aunque en ningún caso su valor puede modificarse una vez ha sido inicializada ya que se generaría un error. Ejemplo de inicialización posterior a la declaración de la constante:
final int MAXIMO;
...
MAXIMO = 15;
Puede parecer que solo se inicializa una vez, pero recordemos que un tipo primitivo siempre se inicializa con un valor por defecto.
Además de estas reglas de inicialización también hay que seguir un convenio a la hora de elegir el nombre que le vamos a poner a nuestra constantes
·         Los identificadores siempre se escriben en mayúsculas. MAXIMO.
·         El carácter de subrayado es aceptable en cualquier lugar del identificador, pero es recomendable solo usarlo para separar las palabras: MAXIMO_VALOR.

Conversión entre tipos de datos

Excepto para los booleanos que no pueden ser transformados a otro tipo de dato, para el resto de tipos de datos existen dos categorías de conversión.
·         Ensanchamiento o promoción.
·         Estrechamiento o contracción.
Las promociones transforman un dato de un tipo a otro con un espacio de memoria mayor para almacenar información. En estos casos podríamos tener una pérdida de precisión al convertir un valor entero a otro real al desechar algunos dígitos significativos si el número de cifras del valor entero original es muy grande. En la siguiente imagen se puede ver cuáles son las posibles conversiones de promoción.

Las conversiones de contracción son un poco más peliagudas ya que cada vez que hacemos una conversión tenemos una pérdida de datos a menos que el origen cumpla con el máximo del destino.

Todas las conversiones se realizan básicamente de tres modos:
·         Asignación: por conversión implícita cuando se asigna una variable de un tipo a otra de otro tipo.
·         Promoción aritmética: conversión implícita como resultado de una operación aritmética.
·         Por casting o “moldes”: conversión explícita con operadores que producen la conversión entre tipos.
En la siguiente imagen se hace un resumen de las diferentes conversiones que se pueden realizar, podremos observar las conversiones implícitas o automáticas (A) en las que no tenemos que hacer nada para convertir el dato, las conversiones en las que es posible que tengamos perdidas de datos (P) y las conversiones en las que hay que hacer una conversión explícita o “casting” (C).


Estructura de un programa en Java

0 comentarios

La clase principal y el método main.

Un programa puede construirse empleando varias clases. En su estructura más simple tendríamos una clase principal que contendría el programa, rutina o método principal: main() en el cual se incluirían las sentencias del programa principal. De esta manera la estructura de un programa simple en Java seria el siguiente:
public class ClasePrincipal {
        public static void main(String[] args) {
                sentencia_1;
                sentencia_2;
                //...
                sentencia_N;
        }
}

Comentarios

Una parte importante de los programas son sus comentarios ya que estos nos permiten saber cuál se supone que tienen que ser el funcionamiento de una sentencia en concreto. Los comentarios no son almacenados a la hora de compilar de manera que el compilador los detecta y los ignora, haciendo que el código sea más ligero.
En Java disponemos de tres tipos de comentarios, entre los cuales podemos encontrar los comentarios clásicos de C y C++ tales como // y /* … */. De esta manera el compilador de Java ignorara todo lo que escribamos desde // hasta el final de la línea:
System.gc(); // Esta parte será ignorada, pero realizara el Garbage collection.
Con el tipo de comentario /* … */ tendremos un comentario multilinea, en este caso solo tendremos que marcar el inicio”/*” y el final “*/”  para que todo lo que se encuentre en su interior sea ignorado por el compilador.
public class suma {
        public static void main(String[] args) {
                int numero = 1;
                numero++;
                int multiplicador = 2;
                numero *= multiplicador;
                System.out.println("salida 1: " + numero);
                numero++;
                numero *= multiplicador;
                System.out.println("salida 2: " + numero);
        }
}
c:\>javac suma.java

c:\>java suma
salida 1: 4
salida 2: 10
public class suma {
        public static void main(String[] args) {
                int numero = 1;
                numero++;
                int multiplicador = 2;
                numero *= multiplicador;
                System.out.println("salida 1: " + numero);/*
                numero++;
                numero *= multiplicador;
                */System.out.println("salida 2: " + numero);
        }
}
c:\>javac suma.java

c:\>java suma
salida 1: 4
salida 2: 4

Por ultimo tenemos el tipo de comentario que se usa para el documentador de Java, este se caracteriza por que comienza con “/**”  y termina con “*/” si nos fijamos en la diferencia con el comentario anterior este contiene dos * al inicio, en lugar de uno solo.
Este tipo de comentarios suele encontrarse al inicio de los métodos y nos indica varios parámetros del mismo así como una breve descripción.
/**
* Método que permite convertir una lista en un array
* @param list
* @return Array
*/

Hay muchos y muy variados tags para este API de JavaDocs, de manera que ya lo miraremos más adelante.

Tokens

                Un token es el elemento más pequeño que se interpretara en nuestro código por el compilador. En Java los tokens se pueden dividir en 4 grupos.

  • Identificadores o nombres que se asignarían a las variables, constantes, clases, paquetes y métodos. Dentro de los identificadores se encuentran las palabras claves que son identificadores reservados por Java para cumplir con un objetivo específico en el código.
  • Constantes literales: representan valores predefinidos que puede tomar una.
  • Operadores: representan una operación que se aplica a un objeto o un dato, sobre una variable o constante (operando).
  •  Separadores: Son empleados para indicarle al compilador de Java donde se ubican los elementos de código. Por ejemplo: { } , : ;
Los identificadores tienen que seguir una serie de normas a la hora de declararse.
  • Los identificadores han de comenzar por una letra, o por un carácter de subrayado “_” o con el carácter de dólar “$”. Aunque se desaconseja utilizar el carácter dólar ya que el compilador lo utiliza de manera interna.
  • A partir del segundo carácter se podrán usar además números u otros digitos. Estarian prohibidos los espacios en blanco, el signo de interrogación “?” y el signo del tanto por ciento “%”.
  •  No hay límite de caracteres.
  • El identificador es case sensitive, lo que viene a significar, que los identificadores “casa”, “CASA” y “Casa” serian diferentes
  • Se pueden incluir caracteres Unicode, con lo que se pueden emplear secuencias de escape \uxxxx para representar estos caracteres
  • No puede emplearse el identificador de una variable o cualquier otro elemento del código fuente del programa para otro ya existente en el mismo bloque. Excepción: variable miembro y local con el mismo identificador.
  • Las palabras reservadas no pueden emplearse como identificadores.

Aunque la elección de cómo escribir los identificadores en Java no se encuentra normalizado, sí que tenemos una serie de convenciones en la que nos podemos basar a la hora de construir nuestros nombres.
  • Los identificadores tienen que ser auto explicativos, de tal manera que cualquier persona que venga, sepa a la perfección que es lo que va a hacer el método. Por ejemplo, si ponemos un método denominado “Integer getmes(Usuario usuario)” lo que cualquiera esperara es que el método me devuelva el numero del mes usuario, pero aquí comienza el problema, el mes de alta, de baja, de nacimiento… como se puede ver un déficit de información en el identificador nos puede llevar a errores en el futuro. Si se hubiera puesto “Integer getmesaltasistema(Usuario usuario)” no habría dudas, devuelve el mes en el que se dio de alta.
  •  Si el identificador contiene más de una palabra se utilizaría la convención ‘Lower Camel Case’ o lo que es lo mismo, la primera letra de la primera palabra en minúscula y el resto de palabras con la primera letra en mayúsculas. Por ejemplo, si nos fijamos en el apartado A) se hace realmente difícil de leer, cuando solamente era “getmes” era sencillo, pero si lo pasamos por el convenio quedaría de la siguiente manera “getMes”, la cosa se complica cuando se incluyen más palabras “getmesaltasistema”, amén de que juntar algunas palabras puede tener un sentido que no queremos dar, de manera que separaremos la palabra según el convenio “getMesAltaSistema”, ahora es mucho más intuitivo de separar.
  • El uso del subrayado ‘_’ está permitido en todo tipo de identificador, pero es aconsejable usarlo únicamente como separador de palabras en las constantes, por ejemplo

public static final int NUMERO_MAXIMO_CARACTERES = 255;

Existen muchas más convenciones, si estás interesado en ellas, no dudes en leerte las convenciones publicadas por Oracle, serán del 1999 pero ya que son convenciones que no varían casi nunca siguen siendo igual de validas; tenéis toda la información aquí 

¿Qué es Derby?

0 comentarios


Derby es una base de datos relacional escrito íntegramente en JAVA. Actualmente se encuentra bajo una licencia Apache 2.0.

Pero esta base de datos no siempre se llamó Derby, en el 1997 una empresa de Oakland, California denominada Cloudscape dio a luz, la que fue reconocida como primera versión de Derby, un motor de base de datos denominado JBMS. Posteriormente el producto adopto el nombre de la empresa Cloudscape y comenzaron a aparecer versiones cada seis meses, esto hizo que otra gran empresa se fijara en ellos y en 1999 Informix Software, Inc. adquirió Cloudscape, Inc. por diez millones de acciones, del paquete de acciones ordinarias para emisión; lo cual la verdad no se a cuánto ascendía, ahora mismo no soy capaz de encontrar el valor. Esta transacción no pasó desapercibida para la gigante IBM que en seguida se fijó en el paquete, o quizás orquesto él la compra, esto último nunca lo sabremos, la cuestión es que apenas dos años después, en Julio del 2001, IBM se hace con la BBDD de Cloudscape tras la compra de parte de Informix.
El motor de la base de datos fue renombrado a IBM Cloudscape y comenzaron a aparecer versiones enfocadas principalmente a los productos de IBM y su Middleware.

En el 2004 IBM cedió el código del "IBM Cloudscape" a la Apache Software Foundation para Derby, un proyecto patrocinado por el proyecto Apache DB. En Julio de 2005 el proyecto Derby continuó como un subproyecto de base de datos de alto nivel de Apache. Sun Microsystem se unió al proyecto para poder lanzar Derby como base de datos empotrada de Java, lo cual consiguió con el lanzamiento de Java 6 en diciembre de 2006, Sun comenzó empaquetando Derby en el JDK bajo el nombre Java DB.


En su modo embebido Derby sólo soporta un hilo, lo cual puede ser un problema para grandes proyectos, pero hay que tener en cuenta que esta base de datos no está pensada para ser utilizada en proyectos de larga duración ya que su consumo de memoria lo haría inviable. Derby más bien lo podríamos utilizar para demos, presentaciones, bases de datos auxiliares durante la instalación o cuando se sabe de antemano que la carga va a ser nula y los registros que se van a cargar van a ser pocos.