Operadores Condicionales

Generalmente los operadores condicionales se usan en combinación con los operadores ralacionales para determinar si una condición es true o false. Los tres operadores condicionales se listan a continuación:

&&: el operador && (AND) se usa para determinar si las condiciones a ambos lados del operador resultan en true o false. Primero se evalúa el resultado de la condición a la izquierda del operando, si resulta en true, entonces el resultado de la condición a la derecha del operador es evaluado. Si ambas condiciones resultan en true, entonces esta operación también resulta en true. Si la condición a la izquierda del operador resulta en false, la condición a la derecha del operador no es evaluada, y la operación completa resulta en false. La siguiente expresión ilustra el uso de este operador:

(a < b) && (b < c)

||: El operador || (OR) se usa para determinar si al menos uno de las dos condiciones en alguno de los lados de este operador es true. Si la condición a la izquierda de este operador resulta en false, entonces la condición a la derecha es evaluada, si esta última condición resulta en true, entonces el resultado de la operación es true. Si la condición a la izquierda de este operador es true, entonces la condición a la derecha no es evaluada, y el resultado de la operación es true. La siguiente expresión ilustra el uso de este operador:

(a < b) || (b < c)

!: El operador ! (NOT) se usa para negar el resultado obtenido en una operación. Si el resultado de una operación es true, entonces el resultado de esta operación después de aplicar el operador ! Es false, y al contrario, el caso que la operación es false, la operación completa es true. La siguiente expresión ilustra el uso del operador NOT:

!(a < b)

He aquí un programa que demuestra el operador &&. El programa determina si el valor de d es un factor de n. Lo hace al realizar una operación de módulo. Si el sobrante de n/d es cero, entonces d es un factor. Sin embargo, como la operación de módulo incluye una división, la forma del operador condicional de && se usa para evitar un error de división entre cero.

// Demuestra los operadores Condicionales

class CCops{

public static void main(String args[]) {

int n, d, q;

n = 10;

d = 2;

if(d != 0 && (n % d) == 0)

System.out.println(d +” es un factor de “ + n);

d = 0; //ahora, fijamos d en cero

// Como d es cero, el segundo operando no se evalúa.

if(d != 0 (n % d) == 0)

System.out.println(d + “ es una factor de “ + n);

}

}

[ Seguir leyendo ]

Operadores Relacionales

Los operadores relacionales se usan para comparar dos valores almacenados en variables. Los diferentes operadores relacionales se listan a continuación:

<: El operador menor que < se usa para determinar si el valor almacenado en una variable es menor que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a < b

>: El operador mayor que > se usa para determinar si el valor almacenado en una variable es mayor que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a > b

<=: El operador menor o igual que <= su usa para determinar si el valor almacenado en una variable es menor o igual que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a <= b

>=: El operador mayor o igual que >= se usa para determinar si el valor almacenado en una variable es mayor o igual que el valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a >= b

==: El operador de igualdad == se usa para determinar si el valor almacenado en una variable es igual al valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a == b

!=: El operador de no igual != se usa para determinar si el valor almacenado en una variable es diferente al valor almacenado en otra variable. Cuando esta condición se satisface, el resultado de esta operación es “true”, caso contrario el resultado es “false”. La siguiente expresión ilustra el uso de este operador:

a != b

Tómese como ejemplo, dos números, 35 y 65, y determine que sucede cuando se usan los diferentes operadores relacionales en ellos:

• 35 < 65 resulta en true
• 35 > 65 resulta en false
• 35 <= 65 resulta en true
• 35 >= 65 resulta en false
• 35 == 65 resulta en false
• 35 != 65 resulta en true

En Java es posible comparar todos los objetos para saber si son iguales o no empleando == y !=. Sin embargo, los operadores de comparación <, >, <= o >= sólo pueden aplicarse a los tipos que soportan una relación de orden. Por lo tanto, todos los operadores relacionales pueden aplicarse a todos los tipos numéricos y a tipos char. Sin embargo, los valores de tipo boolean sólo pueden compararse para igualdad o desigualdad porque los valores “true” y “false” no están ordenados. Por ejemplo, true > false no tiene significado en Java.

[ Seguir leyendo ]

Operadores Aritméticos

Java define los siguientes operadores aritméticos:

Operador: Significado

+ Suma

- Resta

* Multiplicación

/ División

% Módulo

++ Incremento

– Decremento

