Hoy he tenido que recurrir a la biblioteca a retirar algun librito que me permita poder estudiar java mas profundamente, porque la verdad este asunto de la certificacion está muy complicado, son tantos los detalles que como programadores se nos escapan que el tema es bastante serio … jajaja te reirás de mi pero ponte a hacer alguna que otra pregunta de certificacion y mas de alguna te dejará pillo, bueno que mas dá, el tema es que he tenido que volver a repasar desde lo mas básico como lo son las variables, y es por ello el siguiente post … siento latearlos con tanto java, pero creo que estaré hablando de esto por lo menos un mes y medio mas, vamos al grano mejor.
VARIABLES
Las variables son espacios de memoria donde almacenar datos que son manipulados por el programa durante su ejecución, por ende los datos que hay en ellas pueden ir variando en el transcurso de tiempo y es por ello el nombre que llevan.
Para clasificar las variables tenemos dos categorías, variables primitivas y variables de instancia, las cuales serán explicadas a continuación:
a) variables primitivas: Las variables primitivas son aquellas que podemos encontrar en cualquier otro lenguaje de programación y su objetivo es almacenar un dato simple, a su vez están deben estar declaradas con anticipación.
b) variables de instancia: Las variables de instancia son todas aquellas que hacen referencia a un objeto de una clase, estas tienen una complejidad mas grande que las variables primitivas puesto que su comportamiento puede variar dependiendo de lo que permita realizar con ellas.
A continuación se explicará todo lo que concierne a las variables primitivas, puesto que las variables de instancia abarca mucho mas que a un capitulo.
Variables ordinales o enteros
Los números ordinales son aquellos que nos permiten contar cosas, osea asignarles un numero de orden, en la siguiente tabla se describe los tipos de variables que permiten identificar este tipo de números.
+---------------------------------------------------------+ | Tipo | Byetes | Nombre | Rango de Valores | + --------------------------------------------------------+ | byte | 1 | byte | -128 a 127 | | short | 2 | entero corto | -32768 a 32767 | | int | 4 | entero | -2^31 a 2^31-1 | | long | 8 | entero largo | -2^63 a 2^63-1 | +---------------------------------------------------------+
A continuación se muestra un programa donde se declaran y asignan valores a las variables primitivas correspondientes a números enteros u ordinales en java.
public class Asigna{
public static void main(String [] args){
byte mini;
short enteroCorto;
int entero;
long enteroLargo;
mini = (byte)87; // no es necesario el casting
enteroCorto = 23000;
entero = 2300000;
enteroLargo = 109999915;
System.out.println(“Entero mini: “+mini);
System.out.println(“Entero corto: “+enteroCorto);
System.out.println(“Entero Normal: “+entero);
System.out.println(“Entero Largo: “+enteroLargo);
}
}
Mostrando como salida lo siguiente:
bastian@Error-5500:~$ java Asigna
Entero mini: 87
Entero corto: 23000
Entero Normal: 2300000
Entero Largo: 109999915
Variables de números reales
Los datos de números reales son todos aquellos que poseen decimales como por ejemplo 123.45E+12 que significa que su valor es 123.45 multiplicado por 10 elevado a 12 (ya que los números reales están almacenados en potencias de 10).
La siguiente tabla muestra la lista de tipos de variables reales
+----------------------------------------------------------------------------+ | Tipo | Byetes | Nombre | Rango de Valores | + ---------------------------------------------------------------------------+ | float | 4 | real simple precisión | -3.4X10^38 a -1.4X10^-45 | | | | | 1.4^-45X10^-45 a 3.4X10^38 | | double | 8 | real doble precisión | -1.8X10^308 a -4.9X10^-324 | | | | |4.9X10^-324 a 1.8X10^308 | + ---------------------------------------------------------------------------+
A continuación se presenta un programa que muestra como usar las variables de reales o de coma flotante.
public class AsignaReales{
public static void main(String [] args){
float interes;
double capital;
interes = 6.2F;
capital = 3.7E+9D;
System.out.println(“Interés = “+interes);
System.out.println(“Capital = “+capital);
}
}
Dando como salida lo siguiente:
bastian@Error-5500:~$ java AsignaReales
Interés = 6.2
Capital = 3.7E9
Variables boolean y char
Finalmente, completando la lista de tipos de variables primitivas estas son las variables boolean (logicas) y las variables char (caracteres). Las variables boolean pueden contener solo 2 valores true o false y utilizan para su almacenamiento un bit. En java no se pueden interpretar las variables enteras ni de ningún tipo como tipo boolean y viceversa.
En cuanto a las variables char utilizan 16 bits y codifican caracteres según el formato unicode
La siguiente tabla muestra algunos de los caracteres especiales mas utilizados.
+--------------------------------------------------+ | Caracter | Denominación | + -------------------------------------------------+ | '\n' | salto de linea | | '\t' | tabulador | | '\r' | retorno del carro | | '\'' | comillas simples | | '\\' | contra-barra (backslash) | | '\"' | doble comillas | | '\xxx' | caracter en octal | | '' | caracter nulo (null) | | '\uxxxx' | caracter en hexadecimal unicode | + -------------------------------------------------+
A continuación se mostrará un ejemplo de como declarar y asignar valores a variables boolean y de tipo char.
public class AsignaOtras{
public static void main(String [] args){
boolean esCierto;
char letra;
esCierto = false;
letra = ‘a’;
System.out.println(“Es cierto = “+esCierto);
System.out.println(“Letra = “+letra);
letra = ‘\r’;
System.out.println(“Este texto\n se ve en \ntres lineas”);
}
}
y su salida seria la siguiente:
bastian@Error-5500:~$ java AsignaOtras
Es cierto = false
Letra = a
Este texto
se ve en
tres lineas
continuará …
by AngerRising
