Tema 02

FUNDACIÓN GENERAL
Curso para IZAR
Sintaxis básica
del lenguaje Java
El lenguaje Java — Tema 2 — Sintaxis básica

Sintaxis básica del lenguaje Java
Índice
Un par de cosas sobre las clases ... 3
Comentarios ... 4
Identificadores ... 8
Palabras reservadas ... 9
Separadores ... 10
Tipos de datos numéricos ... 11
Tipos de datos no numéricos ... 12
Literales ... 13
Variables ... 14
Constantes de clase ... 16
Bloques y ámbito de los identificadores ... 17
Operadores ... 18
Entrada/salida básica ... 21
Ejercicios ... 22
Una clase muy útil para números: Math ... 24
...
Luis Hernández Yáñez
Curso de Java para IZAR Tema 2 – Sintaxis básica - 2
Carlos Cervigón Rückauer
Sintaxis básica del lenguaje Java
Instrucciones de control de flujo ... 25

Selección condicional: bifurcación ... 26
Ejercicios ... 28
Selección condicional: ramificación múltiple ... 29
Bucles: la instrucción for ... 31
Ejercicios ... 34
Bucles: la instrucción while ... 35
Bucles: la instrucción do...while ... 36
break y continue ... 37
Ejercicios ... 38
Métodos ... 39
Ejercicios ... 43
Sobrecarga de métodos ... 44
Recursividad ... 45
Ejercicios ... 46
Ejercicio de refuerzo ... 47

Un par de cosas sobre las clases
 Un programa está compuesto por un conjunto de clases

(al menos una). Las clases son los módulos del programa.
 Una clase consiste en unos datos (atributos) y unas funciones
(métodos). Debe haber un método main() en una de las clases.
Una plantilla para los primeros programas de prueba:
// Programa.java
public class Programa {

// Declaraciones globales
public static void main(String[] args) {
// Declaraciones locales
// Instrucciones
}
}

Comentarios
 Tres tipos de comentarios:

// De una sola línea
/* De una ó
más líneas
*/
/** De documentación, de una o varias líneas.

Justo antes del elemento que documenta
(clase, método, etcétera)
*/
 Los comentarios de documentación son utilizados por javadoc
para generar documentación en formato HTML.
Pueden llevar etiquetas.

Comentarios: etiquetas para javadoc
 Etiquetas para referencias:

@see <otra clase>
 Etiquetas de documentación de clases:

@version <información sobre la versión>
@author <nombre autor>
 Etiquetas de documentación de métodos:

@param <nombre argumento><descripción>
@return <descripción>
@exception <excepción

Comentarios: ejemplo de uso de javadoc
Hola.java
// Hola.java
/** Primera clase de prueba

@author Luis Hernández
@version 1.0
@see Adios
*/
public class Hola {
/** Método principal
@param args argumentos de línea de órdenes
@return nada
*/
public static void main(String[] args) {
System.out.println("Hola mundo");
}
}

Comentarios: resultado de javadoc
javadoc Hola.java
Hola.html
y otras páginas más.

Identificadores
 En Java, un identificador comienza con una letra,

un subrayado (_) o un símbolo de dólar ($).
Los siguientes caracteres pueden ser letras o dígitos.
Java distingue entre mayúsculas y minúsculas
Convenios:
 Nombre de clase: empieza por mayúscula..
 Nombre de método o atributo: empieza por minúscula
(quizá con un subrayado delante para los atributos).
 Las constantes: todo en mayúsculas.
 Identificadores formados por varias palabras: comienzo de
cada nueva palabra en mayúsculas (dibujaRectangulo)

Palabras reservadas
abstract continue for new switch

boolean default goto null synchronized
break do if package this
byte double implements private threadsafe
byvalue else import protected throw
case extends instanceof public transient
catch false int return true
char final interface short try
class finally long static void
const float native super while

Separadores
() Para delimitar listas de parámetros o de argumentos.

Para modificar la precedencia en una expresión.
Para delimitar condiciones.
Para realizar conversiones de tipo (moldes o casting).
{} Para definir bloques de código.
Para delimitar listas de valores iniciales de los vectores (arrays).
[] Para declarar vectores y referenciar elementos de los mismos.
; Para terminar instrucciones.
, Para separar identificadores en declaraciones.
Para encadenar expresiones (operador coma).
. Para acceder a atributos de objetos u objetos globales de clases.
Para pasar mensajes a objetos.
Para acceder a un subpaquete de un paquete.

