Tipos primitivos. Tipos primitivos numéricos.

Tipos de datos primitivos Nombre

Tipos numéricos: 

- números enteros : byte, short, int, long.

- números reales (en coma flotante): float, double.

Tipo carácter char

Tipo lógico boolean


El tipo determina el tamaño de las variables: una variable ocupa el número de bits necesarios para almacenar la representación en binario de cualquier valor del tipo.

En el texto, en el código fuente, los valores concretos de cada tipo se escriben mediante los literales del tipo, que seguirán reglas sintácticas propias.


Tipos primitivos numéricos enteros:

La sintaxis de los literales enteros corresponde a la notación habitual.

─ Por defecto los literales enteros (0, -1, 1, -2, 2, .....) son de tipo int.


Nombre     Tamaño N en bits        Valor mínimo    ̶  (2 (N-1))        Valor máximo + (2(N-1)- 1)

   byte             8 bits                             -128                                                 127

   short           16 bits                           -32768                                             32767

    int             32 bits                     -2147483648                                       2147483647

    long          64 bits                           -2(63)                                               2(63)-1


Tipos primitivos numéricos reales:

Nombre     Tamaño N en bits        Valor mínimo    ̶  (2 (N-1))        Valor máximo + (2(N-1)- 1)

   float            32 bits                         1.4 x 10(-45)                                   3.4 x 10(38) 

   double         64 bits                        4.9 x 10(-324)                                 1.8 x 10(308)            

    

Los literales reales o en coma flotante pueden representarse en dos tipos de notación:

◦ decimal    -123.05     0.2243         0.00000000001

◦ científica     23.4e2     -1.9E-18             1e-11

Para separar la parte decimal se usa exclusivamente el punto.

Por defecto los literales reales son de tipo double.


Operadores de los tipos numéricos: 

sean e1, e2 expresiones.     v variable.         e expresión

Operador                    Operación                                 Operador                         Operación

e1 + e2                     Suma o signo                                v += e                     Suma y asignación

e1 - e2                      Resta o signo                                v -= e                      Resta y asignación

e1 * e2                     Multiplicación                              v *= e                   Multiplicación y asignación

e1/e2                         División                                       v /= e                     División y asignación

e1%e2                       Módulo                                        v++,  v--                 Incremento, decremento en 1

a++ ==  a = a + 1                                                                             a+=b   ==   a = a + b

Los operadores de los tipos numéricos se dicen que están sobrecargados, pues se suelen utilizar los mismos para los tipos enteros y para los tipos reales, y a veces no se comportan de la misma manera:

2/4 los operandos son enteros > es la división entera, se evalúa a 0

2.0/4.0 los operandos son reales > es la división real, se evalúa a 0.5

En Java, se denomina excepciones a los errores de ejecución.

La división entera por cero produce una excepción o error de ejecución: / by zero.

En cambio, la división real por 0.0 sí está definida: El resultado puede ser Infinity o NaN. 10/0.0 da Infinity, 0/0.0 da NaN: Not a Number., pero sin producir excepciones.

Precedencia de operadores en las expresiones:

Grupo Clasificación Operadores

0 Paréntesis ()

1 Unarios postfijos expr++ expr--

2 Unarios prefijos ++expr --expr +expr !expr

3 Creación, conversión new (tipo) expr

4 Producto * / %

5 Suma + -

6 Relacionales > >= < <=

7 Igualdad == !=

8 Conjunción &

9 Disyunción exclusiva ^

10 Disyunción lógica |

11 Conjunción cortocircuitada &&

12 Disyunción cortocircuitada ||

Si en una expresión aparecen operaciones del mismo grupo, se evalúan con asociatividad por la  izquierda (de izquierda a derecha). La precedencia puede alterarse con los paréntesis de la forma  habitual

Un ejemplo de datos enteros...

public class Ejercicios{

    public static void main(String[] arg){      

         ssAddhhmmss(23456789);

    }

