Procesamiento Numérico: Tipos de Datos en Java (Data Types in Java, Spanish only)

El propósito original de la computadora fue el procesamiento numérico. De hecho recibió su nombre por su capacidad de computar operaciones numéricas. En estas capacidades nos enfocaremos en este articulo.

Liked it? !

Antes de leer este artículo se recomienda haber leído Definiendo Clases.

Índice

1. Tipo int
2. Ejemplo completo
3. Mas sobre Tipos de Datos Intrínsecos
   1. Diferencias entre las clases y los tipos de datos intrinsecos
   2. Todos los Tipos de Datos Intrinsecos
   3. Constantes Literales
   4. Constantes
   5. Operadores
   6. Entrada Numérica

1. Tipo int

   Java no nos provee una clase predefinida para modelar el procesamiento numérico. En vez de esto nos provee un tipo de dato intrínseco llamado int, que modela el comportamiento de los enteros. Este tipo de dato nos provee de operaciones aritméticas básicas como +, -, / y *

   La impresión de este tipo de dato la proveen los métodos (sobrecargados) print y println del PrintStream, que aceptan un entero como parámetro.

   Los tipos de datos intrínsecos, a diferencia de las clases, no tienen métodos ni instancias. Lo único asociado a una variable int es el valor entero que representa. No tiene constructor, ni necesitamos el new. Hablaremos mas detalladamente sobre los tipos intrínsecos después del siguiente ejemplo.

    