Tipos de datos numéricos
Tipo Tamaño Valor mínimo Valor máximo
byte 8 bits -128 127

short 16 bits -32768 32767
int 32 bits -2147483648 2147483647
long 64 bits < -9 x 1018 > 9 x 1018
float 32 bits +/- 3.4 x 1038 con 7 dígitos significativos

double 64 bits +/- 1.7 x 10308 con 15 dígitos significativos
Promoción de tipos
Un tipo A es de mayor rango que un tipo B si A es superconjunto de B.
Las variales de tipo B siempre se pueden asignar a las de tipo A
double > float > long > int > short > byte

Tipos de datos no numéricos
boolean: true false
char: caracteres (16 bits)
Clases envolventes de tipos básicos:
Integer Long Float

Double Boolean Character
Permiten manipular los tipos primitivos como objetos

Literales
 Numéricos: como en otros lenguajes.

Para que una constante sea long y no int, se añade una L (29L).
Para que una constante sea float y no double, se añade una F.
 Literales de carácter: entre comillas simples ('a').
Ciertos caracteres especiales se pueden representar utilizando
secuencias de escape:
\n para un salto de línea (\u000A).
\t para un tabulador (\u0009).
\b para un retroceso (\u0008).
\r para un retorno de carro (\u000D).
 Literales de cadenas de caracteres: entre comillas dobles
"Hola mundo"

Variables: declaración
tipo nombre;
tipo nombre = expresión; // inicialización
tipo nombre1, nombre2,...;
tipo nombre1 = exp1, nombre2 = exp2, ...;
long suma = 234;

int altura = 23, ancho = 45;
double resultado = 0.0;
float area = 23 * 45;
boolean encontrado = false;
char nl = '\n';
Variables.java

Variables: consideraciones
 Variables compuestas por más de una palabra:

iniciales en mayúscula menos la primera (nombreDato).
 Variables globales de la clase: si no se inicializan explícitamente,
se les asigna un valor por defecto.
 Variables locales de los métodos: deben inicializarse siempre
de forma explícita.
El modificador final
Impide que se altere el valor de la variable (constante):
final int ANCHURA_MAXIMA = 120;
final double PI = 3.1416;
final int ABRIR_ARCHIVO = 1;
Por convenio, las constantes se escriben en mayúsculas.

Constantes de clase
 Accesibles en toda la clase.

 Se declaran en la sección de declaraciones globales de la clase.
 Se declaran como static (de clase) y final (inmodificables),
asignándoles el valor en la declaración.
public class Pruebas {

static final double PI = 3.14159265;
public static void main (String[] args) {
System.out.println(PI);
}
}

Bloques y ámbito de los identificadores
 Las llaves delimitan bloques de código: { ... }

 Los bloques están anidados unos dentro de otros
(a excepción del bloque correspondiente a la clase entera).
 Las reglas de ámbito (alcance) y visibilidad de los identificadores
son las habituales:
 El ámbito es el bloque en el que está definido
(junto con todos los bloques que contenga).
 La visibilidad es menor que el ámbito si en bloques interiores
se declaran otros identificadores iguales.
Nota: Java permite que haya variables locales de los métodos
con igual nombre que atributos de la clase (los ocultan), pero no permite
que dentro de los métodos se use dos veces un mismo identificador.
 Por defecto, las variables se crean cuando se entra en su ámbito
y se destruyen cuando se sale de él.

Operadores
Operador de asignación =
variable = expresión;
Operadores aritméticos
Unarios: + - ++ (incremento) -- (decremento)
x = y++; // Se asigna y a x; luego se incrementa y
x = ++y; // Se incrementa y; luego se asigna y a x
Binarios: + - * / % (módulo)
Ternario: ? (x < y) ? x : y (si x < y, entonces x, si no y)
Abreviaturas
x += y; equivale a x = x + y;
x -= y; equivale a x = x - y;
x *= y; equivale a x = x * y;
x /= y; equivale a x = x / y;
x %= y; equivale a x = x % y; Area.java

Operadores
Operadores relacionales == != < <= > >=
Operadores lógicos (booleanos) Evaluación perezosa

