PDF de programación - Tipos de datos básicos en Java

Imágen de pdf Tipos de datos básicos en Java

Tipos de datos básicos en Javagráfica de visualizaciones

Publicado el 10 de Septiembre del 2020
120 visualizaciones desde el 10 de Septiembre del 2020
264,2 KB
12 paginas
Creado hace 15a (17/10/2005)
1.00 Clase 3

Tipos de datos básicos en Java,

Estructuras de control



Tipos de datos en Java

• 8 tipos de datos primitivos o integrados:

- 4 tipos enteros (byte, short, int, long).
- 2 tipos de coma flotante (float, double).
- Booleano (boolean).
- Carácter (char).
• No son objetos.
• Se definen de forma (casi) idéntica en

cada máquina en la que se ejecuta Java,
algo que no ocurre en otros lenguajes de
programación.

• Java es un lenguaje de programación

fuertemente tipado:
- Cada variable debe tener un tipo declarado.



1



Tipos de datos en Java
Tamaño

Rango

Tipo

byte
short
int
long

(en
bits)
8
16
32
64

-128 a 127
-32,768 a 32,767
-2,147,483,648 a 2,147,483,647
-9,223,372,036,854,775,808L a
9,223,372,036,854,775,807L
+/- 3.4E+38F (6-7 dígitos importantes)
32
+/- 1.8E+308 (15 dígitos importantes)
64
16 Conjunto de caracteres Unicode ISO

verdadero o falso

float
double
char
boolean 1



¿Qué tipo de dato utilizaría?

• Qué utilizaría para almacenar:

- La velocidad de la luz.
- Su calificación en el curso 1.00.
- Su nota media de este trimestre.
- El número de frigoríficos de una habitación.
- Localización de un punto en la pantalla.
- 265
- 234,77 dólares.
- La mitad de 234,77 dólares.
- Bits por segundo transmitidos por un módem.

2



¿Qué tipo de datos utilizaría?

• Lo que utilizaría para almacenar:

- La velocidad de la luz.
- Su nota en el curso 1.00.
- Su nota media este trimestre.
- El número de frigoríficos de una habitación.
- Localización de un punto en la pantalla.
- 265
- 234.77 dólares.
- La mitad de 234.77 dólares.
- Bits por segundo transmitidos por un módem. int/float

double
char
double/float
int
float/int
BigInteger
double/int
double/int


Cómo utilizar los tipos de datos de



Java

public class DataTypes {

public static void main(String[] args) {

boolean isReal=true; // Los nombres son sensibles a
// mayúsculas y minúsculas,
// deben empezar por una letra y
// pueden contener números,_,$
byte d= 122; // Deben ser inferiores a 127
short e= -29000; // Deben ser inferiores a 32767
int f= 100000; // Deben ser inferiores a 2100 mill.
long g= 999999999999L; // Deben poner L al final
float h= 234.99F; // Deben ser < 3E38; F al final
double i= 55E100;
char cvalue= '4'; // char '4' no es el entero 4
//Las cadenas (strings) son objetos, no primitivos.
//Ejemplo: String nombre= “Claudius”;


}

}

3



Operadores aritméticos

Tabla por orden de prioridad (mayor precedencia al principio)

Operadores
++
--
+ (unario)
- (unario)
*
/
%
+
-

Significado
incremento
decremento
unario + ( x = +a)
unario - ( x = -a)
multiplicación
división
Resto (mod)
suma
resta

Asociatividad
Derecha a izquierda

Izquierda a derecha

Izquierda a derecha



Cómo utilizar operadores aritméticos
public class DataType2 {

public static void main(String[] args) {

int j, k, m;
int d= 123;
j= d--; // j vale 122 y d vale 123
System.out.println("j= " + j);
k= ++d; // k vale 124 y d vale 124
System.out.println("k= " + k);
m= --d; // m vale 123 y d vale 123
System.out.println("m= " + m);
m= k % j; // operador Resto para los tipos int
System.out.println("m= " + m);
j= 5; k= 3; m= j/k; // División entera: m= 1
System.out.println("m= " + m);
System.exit(0);

// k=124 y j=122, por tanto, m= 2

}

}

4



Operadores lógicos

• Producen resultados de tipo booleano.
• En las comparaciones se utilizan 8 operadores:
!=
<=
>=
||

Distinto
Menor o igual que
Mayor o igual que
Disyunción lógica (O)

Igual
Menor que
Mayor que
Conjunción
lógica (Y)

==
<
>

&&

- Existen también operadores bitwise que utilizaremos próximamente.

• Ejemplo:

double c= 0.0, b= 3.0;
if (c != 0.0 && b/c > 5.0) System.out.println(“Boo”);
// Nunca utilice == (igual) con float/double (es un mal ejemplo)
// Evaluación por corto circuito: salir tras una subexpresión falsa



Operadores de asignación

• Asignación no es lo mismo que igualdad:

-

El operador = no es igual al operador ==

• Las asignaciones son expresiones:

int x, y;
x= y= 5;

// Es lo mismo que x = (y= 5); asociación de dcha. a izq.

• Existen formas abreviadas:

int x= 5, y= 3;
x += y;

// Es lo mismo que x= x + y;

• Entre las formas se incluyen: +=, -=, *=, /=, &=, ^=, |=, %=

5

Ejercicios

• Calcule el porcentaje de estudiantes de postgrado
(licenciados) que hay en el curso 1.00.

int estudiantes= 240;
int licenciados= 35;
_________________________;

• Represente 15*i correctamente:

int i= 100000000 + 100000000;
_________________________;

• Escriba una expresión para comprobar si int x es mayor que

