Este documento introduce los conceptos básicos de tipos de datos y variables en Java. Explica los tipos primitivos como enteros, flotantes y caracteres, así como la clase String. Describe cómo declarar y asignar valores a variables, incluyendo las reglas básicas y el ámbito de vida. También cubre la conversión de tipos, operadores aritméticos y relacionales, y cómo comparar cadenas String.

1. Introducción a Java (I)

2. Indice
2
Índice
 Tipos de datos y operadores
 Entradas y Salidas básicas

3. Tipos de datos y operadores

4. Indice
4
Variables
 Una variable no es algo muy diferente de lo que hemos aprendido en
matemáticas. Pensemos en las siguientes operaciones:
 El largo de la parcela es 60 metros
 El ancho de la parcela es 70 metros
 El área es el producto del ancho por el largo: 4200
 ¿Por qué son necesarias las variables?
 Porque necesitamos etiquetas o identificadores para cosas tales como ancho, largo,
etc.
 Porque necesitamos almacenar datos asociados a dichos identificadores (60, 70,
4200)
 Un ejemplo en Java:
public static void main(String[] args) {
System.out.println( "Ha entrado en la aplicación");
float largo;
float ancho;
float area;
largo = 60;
ancho = 70;
area = ancho * largo; // ¿ Cómo visualizar el área de la parcela
}

5. Indice
5
Variables: las reglas básicas
 Regla básica: toda variable debe ser declarada antes de ser utilizada
 En el formato de la declaración hay que tener en cuenta:
 Lo básico, especificar:
• El tipo de dato
• El nombre o identificador de la variable
 Lo opcional es:
• Dar valor a la variable por primera vez (inicializar)
• Declarar otras variables en la misma línea (ojo: del mismo tipo)
 Formato:
Tipo nombre [ = valor ] [, nombre [ = valor ] ... ];
 Ejemplos:
int alto, ancho = 0, edad;
char x = ‘s’, b;
 El programador tiene completa libertad a la hora de dar nombre a una variable. Por
ejemplo, no hay obligación de llamar a las variables enteras con nombres como
“número”, “entero”, etc.
 Lo mejor a la hora de dar un nombre es dejarse llevar por el sentido común:
claridad, es decir, tratar de ser “significativo” sin alargarse en exceso. Por
ejemplo, el nombre “edad” es más significativo que usar simplemente “e”. La
costumbre de dar nombres no significativos es uno de los vicios que conduce a crear
código “solipsista”: sólo lo comprende el programador que lo creó (siempre que no
haya pasado mucho tiempo, en cuyo caso lo normal es que no lo comprenda ni la
persona que lo hizo)

6. Indice
6
Los tipos de datos: enteros y coma
flotante
 Del mismo modo que existen diferentes tipos de vehículos existen
diferentes tipos de variables
 El tamaño en bits, a diferencia de C/C++, es fijo, es decir, no varía
en función de la máquina. Esto facilita la portabilidad
 Enteros:
 byte: 8 bits (-128 a 127)
 short: 16 bits (-32.768 a 32.767)
 int: 32 bits (-2.147.483.648 a 2.147.483.647)
 long: 64 bits (+/- 9x1018
)
 En coma flotante, también llamados reales. Se utilizan cuando se
precisan posiciones decimales:
 float: 32 bits (3.4e-038 a 3.4e+038)
 double: 64 bits (1.7e-308 a 1.7e+308)

7. Indice
7
Elegir un tipo de datos
 En principio parece que lo más fácil sería trabajar con un único tipo
de dato. ¿Parece lógico tener diferentes tipos de datos?
 La respuesta más sencilla es responder con una pregunta: ¿parece
sensato tener el mismo tipo de vehículo para transportar 5
personas, transportar 3 toneladas de carga o para llevar a 55
personas?
 Tenemos diferentes tipos de datos con la finalidad de optimizar. Del
mismo modo que no es sensato usar el motor de un autobus para
un turismo, no es sensato emplear 64 bits si queremos contar del 1
al 10
 Por tanto, parece que el primer criterio para elegir el tipo es la