! Negación (NOT)
&& Conjunción (AND) (& para evaluación no perezosa)
|| Disyunción (OR) (| para evaluación no perezosa)
^ O exclusiva (XOR)
Conversiones de tipos: los moldes (casts)

La promoción de tipos es automática (de menor a mayor).
Las conversiones de tipos mayores a tipos menores se debe hacer
explícita por medio de moldes: el tipo deseado entre paréntesis.
(tipo) expresión
El molde precede a lo que se quiere convertir. Casting.java

Operadores: precedencia
Mayor moldes
++ -- (prefijos)
!
* / %
+ -
< <= > >=
== !=
Los paréntesis
& nos permiten
^ pasar por alto
| la precedencia
&&
||
Menor = += -= *= /= %=

Entrada/salida básica
Java no proporciona métodos directos para leer datos del teclado.

Proporciona métodos para leer líneas.
Una clase MyInput para leer números y cadenas del teclado:
MyInput.java
...
public class MyInput
{
public static String readString() { ... }
public static int readInt() { ... }
public static double readDouble() { ... }
public static byte readByte() { ... }
public static short readShort() { ... }
public static long readLong() { ... }
public static float readFloat() { ... }
}
Reproducido de “Introduction to Java”, Y. Daniel Liang, Prentice Hall 2001.

Ejercicios
Desarrollar un programa en una clase denominada AreaCirculo

que pida el radio de un círculo y muestre el área del mismo.

Ejercicios
Desarrollar un programa, con una clase que se denomine

CalculoHipoteca, que permita calcular los pagos mensual y
total de un crédito hipotecario. Pedirá la tasa de interés anual
(porcentaje), el número de años y la cantidad a prestar.
cantidad  tasaInteresMensual
pagoMensual 
1
1
(1  tasaInteresMensual ) años12
donde tasaInteresMensual está normalizada (entre 0 y 1).

AB  Math.pow(A,B);
 Si quieres que no se
cambie de línea cuando
imprimas en la pantalla:
System.out.print();

Una clase muy útil para números: Math
La clase Math proporciona dos constantes (Math.E y Math.PI) y

muchos métodos (de clase) útiles para operaciones matemáticas.
Es una clase del lenguaje (java.lang) y por eso se importa
automáticamente.
Algunos de los métodos de la clase son:
Math.abs(num) Math.acos(num) Math.atan(num)
Math.cos(num) Math.exp(num) Math.log(num)
Math.max(a,b) Math.min(a,b) Math.pow(a,b)
Math.random() Math.round(num) Math.sin(num)
Math.sqrt(num) Math.tan(num)
Math.toDegrees(num) Math.toRadians(num)
Práctica:
Rehacer los dos ejercicios anteriores para que el área del círculo
sea más precisa y los resultados se muestren con dos decimales.
AreaCirculo2 CalculoHipoteca2
Instrucciones de control del flujo
 Instrucciones de selección condicional:

 Bifurcación: if if-else
 Selección múltiple: switch
 Instrucciones de bucles:
 Número de iteraciones predeterminado: for
 Bucles condicionales: while do-while
 Instrucciones de paso de control: break continue

Selección condicional: bifurcación
Para la bifurcación condicional disponemos de la típica estructura if.

Veamos sus distintas variaciones:
if(condición) instrucción;
if(condición) instrucción-if;
else instrucción-else; true false
condición
if(condición) {
secuencia-de-instrucciones;
} Instrucción Instrucción
o bloque if o bloque else
if(condición) {
secuencia-de-instrucciones-if;
}
else {
secuencia-de-instrucciones-else;
}

Selección condicional: bifurcación
if-else anidados: cada else se asocia al if anterior más cercano.

if(i == j) {
if(j == k)
System.out.println("i igual a k");
} // Llaves para que el else se asocie al primer if
else {
System.out.println("i no es igual a j");
}
Escalera if-else-if:
if(n == 1 ) { // Bloque 1
}
else if(n == 2) { // Bloque 2
}
else { // Si todo falla, Bloque 3
}

Ejercicios
– Modificar el programa de cálculo de pagos de hipotecas, de forma

que el interés anual dependa del número de años del préstamo:
 7,25% hasta 15 años (exclusive)
 8,5% hasta 20 años (exclusive)
 9,75% hasta 25 años (exclusive) CalculoHipoteca3
 11% hasta 30 años
Además, los préstamos no pueden durar menos de 10 años
ni más de 30.
Nota: para forzar la finalización del programa se puede usar
System.exit(0). A menudo evita tener que anidar demasiadas
bifurcaciones condicionales.
– Crear un programa que pida tres números (num1, num2 y num3)
y los ordene, de forma que num1 contenga el mayor, num2
contenga el intermedio y num3 contenga el menor. Ordena
Selección condicional: ramificación múltiple
Si tenemos que disponer más de dos ramas de ejecución

y la elegida depende del valor de una variable o una expresión,
entonces debemos elegir la instrucción switch.
La sintaxis básica es la siguiente:
switch(expresión) { true
exp==val1 instrucciones1
case valor1:
instrucciones1 false
[break;] true instrucciones2
case valor2: exp==val2
instrucciones2
[break;] false
... ...
[ default: true instruccionesN
exp==valN
por-defecto ]
} false
por-defecto
[...] : opcional La instrucción vacía existe

Selección condicional: ramificación múltiple
switch(mes) {
case 1: case 3: case 5:
case 12:
numeroDias = 31;
break;
case 11:
numeroDias = 30;
break;
default:
numeroDias = 28;
}

Bucles: la instrucción for
Para ejecutar un determinado número de veces una instrucción

o un bloque de código disponemos de la típica instrucción for:
for(inicialización;condición;incremento)
instrucción;
for(inicialización;condición;incremento) {
secuencia-de-instrucciones
}
La sección de inicialización sirve para establecer la situación inicial;
habitualmente se trata simplemente de la asignación de un valor
inicial a una variable de control de bucle.
La sección de condición indica si debe proseguir la repetición;
mientras sea cierta (true) el bucle continuará.
La sección de incremento sirve para establecer la nueva situación
de la siguiente iteración; habitualmente se incrementa la variable.

for(contador = 1; contador <= ciclos; contador++)

instrucción;
contador = 1
true contador false

<= ciclos
instrucción
contador++

TestMulTable.java
...
// Display the number title
System.out.print(" | ");
for(int j = 1; j <= 9; j++) System.out.print(" " + j);
System.out.println(" ");
// Print table body

for(int i = 1; i <= 9; i++) {
System.out.print(i+" | ");
for(int j = 1; j <= 9; j++) { // j de otro bloque
// Display the product and align properly
if(i * j < 10) System.out.print(" " + i * j);
else System.out.print(" " + i * j);
}
System.out.println();
}
...
Reproducido de “Introduction to Java”, Y. Daniel Liang, Prentice Hall 2001.

Ejercicios
– Crear un programa que pida un número y muestre una pirámide

como la siguiente (para el caso en el que el número sea 8):
1
1 2 1
1 2 3 2 1 Piramide
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
– Sabiendo que el valor de  se puede aproximar mediante la

siguiente fórmula:
CalculoPI
 = 4 x (1 – 1/3 + 1/5 – 1/7 + 1/9 – 1/11 + 1/13 ...)
Crear un programa que pida al usuario un número de iteraciones y
calcule el valor de  con ese número de aproximaciones.

Bucles: la instrucción while
La instrucción while es una de las dos que están disponibles para

bucles no determinados, aquellos que no tienen establecido de
antemano un número fijo de iteraciones. La continuidad del bucle
depende de alguna condición. Mientras (while) que la condición sea
cierta, se sigue iterando; en el momento en que la condición se
vuelva falsa, el bucle termina.
while(condición) instrucción;
while(condición) {
instrucciones
true false
} condición
instrucción

Bucles: la instrucción do...while
La instrucción do...while es la otra instrucción disponible para

bucles no determinados. La diferencia con el bucle while se
encuentra en que la condición se comprueba al final, después de
haber ejecutado el bloque. Así, siempre se realiza al menos una
iteración del bucle (con el while puede no haber iteración alguna).
do {
instrucciones
} while(condición)
Se ejecutan instrucciones
las instrucciones
false
hasta que condición
la condición
true
se haga falsa.

break y continue
La instrucción break, además de servir para interrumpir la

ejecución del código en los casos de los switch, sirve para
interrumpir la ejecución de un bucle while o do...while
(dar por terminado el bucle, saliendo de él de forma inmediata).
La instrucción continue sirve para interrumpir la ejecución de
la iteración actual de un bucle while o do...while, pasando
por alto el resto del código del bucle que haya a continuación y
forzando a que siga el bucle con la siguiente iteración.
int i = 0; float suma = 0;
do {
int num = MyInput.readInt();
¿Qué error hay
if(num == 0) break;
en este ejemplo?
if(num < 0) continue;
suma += 1 / num;
i++;
} while(i < 5); ContinueBreak.java

Ejercicios
– Convertir el siguiente bucle for en un while y en un do-while:

long suma = 0;
for(int i = 0; i <= 1000; i++) suma += i;
– ¿Cuál es la salida del siguiente código?

int num = 1000;
while(true) {
if(num < 9) break;
num -= 9;
}
System.out.println("num = " + num);
– ¿Y la de este otro?
int num = 1000;
while(true) {
if(num < 9) continue;
num -= 9;
}
System.out.println("num = " + num);

Métodos
Los métodos de las clases son las unidades funcionales de Java.

Son similares a las funciones de otros lenguajes.
[modificadores] tipo nombre (parámetros)

{
// Cuerpo del método
}
Cabecera
 modificadores: indican cómo (dónde) se puede invocar el método.

De momento, simplemente static.
 tipo: tipo de dato que devuelve el método (void si nada).
 parámetros: declaraciones separadas por comas.

Métodos
static int max(int num1, int num2) Signatura

{
int result; Cada parámetro
if(num1 > num2) result = num1; con su tipo.
else result = num2; int num1, num2
return result;
}
 Para devolver valores se usa la instrucción return.
 El método termina al ejecutar una instrucción return
o al llegar a la llave de cierre.
static int max(int num1, int num2) { Si el método no es
if(num1 > num2) return num1; de tipo void, debe
else return num2; terminar siempre
} con un return.
Se puede forzar el fin de un método void con una instrucción

return;
Métodos: invocación
int mayor = max(3, 4);

int num1, num2;
...
mayor = max(num1, num2);
System.out.println(12 * max(num1, num2) – 3);
max(num1, num2); // válido, pero se pierde el resultado
 Los métodos de tipo void sólo se pueden invocar

como instrucciones independientes:
static void algo(...) {
...
}
algo(...);

Métodos: invocación
 Los métodos static se pueden invocar directamente (con su

nombre) en los demás métodos de su misma clase:
public class MayorMenor {
public static void main(String[] args){
int num1, num2, mayor, menor;
...
mayor = max(num1, num2);
Paso de parámetros
menor = min(num1, num2);
POR VALOR.
}
static int max(int num1, int num2) {
if(num1 > num2) return num1;
else return num2;
}
static int min(int num1, int num2) {
if(num1 < num2) return num1;
else return num2;
}
}
MayorMenor.java

Ejercicios
– Modificar el programa MayorMenor para que muestre el mayor

y el menor de cuatro números.
MayorMenor2
– Crear un programa que pida al usuario un número entero largo

y muestre la suma de los dígitos del número.
Usará un método que se encargue de realizar dicha suma.
SumaDigitos
– Crear un programa que muestre los 100 primeros números primos.

Usará un método esPrimo() que indique si un número es o no
primo. Mostrará diez números primos por línea (y alineados en
columnas).
Primos

Métodos: sobrecarga
 Los métodos se pueden sobrecargar: varios métodos con igual

nombre pero diferente signatura.
public class X {
...
}
static int max(int num1, int num2) { ... }
static long max(long num1, long num2) { ... }
static float max(float num1, float num2) { ... }
static double max(double num1, double num2) { ... }
}
 Se sabe cuál usar por el tipo de los argumentos.
Sobrecarga.java

Métodos: recursividad
 También llamada recursión, es la posibilidad de que un método

se invoque a sí mismo.
public class Factorial {
long num;
System.out.print("Introduce el numero cuyo
factorial quieres calcular: ");
num = MyInput.readLong();
System.out.println("El factorial de " + num +
" es " + factorial(num));
}
static long factorial(long num) {
if(num == 1) return 1; // Caso base
return num * factorial(num - 1);
// Cada vez más cerca del caso base
}
} Factorial.java

Ejercicios
– Crear un programa que calcule números de Fibonacci.

Pedirá el número del que se quiere calcular su Fibonacci.
F(0) = 0
F(1) = 1 Fibonacci
F(N) = F(N-2) + F(N-1) si N > 1
– Crear un programa que indique los movimientos que hay que
realizar para resolver el problema de las torres de Hanoi.
Se pedirá el número de discos que se quieren mover.
Cada pedestal está identificado por una letra (A, B y C).
La torre está inicialmente en el A y se quiere llevar al C.
Para mover una torre de discos de un pedestal X a otro pedestal Y,
el primer movimiento es mover el disco superior de la torre al
tercer pedestal, que se usa como auxiliar.
Hanoi

Ejercicio de refuerzo
Desarrollar un programa que permita manipular fechas.

El día, el mes y el año serán variables de clase (static)
(se podrán acceder en cualquier método de la clase).
Los métodos que se desea que tenga el programa son:
 leer(): leerá del teclado el día, el mes y el año de la fecha.
 valida(): comprobará si la fecha leída es correcta
(entre el 1-1-1900 y el 31-12-2050); si no es válida,
la ajustará para que lo sea. Se llamará al final de leer().
 mostrarCorta(): mostrará la fecha en formato corto
(por ejemplo, 02-09-2003).
 bisiesto(): dirá si el año de la fecha es bisiesto.
 diasMes(mes): devolverá el número de días del mes
que se le pasa para el año de la fecha. ...
Ejercicio de refuerzo
 diasTranscurridos(): devolverá el número de días

transcurridos desde el 1-1-1900 hasta la fecha.
 diaSemana(): devolverá el día de la semana de la fecha
(0 para domingo, 1 para lunes, ..., 6 para sábado).
El 1 de enero de 1900 fue domingo.
 mostrarLarga(): mostrará la fecha en formato largo
(por ejemplo, martes 2 de septiembre de 2003).
 fechaTras(dias): establecerá la fecha que corresponde
a haber pasado esos días desde el 1-1-1900.
 siguiente(): pasará al día siguiente.
El método main() servirá para probar los demás métodos.
Fecha


Tema 02

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 02

Cargado por

Copyright:

Formatos disponibles

FUNDACIÓN GENERAL

Curso para IZAR

El lenguaje Java — Tema 2 — Sintaxis básica

Instrucciones de control de flujo ... 25

Luis Hernández Yáñez

 Un programa está compuesto por un conjunto de clases

Una plantilla para los primeros programas de prueba:

public class Programa {

Luis Hernández Yáñez

 Tres tipos de comentarios:

/** De documentación, de una o varias líneas.

Luis Hernández Yáñez

 Etiquetas para referencias:

 Etiquetas de documentación de clases:

 Etiquetas de documentación de métodos:

Luis Hernández Yáñez

/** Primera clase de prueba

Luis Hernández Yáñez

y otras páginas más.

Luis Hernández Yáñez

 En Java, un identificador comienza con una letra,

Java distingue entre mayúsculas y minúsculas

Luis Hernández Yáñez

abstract continue for new switch

Luis Hernández Yáñez

() Para delimitar listas de parámetros o de argumentos.

Luis Hernández Yáñez

Tipo Tamaño Valor mínimo Valor máximo

byte 8 bits -128 127

float 32 bits +/- 3.4 x 1038 con 7 dígitos significativos

Luis Hernández Yáñez

boolean: true false

char: caracteres (16 bits)

Clases envolventes de tipos básicos:

Integer Long Float

Permiten manipular los tipos primitivos como objetos

Luis Hernández Yáñez

 Numéricos: como en otros lenguajes.

Luis Hernández Yáñez

long suma = 234;

Luis Hernández Yáñez

 Variables compuestas por más de una palabra:

Luis Hernández Yáñez

 Accesibles en toda la clase.

public class Pruebas {

Luis Hernández Yáñez

 Las llaves delimitan bloques de código: { ... }

Luis Hernández Yáñez

Luis Hernández Yáñez

Operadores relacionales == != < <= > >=

Operadores lógicos (booleanos) Evaluación perezosa

Conversiones de tipos: los moldes (casts)

Luis Hernández Yáñez

Luis Hernández Yáñez

Java no proporciona métodos directos para leer datos del teclado.

Luis Hernández Yáñez

Desarrollar un programa en una clase denominada AreaCirculo

Luis Hernández Yáñez

Desarrollar un programa, con una clase que se denomine

donde tasaInteresMensual está normalizada (entre 0 y 1).

Luis Hernández Yáñez

La clase Math proporciona dos constantes (Math.E y Math.PI) y

 Instrucciones de selección condicional:

 Instrucciones de paso de control: break continue