2. Ejemplo completo: Recolección de Peajes

   1. Planteo del Problema

      Supongamos que nos ha contratado el departamento de carreteras para instalar un sistema de peaje en una de sus carreteras principales. Nos dicen que los camiones al llegar a la cabina de cobro, se les exige que paguen Q.10 por cada media tonelada española del peso total del camión y Q.5 por cada eje.

      Para ilustrar el proceso, supongamos un caso hipotético que se podría dar. Supongamos que llega un camión a la cabina. El agente equipado con una computadora obtiene la información del camión (a través de sensores, lecturas en código de barras, etc). La información del camión (para verificación), junto con la cantidad a pagar deben aparecer en la pantalla. Por ejemplo:

      Arribo de camion; ejes: 5, peso (en libras): 12500, tarifa: Q.145

      Para observar el total que la cabina a recolectado, se presiona cierto botón, y los totales se despliegan en la pantalla. Por ejemplo:

      Totales desde el ultimo cierre: Recibido: Q.450, camiones: 3

      Cuando la gaveta de la caja es removida los totales de la cabina se despliegan y se reinicializan en 0. Por ejemplo:

      *** Cierre de caja: Recogiendo dinero ***
      Totales desde el ultimo cierre: Recibido: Q.680, camiones: 5

       

   2. Objetos Primarios

      Los objetos del programa serán las cosas que vamos a modelar. Para escogerlos buscamos los sustantivos relevantes en el planteo del problema. Estos son: camion, eje, peso, cabina y dinero. Los que parecen ser mas importantes de aquí son camión y cabina. El eje y el peso son atributos del camión y el dinero es secundario a la cabina. Por lo tanto, desarrollaremos las clases Camion y Cabina.

       

   3. Clase Camion

      1. Determinando el comportamiento deseado

         La información que requerimos del Camion es aquella que la cabina necesita para calcular la tarifa. Cualquier otra información es irrelevante. A pesar de que estamos en el diseño de la clase Camion, no estamos operando en el vacío. Para definir el comportamiento que el camión debe de tener, necesitamos indagar que comportamiento requiere la cabina, que el camión tenga. Necesitamos por lo tanto una forma de obtener:

         • El numero de ejes del camión.
         • El peso total en libras

          

      2. Definiendo la interfase

         La mejor forma de definir las firmas de los métodos es escribir un pedazo de código, que utilizaría nuestra clase. Las operaciones que quisiéramos poder hacer podrían ser:

         • Supongamos que tenemos un camión de 4000 libras y tres ejes. Esta información se debería de proveer en la creación del objeto Camion. Esta quedaría así :

           Camion camion1 = new Camion(3, 4000);

         • Obtener el numero de ejes:

           int e;
           e = camion1.getAxles();

         • Obtener el peso:

           int w;
           w = camion1.getTotalWeight();

         Observamos que el constructor debe incluir dos parámetros enteros, en donde el primero representa el numero de ejes y el segundo representa el peso. Los métodos getAxles y getWeight no incluirían parámetros y ambos devolverían un entero. Los encabezados quedarían así:

         public Camion (int axles, int weight)
         public int getAxles()
         public int getTotalWeight()

          

      3. Esqueleto

         Unimos los encabezados en la clase y nos quedaría:

         class Camion {
           // los atributos irian aqui
           public Camion (int axles, int totalWeight)
           {
             // enunciados
           }
           /** devuelve el numero de ejes */
           public int getAxles()
           {
             // enunciados
           }
           /** devuelve el peso total en libras */
           public int getTotalWeight()
           {
             // enunciados
           }
         }

          

      4. Implementación

         Como necesitamos tener acceso a el numero de ejes desde el constructor y desde getAxles y necesitamos tener acceso al peso total desde el constructor y desde getWeigth ambos axles y totalWeigth tienen que ser atributos.

         class Camion {
           private int axles, totalWeight;
           public Camion (int axles, int totalWeight)
           {
             this.axles = axles;
             this.totalWeight = totalWeight;
           }
           /** devuelve el numero de ejes */
           public int getAxles()
           {
             return axles;
           }
           /** devuelve el peso total en libras */
           public int getTotalWeight()
           {
             return totalWeight;
           }
         }

       

   4. Clase Cabina

      1. Determinando el comportamiento deseado

         El comportamiento que requerimos de la cabina es:

         • Calcular y desplegar la tarifa para cada camión.
         • Desplegar el total de camiones y dinero recolectado.
         • Reinicializar los totales para cuando se recoja el dinero.

          

      2. Definiendo la interfase

         Escribiremos una porción de código para utilizar la cabina. Comenzando con la declaración y creación de la Cabina. Vemos que no necesitamos información para la construcción de la Cabina.

         Cabina cabina1 = new Cabina();

         Cada vez que se calcule la tarifa, será para un Camion distinto. Por lo tanto se debe de proveer un Camion como argumento.

         cabina1.calculateToll(truck1);

         Para ver los totales tabulados por la cabina podemos hacer la llamada

         cabina.displayData();

         Finalmente, el cierre de caja no requiere información adicional.

         cabina.onReceiptCollection();

         Ninguno de estos métodos devuelve algún valor, únicamente hacen que la cabina se haga cosas. Esto nos lleva saber exactamente el encabezado de todos los métodos de la clase Cabina.

         public Cabina()
         public void calculateToll(Camion camion)
         public void onReceiptCollection()
         public void displayData()

          

      3. Esqueleto

         El esqueleto queda así

         class Cabina {
           // aqui irian los atributos si hay
           public Cabina()
           {
             // enunciados
           }
           public void calculateToll(Camion camion)
           {
             // enunciados
           }
           public void onReceiptCollection()
           {
             // enunciados
           }
           public void displayData()
           {
             // enunciados
           }
         }

          

      4. Implementación

         Vimos que necesitamos registrar el total de camiones y el total de dinero. Inicialmente cuando construimos la cabina estos debe empezar en 0.

         import java.io.*;
         class Cabina {
           private int trucksSinceCollection, receiptsSinceCollection;
           public Cabina()
           {
             trucksSinceCollection = 0;
             receiptsSinceCollection = 0;
           }
           public void calculateToll(Camion camion)
           {
             int axles = camion.getAxles();
             int totalWeight = camion.getTotalWeight();
             int tollDue = 5*axles + 10*(totalWeight/1000);
         
             System.out.print("Arribo de camion; ejes: ");
             System.out.print(axles);
             System.out.print(", peso (en libras): ");
             System.out.print(totalWeight);
             System.out.print(", tarifa: Q.");
             System.out.println(tollDue);

             trucksSinceCollection = trucksSinceCollection+1;
             receiptsSinceCollection = receiptsSinceCollection+tollDue;
           }
           public void onReceiptCollection()
           {
             System.out.println("*** Cierre de caja: Recogiendo dinero ***");
             displayData();
             trucksSinceCollection = 0;
             receiptsSinceCollection = 0;
           }
           public void displayData()
           {
             System.out.print("Totales desde el ultimo cierre: Recibido: Q.");
             System.out.print(receiptsSinceCollection);
             System.out.print(", camiones: ");
             System.out.println(trucksSinceCollection);
           }
         }

       

   5. Utilizando la Clase

      A pesar de que quien va ha hacer las llamadas a los métodos de la clase Cabina será circuitería real, podemos escribir un pequeño programa de prueba para verificar que la clase funcione bien, antes de la inversión en hardware!

      class ProbandoCabina {
        public static void main(String args[])
        {
          Cabina cab = new Cabina();
          Camion c1, c2, c3;
          c1 = new Camion(3,3000);
          c2 = new Camion(5,7000);
          c3 = new Camion(4,5000);
          cab.calculateToll(c1);
          cab.calculateToll(c2);
          cab.displayData();
          cab.calculateToll(c3);
          cab.onReceiptCollection();
        }
      }

    

