Variables, Constructores, Mtodos y Comentarios en java

Objetos y Primitivos.
Al disear sus primeros programas en Java, pudo notar que todo gira alrededor de instancias de Objetos que son
manipuladas a travs de referencias:
Lampara candil = new Lampara();
candil.prender();

Al utilizar referencias en Java estas pueden ser inicializadas sin que pertenezcan a ninguna instancia de Objeto:
String let;

La declaracin anterior genera una referencia, sin embargo, esta no es asociada con ninguna instancia de
Objeto, para llevar acabo este proceso es necesario utilizar el vocablo new.

String let = new String("Algo sencillo")

La declaracin anterior no solo genera una instancia nueva de la Clase String, sino le asigna un valor inicial
("Algo sencillo") el cual es asignado a la referencia let; este mecanismo de agregar valores al generar una
instancia es llevada acabo a travs de mtodos denominados constructores los cuales sern descritos
posteriormente.
El hecho de generar instancias de objetos es un proceso involucrado ( hablando en trminos computacionales
mas no en sintaxis ) , es por esto que Java ofrece un mecanismo simplstico para definir estructuras de datos
como alternativa a utilizar Clases/Objetos, dichas estructuras son conocidas como primitivos.
Aunque estrictamente hablando un primitivo no es una clase a travs de un primitivo se facilita el uso de
valores comnmente utilizados en lenguajes de programacin, donde el generar una instancia de Clase
resultara en un proceso tardado y mecnico. En la siguiente tabla se describen los diversos primitivos
disponibles en el lenguaje Java:
Tipo de Primitivo Tamao Valor Mnimo Valor Mximo Valor Default "Wrapper"
boolean
false
Boolean
16
char
16-bit
Unicode 0
Unicode 2 - 1 `\u0000' (null) Character
byte
8-bit
-128
+127
(byte) 0
Byte
15
15
short
16-bit
-2
+2 -1
(short) 0
Short
int
32-bit
-231
+231-1
0
Integer
long
64-bit
-263
+263-1
0L
Long
float
32-bit
IEEE754
IEEE754
0.0f
Float
double
64-bit
IEEE754
IEEE754
0.0d
Double
void
Void
Ntese que estos primitivos inician con letra minscula, en la tabla anterior se describen los rangos de dichos
primitivos as como sus respectivos "Wrappers"; estos "Wrappers" son Clases utilizadas como contra parte de
primitivos:

char c = 'x';
Character C = new Character(c);

La primer linea genera un primitivo el cual es asignado a la variable c, posteriormente se genera una instancia
de la Clase Character (Ntese el uso del vocablo new); el uso de "Wrappers" (Objetos) para primitivos es
empleado bajo ciertas circunstancias, sin embargo, vale mencionar que existen diversos mecanismos para
convertir de Clases tipo Objeto ("Wrappers") a primitivos y viceversa, a continuacin se describen los
mecanismos para realizar este tipo de conversiones :

Uso de "Wrappers" y primitivos en Java .

El uso prctico para emplear "Wrappers" y/o primitivos ser explorado en una futura seccin de este curso.
Cdigo Fuente Capsulas.java

public class Capsulas {

public static void main(String[] args) {

// Inicializar Primitivos
int i1 = 12;
int i2 = 300;
long l1 = 200L; // sufijo para primitivo long
long l2 = 200l; // sufijo para primitivo long
long l3 = 200;
float f1 = 1e-39F; // sufijo para primitivo float
float f2 = 1e+11f; // sufijo para primitivo float
float f3 = 1;
double d1 = 32e46d; // sufijo para primitivo double
double d2 = 14D; // sufijo para primitivo double
double d3 = 1;
// Inicializar "Wrappers" con primitivos
Integer wi1 = new Integer(i1);
Long wl1 = new Long(l1);
Float wf1 = new Float(f1);
Double wd1 = new Double(d1);

// Convertir/Imprimir Valores de "Wrappers" como double (primitivo)

prt(wi1.doubleValue());
prt(wl1.doubleValue());
prt(wf1.doubleValue());
prt(wd1.doubleValue());
// Convertir/Imprimir Valores de "Wrappers" como float (primitivo)
prt(wi1.floatValue());
prt(wl1.floatValue());
prt(wf1.floatValue());
prt(wd1.floatValue());
// Convertir/Imprimir Valores de "Wrappers" como long (primitivo)
prt(wi1.longValue());
prt(wl1.longValue());
prt(wf1.longValue());
prt(wd1.longValue());

// Convertir/Imprimir Valores de "Wrappers" como integer (primitivo)

prt(wi1.intValue());
prt(wl1.intValue());
prt(wf1.intValue());
prt(wd1.intValue());
// Inicializar "String's" con valores numericos
String str1 = "7";
String str2 = "57";
String str3 = "3.23";
String str4 = "797.43";

// Inicializar "Wrappers" con "String's"

Integer wi2 = new Integer(str1);
Long wl2 = new Long(str2);
Float wf2 = new Float(str3);
Double wd2 = new Double(str4);
// Imprimir Valores
prt(wi2);
prt(wl2);
prt(wf2);
prt(wd2);
// Convertir/Imprimir Valores de "Wrappers" como String's
prt(wi2.toString());
prt(wl2.toString());
prt(wf2.toString());
prt(wd2.toString());
// Inicializar "Wrappers" con primitivos
Integer wi3 = new Integer(0);
Long wl3 = new Long(0);
Float wf3 = new Float(0);
Double wd3 = new Double(0);
// Convertir/Imprimir Valores de "Wrappers" a travs de "String's"
// a su respectivo primitivo
prt(wi3.parseInt(str1));
prt(wl3.parseLong(str2));
prt(wf3.parseFloat(str3));
prt(wd3.parseDouble(str4));
}
static void prt(String s) {
System.out.println("Un String con valor " + s);
}
static void prt(Integer i) {
System.out.println("Un Integer (\"Wrapper\") con valor " + i);
}
static void prt(Long l) {
System.out.println("Un Long (\"Wrapper\") con valor " + l);
}
static void prt(Float f) {
System.out.println("Un Float (\"Wrapper\") con valor " + f);
}
static void prt(Double d) {
System.out.println("Un Double (\"Wrapper\") con valor " + d);
}
static void prt(int i) {

System.out.println("Un int (primitivo) con valor " + i);

}
static void prt(long l) {
System.out.println("Un long (primitivo) con valor " + l);
}
static void prt(float f) {
System.out.println("Un float (primitivo) con valor " + f);
}
static void prt(double d) {
System.out.println("Un double (primitivo) con valor " + d);
}
}

Clase Capsulas

Como en todo programa Java , primeramente se define la Clase a travs del vocablo class.
Se define el mtodo principal main y dentro de ste se generan diversos campos ("fields"), ntese que en
algunas declaraciones se emplea un sufijo para definir el valor del primitivo (L,l,F,f,D,d), lo anterior
se hace con la finalidad de asignar un espacio apropiado para futuras manipulaciones numricas.
Uso de Sufijos

Aunque el uso de sufijos no es obligatorio, su uso se hace ms evidente cuando los primitivos son empleados
para realizar operaciones matemticas con mayor precisin.
Tomemos un nmero definido como 14D, aunque el nmero catorce bien pudiera ser un entero (int) ste se esta
definiendo como un nmero double a travs del sufijo, esto permite que el nmero sea manipulado con otros
primitivos double sin perder precisin, esta prdida de precisin ser ilustrada a continuacin.