Programación.

DW 1º

TEMA 3: SENTENCIAS BÁSICAS DEL LENGUAJE Java

1. Estructura general de una clase Java
Hasta que no profundicemos en la programación orientada objetos (siguiente tema), simplemente debemos saber que los
programas en Java se organizan en CLASES. Algunas clases las diseñaremos nosotros, los programadores. Otras formarán
parte de las librerías de la API de Java.

En este tema, por cada uno de nuestros programas, crearemos una nueva clase, y dentro de la misma, un método
main, que será el primero en ejecutarse al poner nuestro programa en marcha.

Tendremos presente, además, lo siguiente:

• Los nombres de las clases comenzarán por mayúscula, y el resto de caracteres serán minúsculas
• Iremos dejando todas las clases dentro de un “PROYECTO Java”. Además, todas las clases relacionadas, irán dentro
del mismo “PAQUETE”
(De momento, no profundizaremos en estos conceptos)
• Si nuestros programas van a realizar operaciones de entrada de datos desde teclado, será necesario tener accesible
la clase Consola

Organización de un Ejemplo de clase Clase1 con método main

Proyecto Java

Los comentarios de bloque aparecen entre /* y */

Los comentarios de línea irán precedidos por //

2. TIPOS DE DATOS
Las variables en Java deben tener un tipo de dato asociado. El tipo de dato de una variable limitará los valores que
puede contener y las operaciones que se pueden realizar con ella.

Podemos dividir los tipos de datos en Java en dos categorías de datos principales:

• tipos primitivos y
• tipos referenciados

Los tipos primitivos contienen un sólo valor e incluyen los enteros, coma flotante (números reales), caracteres y
booleanos
Los tipos referenciados (que veremos más adelante)s se llaman así porque referencian valores reales. Algunos ejemplos
de datos referenciados son los arrays, las clases, los interfaces, etc.
De momento no nos ocuparemos de ellos

Existen 8 tipos de datos primitivos o integrados en Java:

• 4 tipos enteros: byte, short, int, long
• 2 tipos de coma flotante: float, double
• Booleano: boolean

1
Programación. DW 1º

• Carácter: char

Tipo Rango de valores Descripción

Números enteros
• Representan un número con signo y no pueden representar elementos fraccionarios.
8-bit en complemento a 2
byte Entero de un byte
desde -27 hasta 27 -1 (-128 a 127)
16-bit en complemento a 2
short Entero corto
desde -215 hasta 215-1 (-32768 a 32767)
32-bit en complemento a 2
int Entero
desde -231 hasta 231-1 (-2147483648 a 2147483647)
64-bit en complemento a 2
long desde -263 hasta 263-1 (-9223372036854775808 a Entero largo
9223372036854775807)
Números reales
• Pueden almacenar números en coma flotante con signo. Esto quiere decir que nos permiten
representar números decimales.
• Todos los literales de coma flotante son, por defecto, del tipo double
32-bit IEEE 754 Coma flotante de
float
Desde 1.40239846e–45f a 3.40282347e+38f precisión simple
64-bit IEEE 754
Coma flotante de
double Desde 4.94065645841246544e–324d a
precisión doble
1.7976931348623157e+308d.)
Caracteres
• Representan caracteres simples (letras, números, otros caracteres ). Un carácter esta
almacenado en 16 bits, y sigue el estándar Unicode
char 16-bit Caracter Un sólo carácter
Booleanos
• Sólo guardan dos valores: verdadero (true) o falso(false), y no como ocurre en otros
lenguajes que toman los valores 0 y 1

Un valor booleano
boolean true o false
(verdadero o falso)

Hay que destacar que los tipos de datos primitivos no son objetos y que 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.

2
Programación. DW 1º

3. DATOS: Tipos

3.1. Elección de un nombre identificador:

• Un identificador válido en Java es una serie de caracteres que consiste en letras, números, subrayados ( _ ) y
signos de dólar ($) y que NO empieza con un número.

Ejemplo de identificadores válidos:

variableNumero1
_VariableNumero2
$variable_numero_3

• Se permiten identificadores de cualquier longitud:

Pero_Que$_variablemaslarga_es_la_NUMERO4

• Se distingue entre mayúsculas y minúsculas (case-sensitive):

Mivariable ≠ mivariable

3.2. Declaración de variables (El “Entorno” del pseudocódigo)