Los operadores +, -, * y / funcionan de la misma manera en Java que en cualquier otro lenguaje de cómputo (o el álgebra, si ese es el caso). Estos operadores pueden aplicarse a cualquier tipo numérico de datos y usarse en objetos de tipo char.

Aunque las acciones de los operadores aritméticos le resultan familiares a todos los lectores, existen unas cuantas situaciones especiales que requieren cierta explicación. En primer lugar, recuerde que cuando / se aplica a un entero, cualquier resto se truncará: por ejemplo, 10/3 será igual a 3 en una división entre enteros. Para obtener la fracción de la división debe usar el operador de módulo %. Este operador funciona de la misma forma en Java que en otros lenguajes: presenta el sobrante de una división entre enteros como, por ejemplo, 10%3 es 1. en Java, el % puede aplicarse a tipos enteros y punto flotante. Por lo tanto, 10.0 % 3.0 también es 1. El siguiente programa demuestra el operador de módulo.

//Demuestra el operador %.

class ModDemo {

public static void main(String args[]) {

int iresult, irest;

double dresult, drest;

iresult = 10 / 3;

irest = 10 % 3;

dresult = 10.0 / 3.0;

dresult = 10.0 % 3.0;

System.out.println(“Resultado y sobrante de 10 / 3: “ + iresult + “ “ + irest);

System.out.println(“Resultado y sobrante de 10.0 / 3.0: “ + dresult + “ “ + drest);

}

}

A continuación se muestra la salida del programa:

Resultado y sobrante de 10 / 3: 3 1

resultado y sobrante de 10.0 / 3.0: 3.33333333333333 1.0

Como verá, % presenta un sobrante 1 para ambas operaciones, de entero o de punto flotante.

Incremento y decremento

++ y – son los operadores de incremento y decremento en Java. Como verá, tienen algunas propiedades especiales que los hacen interesantes. Empecemos por revisar de manera precisa las acciones que los operadores de incremento y decremento llevan a cabo.

El operador de incremento agrega 1 a su operando y el de decremento resta 1. De ahí que,

x = x + 1;

es lo mismo que

x++;

y

x = x – 1;

es lo mismo que

--x;

Ambos operadores pueden preceder (prefijo) o seguir (sufijo) al operando. Por ejemplo,

x = x + 1;

puede escribirse como

++x; // forma de prefijo

o como

x++; // forma de sufijo

En el siguiente ejemplo, el que el incremento se aplique como prefijo o como sufijo no representa ninguna diferencia. Sin embargo, se presenta una diferencia importante cuando se usa un incremento o decremento como parte de una expresión más larga, cuando un operador de incremento o decremento precede a su operando, Java realiza la operación correspondiente antes de obtener el valor del operando con el fin de que el resto de la expresión use dicho valor. Si el operador sigue a su operando, Java obtendrá el valor del operando antes de incrementarlo o decrementarlo. Tome en cuenta lo siguiente:

x = 10;

y = ++x;

En este caso, y será 11. Sin embargo, si el código se escribe como:

x = 10;

y = x++;

entonces y será 10. en ambos casos, x aún tendrá un valor de 11; la diferencia es el momento en que ocurre. Tener la capacidad de controlar el momento en que la operación de incremento o decremento tiene lugar implica ventajas importantes.

[ Seguir leyendo ]

Operadores en Java

Cuando se escribe un programa, se usan numerosas expresiones para calcular algunos valores específicos. Estas expresiones hacen uso de varios operadores y son similares a expresiones aritméticas que usan muchos operadores. Las variables usadas en estas expresiones se llaman operandos. Existen algunos operadores que solo necesitan un operando, son llamados operadores unarios (ejemplo: ++). Los operadores que requieren dos operandos se llaman operadores binarios (por ejemplo, +), y los operadores que requieren tres operandos se llaman operadores ternarios (ejemplo: ,?:).

Java soporta los siguientes tipos de operadores:

• 
  
  Operadores aritméticos.
• 
  
  Operadores relacionales.
• 
  
  Operadores condicionales.
• 
  
  Operadores Ternarios.
• 
  
  Operadores de bits.
• 
  
  Operadores de Asignación.

[ Seguir leyendo ]

El Alcance y la Vida de las Variables

