Caracteres y secuencias de escape de Java

Los caracteres que pueden aparecer en un programa Java para formar las constantes,
variables, expresiones, etc., son:
 Las letras mayúsculas y minúsculas de la A(a) a la Z(z) de los alfabetos
internacionales (la ñ y Ñ son válidas)
 Dígitos (0, 1, 2, ...)
 Los caracteres ' _ ' '$' y cualquier carácter unicode por encima del 00C0.
 Los caracteres especiales y signos de puntuación siguientes:
+-*/=%&#!?^“‘~\|<>()[]{}:;.,
 Espacios en blanco: en programación se llaman espacios en blanco no solo a los
caracteres generados por la barra espaciadora. Además de espacios, también se llaman
espacios en blanco a los siguientes caracteres: tabulador y salto de línea. Su labor es la
misma que la de un espacio en blanco, hacer de separadores entre los distintos
elementos de un programa.

Por ejemplo, podemos escribir el método main sin utilizar espacios en blanco, de la
forma:

public static void main(String [] args){System.out.println("Hola Mundo!!!");}

Aunque queda mucho más claro si introducimos espacios:

public static void main(String [] args){

System.out.println("Hola Mundo!!!");
}

SECUENCIAS DE ESCAPE

Una secuencia de escape esta formada por una barra inversa seguida de una letra o de
una combinación de dígitos.
Una secuencia de escape siempre representa un solo carácter aunque se escriba con dos
o más caracteres.
Se utilizan para realizar acciones como salto de línea o para usar caracteres no
imprimibles.

Algunas secuencias de escape definidas en Java son:

 Secuencia Descripción
de escape
Ir al principio de la línea
\n
siguiente

\b Retroceso

\t Tabulador horizontal

\r Ir al principio de la línea

\" Comillas

\' Comilla simple

\\ Barra inversa

\udddd Carácter Unicode

Java: Identificadores y palabras reservadas

IDENTIFICADORES JAVA

Los identificadores son los nombres que el programador asigna a variables, constantes,
clases, métodos, paquetes, etc. de un programa.

Características de un identificador Java:

 Están formados por letras y dígitos.
 No pueden empezar por un dígito.
1. No pueden contener ninguno de los caracteres especiales vistos en una entrada
anterior.
 No puede ser una palabra reservada de Java. Las palabras reservadas en Java
son todas las que aparecen en el punto siguiente.

Ejemplo de identificadores válidos en Java:

Edad nombre _Precio Año año_nacimiento

num4 $cantidad _$cantidad cantidad_10_1 PrecioVenta

bl4nc0 miércoles PrIvAdo máximo

En los ejemplos se puede comprobar que tanto los caracteres ñ y Ñ como las vocales
acentuadas son caracteres válidos para crear identificadores en Java.

Java diferencia mayúsculas y minúsculas, por lo tanto, nombre y Nombre son

identificadores distintos.

Ejemplo de identificadores NO válidos:

 4num : Identificador no válido porque comienza por un dígito

 z# : No válido porque contiene el carácter especial #
 "Edad" : No válido porque no puede contener comillas
 Tom's : No válido porque contiene el carácter '
 año-nacimiento : no válido porque contiene el carácter -
 public : no válido porque es una palabra reservada del lenguaje
 __precio:final : no válido porque contiene el carácter :

PALABRAS RESERVADAS DE JAVA

Las palabras reservadas son identificadores predefinidos que tienen un significado para
el compilador y por tanto no pueden usarse como identificadores creados por el usuario
en los programas.

Las palabras reservadas en Java ordenadas alfabéticamente son las siguientes:

abstract continue for new switch

assert default goto package synchronized

boolean do if private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static void

class finally long strictfp volatile

 const float native super while

Comentarios en Java
Un comentario es un texto que se escribe dentro de un programa con el fin de facilitar
la comprensión del mismo.
Los comentarios se utilizan para explicar y documentar el código fuente.

En Java se pueden utilizar tres tipos de comentarios:

COMENTARIO TRADICIONAL

Los comentarios tradicionales son los mismos que se usan en C.

Las características de los comentarios tradicionales en Java son las siguientes:

 Empieza con los caracteres /* y acaba con */.

 Pueden ocupar más de una línea y pueden aparecer en cualquier lugar donde
pueda aparear un espacio en blanco.
 No pueden anidarse.
Ejemplos de comentarios tradicionales estilo C:

/* Programa Ecuación segundo grado

Calcula las soluciones de una ecuación de segundo grado */

/* Lectura de datos por teclado */

Ejemplo de comentario no válido:

/* linea comentario 1
/* linea comentario 2
linea comemtario 3
*/
linea comentario 4
linea comentario 5
*/

Comentario no válido. Los comentarios no se pueden anidar.

COMENTARIOS DE UNA SOLA LÍNEA