  public static void ssAddhhmmss(long segundos){

            long dias = segundos/(24*60*60);

            segundos = segundos % (24*60*60); // segundos restantes

            System.out.print("Días: "); System.out.println(dias);

            long horas = segundos/(60*60);

            segundos = segundos % (60*60); // segundos restantes

            System.out.print("Horas: "); System.out.println(horas);

            long minutos = segundos/60;

            segundos = segundos % 60; // segundos restantes

            System.out.print("Minutos: "); System.out.println(minutos);

            System.out.print("Segundos restantes: "); 

            System.out.println(segundos);            

        }

Se obtienen los dias, horas, minutos y segundos según los segundos que se apliquen.  es totalmente operativo.


• Realizar operaciones numéricas puede producir desbordamiento: resultado que excede la capacidad de representación del tipo.

• En la aritmética de los enteros cuando se sobrepasa el valor máximo representable se obtiene un resultado incorrecto (error lógico) . 

Ejemplos:

int n = 1000000 * 1000000; //Error lógico, n vale -727379968;

long nL = 1000000 * 1000000; //nL vale 10 elevado a 12

• En la aritmética real se producen desbordamientos hacia infinito (overflow) o hacia cero (underflow).

Ejemplos:

double x = 1e308 * 10; //x vale Infinity

x = x/2.0; // x vale Infinity

x = -1e308*10; //x vale -Infinity

x = 1e-323; 

x = x/10.0; // x vale 0.0


Compatibilidad y conversión de tipos

• En la asignación v = e; la variable v y la expresión e deben ser del mismo tipo de datos o de tipos

compatibles: el tipo de e ha de ser menor que el tipo de v, según la siguiente ordenación

                     byte > short //char > int > long > float > double

• Ejemplos:

                    double x = 5.0;

                                x = 5; // Esto si es compatible.

                    int n = 5.0; // Error de compilación.


• Cuando Java encuentra una expresión e de tipo T1 en un contexto de tipo T2 superior, le aplica automáticamente una conversión implícita al tipo T2:

• Ejemplo:

double x = 5.0; // x vale 5.0

x = 3; // x vale 3.0

x = 5.0/2; // x vale 2.5

En la expresión 5.0/2 de la última línea: ¿el operador / es la división entera o la real?

Se descarta que sea la división entera dado que el 5.0 no se puede convertir automáticamente en un entero. En cambio, sí que hay una transformación posible:  Si se considera que el operador / corresponde a la división real, entonces el 2 se considera en un contexto de tipo real, y se transforma automáticamente a 2.0 antes de poderse evaluar la expresión.

• El casting o conversión de tipos explícita fuerza la conversión entre tipos.

• Sintaxis:        (T2) e 