Hasta ahora, todas la variables que hemos usado se declararon al principio del método main(). Sin embargo, Java permite que las variables se declaren dentro de cualquier bloque. El inicio de un bloque se marca con un carácter '{', y el fin del bloque, con el correspondiente carácter '}'. Un bloque puede contener otro bloque (o cualquier número de bloques) dentro de él, estos se denominan bloques anidados. Un bloque define el alcance; por lo tanto, cada vez que inicia un nuevo bloque, está creando un nuevo alcance. Un alcance determina cuáles objetos son visibles a otras partes de su programa. Así mismo, determina la vida de dichos objetos.

Casi todos los demás lenguajes de cómputo definen dos categorías generales de alcance: global y local. Aunque están soportadas por Java, no constituyen las mejores formas de categorizar los alcances de Java. Los alcances más importantes son los definidos por una clase y los definidos por un método.

El alcance definido por un método inicia con su llave de apertura. Sin embargo, si dicho método contiene parámetros, éstos se incluyen también dentro de su alcance.

Como regla general, las variables que están declaradas dentro de un alcance no son visibles (es decir, accesibles) a un código que esté definido fuera de este alcance. Por lo tanto, cuando declara una variable dentro del un alcance, localiza esa variable y la protege de acceso no autorizado, de modificación o de ambas posibilidades. Por supuesto, las reglas de alcance proporcionan la base del encapsulamiento.

Así mismo, los alcances pueden están anidados. Por ejemplo, cada vez crea un bloque de código, crea un nuevo alcance anidado. Cuando esto ocurre, el alcance exterior encierra al interior. Esto significa que los objetos declarados en el alcance exterior se volverán visibles al código dentro del alcance interno. Sin embargo, la situación contraria no aplica: los objetos declarados dentro del alcance interior no serán visibles fuera de él.

Para comprender el efecto del los alcances anidados, considere el siguiente programa:

// Demuestra el alcance del bloque.

class AlcanceDemo {

public static void main(String args[]) {

int x; // conocido a todo el código en main

x = 10;

if (x == 10) { //inicia nuevo alcance

int c = 20; //conocido sólo a este bloque

// x y c son conocidos aquí.

System.out.println(“ x y c : “+ x +” “+ c);

x= c * 2;

}

c = 100 // Error. A c no se le conoce aquí, está fuera de su alcance.

// x es aún conocido aquí.

System.out.pritnln(“x es “ + x);

}

}

Como lo indica el comentario, la variable x se declara al principio del alcance de main() y es accesible a todo el código posterior dentro de main(). Dentro del bloque if, está declarada c. Debido a que un bloque define un alcance, c sólo es visible dentro del código de su bloque. Por tal motivo, fuera de su bloque, la línea c = 100; hará que ocurra un error en tiempo de ejecución porque c no es visible fuera de su bloque. Dentro del bloque if, x puede usarse porque el código dentro del bloque (es decir, un alcance anidado) tiene acceso a variables declaradas por un alcance incluido.

Dentro de un bloque, las variables pueden declararse en cualquier punto; sin embargo, sólo son válidas después de ser declaradas. De manera que, si define una variable al inicio de un método, ésta estará disponible para todo el código dentro del método . Por el contrario, si declara un variable al final de un bloque, ésta carecerá de uso porque ningún código tendrá acceso a ella.

A este respecto, hay que recordar otro elemento: las variables se crean cuando se introduce su alcance y se destruye cuando se abandona su alcance. Esto significa que una variable no contendrá su valor una vez que se haya salido de sus alcance. Por lo tanto, las variables declaradas dentro de un bloque perderán su valor cuando se abandone el bloque. Así, la vida de una variable está confinada a su alcance.

[ Seguir leyendo ]

Declaración e Inicialización de Variables

Java es un lenguaje fuertemente tipificado, es decir, toda variable debe tener un tipo de dato asociado. Esto ayuda a saber el tipo de dato almacenado dentro de la variable o el tipo de dato que necesita ser almacenado dentro de la variable. Las variables se declaran usando esta forma de instrucción:

tipo nombre-var;

Donde tipo es el tipo de datos de la variable y nombre-var es el nombre de la variable. Puede declarar una variable de cualquier tipo válido. Cuando crea una variable, está creando una instancia de su tipo. Por lo tanto, las capacidades de una variable están determinadas por su tipo. Por ejemplo, una variable de tipo boolean no puede utilizarse para almacenar valores de punto flotante. Más aún, el tipo de una variable no puede cambiar durante su existencia. Una variable int no puede convertirse en un char, por ejemplo.