optimización: no malgastar memoria. Pero hay un criterio más
importante, el sentido común, que nos indica que resulta
prudente actuar con holgura. De hecho, en nuestra vida
cotidiana no llevamos nuestros coches siempre llenos y
perfectamente optimizados. Sino que con frecuencia, transportan
menos personas que su límite máximo

8. Indice
8
Un ejemplo con double
 Un ejemplo para calcular el área de un círculo (PI*r2
)
public class j01_radio {
public static void main(String[] args) throws IOException
{
double PI = 3.1416;
double radio = 3.2, area;
area = radio * radio * PI; // Calculo el área
System.out.println( "El área es: " + area);
}
}
 Ejercicio: hacer un programa que calcule volumen de un
contenedor a partir de su largo, ancho y altura (pueden
admitir dos decimales).

9. Indice
9
Booleanos
 Es un tipo de dato propio de una lógica binaria: sólo tiene como
valores true o false.
int edad = 0;
boolean mayor_de_edad = false;
edad = 18;
mayor_de_edad = true;
 Es el tipo utilizado para evaluar los condicionales:
int edad = 0;
boolean mayor_de_edad = false;
if (edad >= 18) // Si es verdad que la edad es > ó = que 18
mayor_de_edad = true; // entonces es mayor de edad
if (mayor_de_edad == true) // Si es verdad que es mayor de edad ...
System.out.println( “Puede obtener el carnet B1” );
 El último condicional se puede escribir de manara más cómoda (y
más usual):
if (mayor_de_edad) // Si es verdad que es mayor de edad ...
System.out.println( “Puede obtener el carnet B1” );

10. Indice
10
Caracteres (char)
n Java los caracteres se almacenan en variables de 16 bits. Se
tiliza un formato estándar e internacional denominado Unicode que
dmite 65.537 caracteres, de esta forma podemos utilizar desde el
tín hasta el arábigo. Unicode es el formato más utilizado en
nternet.
n el siguiente ejemplo cambiamos el valor de una variable char:
char cuadricula = ‘A’;
System.out.println( “La cuadrícula del mapa es ” + cuadricula );
cuadricula = ‘b’;
System.out.println( “La cuadrícula del mapa es ” + cuadricula );
l siguiente ejemplo nos muestra como funciona internamente el
rdenador: asocia a cada carácter un número. Puesto que con 16
ts podemos representar números enteros de 0 a 65.536, entonces
odemos representar 65.537 caracteres. En nuestro ejemplo
sociamos a un char el número 126, que se representa en formato
e carácter como ‘~’:
char a = 126;
System.out.println( “El carácter es ” + a );
bservar que una cadenas de caracteres (String) se delimita por
omillas dobles y los caracteres aislados (char) se delimitan por
omillas simples.

11. Indice
11
String
 String no es un tipo simple (como float, char, etc.), sino una clase que
nos ayuda a manejar de forma sencilla cadenas de caracteres.
 Ejemplos de instancias:
String j = “Hola mundo”;
String k = new String( “Hola mundo” );
 Podemos concatenar cadenas:
String k = "Hola“, String m = "Adios";
String h = "Saludos: " + k + " y " + m;
System.out.println( h );
 Podemos saber su ancho:
String k = “Antonio”;
System.out.println( k.length() );
 Mediante compareTo() podemos ordenar diferentes cadenas (ver más
adelante)
 Conversión de númerico a cadena mediante el método static valueOf():
int anio = 1999;
String p = String.valueOf( anio);
System.out.println( p );
 La conversión inversa se hace con métodos static que están en las clases
Double, Float, etc:
radio = Double.parseDouble( cadena ); // Convierto el String en double
 Se puede acceder a un carácter de la cadena:
char car = c.charAt(1);

12. Indice
12
Ámbito de vida
 El ámbito de una variable u objeto es el espacio del programa en el
que esa variable existe. Por ello, se habla de “ámbito de vida”
 De forma general (hay excepciones que veremos más adelante), la