El formato simplificado para declarar variables en Java es:

tipoVariable nombreVariable1, nombreVariable2, nombreVariable3, …….;

• Se puede declarar en una misma instrucción más de una variable del mismo tipo, separadas por una coma
• Se puede inicializar una variable en el momento de declararla.
Inicializar una variable consiste en almacenar un determinado valor en el espacio de memoria reservado para
ella.

Ejemplo float temperatura;

float temperatura, humedad, presion; float humedad;
Equivale a float presion;

Ejemplo

int p=5, r, s=6;

char letra=’A’;

La primera instrucción asignaría el valor 5 a la variable entera p y el valor 6 a s. A la variable r no se le asigna

ningún valor inicial.
La variable letra tomaría una A como valor inicial.

Java es un lenguaje de programación fuertemente tipado, es decir, cada variable debe ser obligatoriamente de
un tipo declarado

3
Programación. DW 1º

3.3. DECLARACIÓN DE CONSTANTES o LITERALES

Un literal es un valor constante formado por una secuencia de caracteres,
Ejemplos: 3 es un literal entero , 4.5 es un literal real, ‘#’ es un literal de tipo carácter, etc

TIPO DE LITERAL EJEMPLO

Booleanos true
false
Enteros
23
Las constantes enteras son cadenas de dígitos octales, decimales o hexadecimales. -6709
0
El comienzo de la constante declara la base del número: 056
• un 0 inicial denota un número octal (035). 0x23A3
875L
• un 0x o un 0X inicial denota un número hexadecimal(0x1D, 0X1D)).
• cualquier otra posibilidad denota un número decimal, base 10 (29).
Las constantes de tipo long se indican con una L al final
Las constantes enteras, por defecto,son de tipo int

Coma Flotante/Reales
0.78
Los números en coma flotante se expresan como números decimales con punto decimal -608.32
opcional, seguidos opcionalmente por un exponente. Deben contener como mínimo un 0.0
dígito: 18., 1.8e1, .18E2 2.7f
-32.7D
El número puede ir seguido por f o F para denotar una constante float, o por d o D para
las constantes double: 1.8F , 1.8D.

El cero puede ser positivo, +0.0, o negativo, -0.0. Ambos son iguales a efectos de
comparación

Las constantes de coma flotante son, por defecto, double.

char ‘Q’
Los literales de carácter aparecen entre comillas simples, como 'a'. ‘0’
Ciertos caracteres especiales se representan utilizando secuencias de escape: ‘$’
• \n salto de línea (\u000A). ‘\n’
• \t tabulador (\u0009). ‘\t’
• \b retroceso (\u0008). ‘ ‘
• \r retorno de carro (\u000D).
• \f salto de página (\u000C).
• \\ barra invertida (\u005C).
• \' apóstrofe ' (\u0027).
• \" dobles comillas " (\u0022).
• \ddd un carácter dado en código octal (sólo ASCII).
• \uhhhh un carácter dado en código hexadecimal (Unicode)

Cadenas de Caracteres /Strings

“Egun on”
Los literales de cadenas de caracteres son secuencias de caracteres entre comillas dobles “A\tBC\n”

Todas las secuencias de escape para los literales tipo carácter son válidas para las cadenas
de caracteres.

Un literal de cadena de caracteres referencia un objeto de tipo String, aunque esto ya lo

explicaremos más adelante.

4
Programación. DW 1º

Java, puede identificar literales mediante nombres, definiendo CONSTANTES.

Para definir una constante se antepone la palabra reservada final en la declaración de una variable, y se le da,
normalmente, un valor al declararlo.

Ejemplo

final double PI = 3.141592;

final char SALTO_LINEA = ‘\n’;

Existe el convenio de nombrar las constantes mediante TODO MAYUSCULAS

4. LOS OPERADORES

4.1. OPERADORES ARITMÉTICOS BINARIOS

+ Suma
- Resta
* Multiplicación
/ Cociente de la división
% Resto de una división entera

• La división entera produce un cociente entero. Cualquier parte fraccionaria se desecha, no hay redondeo:
17 / 5 produce 3
• El operador módulo produce el resto de la división entera. Sólo puede usarse con tipos enteros. El signo es
el del numerador : 17 % 5 produce 2
• Reglas de precedencia:
1. Las expresiones contenidas entre paréntesis se evalúan primero, aplicando primero los operadores
del par de paréntesis más interno.
2. A continuación se aplican las operaciones de multiplicación, división y residuo de izquierda a
derecha.
3. A continuación se aplican las operaciones de suma y resta de izquierda a derecha.