Todas las variables en Java deben declararse antes de ser utilizadas. Esto es necesario porque el compilador debe saber qué tipo de datos contiene una variable antes de poder compilar apropiadamente cualquier instrucción que emplee la variable. También le permite a Java realizar una revisión estricta del tipo.

Inicialización de una variable

En general, debe proporcionar a una variable un valor antes de usarla. Una manera de hacerlo es mediante una instrucción de asignación, como ya lo ha visto. Otra manera consiste en proporcionarle un valor inicial cuando se declara. Para ello, coloque un signo de igual después del nombre de la variable y luego incluya el valor asignado. Aquí se muestra la forma general de inicialización:

tipo var = valor;

En este caso, valor es el valor que se le da a var cuando se crea. El valor debe ser compatible con el tipo especificado. He aquí algunos ejemplos:

int cuenta = 10; // proporciona a cuenta un valor inicial de 10

char ch = 'X'; // inicializa ch con la letra X

float f = 1.2F; // f se inicializa con 1.2

Cuando se declaran dos o más variables del mismo tipo empleado una lista separada por comas puede dar a una o más de estas variables un valor inicial. Por ejemplo:

int a, b = 8, c = 19, d; // b y c tienen inicializaciones

En este caso, sólo b y c están inicializadas.

Inicialización dinámica

Aunque en los ejemplos anteriores sólo se han usado constantes como inicializadores, Java permite que las variables se inicialicen dinámicamente empelando cualquier expresión válida en el momento en que se declara la variable. Por ejemplo, he aquí un programa corto que calcula el volumen de un cilindro dados el radio de su base y su altura.

// Demuestra la inicialización dinámica.

class InicDin{

public static void main(String args[]) {

double radio = 4, altura = 5;

// inicializa dinámicamente el volumen

double volumen = 3.1416 * radio * radio * altura:

System.out.println(“El volumen es “ + volumen);

}

}

En este caso, están declaradas tres variables locales (radio, altura y volumen). Las primeras dos (radio y altura) están inicializadas. Sin embargo, volumen está inicializada dinámicamente al volumen del cilindro. La clave aquí es que la expresión de inicialización puede ser cualquier elemento válido en el tiempo de la inicialización, incluidas llamadas a métodos, así como otras variables o literales.

[ Seguir leyendo ]

Identificadores (variables)

Cuando se escribe un programa se necesita almacenar los valores usados en el programa. Estos valores se almacenan en la memoria, se necesita tener un método simple para acceder a estas posiciones en la memoria. Por esto se usa un identificador o variable para referirnos a estas posiciones en memoria.

Convenciones de Nombres

Hay algunas reglas que tienen que seguirse al momento de nombrar variables en Java. Estas son:

• Los nombres de variables deben comenzar con una letra, subrayado (_) o dólar($). Sin embargo, no hay restricción en el número de letras que se pueden usar.
• Los nombres de variables pueden contener letras, números, el subrayado (_) y el carácter dólar ($).
• No debe haber espacio entre los caracteres.
• No hay límite de longitud del nombre de la variable.
• Las palabras clave de Java no pueden usarse como nombres de variables.
• Para una mejor legibilidad, los nombres de variables deben componerse de dos o más palabras significativas. La primera letra de la variable será siempre en minúsculas y las primeras letras de las palabras subsecuentes en mayúsculas (Ejemplo: numeroCuenta).
• En el caso de nombres de clase, todas las palabras que son parte del nombre de la clase deben comenzar con una letra mayúscula (Ejemplo: StringBuffer).

[ Seguir leyendo ]

Manejo de String

El manejo de cadenas de caracteres (string) en Java se hace usando las clases String o StringBuffer, ambas clases se usan para almacenar y manipular cadenas de caracteres. Sin embargo, hay una diferencia principal entre estas dos clases en la forma en la que son manejados por el sistema de tiempo de ejecución de Java.

La Clase String

El literal string se usa para almacenar valores string (cadena de caracteres). La clase String se usa para denotar un literal string. Se puede especificar strings al cerrar el texto dentro de comillas dobles, es importante notar la diferencia entre comillas simples y dobles: 'z' no es equivalente a “z”. La primera es el carácter z, la segunda es una cadena de caracteres (string) de una carácter. El siguiente código muestra la declaración de una variable String.

String str = “Hola”;

El fin de una cadena de caracteres es usualmente indicado por '\0'.

