softyemprende@gmail.com
Un ejemplo de char es el siguiente:char ch = 'a';
// Caracter griego omega
char uniChar = '\u039A';
// Un array de caracteres
char[] charArray = { 'a', 'b', 'c', 'd', 'e' };
class ArrayDemo {
public static void main(String[] args) {
// declares an array of integers
int[] anArray;
// allocates memory for 10 integers
anArray = new int[10];
// initialize first element
anArray[0] = 100;
// initialize second element
anArray[1] = 200;
// etc.
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: "+ anArray[0]);
System.out.println("Element at index 1: "+ anArray[1]);
System.out.println("Element at index 2: "+ anArray[2]);
System.out.println("Element at index 3: "+ anArray[3]);
System.out.println("Element at index 4: "+ anArray[4]);
System.out.println("Element at index 5: "+ anArray[5]);
System.out.println("Element at index 6: "+ anArray[6]);
System.out.println("Element at index 7: "+ anArray[7]);
System.out.println("Element at index 8: "+ anArray[8]);
System.out.println("Element at index 9: "+ anArray[9]);
}
}
Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
void applyBrakes() {
if (isMoving) {
currentSpeed--;
} else {
System.err.println("The bicycle has " + "already stopped!");
}
}
Si la condición isMoving es true se reduce la velocidad, si no, se muestra el mensaje de bibicleta parada.
Las sentencias if else se podrán anidar en bloques alternativos tal y como veremos en ejercicios
subsiguientes.
Control de flujo en bloques alternativos switch:
En el caso de varios bloques alternativos se debe usar la sentencia de control de flujo switch. Se evalúa la
condición de dentro del paréntesis del switch y dependiendo del resultado se ejecutan unas u otras sentencias.
Un ejemplo es el siguiente:
public class SwitchDemo {
public static void main(String[] args) {
int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
case 4: monthString = "April";
break;
case 5: monthString = "May";
break;
case 6: monthString = "June";
break;
case 7: monthString = "July";
break;
case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
for (initialization; termination; increment) {
statement(s)
}
El siguiente ejemplo imprime en pantalla los números del 1 al 10:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11 i="i" span="span">
System.out.println("Count is: " + i);
}
}
}
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Bloques repetitivos con evaluación de la condición al final del
bloque: la estructura do ... while:
Para implementar un bloque repetitivo condicionado con evaluación al final del bloque tendremos que recurrir
al bucle do...while.
El bucle do...while ejecuta y luego evalúa, vamos 007, es decir, siempre se ejecuta al menos una vez.
Se puede expresar como sigue:
do {
statement(s)
} while (expression);
Un ejemplo de programa con do...while es el siguiente:
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " + count);
count++;
} while (count < 11);
}
}
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Bloque repetitivo con la evaluación de la condición al principio del
bloque: la estructura while:
Para implementar un bloque repetitivo condicionado con evaluación al principio del bloque tendremos que
recurrir al bucle while.
El bucle while evalúa y luego ejecuta, es decir, no tiene porque ejecutarse ni una sola vez.
Se puede expresar como sigue:
while (expression) {
statement(s)
}
El mismo programa de ejemplo de los bucles anteriores para la estructura while:
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: "
+ count);
count++;
}
}
}
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
public class SwitchDemo {
public static void main(String[] args) {
int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
case 4: monthString = "April";
break;
case 5: monthString = "May";
break;
case 6: monthString = "June";
break;
case 7: monthString = "July";
break;
case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
La anterior clase muestra el mes que le pasamos al entero month.
for (Type type : types) {
for (Type t : types2) {
if (some condition) {
// Hace algo
break; // Reanuda la ejecución del bucle interno
}
}
} search: {
for (Type type : types) {
for (Type t : types2) {
if (some condition) {
// Hace algo
break search;
}
}
}
}
class BoolTest {Esta es la salida generada por el programa.
public static void main(String args[]) {
boolean b;
b = false;
System.out.println("b is " + b);
b = true;
System.out.println("b is " + b);
// El valor boolena b controlará la salida
if(b)System.out.println("This is executed.");
b = false;
if(b) System.out.println("This is not executed.");
// salida de una operación booleana
System.out.println("10 > 9 is " + (10 > 9));
}
}
assert La
palabra assert, que fué añadida en la versión 1.4 de Java, se usa para
hacer aserciones- una sentencia que el programador sabe que es siempre
true en un punto del programa. Si las aserciones están habilitadas
cuando el programa está corriento y nos salimos del flujo de ejecución
la aserción se vuelve false, y una excepción AssertionError se lanza
terminando el programa. El motivo de esta palabra reservada es el
debugging.
|
Nivel de Acceso
|
Clase
|
Subclase
|
Paquete
|
Todas
|
|
Private
|
X
|
X |
X
|
X
|
|
Protected
|
X
|
X |
X
|
|
|
Public
|
X
|
X |
|
|
|
Package
|
X
|
|
|
|
|
VARIABLES DE TIPOS PRIMITIVOS
|
|||||
|
Nombre
|
Tipo
|
Tamaño
|
Valor por defecto
|
Forma de inicializador
|
Rango
|
|
boolean
|
Lógico
|
1 bit
|
False
|
boolean a=true
|
True-False
|
|
char
|
Carácter
|
16 bits
|
NULL
|
char a =’a’
|
Unicodde
|
|
byte
|
Número entero
|
8 bits
|
0
|
byte a=0
|
-128 a 127
|
|
short
|
Número entero
|
16 bits
|
0
|
short a = 12
|
-32768 a 32767
|
|
int
|
Número entero
|
32 bits
|
0
|
int a = 1280
|
-2147483648 a 2147483649
|
|
long
|
Número entero
|
64 bits
|
0
|
long a = 12500
|
-2^63 a 2^63-1
|
|
float
|
Número entero
|
32 bits
|
0
|
float a = 3.1
|
-3,4x10^38 a 3,4x10^38
|
|
double
|
Número entero
|
128 bits
|
0
|
double = 125.335
|
-1,79x10^308 a -1,79x10^308
|
|
Operador
|
Utilización
|
Expresión equivalente
|
|
+=
|
op1 += op2
|
op1 = op1 + op2
|
|
-=
|
op1 -= op2
|
op1 = op1 - op2
|
|
*=
|
op1 *= op2
|
op1 = op1 * op2
|
|
/=
|
op1 /= op2
|
op1 = op1 / op2
|
|
%=
|
op1 %= op2
|
op1 = op1 % op2
|
|
Operador
|
Nombre
|
Utilización
|
Resultado
|
|
|
&&
|
AND
|
op1 && op2
|
true si op1 y op2 son true. Si
op1 es false ya no se evalúa op2
|
|
|
||
|
OR
|
op1 || op2
|
true si op1 u op2 son true. Si op1
es true ya no se evalúa op2
|
|
|
!
|
negación
|
! op
|
true si op es false y false si op es true
|
|
|
&
|
AND
|
op1 & op2
|
true si op1 y op2 son true. Siempre se evalúa op2
|
|
|
|
|
OR
|
op1 | op2
|
true si op1 u op2 son true. Siempre
se evalúa op2
|
|
|
Operador
|
Utilización
|
El resultado es true
|
|
>
|
op1 > op2
|
si op1 es mayor que op2
|
|
>=
|
op1 >= op2
|
si op1 es mayor o igual
que op2
|
|
<
|
op1 < op2
|
si op1 es menor que op2
|
|
<=
|
op1 <= op2
|
si op1 es menor o igual
que op2
|
|
==
|
op1 == op2
|
si op1 y op2 son iguales
|
|
!=
|
op1 ¡= op2
|
si op1 y op2 son
diferentes
|