4.2. OPERADORES DE INCREMENTO Y DECREMENTO

++ Incremento en una unidad
-- Decremento en una unidad

Los operadores ++ y - - incrementan y decrementa en una unidad, y se pueden colocar a la izquierda o a la

derecha de una variable.
Si se colocan a la izquierda, se realiza el incremento antes que ninguna otra operación de la expresión.
Si se colocan a la derecha, se realizan antes las demás operaciones de la expresión, incluida la asignación y después
se incrementa la variable

Ejemplo: Si el valor de x es 5,
→ la instrucción j = x++ * 2, asignaría un 10 a la variable j
→ la instrucción j = ++x * 2, asignaría un 12 a la variable j.

4.3. OPERADORES RELACIONALES

> Mayor que >= Mayor o igual que = = Igual que
< Menor que <= Menor o igual que != Distinto que

(Ojo! No confundir = = con =. No usar un simple = para comparar !!!!!)

5
Programación. DW 1º

4.4. OPERADORES DE ASIGNACIÓN ARITMÉTICA

+=
-=
*=
/=
%=

Ejemplos:

c += 7 equivale a c = c + 7
d -= 4 equivale a d = d - 4
e *= 5 equivale a e = e * 5
f /= 3 equivale a f = f / 3
g %= 9 equivale a g = g % 9

4.5. OPERADORES LÓGICOS

&& Operador AND
|| Operador OR
! Operador NOT

Ejemplos:
if (!(calificación < 5))
System.out.println (“Aprobado”);

( i == 2) | | ( ( j > 4 ) && ! ( j > 8) ) es verdad si (i vale 2) o si (j vale más de 4 y menos de 9)

Operadores Lógicos. Evaluación en cortocircuito

La evaluación en cortocircuito es una forma de evaluar condiciones muy común en los lenguajes de
programación modernos. Consiste en que en cuanto se conoce el valor final de la expresión no se evalúan el
resto de condiciones.

El && (AND lógico) y || (OR lógico) se evalúan en cortocircuito.

Ejemplo 1:
(sexo == ‘m’) && (edad >= 65) →Si sexo no es mujer, no se evalúa la segunda condición edad >= 65.

Ejemplo 2:
(notaLab == noApto) || (notaTeoría < 5) → Si notaLab es noApto no se evalúa la segunda condición
Deducimos de los ejemplos que:
• En expresiones con &&, si las condiciones son independientes, conviene colocar primero la que tenga
mayores probabilidades de ser falsa.
• En expresiones con ||, si las condiciones son independientes, conviene colocar primero la que tenga
mayores probabilidades de ser verdadera.

Operadores lógicos. Condiciones dependientes

En expresiones que usan && y || es posible que sólo tenga sentido evaluar una condición (condición
dependiente) si se cumple la otra. La condición dependiente debe incluirse al final, para no incurrir en error.

Ejemplo:
int counter;
int media;
if (counter != 0 && media/counter > 5) { ... }

6
Programación. DW 1º

5. INSTRUCCIÓN DE ASIGNACION ( en pseudocódigo)

Lo que en pseudocódigo expresábamos como , en Java es =

Variable = expresión;

Ejemplos:
aux = 5;
preciofinal = precio – (precio * 20/100);

Java, al ser un lenguaje fuertemente tipado:

• No permite asignaciones inconsistentes respecto de los tipos.
• El valor del lado derecho de la asignación debe ser del mismo tipo que la variable del lado izquierdo

Ejemplo:

int operando1;
int operando2;
float operando3;

// Asignaciones válidas // Asignaciones no válidas

operando1 = 7; suma = operando1 + operando2; // variable suma no declarada
operando2 = 9; operando1 = 7.83; // 7.83 no es de tipo entero
operando3 = 4.7f; operando1 = operando3; // operando3 no es de tipo int

// Asignación curiosamente válida.

operando3 = operando1 + operando2; operando1 + operando2 es int, pero se promociona de
forma automática a float

7
Programación. DW 1º

6. Casting o conversión explícita de tipos

El casting es un procedimiento para transformar una variable primitiva de un tipo a otro.
Dicho casting puede ser implícito o explícito

El casting implícito es el que utiliza Java automáticamente para convertir de un tipo más restringido a un tipo
más amplio. Es posible asignar by te -> short -> int -> long -> float -> double

Ejemplo casting implícito:

int num1 = 100;

long num2 = num1;

Sin embargo, se requiere casting explícito cuando existe una potencial pérdida de exactitud, o cuando lo desea
expresamente el usuario. El casting explícito se codifica con el operador paréntesis

(char)98 devuelve ´b´

(int)10.0 devuelve el entero 10
(double)10 devuelve el double 10.0
(int)19.8 devuelve el entero 19

Ejemplo 1 casting explícito:

int num1=1000;
short num2= (short) num1;

* Si se sustituyera la primera línea int num1=100 por int num1=1000000, el código compilaría bien, pero
habría pérdida de datos, pues el 1000000 se sale del rango de short [-32768, 32767]. Al mostrar por consola el
valor se obtendría un resultado incongruente.

Ejemplo 2 casting explícito:

int a = 5;
int b = 4;
a / b toma el valor 1
(float) (a/b) toma el valor 1.0
(float) a / b toma el valor 1.25

8
Programación. DW 1º

7. INSTRUCCIÓN DE SALIDA o ESCRITURA EN PANTALLA

System.out.print (…………)
System.out.println ( ………….)

La diferencia entre print y println es que println introduce un salto de línea al final de la expresión visualizada

Podemos usarlas de los siguientes modos:

1. System.out.print (“string constante”) Ejemplo: System.out.print(“Hola mundo”);

2. System.out.print (variable)
3. System.out.print (“string constante” + variable)

Ejemplos:
System.out.print(“Introduce tu edad”);
System.out.println(“El máximo es “ + max + “ y el mínimo es “ + min);

8. INSTRUCCIÓN DE ENTRADA o LECTURA DE TECLADO

Usaremos los métodos estáticos de la clase Consola

Consola.leeInt( ) → Lee un entero de teclado y lo devuelve

Consola.leeFloat( ) → Lee un float de teclado y lo devuelve
Consola.leeChar( ) → Lee un carácter de teclado y lo devuelve
etc

9
Programación. DW 1º

9. INSTRUCCIONES CONDICIONALES

9.1. INSTRUCCIÓN if (equivalente a la Si/FinSi en pseudocódigo)

Ejecuta las instrucciones de un camino u otro dependiendo de si la condición es verdadera o falsa. El
formato es el siguiente:

if (condicion)
{
instrucciones_si_condicion_verdadera ;
}
else
{
instrucciones_si_condicion_falsa ;
}

La parte else es opcional.

Si en alguno de los dos caminos (if o else) sólo hay una instrucción pueden omitirse las llaves.

9.2. EL OPERADOR ? :

Condición ? Expresion1 : Expresion2

Se utiliza, generalmente, para dar un valor u otro a una variable, en función de una condición.
Evalúa la Condición. Si es verdadera se evalúa la Expresión1, sino la Expresión2

Ejemplo:

boolean haceCalor;
if (temperatura >= 30)
boolean haceCalor;
haceCalor=true; es equivalente a
haceCalor=(temperatura>=30 ? true : false);
else
haceCalor=false;

10
Programación. DW 1º

9.3. INSTRUCCIÓN switch

Ejecuta las instrucciones de un camino u otro dependiendo del valor que tome una variable. El
formato es el siguiente:

switch (expresión)
{
case valor1: instrucciones1;
break;
case valor2: instrucciones2;
break;
............
............
case valorN: instruccionesN;
break;
default: instrucciones_por_defecto;
}

Después de evaluarse la expresión se ejecutan las instrucciones de la rama cuyo valor coincida con el de la
expresión.
La parte default es opcional y se ejecuta cuando ninguno de los valores enumerados, de valor1 a valorN, ha
coincidido con el valor de la expresión.

Ejemplo
Programa que reciba un número de día de la semana y escriba su nombre.
public static void main(String[] args) {
int dia;
dia = Consola.leeInt();
switch (dia)
{
case 1: System.out.print (“Lunes\n”);
break;
case 2: System.out.print (“Martes\n”);
break;
case 3: System.out.print (“Miércoles\n”);
break;
case 4: System.out.print (“Jueves\n”);
break;
case 5: System.out.print (“Viernes\n”);
break;
case 6: System.out.print (“Sábado\n”);
break;
case 7: System.out.print (“Domingo\n”);
break;
default: System.out.print (“El día tiene que estar entre 1 y 7\n”);
}
}

Si la variable día hubiera sido declarada como char (char dia;), las sentencias case habrían sido de la forma:

case ‘1’: ................

y en la instrucción de lectura se hubiera utilizado Consola.leeChar();

11
Programación. DW 1º

10. INSTRUCCIONES REPETITIVAS

Permiten realizar un bloque de instrucciones varias veces. Existen tres instrucciones iterativas: while,
do while y for.

10.1. INSTRUCCIÓN while (Mientras DE PSEUDOCÓDIGO)

La instrucción while repite una o varias instrucciones mientras el valor de una condición sea true
El formato es el siguiente:

while ( condicion )
{
Instrucciones_que_se_repiten ;
}

Ejemplo: Programa que pida un número y escriba todos sus divisores en orden descendente:

public static void main(String[] args)

{
int num, divisor;

System.out.print (“Introduce numero: “);

num = Consola.leeInt( );
divisor = num;
while (divisor > 0)
{
if (( num % divisor) == 0 )
System.out.println (divisor + “ es divisor de “ + num );
divisor - -;
}
}

Al igual que en la instrucción if, es posible omitir las llaves cuando el while tiene una única sentencia.

10.2. INSTRUCCIÓN do …..while

Repite una instrucción o una serie de instrucciones hasta que se deja de cumplir una condición. La
diferencia con la WHILE es que la condición se evalúa después de ejecutar las instrucciones del bucle,
y por lo tanto, estas instrucciones siempre se ejecutarán por lo menos una vez.
El formato es:

do
{
instrucciones_que_se_repiten ;
} while (condición);

12
Programación. DW 1º

Ejemplo

Programa que lee una línea, carácter a carácter, y visualiza cuántas veces aparece la letra X

public static void main(String[] args) {

char c;
int cont = 0;

System.out.println (“Introduzca línea: “);

do{
c = Consola.leeChar( );
if (c == ‘X’ )
{
cont = cont + 1;
}
} while (c != ‘\n’);
System.out.println (“La X aparece “+ cont + “ veces” );
}

10.3. INSTRUCCIÓN for

Esta instrucción, en la mayoría de los lenguajes, está pensada para repetir un bloque de sentencias un
número determinado de veces. Su formato es:

for ( Inicialización ; Condición_para_continuar ; Cambio )

{
instrucciones_que_se_repiten ;
}

donde:

• La Inicialización es una instrucción, o varias separadas por comas, que se ejecutan tan sólo la primera vez.
Suele usarse para inicializar variables de control del bucle.
• La Condición_para_continuar (al igual que en la instrucción while) provoca el fin del bucle cuando su valor
es falso
• El Cambio es una instrucción, o varias separadas por comas, que se ejecutan una vez en cada iteración del
bucle antes de evaluar la condición de fin. Suele ser la instrucción de incremento de la variable índice, como,
por ejemplo,
i = i + 3;
i ++ ;
pero puede ser cualquier tipo de instrucción.

Cualquiera de las partes de la for puede estar vacía.

Por ejemplo, la siguiente es una for correcta: for ( ; ; )

Ejemplos

• Programa que escriba los 10 primeros números enteros en orden creciente:

for ( i = 1; i <= 10 ; i++ )
{
System.out.println ( i );
}

13
Programación. DW 1º

• Programa que escriba los 10 primeros números enteros en orden decreciente:

for ( i = 10; i >=1; i - - )
{
System.out.println ( i );
}

• Programa que lea dos números y escriba parejas de números formados por cada uno de los leídos
incrementando el primero y decrementando el segundo en dos unidades hasta que el primero sea mayor
o igual que 10 y el segundo sea menor o igual que 10.
main ( )
{
int i, j;
System.out.println(“Introduzca dos números:”);
i = Consola.leeInt( );
j = Consola.leeInt( );
for ( ; (i < 10) && (j > 10); i = i + 2, j = j – 2)
{
System.out.println ( i + “\t” + j );
}
}

Si los números leídos fueran el 3 y el 15, mostrará en pantalla:

3 15
5 13
7 11

14