La clase String es inmutable, lo que significa que su valor no puede ser cambiado una vez que se crea un objeto del tipo String.

• Se pueden usar métodos definidos en la clase String para hacer lo siguiente:
• Examinar los diferentes caracteres que componen una cadena de caracteres.
• Buscar una sub-vadena dentro de una cadena de caracteres.
• Comparar dos cadenas de caracteres.
• Crear otra cadena de caracteres que tengan todos los caracteres de la primera cadena de caracteres en mayúsculas o minúsculas.

Dos cadenas de caracteres pueden ser concatenadas usando el operador “+”. Como String es inmutable, esta concatenación es actualmente implementada usando internamente la clase StringBuffer por Java.

String uno = “abcde”;

String dos = “fhgij”;

String tres;

tres = uno + dos;

System.out.println(tres);

El objeto tres es creado y tiene el valor abcdefghij.

La clase StringBuffer

La clase StringBuffer es similar a la clase String y se usa para denotar a un literal string. Sin embargo, StringBuffer es mutable, a diferencia de la clase String. Esto significa que los valores almacenados por objetos de esta clase pueden ser cambiados. StringBuffer juega un rol vital en la concatenación de cadenas de caracteres, actualmente se implementa a través de la creación de objetos StringBuffer, y luego se usa el método append() sobre los obejtos creados. Esto es una alternativa mejor que usar el operador “+” sobre dos objetos String.

Los objetos StringBuffer se pueden usar en aplicaciones multihilos, ya que los métodos que operan en estos objetos pueden ser sincronizados para evitar la ocurrencia del interbloqueo.

La clase StringBuilder

Esta clase proporciona un API compatible de StringBuffer, pero no se garantiza su bajo escenarios de sincronización. Fue diseñada para usarla como el reemplazo de StringBuffer en donde el stringsea utilizado por un solo hilo (generalmente es el caso). En lo posible, se recomienda que esta clase sea utilizada preferiblemente en lugar de StringBuffer pues será más rápida en la mayoría de los casos.

Las operaciones principales de StringBuilder son los métodos append e insert, cuando son sobrecargados para aceptar datos de cuallquier tipo. Cada uno convierte con eficacia un dato dado a un string y añade o inserta los caracteres de ese string al string en construcción. El método append agrega siempre estos caracteres al final de la secuencia de caracteres en construcción; el método insert agrega los caracteres en un punto especificado.

Por ejemplo, si x se refiere a un objeto StringBuilder que contiene “lava”, después de la llamada x.append(“manos”) del método haría que la secuencia construida contenga “lavamanos”, mientras que x.insert(4,”nos”) alteraría la construcción de la secuencia para contener “lavanosmanos”.

Las instancias StringBuilder no son seguras para el uso con múltiples hilos. Si se necesita o requiere la sincronización entonces se recomienda que StringBuffer sea utilizado.

Diferencias entre String, StringBuilder y StringBuffer

String es inmutable mientras que StringBuffer y StringBuilder pueden cambiar sus valores.

La única diferencia entre StringBuffer y StringBuilder es que StringBuilder es asíncrono mientras que StringBuffer es síncrono. Por lo tanto cuando una aplicación necesita funcionar solamente con un hilo entonces es mejor utilizar StringBuilder. StringBuilder es más eficiente que StringBuffer.

Criterios para elegir entre String, StringBuffer y StringBuilder:

• Si el texto no va a cambiar usar la clase String porque un objeto String es inmutable.
• Si el texto puede cambiar y es accedido solamente por un hilo, utilizar un StringBuilder porque StringBuilder no es síncrono.
• Si el texto puede cambiar, y es accedido por múltiples hilos, utilizar un StringBuffer porque StringBuffer es síncrono.

[ Seguir leyendo ]

Math Clases Colaboradoras sobre los Tipos de Datos

Math Clases Colaboradoras sobre los Tipos de Datos

Existen otras dos clases en Java, una de ellas se ocupa de los enteros de precisión arbitraria inmutables, y la otra de números decimales con signo de precisión arbitraria inmutables. La primera está representada por java.math.BigInteger y la segunda clase por java.math.BigDecimal. Dado, que ambas clases tratan también con números en Java, se va a discutir acerca de ellas brevemente.

Los tipos primitivos enteros de Java no pueden efectuar operaciones sobre números largos, por esto Java provee un paquete llamado Math, que tiene dos clases, son estas: BigInteger y BigDecimal, para realizar operaciones matemáticas sobre números largos.