vida de una variable comienza con su declaración y
termina en el bloque en el que fue declarada (los bloques
de código se delimitan por llaves: {}). Por ejemplo, ¿cuál es el
ámbito de la variable ‘radio’ y del vector ‘args’?:
public static void main(String[] args)
{
double PI = 3.1416;
double radio = 3;
System.out.println( “El área es” + (PI*radio*radio) );
}

13. Indice
13
Conversión de tipos
 Hemos visto que los datos tienen un tipo. Pero en ocasiones nos conviene
convertir un dato de su tipo original a otro
 Tipos de conversión:
 Automática o implícita. El tipo destino es más grande (mayor número de bits)
que el tipo origen (ensanchamiento o promoción):
int Origen = 65;
float Destino = 4.35f;
Destino = Origen; // ¿Cuál es el valor de ‘Destino’?
También hay conversión automática ante tipos compatibles. Por ejemplo, la
asignación de un int a un char que vimos anteriormente
 Explicita. La conversión se produce cuando el tipo destino es más pequeño
que el origen (estrechamiento). Para ello debemos realizar un moldeado (cast):
double Origen = 65.13;
int Destino = 4;
Destino = (int) Origen; // ¿Cuál es el valor de ‘Destino’?

14. Indice
14
Comprender la conversión de tipos
 Supongamos que tenemos en una variable (int) el precio de un producto. Queremos
incrementarlo en un 20%:
int precio = 10000;
precio = precio * 1.2;
 Este código parece correcto, sin embargo el compilador nos informa de un error:
“Error num.: 355 : puede perderse precisión: double, hacía falta int”. ¿Cuál es la
razón? Para entenderlo, conviene comprender como trabaja la computadora:
 La computadora trata de realizar el producto (precio*1.2) entre un int y un double (1.2),
para lo cual el ordenador convierte de forma automática el int en un double. Hasta aquí
todo va bien, el resultado de multiplicar dos números double es un double:
precio = precio * 1.2;
(int) (double)
(conversión
automática a
double)
(double)
 El problema viene a continuación: no hay conversión automática de un double (el resultado
del producto) a un int (la variable a la izquierda del operador =)
 Para que se produzca esta conversión es necesario realizar un moldeado (cast):
 precio = (int) (precio * 1.2); // Esto si es correcto

15. Indice
15
Operadores aritméticos
 Suma: +
 Resta: -
 Producto: *
 División: /
 Módulo: % (se puede aplicar a coma flotante y a int)
 Incremento: ++ (a++ es equivalente a: a=a+1)
 Decremento: -- (a-- es equivalente a: a=a-1)
 Suma y asignación: += (a+=3 es equivalente a: a=a+3)
 Resta y asignación: -= (a-=3 es equivalente a: a=a-3)

16. Indice
16
Operadores relacionales
 El resultado de los operadores relacionales es un valor
boolean (true o false):
 Igual a: == (no confundirlo con el operador de asignación)
 Distinto de: !=
 Mayor que, mayor o igual: >, >=
 Menor que, menor o igual: <, <=
 Ejemplo 1:
int a = 5, b = 2;
boolean c = a >= b;
 Ejemplo 2:
float a = 3;
if (a == 3)
System.out.println( “El valor es:” + a);

17. Indice
17
¿Qué ocurre con String?
 A menudo necesitamos comparar cadenas de caracteres, para
saber si una es lexicográficamente igual, mayor o menor que otra.
El ejemplo típico es ordenar una lista de nombres
 Ya sabemos que String no es un tipo simple, sino que es una clase.
Para ayudarnos en la comparación tenemos los métodos
compareTo y compareToIgnoreCase. Podemos saber el
orden de las cadenas en función de lo que devuelvan los métodos:
String j = "Belén", k = "Susana", m = "Belén", n = "Antonio";
if (j.compareTo(m) == 0)
System.out.println( j + " es igual a " + m);
if (j.compareTo(k) < 0)
System.out.println( j + " es menor que " + k);
if (j.compareTo(n) > 0)
System.out.println( j + " es mayor que " + n);
 Existe también el método equals( String ), que devuelve true si
las cadenas son iguales. Hay otra versión
equalsIgnoreCase(String)
Belén es igual a Belén
Belén es menor que Susana
Belén es mayor que Antonio

18. Indice
18
Operadores lógicos
 Operan solamente con valores booleanos:
 Conjunción (Y): &&
 Disyunción inclusiva (O): ||
 Negación: !
 Ejemplo:
int edad = 17;
float nota = 6f;
boolean mayoria_edad = edad >= 18;
if (mayoria_edad && nota >= 5)
System.out.println( "aprobado" );
if (!mayoria_edad)
System.out.println( "Le falta(n) " + (18-edad) + " año(s)" );

19. Entradas y Salidas básicas

20. Indice
20
Streams (I)
 Cualquier programa realizado en Java que necesite llevar a cabo una operación de
I/O lo hará a través de un stream.
 Un stream, cuya traducción literal es "flujo", es una abstracción de todo aquello que
permite introducir o extraer información. Así, un stream de teclado es un flujo de
entrada para el programa y un stream de pantalla es un flujo de salida del programa
Input:
Teclado
Output:
Pantalla
 La vinculación de este stream al dispositivo físico (teclado, pantalla, impresora,
etc.) la hace el sistema de entrada y salida de Java.

21. Indice
21
Streams (II)
 El paquete System define tres clases:
 in (entrada estándar)
 out (salida estándar)
 err (salida de errores estándar)
 La escritura hacia pantalla se hace con System.out
System.out.println(“Hola Mundo”); // Añade nueva línea al final
System.out.print(“Adios”); // NO añade nueva línea al final
 La lectura desde teclado se hace con System.in

22. Indice
22
Stream de entrada por teclado
 Para manejar entradas por teclado tenemos que crear un BufferedReader a partir de
System.in:
import java.io.*;
public class inicio {
public static void main(String[] args) throws IOException {
String cadena;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in)); // Crear objeto de entrada
System.out.println("Escribe tu nombre:");
cadena = entrada.readLine(); //leemos cadena de caracteres mediante readLine()
}
}
 Condiciones previas a la creación de un BufferedReader:
 Tengo que importar las clases que uso (BufferedReader y InputStreamReader), que están en el
paquete java.io, por medio de import.
 Tengo que poner “throws IOException” en la función que usa BufferedReader (ya se explicará más adelante
el manejo de excepciones).
 Una vez creado el objeto de entrada para teclado, mediante BufferedReader, puedo leer la
entrada por teclado mediante una llamada a objeto.readLine() (la entrada termina al pulsar
Enter). No olvidar que esta función devuelve un String, es decir, cualquier cosa que
el usuario teclea se almacena como una cadena, sea “pedro” o “3420”. Java es un
lenguaje fuertemente tipado y si queremos que lo tecleado se convierta en un número habrá que
hacer posteriormente una conversión mediante métodos, como veremos en el siguiente ejemplo.

23. Indice
23
Un ejemplo entrada por teclado y
conversión
public static void main(String[] args) throws IOException {
double PI = 3.1416, radio;
int area_int;
String c;
/* Creo el objeto 'entrada', es un lector de entradas por teclado */
BufferedReader entrada = new BufferedReader( new InputStreamReader(System.in));
System.out.print( "Escriba el radio: " );
c = entrada.readLine(); // Leo un String de la entrada de teclado
radio = Double.parseDouble( c ); // Convierto el String en double radio
System.out.println( "El área es: " + radio * radio * PI);
area_int = (int) (radio * radio * PI); // Calculo el área entera del círculo. Hago casting
System.out.println( "El área (entera) es: " + area_int);
}
 Desde un String existen conversiones a otros tipos: Integer.parseInt( cadena ) o
Float.parseFloat( cadena). La conversión inversa utiliza String.valueOf( numero).
 Qué paquete de librerías se necesita importar para poder utilizar System.in??

24. Indice
24
final
 Cuando se declara una variable como final estamos
dando la orden de que no se modifique. Es como definir
una constante
 Debe ser inicializada en la declaración, ya que cualquier
intento de modificarla provoca un error de compilación
 Utilidad: no permitir que un error de programación altere
el valor de una constante. Ejemplo:
class circulo {
private punto posicion;
private double radio;
static final public double PI = 3.1416;