Almacenamiento de datos en variables.
El trabajo con datos es parte fundamental de cualquier programa, las variables y sus tipos se encargan de almacenar esa información y la memoria que es necesaria para gestionarlas. La manera mas habitual de declarar una variable siempre contiene dos elementos, el tipo de la variable y su nombre y terminando la declaración con punto y coma. Pero también se puede declarar en una misma instrucción mas de una variable del mismo tipo siempre separadas por una coma, al igual que se puede inicializar una variable en el momento de declararla.
Inicializar una variable consiste en almacenar un determinado valor en el espacio de memoria reservado para ella. int midato; int midato1 = 3, midato2 = 6,midato3 = 5; Los deferentes tipos de variables.
Las variables en Java deben tener un tipo de dato asociado. El tipo de dato de esa variable indicara los valores que la variable puede contener y las operaciones que se pueden realizar con ella. Podemos diferenciar los datos en Java en dos categorías de datos principales: los tipos primitivos y los tipos referenciados.
Los tipos primitivos contienen un sólo valor e incluyen los tipos como los enteros, coma flotante, los caracteres, de tipo booleano etc...
Los tipos referenciados se llaman así porque el valor de una variable de referencia es una referencia (un puntero) hacia el valor real. En Java tenemos los arrays, las clases y los interfaces como tipos de datos referenciados.
Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor, estos representan un número y no pueden representar elementos fraccionarios.
Esto puede ser un buen ejemplo de declaración de tipos de datos enteros:
public class enteros
{
public static void main(String[] arg)
{
byte midato1 = 1;
short midato2 = 100;
int midato3 = 10000;
long midato4 = 100000000;
System.out .println("midato = " + midato1);
....
}
}
Números en coma flotante: Estos son float y double y pueden almacenar números en coma flotante y con signo, esto quiere decir que nos permiten representar números decimales.
Todos los literales de coma flotante son del tipo double salvo que se especifique lo contrario, por eso si se intenta asignar un literal en coma flotante a una variable de tipo float el compilador nos dará un error (tipos incompatibles):
public class tipoDecinales
{
public static void main(String[] arg)
{
float valor;
valor = 2.6;
System.out .println("Valor del dato= " + valor); //esto dara un error.
}
}Esto se solucionaría indicando que el valor 2.6 es de tipo float con una f al final 2.6f
El tipo Caracter: Estos son de tipo char, que almacena la representación de los caracteres (letras o números), un carácter esta almacenado en 16 bits, y siguen un estándar que es el Unicoide.
Los caracteres en Java se pueden especificar de forma normal o con secuencias de escape, utilizando la barra invertida "\" seguida de una letra:( \r) o utilizando la barra invertida con una "u" seguida de un numero hexadecimal (\u0000d), en este caso hemos especificado la secuencia de escape \r y su código unicoide correspondiente del retorno de carro.
public class tipoCaracter
{
public static void main(String[] arg)
{
char valor, valor1, valor2;
valor = 'a'; // el literal de tipo carácter tiene que estar encerrado entre comillas simples.
valor1 = 65;
}
}Ejemplo de secuencias de escape:
\'...................... comillas simples.
\"......................comillas dobles.
\\......................barra invertida.
\b......................espacio en blanco.
\ddd..................carácter octal.
\f.......................avance.
\n......................nueva línea.
\r.......................retorno de carro.
\t.......................tabulador.
\uxxxx..............carácter Unicoide
El tipo booleano: Este solo guarda dos valores: verdadero (true) o falso(false), y no como ocurre en otros lenguajes que toman los valores 0 y 1. Generalmente su utilización es muy frecuente para determinar el flujo de los programas:public class tipoBoolean
{
public static void main(String[] arg)
{
boolean valor1, valor2 ;
valor = true;
valor1 = false;
if (valor1){
System.out .println("valor1 = verdadero");
} else {
System.out .println("valor1 = falso");
}
}
}
| Tipos de datos | Rango de valores | Descripción |
Números enteros |
| byte | 8-bit complemento a 2 | Entero de un Byte |
| short | 16-bit complemento a 2 | Entero corto |
| int | 32-bit complemento a 2 | Entero |
| long | 64-bit complemento a 2 | Entero largo |
Números reales |
| float | 32-bit IEEE 754 | Coma flotante de precisión simple |
| double | 64-bit IEEE 754 | Coma flotante de precisión doble |
otros tipos |
| char | 16-bit Caracter | Un sólo carácter |
| boolean | true o false | Un valor booleano (verdadero o falso) |
Los Arrays (Matrices)
Java dispone de un tipo de dato de posiciones secuenciales y que cuenta de unas comprobaciones exhaustivas para su correcta manipulación como puede ser la comprobación de no sobrepasar los limites permitidos en la definición del array.
Los arrays permiten guardar grupos de datos similares, puesto que Java trata los arrays como un tipo de objeto y por lo tanto este se tendra que instanciar con el operador new.
Para crear un array tenemos que especificar una variable que se utilizara como índice para acceder al array y el tipo de datos que este contendrá.
Antes de poder utilizar un array hay que declararlo, como Java trata este tipo como un objeto, el array en este caso no reserva memoria para contener los datos, sino que solamente localiza memoria para almacenar una referencia al array, por ejemplo cuando se pasa una matriz a un metodo, sólo se pasa la referencia y no todos los elementos de la matriz.
En este ejemplo he creado un array unidimensional del tipo int que nos permite almacenar diez enteros, pero tambien pueden ser bidimensionales...
int miDato[] = new int[5];
Podriamos inicializar el array de la siguiente manera:
int miDato[] ={5,9,4,2,7};
String misdatos[] = new String[4];
int misdatos[][] = new int[20][10];
Y para acceder al tercer elemento utilizariamos los indices en este caso seria la posicion elemento -1, pues Java considera el indice del primer elemento como 0.
misDatos[] = {"uno","dos","tres","cuatro");
misDatos[1] = "dos"
misDatos[0] = "uno"
....
Resaltar que todos los objetos array disponen de un metodo publico "lenght()" que se utiliza para determinar su tamaño.
int array[][] = new int[5][2];
array.length; //= 5
array[0].length; //= 2
Ver ejemplo matrices.java
Tipos de datos string (las cadenas)
En realidad una variable de tipo string, más que un típo propio de Java es una clase tratada con todo rigor como un objeto más de Java.
En Java el contenido de las cadenas no se pueden modificar aun que se vuelva a definir la variable String, si en un programa se necesita modificar el contenido de una cadena lo más correcto seria utilizar la clase StringBuffer, la cual posee muchos metodos para este cometido como append() etc..
En este ejemplo definimos una cadena:
String miCadena = "Esto es una cadena";
No podemos modificar su contenido pero si podemos hacer que miCadena se refiera a otra cadena nueva:
miCadena = miCadena + "otra cadena";
En este ejemplo muestra el hecho de que una cadena no puede ser modificada, y sin embargo una variable de referencia puede modificarse para que apunte a una nueva cadena para que parezca que se ha modificado la cadena original:
class miCadena{
String cadena1 = "PRIMERA CADENA";
String cadena2 = "SEGUNDA CADENA";
public static void main( String args[] ) {
miCadena cad = new miCadena();
System.out.println( "Los valores originales de las cadenas son:" );
System.out.println( cad.cadena1 );
System.out.println( cad.cadena2 );
System.out.println( "Reemplaza cadena1 con otra cadena" );
cad.cadena1 = cad.cadena1 + " " + cad.cadena2;
System.out.println( "Nuevo valor de cadena1:" );
System.out.println( cad.cadena1 );
}
}
Nombres de Variables
Un programa se refiere al valor de una variable por su nombre. Por convención, en Java, los nombres de las variables empiezan con una letra minúscula (los nombres de las clases empiezan con una letra mayúscula).
Todas los nombres de variables de instancia o de clase deben estar constituidos por palabras con la primera letra de la primera palabra en minúscula y la primera letra de las palabras internas en mayúscula.Los nombres de variables deben ser cortos y significativos. La elección de un nombre de variable debe ser mnemotécnico, es decir, pensado para que un lector casual al verla comprenda su uso. Se deben evitar las variables de una sola letra, excepto en variables temporales de corto uso. Nombres comunes para este tipo de variables son: i, j, k, m y n para enteros; c, d, y e para caracteres.
char c;
Double myMedida;
int j,k;
| |