La Clase java.math.BigInteger

Esta clase provee la abstracción de enteros de un “tamaño de palabras infinito” representados por el tipo de datos int. Esta clase es inmutable, lo que significa que el valor representado por esta clase no puede cambiar; representa enteros de precisión arbitraria. BigInteger se representa usando la forma de complemento dos, como en el caso del tipo de dato primitivo int. Todos los operadores que se pueden usar con el tipo de dato primitivo entero tienen operadores análogos que se pueden usar con BigInteger. Usando BigInteger,se pueden realizar manipuaciones de bits, verificar si un número es primo,generar un número primo, calcular el Máximo Común Divisor, etc.

La Clase java.math.BigDecimal

Esta clase se usa para representar dígitos a la derecha del punto decimal en una escala deun entero de 32-bit.BigDecimal usa un valor sin escala que es entero de precisión arbitraria. Esta clase provee métodos que permiten realizar operaciones aritméticas básicas y manipulaciones de escala, también ayuda a comparar dos valores BigDecimal y a convertir el formato de los valores BigDecimal. La clase BigDecimal también permite especificar el comportamiento del redondeo para los valores decimales proporcionando ocho modos de redondeo.

[ Seguir leyendo ]

Uso de las clases envolventes en Java

 Uso de las clases envolventes en Java

El código que sigue usa varios métodos estáticos y métodos de instancia en las clases envolventes. El programa mostrará el uso de las clases envolventes para Integer y Float.

/*Definición de la clase EnvolventesEjemplo comienza aquí*/

public class EnvolventesEjemplo {

/*El método main comienza aquí */

public static void main(String args[]) {

Integer i = new Integer(5);

String s = “250.47”;

System.out.println(“Valor de i es: “

+ i.toString());

System.out.println(“Valor de s es: “

+ Float.parseFloat(s));

Float f = Float.valueOf(s);

float primitivoFloat = f.floatValue();

int primitivoInt = f.intValue();

System.out.println(“Valor del primitivo float es: “

+ primitivoFloat);

System.out.println(“Valor del primitivo int es: “

+ primitivoInt);

}/*El método main termina aquí */

}/*Definición de la clase EnvolventesEjemplo termina aquí */

La salida del código anterior es la siguiente:

Valor de i es: 5

Valor de s es: 250.47

Valor del primitivo float es: 250.47

Valor del primitivo int es: 250

[ Seguir leyendo ]

Clases Envolventes

Clases Envolventes

Java provee clases envolventes para cada uno de los de datos primitivos. Una clase envolvente da la funcionalidad de una clase para un tipo de datos primitivo. Estas clases envolventes tienen métodos que permiten manipular el tipo de dato primitivo correspondiente que ellos envuelven.

Los tipos de datos primitivos tienen conjuntos de operaciones que se pueden usar con ellos. Sin embargo, cuando se quiere proveer algunas funciones utilitarias para un tipo de dato en particular, se usan las clases envolventes y se proveen funciones primitivas dentro de las clases envolventes.

Hay ciertas clases, que vienen como parte de la librería de Java, que requieren de un objeto en vez de una variable de tipo de dato primitivo. Los objetos de las clases envolventes se pueden usar también para este propósito.

Java provee clases envolventes para todos los tipos de datos primitivos.

La Clase java.lang.Boolean

La clase Boolean es la representación en objeto del tipo de dato primitivo boolean. Esta clase, es una clase envolvente para el tipo primitivo boolean, por lo tanto, tiene un miembro del tipo boolean. También tiene ciertos métodos que se pueden usar para manipular el valor del boolean almacenado internamente.

La clase Boolean tiene el método booleanValue(), que retorna el valor del boolean que está envuelto en este objeto. También tiene los métodos equals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseBooleantiene el métodostatic valueOf()para convertir una representación de objetoStringen un valorBoolean.

La Clase java.lang.Byte

La claseBytees la representación en obejto del tipo de dato primitivobyte. Esta clase, por ser una clase envolvente para el tipo de dato primitivobyte, tiene un miembro del tipobyte. Esta clase tiene métodos que permiten obtener el valor delbytealmacenado en el objetoByteen la forma debyte, short, int, float o double. Esto se hace usando los siguientes métodos:

• 
  
  byteValue()
• 
  
  shortValue()
• 
  
  intValue()
• 
  
  floatValue()