Las características de los comentarios de una línea son las siguientes:

 Comienzan con una doble barra ( // )
 Pueden escribirse al principio de la línea o a continuación de una instrucción.
 No tienen carácter de terminación.
Ejemplos de comentarios Java de una sola línea:

// Programa Ecuación segundo grado

// Calcula las soluciones de una ecuación de segundo grado

double p; // precio del producto

COMENTARIOS DE DOCUMENTACIÓN JAVADOC

Son comentarios especiales para generar documentación del programa.

Comienza con /** y termina con */

Ejemplo de comentario de documentación Javadoc:

/**
*
* @author Enrique
* @version 1.0
*
*/

Estructuras de control
ESTRUCTURA CONDICIONAL, ALTERNATIVA O SELECTIVA

La estructura condicional determina si se ejecutan unas instrucciones u otras según se

cumpla o no una determinada condición.

En java la estructura condicional se implementa mediante:

 Instrucción if.
 Instrucción switch.
 Operador condicional ? :

2.1 INSTRUCCION if

La instrucción condicional if puede ser de tres tipos::

 Condicional simple: if
 Condicional doble: if ... else ...
 Condicional múltiple: if .. else if ..
La condición a evaluar debe ser una expresión booleana es decir debe dar como
resultado un valor booleano (true ó false).

Condicional simple: se evalúa la condición y si ésta se cumple se ejecuta una

determinada acción o grupo de acciones. En caso contrario se saltan dicho grupo de
acciones.

if(expresión_booleana){
instrucción 1
instrucción 2
.......
}
Si el bloque de instrucciones tiene una sola instrucción no es necesario escribir las llaves
{ } aunque para evitar confusiones se recomienda escribir las llaves siempre.

Ejemplo de programa Java con estructura condicional: Programa que pide por teclado
la nota obtenida por un alumno y muestra un mensaje si el alumno ha aprobado.

/*
* Programa que pide una nota por teclado y muestra un mensaje si la nota es
* mayor o igual que 5
*/
import java.util.*;
public class Ejemplo0If {
public static void main( String[] args ){
Scanner sc = new Scanner( System.in );
System.out.print("Nota: ");
int nota = sc.nextInt();
 if (nota >= 5 ){
System.out.println("Enorabuena!!");
System.out.println("Has aprobado");
}
}
}

Condicional doble: Se evalúa la condición y si ésta se cumple se ejecuta una

determinada instrucción o grupo de instrucciones. Si no se cumple se ejecuta otra
instrucción o grupo de instrucciones.

if(expresión booleana){
instrucciones 1
}
else{
instrucciones 2
}

Ejemplo de programa Java que contiene una estructura condicional doble: Programa
que lee la nota de un alumno y muestra si el alumno ha aprobado o no.

/*
* Programa que pide una nota por teclado y muestra si se ha aprobado o no
*/
import java.util.*;
public class Ejemplo0If {
public static void main( String[] args ){
Scanner sc = new Scanner( System.in );
System.out.print("Nota: ");
int nota = sc.nextInt();
if (nota >= 5 ){
 System.out.println("Enorabuena!!");
System.out.println("Has aprobado");
}
else
System.out.println("Lo Siento, has suspendido");
}
}

2.2 INSTRUCCION switch

Se utiliza para seleccionar una de entre múltiples alternativas.

La forma general de la instrucción switch en Java es la siguiente:

switch (expresión){
case valor 1:
instrucciones;
break;
case valor 2:
instrucciones;
break;
···
default:
instrucciones;
}

La instrucción switch se puede usar con datos de tipo byte, short, char e int. También
con tipos enumerados y con las clases envolventes Character, Byte, Short e Integer. A
partir de Java 7 también pueden usarse datos de tipo String en un switch.

Funcionamiento de la instrucción switch:

 Primero se evalúa la expresión y salta al case cuya constante coincida con el valor de
la expresión.
 Se ejecutan las instrucciones que siguen al case seleccionado hasta que se encuentra
un break o hasta el final del switch. El break produce un salto a la siguiente
instrucción a continuación del switch.
 Si ninguno de estos casos se cumple se ejecuta el bloque default (si existe). No es
obligatorio que exista un bloque default y no tiene porqué ponerse siempre al final,
aunque es lo habitual.
Ejemplo de programa Java que contiene una instrucción switch: Programa que lee por
teclado un mes (número entero) y muestra el nombre del mes.

/*
 * Programa que pide un número de mes y muestra el nombre correspondiente
*/
import java.util.*;
public class Ejemplo0Switch {
public static void main(String[] args) {
int mes;
Scanner sc = new Scanner(System.in);
System.out.print("Introduzca un numero de mes: ");
mes = sc.nextInt();
switch (mes)
{
case 1: System.out.println("ENERO");
break;
case 2: System.out.println("FEBRERO");
break;
case 3: System.out.println("MARZO");
break;
case 4: System.out.println("ABRIL");
break;
case 5: System.out.println("MAYO");
break;
case 6: System.out.println("JUNIO");
break;
case 7: System.out.println("JULIO");
break;
case 8: System.out.println("AGOSTO");
break;
case 9: System.out.println("SEPTIEMBRE");
break;
case 10: System.out.println("OCTUBRE");
break;
case 11: System.out.println("NOVIEMBRE");
break;
case 12: System.out.println("DICIEMBRE");
break;
default : System.out.println("Mes no válido");
}
}
}

3. ESTRUCTURA ITERATIVA O REPETITIVA

Permiten ejecutar de forma repetida un bloque específico de instrucciones.

Las instrucciones se repiten mientras o hasta que se cumpla una determinada

condición. Esta condición se conoce como condición de salida.
Tipos de estructuras repetitivas:

 ciclo while
 ciclo do – while
 ciclo for

3.1 CICLO WHILE

Las instrucciones se repiten mientras la condición sea cierta. La condición se comprueba

al principio del bucle por lo que las acciones se pueden ejecutar 0 ó más veces.

La ejecución de un bucle while sigue los siguientes pasos:

1. Se evalúa la condición.
2. Si el resultado es false las instrucciones no se ejecutan y el programa sigue
ejecutándose por la siguiente instrucción a continuación del while.
3. Si el resultado es true se ejecutan las instrucciones y se vuelve al paso 1
Ejemplo de programa Java que contiene una instrucción while:
Programa que lee números por teclado. La lectura acaba cuando el número introducido
sea negativo. El programa calcula y muestra la suma de los números leídos.
/*
* Programa que lee números hasta que se lee un negativo y muestra la
* suma de los números leídos
*/
import java.util.*;
public class Ejemplo1While {
public static void main(String[] args) {
int suma = 0, num;
Scanner sc = new Scanner(System.in);
System.out.print("Introduzca un número: ");
num = sc.nextInt();
while (num >= 0){
suma = suma + num;
System.out.print("Introduzca un número: ");
num = sc.nextInt();
}
 System.out.println("La suma es: " + suma );
}
}

3.2 CICLO DO – WHILE

Las instrucciones se ejecutan mientras la condición sea cierta.

La condición se comprueba al final del bucle por lo que el bloque de instrucciones se

ejecutarán al menos una vez. Esta es la diferencia fundamental con la instrucción
while. Las instrucciones de un bucle while es posible que no se ejecuten si la condición
inicialmente es falsa.

La ejecución de un bucle do - while sigue los siguientes pasos:

1. Se ejecutan las instrucciones a partir de do{
2. Se evalúa la condición.
3. Si el resultado es false el programa sigue ejecutándose por la siguiente
instrucción a continuación del while.
4. Si el resultado es true se vuelve al paso 1
Ejemplo de programa Java que contiene una instrucción do while:
Programa que lee un número entero N. El número debe ser menor que 100.

/*
* Programa que obliga al usuario a introducir un número menor que 100
*/
import java.util.*;
public class Ejemplo1DoWhile {
public static void main(String[] args) {
int valor;
Scanner in = new Scanner( System.in );
do {
System.out.print("Escribe un entero < 100: ");
valor = in.nextInt();
}while (valor >= 100);
System.out.println("Ha introducido: " + valor);
}
}
3.3 CICLO FOR

Hace que una instrucción o bloque de instrucciones se repitan un número determinado

de veces mientras se cumpla la condición.

La estructura general de una instrucción for en Java es la siguiente:

for(inicialización; condición; incremento/decremento){

instrucción 1;
...........
instrucción N;
}

A continuación de la palabra for y entre paréntesis debe haber siempre tres

zonas separadas por punto y coma:
 zona de inicialización.
 zona de condición
 zona de incremento ó decremento.
Si en alguna ocasión no es necesario escribir alguna de ellas se pueden dejar en blanco,
pero los dos punto y coma deben aparecer.

Inicialización es la parte en la que la variable o variables de control del bucle toman su

valor inicial. Puede haber una o más instrucciones en la inicialización, separadas por
comas. La inicialización se realiza solo una vez.

Condición es una expresión booleana que hace que se ejecute la sentencia o bloque de
sentencias mientras que dicha expresión sea cierta. Generalmente en la condición se
compara la variable de control con un valor límite.

Incremento/decremento es una expresión que decrementa o incrementa la variable de

control del bucle.

La ejecución de un bucle for sigue los siguientes pasos:

1. Se inicializa la variable o variables de control (inicialización)
2. Se evalúa la condición.
3. Si la condición es cierta se ejecutan las instrucciones. Si es falsa, finaliza
la ejecución del bucle y continúa el programa en la siguiente instrucción
después del for.
4. Se actualiza la variable o variables de control (incremento/decremento)
5. Se vuelve al punto 2.
Ejemplo de programa Java que contiene una instrucción for:

/*
* programa que muestra los números del 1 al 10
*/
public class Ejemplo0For {
public static void main(String[] args) {
int i;
for(i=1; i<=10;i++)
System.out.println(i + " ");
}
}
3.5 BUCLES ANIDADOS

Bucles anidados son aquellos que incluyen instrucciones for, while o do-while unas
dentro de otras.
Debemos tener en cuenta que las variables de control que utilicemos deben ser
distintas.

Los anidamientos de estructuras tienen que ser correctos, es decir, que una estructura
anidada dentro de otra lo debe estar totalmente.

Ejemplo de programa Java con bucles anidados:

/*
* Programa que dibuja un rectángulo sólido de asteriscos.
* El número de filas y columnas se pide por teclado
*/
import java.util.*;
public class Ejemplo1BuclesAnidados {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int filas, columnas;
//leer número de filas hasta que sea un número > 0
do{
System.out.print("Introduce número de filas: ");
filas = sc.nextInt();
}while(filas<1);
//leer número de columnas hasta que sea un número > 0
do{
System.out.print("Introduce número de columnas: ");
columnas = sc.nextInt();
}while(columnas<1);
for(int i = 1; i<=filas; i++){ //filas
for(int j = 1; j<=columnas; j++){ //columnas
System.out.print(" * ");
}
System.out.println();
}

}
}
La salida de este programa para filas = 6 y columnas = 10 es:

* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
Ejemplo de programa Java con bucles anidados:

/*
* Programa que muestra una tabla con las potencias de x (x x2 x3 x4)
* para valores de x desde 1 hasta XMAX
*/
public class JavaApplication22 {
public static void main(String[] args) {
final int XMAX = 10;
int x, n;
//mostrar la cabecera de la tabla
System.out.printf("%10s%10s%10s%10s%n", "x","x^2","x^3","x^4");
for (x = 1; x <= XMAX; x++){ //filas
for (n = 1; n <= 4; n++){ //columnas
System.out.printf("%10.0f", Math.pow(x,n));
}
System.out.println();
}
}
}

El programa muestra por pantalla la siguiente tabla de potencias:

x x^2 x^3 x^4
1 1 1 1
2 4 8 16
3 9 27 81
4 16 64 256
5 25 125 625
6 36 216 1296
7 49 343 2401
8 64 512 4096
9 81 729 6561
10 100 1000 10000

Java Scanner para lectura de datos

La clase Scanner está disponible a partir de Java 5 y facilita la lectura de datos en los
programas Java.
Primero veremos varios ejemplos de lectura de datos en Java con Scanner y después
explicaremos en detalle como funciona.
Para utilizar Scanner en el programa tendremos que hacer lo siguiente:
1. Escribir el import
La clase Scanner se encuentra en el paquete java.util por lo tanto se debe incluir al inicio
del programa la instrucción:
import java.util.Scanner;
2. Crear un objeto Scanner
Tenemos que crear un objeto de la clase Scanner asociado al dispositivo de entrada.
Si el dispositivo de entrada es el teclado escribiremos:
Scanner sc = new Scanner(System.in);
Se ha creado el objeto sc asociado al teclado representado por System.in
Una vez hecho esto podemos leer datos por teclado.
Ejemplos de lectura:
Para leer podemos usar el método nextXxx() donde Xxx indica en tipo, por ejemplo
nextInt() para leer un entero, nextDouble() para leer un double, etc.

Ejemplo de lectura por teclado de un número entero:

int n;
System.out.print("Introduzca un número entero: ");
n = sc.nextInt();

Ejemplo de lectura de un número de tipo double:

double x;
System.out.print("Introduzca número de tipo double: ");
x = sc.nextDouble();

Ejemplo de lectura de una cadena de caracteres:

String s;
System.out.print("Introduzca texto: ");
s = sc.nextLine();

Funcionamiento la clase Java Scanner.

De forma resumida podemos decir que cuando se introducen caracteres por teclado, el
objeto Scanner toma toda la cadena introducida y la divide en elementos
llamados tokens.
El carácter predeterminado que sirve de separador de tokens es el espacio en blanco.
Por ejemplo, si introducimos:
Esto es un ejemplo, lectura de datos.
Scanner divide la cadena en los siguientes tokens:
Esto
es
un
ejemplo,
lectura
de
datos.

Mostrar la tabla de multiplicar de un número en Java

Programa Java que lea un número entero N y muestre la tabla de multiplicar de ese
número. Por ejemplo, si se lee el valor 7 se mostrará por pantalla:

Tabla del 7
--------------
7*1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

import java.util.*;
/**
* Programa que lea un número entero N y muestre la tabla de multiplicar de ese
número.
* @author Enrique
*/
public class TablaMultiplicar {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n;
System.out.print("Introduce un número entero: ");
n = sc.nextInt();
System.out.println("Tabla del " + n);
for(int i = 1; i<=10; i++){
System.out.println(n + " * " + i + " = " + n*i);
}
}
}

Métodos en Java
Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que
realizan una determinada tarea y a las que podemos invocar mediante un nombre.

Algunos métodos que hemos utilizado hasta ahora:

 – Math.pow()
– Math.sqrt()
– Character.isDigit()
- System.out.println();

Cuando se llama a un método, la ejecución del programa pasa al método y cuando éste
acaba, la ejecución continúa a partir del punto donde se produjo la llamada.

Utilizando métodos:
- Podemos construir programas modulares.
- Se consigue la reutilización de código. En lugar de escribir el mismo código repetido
cuando se necesite, por ejemplo para validar una fecha, se hace una llamada al
método que lo realiza.
En Java un método siempre pertenece a una clase.
Todo programa java tiene un método llamado main. Este método es el punto de entrada
al programa y también el punto de salida.
1. ESTRUCTURA GENERAL DE UN MÉTODO JAVA
La estructura general de un método Java es la siguiente:
[especificadores] tipoDevuelto nombreMetodo([lista parámetros]) [throws
listaExcepciones]
{
// instrucciones
[return valor;]
}
Los elementos que aparecen entre corchetes son opcionales.

especificadores (opcional): determinan el tipo de acceso al método. Se verán en detalle

más adelante.

tipoDevuelto: indica el tipo del valor que devuelve el método. En Java es imprescindible
que en la declaración de un método, se indique el tipo de dato que ha de devolver. El
dato se devuelve mediante la instrucción return. Si el método no devuelve ningún valor
este tipo será void.
nombreMetodo: es el nombre que se le da al método. Para crearlo hay que seguir las
mismas normas que para crear nombres de variables.
Lista de parámetros (opcional): después del nombre del método y siempre entre
paréntesis puede aparecer una lista de parámetros (también llamados argumentos)
separados por comas. Estos parámetros son los datos de entrada que recibe el método
para operar con ellos. Un método puede recibir cero o más argumentos. Se debe
especificar para cada argumento su tipo. Los paréntesis son obligatorios aunque estén
vacíos.
throws listaExcepciones (opcional): indica las excepciones que puede generar y
manipular el método.
return: se utiliza para devolver un valor. La palabra clave return va seguida de una
expresión que será evaluada para saber el valor de retorno. Esta expresión puede ser
compleja o puede ser simplemente el nombre de un objeto, una variable de tipo
primitivo o una constante.
El tipo del valor de retorno debe coincidir con el tipoDevuelto que se ha indicado en la
declaración del método.
Si el método no devuelve nada (tipoDevuelto = void) la instrucción return es opcional.
Un método puede devolver un tipo primitivo, un array, un String o un objeto.
Un método tiene un único punto de inicio, representado por la llave de inicio {. La
ejecución de un método termina cuando se llega a la llave final } o cuando se ejecuta la
instrucción return.
La instrucción return puede aparecer en cualquier lugar dentro del método, no tiene
que estar necesariamente al final.
2. IMPLEMENTACIÓN DE MÉTODOS EN JAVA
Pasos para implementar un método:
1. Describir lo que el método debe hacer
2. Determinar las entradas del método
3. Determinar los tipos de las entradas
4. Determinar el tipo del valor retornado
5. Escribir las instrucciones que forman el cuerpo del método
6. Prueba del método: diseñar distintos casos de prueba
Ejemplo de método: método que suma dos números enteros.
import java.util.*;
public class Metodos1 {
 public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int numero1, numero2, resultado;
System.out.print("Introduce primer número: ");
numero1 = sc.nextInt();
System.out.print("Introduce segundo número: ");
numero2 = sc.nextInt();
resultado = sumar(numero1, numero2);
System.out.println("Suma: " + resultado);
}
public static int sumar(int a, int b){
int c;
c = a + b;
return c;
}
}

El método se llama sumar y recibe dos números enteros a y b. En la llamada al

método los valores de las variables numero1 y numero2 se copian en las variables a y
b. El método suma los dos números y guarda el resultado en c. Finalmente devuelve
mediante la instrucción return la suma calculada.
Ejemplo de programa Java que contiene un método con varios return:
Programa que lee por teclado un año y calcula y muestra si es bisiesto. Para realizar el
cálculo utiliza un método llamado esBisiesto.

package bisiesto;
import java.util.*;
public class Bisiesto {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int año;
 System.out.print("Introduce año: ");
año = sc.nextInt();
if(esBisiesto(año)) //llamada al método
System.out.println("Bisiesto");
else
System.out.println("No es bisiesto");
}
/**
* método que calcula si un año es o no bisiesto
*/
public static boolean esBisiesto(int a){
if(a%4==0 && a%100!=0 || a%400==0)
return true;
else
return false;
}
}

En la llamada al método bisiesto, el valor de la variable año se copia en la variable a y el

método trabaja con esta variable. El valor true ó false devuelto por return pasa a ser el
valor de la condición.
Ejemplo de programa Java: Método que no devuelve ningún valor. El método cajaTexto
recibe un String y lo muestra rodeado con un borde.
El tipo devuelto es void y no es necesario escribir la sentencia return. El método acaba
cuando se alcanza la llave final.
import java.util.*;
public class MetodoVoid {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String cadena;
System.out.print("Introduce cadena de texto: ");
 cadena = sc.nextLine();
cajaTexto(cadena); //llamada al método
}
/**
* método que muestra un String rodeado por un borde
*/
public static void cajaTexto(String str){
int n = str.length();
for (int i = 0; i < n + 4; i++){
System.out.print("#");
}
System.out.println();
System.out.println("# " + str + " #");
for (int i = 0; i < n + 4; i++){
System.out.print("#");
}
System.out.println();
}
}

Arrays unidimensionales en Java

Concepto de Array o Arreglo:
Un array es una colección finita de datos del mismo tipo, que se almacenan en
posiciones consecutivas de memoria y reciben un nombre común.
Por ejemplo, supongamos que queremos guardar las notas de los 20 alumnos de una
clase.
Para almacenar las notas utilizaremos un array de 20 elementos de tipo double y en cada
elemento del array guardaremos la nota de cada alumno
Podemos representar gráficamente el array de notas de la siguiente forma:

Array notas:
 8.50 6.35 5.75 8.50 ··· 3.75 6.00 7.40

notas[0] notas[1] notas[2] notas[3] ··· notas[17] notas[18] notas[19]

Para acceder a cada elemento del array se utiliza el nombre del array y un índice que
indica la posición que ocupa el elemento dentro del array.
El índice se escribe entre corchetes.
El primer elemento del array ocupa la posición 0, el segundo la posición 1, etc. En un
array de N elementos el último ocupará la posición N-1.
En el ejemplo anterior, notas[0] contiene la nota del primer alumno y notas[19]
contiene la del último
Los índices deben ser enteros no negativos.
1. CREAR ARRAYS UNIDIMENSIONALES
Para crear un array se deben realizar dos operaciones:
- Declaración
- Instanciación
Declarar de un array
En la declaración se crea la referencia al array.
La referencia será el nombre con el que manejaremos el array en el programa.
Se debe indicar el nombre del array y el tipo de datos que contendrá.
De forma general un array unidimensional se puede declarar en java de cualquiera de
estas dos formas:
tipo [] nombreArray;
tipo nombreArray[];
tipo: indica el tipo de datos que contendrá. Un array puede contener elementos de
tipo básico o referencias a objetos.
nombreArray: es la referencia al array. Es el nombre que se usará en el programa para
manejarlo.
Por ejemplo:
int [] ventas; //array de datos de tipo int llamado ventas
double [] temperaturas; //array de datos de tipo double llamado temperaturas
String [] nombres; //array de datos de tipo String llamado nombres
Instanciar un array
Mediante la instanciación se reserva un bloque de memoria para almacenar todos los
elementos del array.
La dirección donde comienza el bloque de memoria donde se almacenará el array se
asigna al nombre del array.
De forma general:
nombreArray = new tipo[tamaño];
nombreArray: es el nombre creado en la declaración.
tipo: indica el tipo de datos que contiene.
tamaño: es el número de elementos del array. Debe ser una expresión entera positiva.
El tamaño del array no se puede modificar durante la ejecución del programa.
new: operador para crear objetos. Mediante new se asigna la memoria necesaria para
ubicar el objeto. Java implementa los arrays como objetos.
Por ejemplo:
ventas = new int[5]; //se reserva memoria para 5 enteros y
//se asigna la dirección de inicio del array a ventas.
Lo normal es que la declaración y la instanciación se hagan en una sola instrucción:
tipo [] nombreArray = new tipo[tamaño];
Por ejemplo: int [] ventas = new int[5];
El tamaño del array también se puede indicar durante la ejecución del programa, es
decir, en tiempo de ejecución se puede pedir por teclado el tamaño del array y crearlo:

Scanner sc = new Scanner(System.in);

System.out.print("Número de elementos del array: ");
int numeroElementos = sc.nextInt();
int [] ventas = new int[numeroElementos];
Si no hay memoria suficiente para crear el array, new lanza una excepción
java.lang.OutOfMemoryError.
Diferencia entre la referencia y el contenido del array
Debe quedar clara la diferencia entre la referencia (manejador del array o nombre del
array) y el contenido del array.
El nombre del array contiene la dirección de memoria del contenido del array.
2. INICIALIZAR ARRAYS UNIDIMENSIONALES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automáticamente un valor inicial:
Valores iniciales por defecto para un array en java:
0 para arrays numéricos
'\u0000' (carácter nulo) para arrays de caracteres
false para arrays booleanos
null para arrays de String y de referencias a objetos.
También podemos dar otros valores iniciales al array cuando se crea.
Los valores iniciales se escriben entre llaves separados por comas.
Los valores iniciales deben aparecer en el orden en que serán asignados a los elementos
del array.
El número de valores determina el tamaño del array.
Por ejemplo:
double [] notas = {6.7, 7.5, 5.3, 8.75, 3.6, 6.5};
se declara el array notas de tipo double, se reserva memoria para 6 elementos y se les
asignan esos valores iniciales.
Ejemplos:
//creación de un array de 4 elementos booleanos
boolean [] resultados = {true,false,true,false};
 //creación de un array de 7 elementos de tipo String
String [] dias = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado",
"Domingo"};
3. ACCEDER A LOS ELEMENTOS DE UN ARRAY
Para acceder a cada elemento del array se utiliza el nombre del array y un índice que
indica la posición que ocupa el elemento dentro del array.
El índice se escribe entre corchetes.
Se puede utilizar como índice un valor entero, una variable de tipo entero o una
expresión de tipo entero.
El primer elemento del array ocupa la posición 0, el segundo la posición 1, etc. En un
array de N elementos el último ocupará la posición N-1.
Un elemento de un array se puede utilizar igual que cualquier otra variable. Se puede
hacer con ellos las mismas operaciones que se pueden hacer con el resto de variables
(incremento, decremento, operaciones aritméticas, comparaciones, etc).
Por ejemplo:

Si se intenta acceder a un elemento que está fuera de los límites del array (un elemento
con índice negativo o con un índice mayor que el que corresponde al último elemento
 del array) el compilador no avisa del error. El error se producirá durante la ejecución. En
ese caso se lanza una excepción java.lang.ArrayIndexOutOfBoundsException.
Se puede saber el número de elementos del array mediante el atributo length.
Podemos utilizar length para comprobar el rango del array y evitar errores de acceso.
Por ejemplo, para asignar un valor a un elemento del array que se lee por teclado:
Scanner sc = new Scanner(System.in);
int i, valor;
int [] a = new int[10];
System.out.print("Posición: ");
i = sc.nextInt();
System.out.print("Valor: ");
valor = sc.nextInt();
if (i>=0 && i < a.length) {
a[i] = valor;
}

4. RECORRER UN ARRAY UNIDIMENSIONAL

Para recorrer un array se utiliza una instrucción iterativa (normalmente una instrucción
for, aunque también puede hacerse con while o do..while) utilizando una variable
entera como índice que tomará valores desde el primer elemento al último o desde el
último al primero.
Por ejemplo, el siguiente fragmento de programa Java declara un array de 7 elementos
de tipo double y le asigna valores iniciales. A continuación recorre el array, utilizando
la instrucción for, para mostrar por pantalla el contenido del array.
double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < 7; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}
Para evitar errores de acceso al array es recomendable utilizar length para recorrer el
array completo.
Por ejemplo:
double[] notas = {2.3, 8.5, 3.2, 9.5, 4, 5.5, 7.0}; //array de 7 elementos
for (int i = 0; i < notas.length; i++) {
System.out.print(notas[i] + " "); //se muestra cada elemento del array
}
Ejemplo de recorrido de un array en java:
Programa que lee por teclado la nota de los alumnos de una clase y calcula la nota
media del grupo. También muestra los alumnos con notas superiores a la media. El
número de alumnos se lee por teclado.
Este programa crea un array de elementos de tipo double que contendrá las notas de
los alumnos. El tamaño del array será el número de alumnos de la clase.
Se realizan 3 recorridos sobre el array, el primero para asignar a cada elemento las
notas introducidas por teclado, el segundo para sumarlas y el tercero para mostrar los
alumnos con notas superiores a la media.
import java.util.*;
public class Recorrido2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int numAlum, i;
double suma = 0, media;
do {
System.out.print("Número de alumnos de la clase: ");
numAlum = sc.nextInt();
} while (numAlum <= 0);
double[] notas = new double[numAlum]; //se crea el array
// Entrada de datos. Se asigna a cada elemento del array
// la nota introducida por teclado
for (i = 0; i < notas.length; i++) {
System.out.print("Alumno " + (i + 1) + " Nota final: ");
notas[i] = sc.nextDouble();
}
// Sumar todas las notas
for (i = 0; i < notas.length; i++) {
 suma = suma + notas[i];
}
// Calcular la media
media = suma / notas.length;
// Mostrar la media
System.out.printf("Nota media del curso: %.2f %n", media);
// Mostrar los valores superiores a la media
System.out.println("Listado de notas superiores a la media: ");
for (i = 0; i < notas.length; i++) {
if (notas[i] > media) {
System.out.println("Alumno numero " + (i + 1)+ " Nota final: " + notas[i]);
}
}
}
}
Recorrer un Array en java con foreach. Bucle for para colecciones
A partir de java 5 se incorpora una instrucción for mejorada para recorrer arrays y
contenedores en general.
Permite acceder secuencialmente a cada elemento del array.
La sintaxis general es:
for(tipo nombreDeVariable : nombreArray){
….
}
tipo: indica el tipo de datos que contiene el array.
nombreDeVariable: variable a la que en cada iteración se le asigna el valor de cada
elemento del array. Esta definida dentro del for por lo que solo es accesible dentro de
él.
nombreArray: es el nombre del array que vamos a recorrer.
Mediante este bucle solo podemos acceder a los elementos del array. No podemos
hacer modificaciones en su contenido.
Ejemplo: El siguiente programa crea un array temperatura de 10 elementos. Lee por
teclado los valores y a continuación los muestra por pantalla.
import java.util.*;
public class Recorrerforeach1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double [] temperatura = new double[10];
int i;
for(i = 0; i<temperatura.length;i++){
System.out.print("Elemento " + i + ": ");
temperatura[i] = sc.nextDouble();
}

for(double t: temperatura){
System.out.print(t + " ");
}
System.out.println();
}
}

Arrays de caracteres en Java

Un array de caracteres es un array que contiene datos de tipo char.

Los arrays de caracteres en Java se crean de forma similar a un array unidimensional de

cualquier otro tipo de datos.

A diferencia de los demás arrays, se puede mostrar el contenido completo de un array

de caracteres mediante una sola instrucción print o printf.
Ejemplo: Array de 8 caracteres llamado cadena. Por defecto los elementos del array se
inicializan con el carácter nulo (carácter \u0000 Unicode).
char [] cadena = new char[8];

De forma gráfica el array de caracteres cadena se puede representar así:

 \u0000 \u0000 \u0000 \u0000 \u0000 \u0000 \u0000 \u0000

cadena cadena cadena cadena cadena cadena cadena

cadena[0]
[1] [2] [3] [4] [5] [6] [7]
Para mostrar el contenido completo del array:
System.out.println(cadena);
Mostrará 8 caracteres nulos (en blanco)

Ejemplo: Array de 5 caracteres llamado vocales. Se asignan valores iniciales: a, e, i, o, u

char [] vocales = {'a', 'e', 'i', 'o', 'u'};

a e i o u

vocales vocales vocales vocales

vocales[0]
[1] [2] [3] [4]

System.out.println(vocales);
Mostrará:
aeiou
El atributo length de un array de caracteres contiene el tamaño del array
independientemente de que sean caracteres nulos u otros caracteres.
Por ejemplo:
char [] cadena = new char[8];

\u0000 \u0000 \u0000 \u0000 \u0000 \u0000 \u0000 \u0000

cadena cadena cadena cadena cadena cadena cadena

cadena[0]
[1] [2] [3] [4] [5] [6] [7]
System.out.println(cadena.length);
Muestra: 8
cadena[0] ='m';
cadena[1] ='n';
 m n \u0000 \u0000 \u0000 \u0000 \u0000 \u0000

cadena cadena cadena cadena cadena cadena cadena

cadena[0]
[1] [2] [3] [4] [5] [6] [7]
System.out.println(cadena.length);
Muestra: 8
System.out.print(cadena);
System.out.print(cadena);
System.out.println(".");
Mostrará:
mnbbbbbbmnbbbbbb.
Los espacios en blanco se han representado por el carácter b

Se puede asignar un String a un array de caracteres mediante el método toCharArray()

de la clase String.
Ejemplo:
String s = "Ordenador";

char [] palabra = s.toCharArray();

Se crea un nuevo array de caracteres con el contenido del String s y se asigna la dirección
de memoria a palabra.
Se puede crear un String a partir de un array de caracteres.
Ejemplo:
char [] vocales = {'a', 'e', 'i', 'o', 'u'};

String s = new String(vocales);

Se crea un nuevo String con el contenido del array vocales y se asigna la dirección de
memoria a s.

RECORRER UN ARRAY DE CARACTERES UNIDIMENSIONAL

Se puede recorrer de forma completa utilizando una instrucción iterativa, normalmente
un for.
Por ejemplo:
char [] s = new char[10];
s[0]='a';
s[1]='b';
s[2]='c';
for(int i = 0; i<s.length; i++)
System.out.print(s[i]+ " ");
Mostrará todos los caracteres del array, incluidos los nulos.

Si los caracteres no nulos se encuentran al principio del array se puede recorrer

utilizando un while, mientras que no encontremos un carácter nulo.
Por ejemplo:
char [] s = new char[10];
s[0]='a';
s[1]='b';
s[2]='c';
int i = 0;
while(s[i]!='\0'){
System.out.print(s[i]);
i++;
}
Muestra los caracteres del array hasta que encuentra el primer nulo.

Matrices en Java
Un array en Java puede tener más de una dimensión. El caso más general son los arrays
bidimensionales también llamados matrices o tablas.
La dimensión de un array la determina el número de índices necesarios para acceder a
sus elementos.
Los vectores que hemos visto en otra entrada anterior son arrays unidimensionales
porque solo utilizan un índice para acceder a cada elemento.
Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos
representar una matriz como una tabla de n filas y m columnas cuyos elementos son
todos del mismo tipo.
La siguiente figura representa un array M de 3 filas y 5 columnas:
Pero en realidad una matriz en Java es un array de arrays.
Gráficamente podemos representar la disposición real en memoria del array anterior
así:

La longitud del array M (M.length) es 3.

La longitud de cada fila del array (M[i].length) es 5.
Para acceder a cada elemento de la matriz se utilizan dos índices. El primero indica la
fila y el segundo la columna.
CREAR MATRICES EN JAVA
Se crean de forma similar a los arrays unidimensionales, añadiendo un índice.
Por ejemplo:
matriz de datos de tipo int llamado ventas de 4 filas y 6 columnas:
int [][] ventas = new int[4][6];
matriz de datos double llamado temperaturas de 3 filas y 4 columnas:
double [][] temperaturas = new double[3][4];
En Java se pueden crear arrays irregulares en los que el número de elementos de cada
fila es variable. Solo es obligatorio indicar el número de filas.
Por ejemplo:
int [][] m = new int[3][];
crea una matriz m de 3 filas.
A cada fila se le puede asignar un número distinto de columnas:
m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];
Gráficamente podemos representar la disposición real en memoria del array anterior
así:
INICIALIZAR MATRICES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna
automáticamente un valor inicial:
2. 0 para arrays numéricos
3. '\u0000' (carácter nulo) para arrays de caracteres
4. false para arrays booleanos
5. null para arrays de String y de referencias a objetos.
También podemos dar otros valores iniciales al array cuando se crea.
Los valores iniciales se escriben entre llaves separados por comas.
Los valores que se le asignen a cada fila aparecerán a su vez entre llaves separados por
comas.
El número de valores determina el tamaño de la matriz.
Por ejemplo:
int [][] numeros = {{6,7,5}, {3, 8, 4}, {1,0,2}, {9,5,2}};
se crea la matriz numeros de tipo int, de 4 filas y 3 columnas, y se le asignan esos valores
iniciales.
Asignando valores iniciales se pueden crear también matrices irregulares.
int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};
Crea una matriz irregular de 4 filas. La primera de 5 columnas, la segunda de 3, la tercera
de 4 y la cuarta de 2.

RECORRER MATRICES
Para recorrer una matriz se anidan dos bucles for. En general para recorrer un array
multidimensional se anidan tantas instrucciones for como dimensiones tenga el array.
Ejemplo de recorrido de una matriz en Java:
Programa que lee por teclado números enteros y los guarda en una matriz de 5 filas y 4
columnas. A continuación muestra los valores leídos, el mayor y el menor y las
posiciones que ocupan.

import java.util.*;
public class Bidimensional2 {
public static void main(String[] args) {
final int FILAS = 5, COLUMNAS = 4;
Scanner sc = new Scanner(System.in);
int i, j, mayor, menor;
int filaMayor, filaMenor, colMayor, colMenor;
int[][] A = new int[FILAS][COLUMNAS];
System.out.println("Lectura de elementos de la matriz: ");
for (i = 0; i < FILAS; i++) {
for (j = 0; j < COLUMNAS; j++) {
System.out.print("A[" + i + "][" + j + "]= ");
A[i][j] = sc.nextInt();
}
}
System.out.println("valores introducidos:");
for (i = 0; i < A.length; i++) {
for (j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();
}
mayor = menor = A[0][0];//se toma el primero como mayor y menor
filaMayor = filaMenor = colMayor = colMenor = 0;

for (i = 0; i < A.length; i++) { //

for (j = 0; j < A[i].length; j++) {
if (A[i][j] > mayor) {
mayor = A[i][j];
filaMayor = i;
colMayor = j;
} else if (A[i][j] < menor) {
menor = A[i][j];
filaMenor = i;
colMenor = j;
}
}
}
System.out.print("Elemento mayor: " + mayor);
System.out.println(" Fila: "+ filaMayor + " Columna: " + colMayor);
System.out.print("Elemento menor: " + menor);
System.out.println(" Fila: "+ filaMenor + " Columna: " + colMenor);
}
}
En este ejemplo se han utilizado dos formas distintas para recorrer la matriz:
1. utilizando en el for el número de filas y columnas
2. utilizando en el for el atributo length

Para recorrer arrays irregulares como el siguiente:

int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};
Usaremos siempre length para obtener el número de columnas que tiene cada fila:
for (i = 0; i < a.length; i++) { //número de filas
for (j = 0; j < a[i].length; j++) { //número de columnas de cada fila
System.out.print(a[i][j] + " ");
}
System.out.println();
}

Formularios en NetBeans
1. Abrir NetBeans y crear un "New Project"--"java"--"Java Class Library".
(Dar el nombre que uno quiera no influye en nuestro objetivo).

Para efectos del ejemplo se llamará Formulario1

 2. Se creará un formulario con el nombre de "InterfazFormulario".

En este ejemplo pediremos los siguientes datos (Nombre, apellidos, RUT, email,
telefono)
seran obligatorios todos los datos (El rut es para los chilenos asique su codigo lo
enseñare al final de este pequeño tutorial).

Para este fin tendremos estos jlabel:

Nombre, Apellidos, Rut, Email, Telefono, y que sus Nombres de variables seran
"JLNombre" en el caso del nombre. (en caso de tener titulo crear un jlabel con el titulo).

Ponerle nombre visible por el usuario es click secundario y "Edit Text"

Ponerle nombre a la variable es click secundario y "Change Variable Name"
Nos quedará algo asi:
1.
3. Crearemos los JTextField:

uno para cada Dato, excepto para el rut que necesita 2, con el siguiente nombre de
varible por ejemplo: para el Nombre se llamara "txtNombre" para el Apellido se llamara
"txtApellidos", (RUT; txtRut .... txtValidador).

Le hará clic secundario "Edit Text" y le borramos el contenido sin ningun espacio luego
agrandamos el textfield en caso de achicarse este.

Nos quedara algo así.

2.
4. Le damos un titulo al JFrame eso se hace dandolo click secundario encima del frame
en cualquier lugar que no sea ni un jlabel o un JtextField y damos en "Propiedades",
luego en donde dice "title" escribimos "Formulario"
3.

5. Ahora crearemos botones "Button". crearemos 3 uno para "Guardar" uno para
"Limpiar" y uno para "Salir" en los cuales al igual que en los jlabel y textfield vamos a
ponerle nombre de variable.

Guardar = BotonGuardar; Limpiar = BotonLimpiar; Salir = BotonSalir.

6. Un detalle importante tendremos que cambiar de color los JLABEL dado que el fondo
que escogí es oscuro por lo tanto las dejare amarillas y para efectos del ejemplo también
sirve que vean como se hace Click secundario sobre el JLabel a cambiar el color y
"Propiedades"
7.
7. Pero su tamaño puede ser cambiado por el usuario, por lo que debemos meternos
denuevo a las propiedades del JForm principal y cambiar esa virtud...