 Si el valor de e es de tipo T1, y T2 pertenece a T1 o T1 pertenece a T2 entonces Java convierte el valor de e a un valor correspondiente de tipo T2.

La conversión de un tipo inferior a uno superior es la obvia.

La conversión de un tipo superior a uno inferior, no es tan evidente y depende del par de tipos implicados.

En el caso de double a int se produce un truncamiento en el casting o conversión explicita. En la implícita no lo admitiría.

Ejemplos:

double x = 5; 

double z = 5.2; 

int n = x; // Error de compilación: pérdida de precisión

int m = 5.0; // Error de compilación: pérdida de precisión 

double x = 5; // x vale 5.0

double z = 5.2; // z vale 5.2

int m = (int) x; // m vale 5

m = (int) z; // m vale 5

•  public static void promedioHijos(int hijos, int familias){

            System.out.println("Num promedio hijos:"+(double)hijos/familias);        

}

convertimos los hijos y las familias en doubles para obtener el promedio real.


• public static void redondeo(int numPiezas, double precioTotal){

            double precioUnidad = precioTotal/numPiezas;

            System.out.print("Precio unidad, redondeado a euros: ");

            System.out.println( (int) (precioUnidad + 0.5) );                   

    }

Aquí convertimos un real en un entero, redondeando así: 13.45 (+0.5) > 13 y 13.82 (+0.5) > 14


• Problema. Dado un intervalo de reales [inf,sup[, dividido en una cantidad entera de subintervalos iguales, averiguar a qué subintervalo pertenece un cierto valor.

double inf = 10.0; //cota inferior inclusive del intervalo

double sup = 20.0; //cota superior exclusive del intervalo

int cInt = 2; // cantidad de intervalos

double valor = 14.9; // valor real

// Cálculo y escritura del intervalo al que pertenece valor:

double tamInt = (sup - inf)/cInt;

int numInt = (int)((valor - inf )/tamInt); // 0,1,...

double limInfInt = inf + numInt*tamInt,

limSupInt = inf + (numInt + 1)*tamInt;

System.out.print ("Subintervalo al que pertenece el valor: ["); 

System.out.print(limInfInt); 

System.out.print(","); 

System.out.print(limSupInt); 

System.out.println("["); 

En pantalla:

Subintervalo al que pertenece el valor : [10.0,15.0[

Este problema es muy difícil de ver e imaginar. Se puede ver mas claro si se hace un cambio de coordenadas: 

double inf = 10.0; //cota inferior inclusive del intervalo. Lo pasamos a 0.0;

double sup = 20.0; //cota superior exclusive del intervalo. Lo pasamos a 10.0;

int cInt = 2; // cantidad de intervalos lo mismo.

double valor = 14.9; // valor real: lo pasamos a 4.9; se ve a simple vista que pertenece al primer subintervalo de [0.0, 5.0[, que añadiéndole los 10.0 del corrimiento, queda en [10.0,15.0[

Comentarios

Publicar un comentario

Entradas populares de este blog

Definición de la estructura o atributos que tendrán los objetos de una clase.

Imagen
 Los objetos de una clase tendrán una determinada estructura, que se declara al inicio de la clase que define ese tipo de objetos. Por ejemplo si queremos trabajar con objetos punto, de dos dimensiones, tendrán dos atributos del tipo double, x e y. A esto se le llama estructura del punto. Y  requiere previamente definirlos en la clase Punto como variable atributo, en el inicio  de la clase: public class Punto { [modificadores] double x ; [modificadores] double y; ..... } Es decir se declaran sin siquiera inicializar las variables atributo, aunque se pueden inicializar a unos valores predeterminados que luego podrán modificarse. Los modificadores pueden establecer unas propiedades de los atributos. public class Punto { [modificadores] double x ; [modificadores] double y;  public Punto(){ }//constructor por defecto. public Punto(double x, double y){ this.x = x; this.y =y;//Significa que los atributos del punto tomarán los valores x, y de los parámetros del constructor....
Leer más

Métodos: Declaración.

 Además de crear objetos de unas propiedades determinadas -atributos-, las Clases en Java permiten crear, declarar o definir operaciones o métodos que actúen con los objetos creados al ser invocados o llamados por ellos. El obrar sigue al ser: se crean objetos y esos objetos pueden operar de muchos modos. Los métodos son esas herramientas que utilizan los objetos en su operar. Además se pueden definir métodos que no precisan objetos para operar. Se emplean en cualquier Clase, y se llaman métodos estáticos o de clase. Por ejemplo System.out.println(), o Math.ramdow(); Es preciso para usarlos que la Clase esté cargada: import.java.util.*;  .... u otros modos para clases específicas. Los métodos de objeto o dinámicos, en contraposición a los estáticos o de clase, requieren ser utilizados, llamados o invocados por objetos ya existentes, para ello se utilizan los métodos constructores que los crean e inicializan sus atributos mediante los valores de los parámetros materiales. •En c...
Leer más

La clase String de java

• El tratamiento de cadenas de caracteres es un problema básico en  informática. • Java proporciona la clase predefinida String, cuyos objetos agrupan todos los caracteres de una cadena de caracteres. • En la clase se proporcionan métodos que facilitan el tratamiento de cadenas. • Internamente, los caracteres de la cadena están en una serie de char, numerados de 0 en adelante, junto con otros datos, como su longitud: 'S' 'a' 'l' 'u' 'd' 'o' 's' '.'  0  1  2   3  4  5  6  7      Longitud  8  • De acuerdo con esta numeración, encontramos métodos para: - averiguar el carácter que ocupa una posición en la cadena, - encontrar la posición en la que aparece un carácter, o una subcadena - calcular la subcadena que se extiende entre dos posiciones... • Métodos mas usuales: Método compareTo(). La documentación detallada indica que: - s1.compareTo(s2) es <0 si s1 es menor lexicográficamente que s2, - s1.compareTo(s2) es ...
Leer más