• 
  
  doubleValue()

La claseBytetambién tiene métodos que son sobrescritos de la clasejava.lang.Object. Estos métodos son los siguientes:

• 
  
  equals()
• 
  
  toString()
• 
  
  hashCode()

Además de estos métodos, la clase Byte tiene el métodostatic valueOf()para convertir una representación de objetoStringen un valorbyte.

La Clase java.lang.Short

La claseShortes la representación en objeto del tipo de dato primitivoshort. Esta clase, por ser una clase envolvente para el tipo primitivoshort, tiene un miembro del tiposhort. Esta clase tiene métodos que permiten obtener el valor delshortalmacenado en el objetoShorten la forma debyte, short, int, float, odouble. Esto se hace usando los métodos:

• 
  
  byteValue()
• 
  
  shortValue()
• 
  
  intValue()
• 
  
  floatValue()
• 
  
  doubleValue()

La claseShorttambién tiene los métodosequals(),toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseShorttiene el métodostatic valueOf()para convertir una representación delobjetoStringen un valorShort.

La Clase java.lang.Character

la claseCharacteres la representación en objeto del tipo de dato primitivochar. La claseCharacter, al ser una clase envolvente, tiene un campo del tipo primitivochar. Se pueden usar los métodos provistos por esta clase para manipular variables que mantienen valores del tipo primitivochar. Algunas de las funciones importantes provistas por esta clase dan la posibilidad de determinar el tipo de carácter y convertir un carácter en minúscula a mayúscula y viceversa. Los métodos definidos en la claseCharacterestán basados en la tabla de atributos Unicode. Esta tabla asocia a cada código Unicode definido con un nombre. Los caracteres están encerrados dentro de comillas simples. Así, 'a' es el caráctera. Se pueden obtener caracateres especiales usando secuencias de escape. '\n' es la secuencia de escape para el carácter de nueva línea.

Se puede usar el métodocharValue()de esta clase para obtener el valorcharalmacenado por el objeto en la forma del tipo de dato primitivochar.

La Clase java.lang.Integer

La claseIntegeres la representación en objeto del tipo de dato primitivoint. Un objetoIntegertiene un campo, que es del tipo primitivoint. Es posible usar los métodos provistos por esta clase para manipular variables que mantienen valores del tipo primitivoint.

Algunas de las funciones más importantes provistas por esta clase son la posibilidad de convertir uninta unStringcon el métodotoString(), y de unStringa unintusando el métodoparseInt(String s). Cuando la encuentra valoresinten el código, los interpretará como enteros. Cuando se usa un número como2, la JVM asume que es de tipoint. Si se quiere que la JVM lo interprete como algo diferente a unint, se debe proveer información más específica. Si se quiere que la JVM “piense” que es del tipolong, se debe usar una “L” después del entero. Los otros tipos de datos enterosbyteyshortno pueden ser especificados. Estos serán convertidos al momento de la asignación de valores. Así, la sentenciabyte b = 120;convertirá 120 deintabyte, siempre y cuando el valor pertenezca al rango válido para unbyte.

Esta clase tiene métodos que permiten obtener el valor delintalmacenado en el objetoIntegeren la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue(), ydoubleValue()respectivamente.

La Clase java.lang.Long

La claseLonges la representación en objeto del tipo primitivolong. Esta clase, por ser una clase envolvente del tipo primitivolong, tiene un miembro del tipolong. Sta clase tiene métodos que permiten obtener el valor dellongalmacenado en el objetoLongen la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), longValue(), intValue(), floatValue()ydoubleValue()respectivamente. La claseLongtiene también los métodosequals(), toString()yhashCode()que son sobrescritos desde la clasejava.langObject.

La claseLongtiene un métodostatic valueOf()para convertir una representación del objetoStringen un valorLong.

La Clase java.lang.Float

La claseFloates la representación en objeto del tipo de dato primitivofloat. Esta clase, por se una clase envolvente del tipo primitivofloat, tiene un miembro del tipofloat. También tiene métodos que permiten obtener el valor delfloatalmacenado en el objetoFloaten la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue(), longValue()ydoubleValue()respectivamente.

La clase Float también tiene los métodosequals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object.

La claseFloattiene el métodostatic valueOf()para convertir una representación del objeto String en un valor Float.

La Clase java.lang.Double