double y, si x es menor que y2 y si x es distinto de x2:
_________________________; // Declare x, y
if (_____________________; // Escriba la expresión lógica

• Incremente int z con int a:

_________________________;

// Declare a, z
// Incremente z con a

Ejercicios

• Calcule el porcentaje de estudiantes de postgrado
(licenciados) del curso 1.00:

int estudiantes= 240;
int licenciados= 35;
double pctLic= licenciados/(double) estudiantes;

• Represente 15*i correctamente:

int i= 100000000 + 100000000;
long j= 15*i;

• Escriba una expresión para comprobar si int x es mayor que

double y, si x es menor que y2 y si x es distinto de x2:
int x; double y;
if (x > y && x < y*y && x != x*x) …

• Incremente int z con int a:

int a;
int z += a;

6

Estructuras de control: Ramificación

Forma general

Ejemplo

if (condición)
sentencia;

if (condición)
sentencia 1;
else

sentencia 2;

if (condición1)
sentencia1;

else if (condiciónN)
sentenciaN;
else
sentencia;

if (x == y)
a = 20;
if (x ==z) {
b = 10;
c = 20; }
if ( x == y ) {
a = 10;
b = 20; }
else
x = y;
if ( x > 60)
y = 20;
else if (x < 30) {
z += y;
y = 25; }
else
y= 40;

Estructuras de control: Ramificación
• Una sentencia se puede reemplazar por una serie o conjunto
de sentencia entre llaves: { }
• Una cláusula else enlaza con su sentencia if más cercana.



- Si desea asociarla con un if más lejano, añada
enunciados if intermedios entre { }.
if (x > 3) {
if (y < 7) z= 5; }
else
z = y;

// Este else va enlazado con if (x > 3)

• Sentencia de comparación en forma de terna (tres

sentencias en una)

- (condición ? expr_si_es_verdadera : expr_si_es_falsa)

boolean esCelsius= true;
double tC= 10.0;
double mostrarTemp= (esCelsius ? tC : 1.8*tC + 32.0);

7

Ejemplo de control

import javax.swing.*;
public class Control {

// Para soportar la entrada simple

// fórmula cuadrática

public static void main(String[] args) {

final double TOL= 1E-15; // Constante (utilice ‘final’)
String entrada= JOptionPane.showInputDialog("Introduzca a");
double a= Double.parseDouble(entrada);
entrada= JOptionPane.showInputDialog("Introduzca b");
double b= Double.parseDouble(entrada);
entrada= JOptionPane.showInputDialog("Introduzca c");
double c= Double.parseDouble(entrada);
double discriminante= b*b - 4.0*a*c;
if ( discriminante < 0)
else if (Math.abs(discriminante) <= TOL) {

System.out.println("Lo siento, la raíz no es un número real");
double raiz= -0.5 * b / a;
System.out.println("La raíz es" + raiz); }
double raiz=(-b + Math.sqrt(discriminante))/ (2.0*a);
double raiz2=(-b- Math.sqrt(discriminante))/ (2.0*a);
System.out.println("Raíces: " + raiz + “ y " + raiz2;); }

else { // Redefinir ‘raíz’; los bloques tienen sus propios ámbitos

System.exit(0); } }

8



Ejemplo de control

• El programa anterior presenta un error sutil
e intencionado:
- ¿Puede verlo?
- ¿Es probable que lo encuentre al pasar las
pruebas?
- ¿Es posible que lo encuentre utilizando el
depurador y leyendo el código?

• Repare el error reorganizando el orden de las

cláusulas if-else.



Ejercicios de control
• Ejercicio 1. Escriba el código de main()

- Si la demanda d > las existencias s, aumente el precio p
con a(d-s).
- Si la demanda = las existencias, no haga nada.
- Si la demanda d < las existencias s, baje el precio p con b(d-s).

• Ejercicio 2. Escriba el código de main()

- Si el tiempo hoy está nublado, mañana lloverá.
- Si el tiempo hoy es cálido y nublado, mañana será más cálido.
- Si el tiempo hoy es soleado, mañana estará nublado.
- Si el tiempo hoy es cálido y soleado, mañana será más
frío y estará nublado.
- Si hoy llueve, mañana saldrá el sol.
- (Utilice strings para “nublado”, “cálido”, etc.).



9



Soluciones al ejercicio de control
// Ejercicio 1. En Forte, declare e inicialice todas las variables.
if (d > s)
p += a*(d-s);
else if (d < s)
p -= a*(d-s);

// Se puede omitir “if (d < s)”
// Se puede omitir la cláusula de == dado
// que (d-s)=0

// Ejercicio 2. En Forte, declare e inicialice todas las variables.
if (tiempoHoy.equals("Soleado")) {
tiempoMa= "Nublado";
if (tempHoy.equals("Calido"))
tempMa= "MasFrio";
}
tiempoMa= "Llueve";
if (tempHoy.equals("Calido"))

else if (tiempoHoy.equals("Nublado")) {

tempMa= "MasCalido";

}
else // Lluvia

tiempoMa= "Soleado";

Estructura de control: Iteración



Forma general
while (condición)
enunciado;

do
enunciado;
while (condición);
// Siempre ejecuta el enunciado al
// menos una vez

Ejemplo

while (x > 0) {
System.out.println(“x= “ + x);
x--;

}
do {

System.out.println(“x=“ + x);
x--;
} while (x > 0);

for (expr_inic; condic_fin; cuenta)
enunciado;

for ( x= 20; x > 0; x--)
System.out.println(“x=“ + x);

10



Bucles For

for (expr_inic; condic_fin; cue
  • Links de descarga
http://lwp-l.com/pdf18192

Comentarios de: Tipos de datos básicos en Java (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad