Suplemento Nº 9 de New 2 Java (Mar-2002)
Lenguaje Java Básico
Castin (Forzado)
Casting es el proceso de tomar una variable declara como de un tipo y decirle al compilador que queremos tratarla como otro tipo. El Casting no modifica el ítem original. Solo le dice al compilador que lo trate de manera diferente. El Casting se puede hacer tanto con tipos primitivos como int o float como con tipos de objetos como java.lang.Object y java.lang.String.
La forma general para la operación de casting es la siguiente:
(datatype)expression
donde data type es el nuevo tipo como queremos que se trate el valor de la expresión.
En el caso de datos primitivos, el casting es necesario cuando cambiamos entre tipos de datos y hay una oportunidad de perder información. Por ejemplo, si tenemos un int y queremos tratarlo como un double, no se necesita casting porque un double puede contener todo el rango de valores disponibles dentro de un int. En las siguientes operaciones, no es necesario el casting. El valor de i es promocionado al tipo de d:
int i = 5;
double d = i;
Para ir en la dirección inversa se requiere el casting. Porque una variable double puede contener datos con valores más allá del punto de decimal, un int no puede contener los valores de un double. El rango de números posibles es mayor para un double que para un int. A causa de estos dos problemas específicos, intentar pasar de un double a un int requiere casting:
double d = 5.0;
int i = (int)d;
El uso de (int) aquí dice: "Oye, ya se que esto puede perder información, pero realmente quiero tratar esta variable double como un int."
Con objetos, alguna veces también es necesario el casting. El Casting con referencias de objetos dice que trate la variable declarada como del tipo X como si fuera del tipo Y. Es importante saber que cuando forzamos una objeto referencia, el tipo de dato del objeto no cambia, sólo el modo en que el compilador trata el objeto.
Frecuentemente, los métodos son declarados para ser genéricos, posiblemente aceptando (o devolviendo) un tipo Object. Entonces se convierte en necesario acceder a la variable por su tipo específico. Aquí es cuando necesitamos el casting. Si sabemos que un parámetro se supone que va a ser de un tipo específico, podemos forzarlo, como en el siguiente ejemplo:
public void myMethod(Object param) {
Number num = (Number)param;
double d = num.doubleValue();
System.out.println("Value is: " + d);
}
Si, sin embargo, no conocemos el tipo espécifico, podemos usar la palabra clave instanceof. Esto nos permite chequear primero el tipo, y luego forzarlo:
public void myMethod(Object param) {
if (param instanceof Number) {
Number num = (Number)param;
double d = num.doubleValue();
System.out.println("Value is: " + d);
} else {
logError(param);
}
}
Si no usamos la palabra clave instanceof para chequear el tipo e intentar realizar el forzado entre tipos incompatibles, se lanzará una ClassCastException en tiempo de ejecución. Esto se muestra en el siguiente fragmento de código:
// Create object
Object o = new Object();
// The cast
String s = (String)o;
// The object s refers to is not really a String
// so a ClassCastException is thrown
System.out.println(s.length());
La sentencia sería válida si el objeto referenciado por la variable o fuera un String, como en este fragmento de código:
// Create object
Object o = "Hello";
// The cast
String s = (String)o;
// The object s refers to really is a String
// so no ClassCastException is thrown
System.out.println(s.length());
Entender la Librería de Clases Java
Interfaces Collection, Iterator, y List
El Marco de Tabajo Collections proporciona un conjunto de clases e interfaces para almacenar y manipular grupos de datos como una sóla unidad, o una colección. Una colección es un objeto que representa un grupo de objetos. Interfaces específicos describen los diferentes tipos de grupos, como conjuntos, listas y mapas.
Ya has visto algunos objetos collection en Suplementos anteriores como los arrays y ArrayList.
El interface Collection se usa para representar cualquer grupo de objetos, o elementos. Usamos este interface cuando queremos trabajar con un grupo de elementos de una forma lo más general posible. Este interface tiene dos métodos que deberíamos entender:
- add(Object obj)
añade un objeto a una colección. El método add devuelve true si la adición del objeto cambió la collection y false si no lo cambió.
- Iterator iterator
devuelve un objeto que implementa el interface Iterator.
Los métodos del interface Iterator nos permiten pasar a través de cada elemento de una collection desde el principio hasta el final. Podemos usar un iterator para recuperar o eliminar objetos en una collection uno por uno. Los tres métodos del interface Iterator que puedes usar son:
- hasNext
Devuelve true si la iteración tiene más elementos. Devuelve true si next devuelve un elemento en vez de lanzar una excepción.
- next
Devuelve el siguiente elemento de la iteración. Lanza NoSuchElementException si la iteración no tiene más elementos.
- remove
Elimina el último elemento devuelto por el iterator. Este método sólo puede llamarse una ver por cada llamada a next.
El interface List extiende el interface Collection para definir una coleción ordenada, una secuencia de elementos, permitiendo duplicados. Este interface añade operaciones orientadas a la posición, así como la habilidad de trabajar sólo con una parte de la lista. Este interface nos da el control sobre dónde se inserta cada elemento, y podemos acceder a elementos por su índice entero de posición en a lista, y buscando por los elementos de la lista. Abajo puedes ver algunos de los métodos del interface List:
- add(int index, Object element)
Inserta el elemento especificado en la posición especificada de esta lista (operación opcional).
- add(Object o)
Añade el elemento especificado al final de la lista (operación opcional).
- clear()
Elimina todos los elementos de la lista (operación opcional).
- get(int index)
Devuelve el elemento en la posición de la lista especificada.
La siguiente aplicación demuestra todos los conceptos anteriores:
// The Collection, List, and Iterator interfaces are a
// part of the java.util package.
import java.util.*;
public class CreatingCollections
{
public static void main(String args[])
{
// Creates a collection object
List list = new ArrayList();
// Uses the add method to add
// each element
list.add("This is a String");
list.add(new Short((short)12));
list.add(new Integer(35));
// Get an iterator for the input list
// and step through each element within the
// for statement.
for (Iterator i = list.iterator(); i.hasNext(); )
{
System.out.print(i.next());
}
}
}
Resulta en:
This is a String1235
Programa Ejercicio
- Crea un programa que tome una lista de objetos como entrada
- Haz que la mitad de los objetos sean strings.
- Haz que la otra mitad de los objetos sean números.
- Añade otro objeto a la lista que no sea ni un String ni un número
- Itera sobre los elementos.
- Concatena los Strings.
- Suma los números.
- Ignora el resto.
- Usa instanceof para dererminar de que tipo es cada elemento.
- Fuerza el elemento al tipo apropiado antes de acceder al dato.
- Saca los strings concatenados.
- Saca la suma de los números.
Un poco de Java
Buenas Prácticas de Programación
Escribir código que se compile y se ejecute es sólo una parte del desarrollo de software. También podemos necesitar depurar aplicaciones, ampliarlas, añadir cambios, y compartir partes de código. En otras palabras, nuestro código debe escribirse de forma legible para que sea fácil de entender y consistente.
Puedes hacer esto siguiendo estas buenas prácticas de programación:
- Comenta de forma completa pero no excesiva:
No expliques lo obvio, pero si explica el propósito de los métodos complejos. Esto es una ayuda para los desarrolladores y para tí mismo si ha pasado mucho tiempo desde que escribiste el código. Por ejemplo:
// Creates a new entry in the jiveForum database
// table and inserts the forum object into memory
// cache for future fast access:
try {
Forum newForum = factory.createForum(
"New Forum Name",
"Some description for new forum.");
}
- Crea nombres de métodos y parámetros con significado:
Un nombre de método con significado describe la funcionalidad de un método, y ayuda a evitar la necesidad de largos comentarios. Por ejemplo:
public void getLastVisited(request,response){}
- Manten los métodos tan pequeños como sea posible:
Un método que requiere muchos parámetros podría hacer más de lo que debería. Considera el dividir dichos métodos en varios métodos para realizar las distintas tareas. Por ejemplo:
private void buildImagePanel()
{ // Opens method
images = new JPanel();
// Sets the color, layout, and adds the
// seahorse object
images.setLayout(new FlowLayout() );
images.setBackground(Color.white);
images.add(seahorse);
} // Closes method
- Indenta las sentencias en el cuerpo de las sentencias de control:
Esto hace más fácil seguir lo que está haciendo cada sentencia de control, y hace más facil localizar la siguiente. Por ejemplo:
if (!str1.equals(str2)) {
System.out.println("str1/str2 mismatch");
}
Solución al Programa de Ejercicio
Esta es una de las posibles soluciones al programa del ejercicio:
import java.util.*;
public class Cast {
public static void main(String args[]) {
// Configure the "input"
List list = new ArrayList();
list.add("The ");
list.add(new Integer(35));
list.add("quick ");
list.add(new Double(Math.PI));
list.add("brown ");
list.add(new java.awt.Point(1, 2));
list.add("fox ");
list.add(new Float(89.124f));
list.add("jumps ");
list.add("over ");
list.add(new Short((short)14));
list.add("the ");
list.add(new Byte((byte)12));
list.add("lazy ");
list.add("sleeping ");
list.add(new Long(9012));
list.add("dog.");
// Get an iterator for the input list
Iterator it = list.iterator();
// Create a StringBuffer to store
// the concatenated elements
StringBuffer sb = new StringBuffer();
// Initialize a variable to store the sum
double sum = 0;
// Loop through the list using the iterator
while(it.hasNext()) {
// Get the next element
Object next = it.next();
// Check for type
if (next instanceof Number) {
// Sum up the numbers.
Number num = (Number)next;
sum += num.doubleValue();
} else if (next instanceof String) {
// Combine the strings
sb.append((String)next);
} else {
// ignore
}
}
// Display the results
System.out.println("Sentence: " + sb.toString());
System.out.println("Sum: " + sum);
}
}
Descargar la Plataforma Java 2
Para la mayoría del desarrollo Java, necesitas las librerías de clases Java, el compilador, las herramientas, y el entorno de ejecución proporcionado por el kit de desarrollo de Java 2, Standard Edition.
Tutoriales