La claseDoublees la representación en objeto del tipo de dato primitivodouble. Esta clase, por ser una clase envolvente para el tipo primitivodouble, tiene un miembro del tipodouble. También tiene métodos que nos permiten obtener el valor deldoublealmacenadoen el objetoDoubleen la forma debyte, short, int, floatodoubleusando los métodosbyteValue(), shortValue(), intValue(), floatValue()ydoubleValue()respectivamente.

La claseDoubletambién tiene los métodosequals(), toString()yhashCode()que son sobrescritos de la clasejava.lang.Object, así como el método static valueOf() para convertir una representación del objetoStringen un valorDouble.

[ Seguir leyendo ]

Tipos de Datos Boolean

Tipo de Datos Boolean

El tipo boolean representa valores de verdadero/falso. Java define los valores verdadero y falso empleando las palabras reservadas true y false. Por lo tanto, una variable o expresión de tipo boolean será uno de estos dos valores.

He aquí un programa que demuestra el tipo boolean:

//Demuestra valores boolean.

Class BoolDemo {

public static void main(String args[]) {

boolean b;

b = false;

System.out.println(“b es “ + b);

b = true;

System.out.println(“b es “ +b);

//Un valor boolean puede controlar la instrucción if

if(b) System.out.println(“ Esto se ejecuta.”);

b = false;

if(b) System.out.println(“ Esto no se ejecuta.”);

// La salida de un operador relacional es un valor boolean

System.out.println(“10 > 9 es “ + (10 > 9));

}

}

La Salida generada por este programa se muestra aquí:

b es false

b es true

Esto se ejecuta

10 > 9 es true

Hay que observar aquí tres aspectos interesantes acerca de este programa. En primer lugar, como puede ver, cuando se da salida a un valor boolean con println() se despliega “true” o “false”. En segundo lugar, el valor de una variable boolean es suficiente, en sí misma, para controlar la instrucción if. No es necesario escribir una instrucción if como ésta:

if(b == true) …

En tercer lugar, la salida de un operador relacional , como <, es un valor boolean. Por eso la expresión 10 > 9 despliega el valor “true”. Más aún, el conjunto extra de paréntesis alrededor de 10 > 9 es necesario porque el operador + tiene una mayor precedencia que >.

[ Seguir leyendo ]

Caracteres en Java

En Java, los caracteres no son cantidades de 8 bits como en casi todos los demás lenguajes de cómputo. En cambio, Java usa Unicode. Unicode define un conjunto de caracteres que puede representar todo los caracteres encontrados en el lenguaje humano. Por lo tanto, en Java, char es un tipo de 16 bytes sin signo que tiene un rango de 0 a 65,536. El conjunto de caracteres ASCII estándar de 8 bits es un subconjunto de Unicode y va de 0 a 127. Por consiguiente, los caracteres ASCII aún son caracteres válidos de Java.

Es posible asignar un valor a una variable de carácter al encerrar éste entre comillas. Por ejemplo, para asignar a la variable carácter la letra X:

char ch;

ch = 'X';

Puede dar salida a un valor char empleando la instrucción println(). Por ejemplo, esta línea da salida al valor de ch:

System.out.println(“Este es ch: “ + ch);

Debido a que char es un tipo de 16 bits sin signo, es posible realizar varias manipulaciones aritméticas en una variable char. Por ejemplo, considere el siguiente programa:

// Las variables de carácter se manejan como enteros.

Class CarAritDemo {

public static void main(String args[]) {

char ch;

ch = 'X';

System.out.println(“ch contiene “ + ch);

ch++; //incrementa ch

System.out.println(“ch ahora es “ + ch);

ch = 90; // da a ch el valor Z

System.out.println(“ch es ahora “ + ch);

}

}

Aquí se muestra la salida generada por este programa:

ch contiene X

ch es ahora Y

ch es ahora Z

En el programa, a ch se le da primero el valor X. Luego se aumenta ch. El resultado es que ahora contiene Y, el siguiente carácter en la secuencia ASCII (y Unicode). Aunque char no es un tipo entero, en algunos casos puede manejarse como si lo fuera. A continuación, se le asigna a ch el valor 90, que es el valor de ASCII (y Unicode) que corresponde a la letra Z. Debido a que el conjunto de caracteres de ASCII ocupa los primeros 127 valores en el conjunto de caracteres de Unicode, todos los “viejos trucos” que ha usado con caracteres en el pasado funcionarán también en Java.

[ Seguir leyendo ]