3. Mas sobre Tipos de Datos Intrínsecos

   1. Diferencias entre las clases y los tipos de datos intrinsecos

      	Variable de Referencia	Variable de Tipo de Dato Intrínseco
      Tipo definido en	Definición de clase	Lenguaje
      Valor creado en	new	A través de hardware
      Valor inicializado en	Constructor	A través de hardware
      Variable inicializada con	Asignación de una referencia a objeto	Asignación del valor de un dato intrínseco
      Variable contiene	Referencia a un objeto	dato intrínseco
      Usada con	Mensajes	Operadores
      Puede aparecer como receptor	Si	No

       

   2. Todos los Tipos de Datos Intrinsecos

      Tipo de Dato	Tamaño (en bits)	Valor predeterminado
      boolean	8	false
      byte	8	0
      char	16	'\x0'
      short	16	0
      int	32	0
      long	64	0L
      float	32	0.0F
      double	64	0.0D

      El carácter de Java se asume Unicode (conjunto extendido de ASCII). Las hileras no se trabajan como vectores de char, sino son una clase.

       

   3. Constantes Literales

      • Enteros normales se asumen como int
      • Números precedidos por 0 se asumen octal. Por ejemplo podemos hacer la siguiente asignación.

        int n = 0666; // estamos asignando 438

      • Números precedidos por 0x, 0X se asumen hexadecimal

        int n = 0xFA;

      • Se puede forzar un numero constante para long sucediéndole l, L

        long n = 346L;

      • Números con decimal o exponente se asumen double
      • Se puede forzar un numero constante para float sucediéndole f, F

        float n = 3.14F;

      • Se puede forzar un numero constante para double sucediéndole d, D

        double n = 3.14D;

      • Los valores true y false ya están definidos en Java y no se pueden "castear" a entero.
      • Los caracteres se encierran entre "'. Además se pueden declarar como '\xNN' donde NN es el código hexadecimal en Unicode.

        char espacio = '\x20';

      • La mayoría de secuencias de escape de C son validas en Java. Estas son:

        \n	nueva línea
        \t	tabulación horizontal
        \b	backspace
        \r	retorno de carro
        \f	avance de hoja
        \'	comilla simple
        \"	comilla doble
        \\	backslash

         

   4. Constantes

      En el ejemplo del peaje calculábamos la tarifa con la formula:

      int tollDue = 5*axles + 10*(totalWeight/1000);

      Aquí el programa no es legible, ya que otro programador no entendería que representa el 5, 10 y el 1000. Además el programa necesita mas flexibilidad para hacer cambios. Si los legisladores cambian la tarifa seria un esquema muy ineficiente el tener que ir a buscar a todos los 5 y 10 que representen tarifas. Para esto utilizamos las constantes. Para remediar esta situación, podemos declarar variables que media vez se inicializan su valor permanece constante. Estas variables las declaramos con la palabra reservada final al principio. La solución quedaría así:

      static final int DuePerAxle = 5, 
                       DuePerHalfTon =10,
                       TonInPounds = 2000,
                       HalfTonInPounds = TonInPounds/2;
      

      La palabra reservada final indica que el valor de la variable es final, es decir que no cambia. La palabra reservada static significa que la variable pertenece a la clase y no al objeto. Entonces podemos reescribir la ecuación de la siguiente forma:

      int tollDue = DuePerAxle*axles+DuePerHalfTon*(totalWeight/HalfTonInPounds);

       

   5. Operadores

      En orden de precedencia:

      . [] ()
      ++ -- ! ~
      * / %
      + -
      << >> >>>
      < > <= >=
      == !=
      &
      ^
      |
      &&
      ||
      ?:
      = op =
      ,

      Para asignar a variables expresiones de distinto tipo usamos el operador cast. Su sintaxis es:

      (tipo) expresion

      Por ejemplo:

      int i=250;
      byte b = (int) 250;

      Para las operaciones entre enteros, si el tipo es menor que int el resultado que devuelve es int; si algún operando es long el resultado que devuelve es long. Por ejemplo:

      byte b1, b2=3, b3=5;
      b1 = b2 + b3 // invalido!
      b1 = (byte) (b2 + b3) // valido

      Para operaciones entre float, el resultado es float; si cualquier operando es double el resultado es double.

      Los operadores de <<,>> hacen corrimiento de bits con signo. El operador >>> hacen un corrimiento de bit sin signo (entran 0's a la izquierda independientemente del bit del signo)

      Los operadores relacionales son: >, <, >=, <=, ==, != devuelven un boolean.

      Las operaciones con punto flotante pueden devolver Nan, +Inf, -Inf. Por ejemplo:

      int n1 = 5/0; // da un ArithmeticExpception
      float n2 = 3.0/0// da +Inf

      Los operadores &, |, ^ al tener operandos enteros trabajan como operadores logicos de bits AND, OR, XOR respectivamente. Cuando sus argumentos son boolean trabajan como operadores logicos (sin short circuit evaluation). Por ejemplo:

      int n1=5, n2=3;
      boolean b;
      b = n1<n2 & f(); // de todos modos se ejecuta f()

      Los operadores &&, || son operadores lógicos, con short circuit evaluation. Por ejemplo:

      int n1=5, n2=3;
      boolean b;
      b = n1<n2 && f(); // no se ejecuta f() !

      El único operador, además de la asignación que trabaja con hileras es + (concatenación). Si cualquiera de los operandos es String los otros son convertidos a String automáticamente. Por ejemplo:

      int n=8;
      String s;
      s = "El numero es " + n; // nuevo valor de s = "El numero es 8"

      El operador coma separa dos expresiones para se evaluada de primero la izquierda y después la derecha. Únicamente se permite en el for. Vamos a ver de que forma mas adelante.

      Para todo los operador binario se define el operador compuesto como op = (+=, *=, -=, <<=, >>=, etc.) de la siguiente forma:

      x op= y

      es equivalente a:

      x = x op y

      Por ejemplo:

      int x=2;
      x *= 3; // exactamente lo mismo a x = x*3

      El operador ?: es el único operador ternario y es llamado asignación condicional. El primer operando es una condición y el segundo y tercer operando son expresiones. La forma en que opera es que si la condición es verdadera asigna el segundo operando y si la condición es falsa asigna el tercer operando. Por ejemplo:

      int x=6, y=8, mayor;
      mayor = (x>y)?x:y;

      Si la condición (x>y) es verdadera asigna x, de lo contrario asigna y.

      Ejercicios de Clase:

      1. Diseñe e implemente la clase Estudiante, que deberá de incluir su nombre y las notas del examen medio ano y fin de ano. Incluya un comportamiento para producir el promedio de dicho estudiante.
      2. Diseñe e implemente la clase Circulo, que incluya comportamientos para obtener el área y perímetro.
      3. Diseñe e implemente la clase Rectangulo que incluya comportamientos para obtener el perímetro y el área.

       

   6. Entrada Numérica

      Quisiéramos estar en la capacidad de leer enteros a través del BufferedReader. A pesar que el BufferedReader provee un método readInt este no se comporta como nosotros quisiéramos. readInt lo que hace es que jala los próximos 4 bytes del buffer de entrada y los interpreta como un int y esto no es lo que nosotros deseamos. Nosotros desearíamos que los números leídos del buffer como hileras de caracteres se interpretaran como números. Para hacer esto necesitamos realizar los siguientes pasos:

      1. Leer una línea desde el buffer de entrada usando el método readLine que provee la clase BufferedReader en un String. Por ejemplo si la línea contiene 465, leeríamos y almacenaríamos en una hilera "465".
      2. Convertir la hilera en un numero, usando el método static parseInt que nos provee la clase Integer. Por ejemplo convertiríamos la hilera "465" en el numero 465.

      Estos pasos se traducen en:

      String s = br.readLine();
      int i = Integer.parseInt(s);

      o mas compactamente:

      int i = Integer.parseInt(br.readLine());

      La hilera debe ser convertible a numero, sino Java levanta una excepción NumberFormatException.

      Para los otros tipos de datos existen métodos de conversión similares. Supongamos que deseamos convertir un String hilera, para los otros tipos:

      • long: Long.parseLong (hilera)
      • float: Float.valueOf (hilera).floatValue()
      • double: Double.valueOf(hilera).doubleValue()
      • char: hilera.charAt(0)
      • byte: (byte) Integer.parseInt(hilera)
      • short: (short) Integer.parseInt(hilera)

      Ejercicios de Clase

      1. Agregue un método read a la clase Camion, que permita crear una instancia del Camion a partir de cualquier entrada de datos.
      2. Agregue un método readi a la clase Camion, que permita crear una instancia del Camion a partir de una entrada de datos interactiva.
      3. Agregue un método read y readi a las clases Estudiante, Circulo y Rectangulo desarrolladas en el ultimo ejercicio.

Siguiente articulo que se recomienda leer: Ejecución Condicional

Etiquetas de technorati: java

Liked it? !