INTRODUCCIÓN A JAVA

Java es un lenguaje de programación potente y robusto, usado en todo tipo de electrónicos. Las
características son:
• Orientado a objetos: es un paradigma de la programación que nos permite descomponer el código
en pequeñas unidades lógicas llamadas objetos.
• Multiplataforma: se pueden ejecutar en cualquier sistema operativo.
• Es sencillo de manejar.
• Es muy robusto, ya que el desarrollador no tendrá que manejar direcciones de memoria RAM.
• Es seguro, Java detecta los códigos maliciosos.
• Orientado a la red: incorpora diferentes protocolos de red.
• Multihilo: pueden ejecutar más de una tarea al mismo tiempo.

Como Usar Netbeans

Netbeans, un IDE para programar en varios lenguajes de programación como Java, C++, PHP, etc.
Una vez lo hayamos instalado, podremos empezar a crear nuetros propios proyectos. Os dejo una serie de
acciones comunes que debéis saber para manejar bien el IDE. Nosotros para este manual usamos el 8.0,
también lo vamos a centrar un poco en Java.
Crear proyectos
Para empezar a programar, necesitamos crear un proyecto, que se almacenará en una carpeta de nuestro
sistema de archivos. Pinchamos en Archivo -> Nuevo proyecto…. o en el iconode una carpeta con un más.

1
Elegimos el tipo de proyecto que queremos, según lo que elijamos los datos posteriores pedidos a
continuación pueden cambiar. En nuestro caso, será una aplicación Java (Java -> Java aplication).

Ahora elegimos el nombre del proyecto y donde se almacenará. Recomiendo tener carpetas distintas para
cada lenguaje. También podemos indicar un subdirectorio para guardar las bibliotecas, esto lo detallaremos
más adelante.

2
Crear ficheros
Cuando tenemos un proyecto creado, podemos añadir todos los ficheros que queramos, algunos específicos
por el lenguaje, como un paquete Java por ejemplo.
Simplemente, seleccionamos donde queremos crear el fichero y con el boton derecho, pinchamos en Nuevo
-> Fichero que queremos.

Si no aparece el fichero que queremos, podemos elegir la opción Other…

Crear grupos de proyectos

Una buena manera de ordenar nuestros proyectos es creando un grupo de proyecto, por ejemplo: un grupo
llamado clase u otro llamado Mis aplicaciones. Solo debemos hacer lo siguiente:
Primero, fuera del programa, creamos una carpeta donde queramos (lo suyo seria donde tenemos los
proyectos).
En Netbeans, pinchamos en Archivo -> Grupo de proyecto… Creamos un nuevo grupo.

|
Escribimos el nombre del grupo y la última opción y elegimos la carpeta que hemos creado antes.

3
Ahora copiamos todas las carpetas que queremos añadir al grupo y aceptamos.
Para cambiar de grupo, pinchamos en Archivo -> Grupo de proyecto… y en lugar de crear elegimos el grupo
y pinchamos select group. El grupo none es para aquellos que no tienen grupo.

Importar y exportar proyectos

Si queremos llevar algunos de nuestros proyectos a otro equipo, podemos exportarlo y si queremos añadir a
otro netbeans lo importamos.
Para exportar, seleccionamos el proyecto, pinchamos en Archivo -> Exportar proyecto y elegimos donde
queremos guardar el proyecto.
Para importar, seleccionamos el proyecto, pinchamos en Archivo -> Importar proyecto y elegimos el fichero
exportado.

Añadir bibliotecas a nuestros proyecto

Podemos añadir elementos externos, como JAR en Java. En las propiedades del proyecto, seleccionamos el
proyecto, botón secundario y pinchamos en propiedades.

En libraries, en la pestaña compilar podemos añadir un proyecto, un JAR o una biblioteca.

4
También podemos elegir la carpeta donde se guardan las librerías de nuestro proyecto, en la parte de arriba.

Generar JAR (Java)

Si queremos generar un JAR de nuestro proyecto, simplemente seleccionamos el proyecto y con el botón
secundario elegimos la opción Limpiar y construir.
En la carpeta dist del proyecto estará nuestro JAR.

Añadir elementos o controles en una aplicación gráfica

Creamos un proyecto y añadimos un JFrame Form (Java), veremos que tenemos a la derecha una paleta
donde tenemos los elementos disponibles, simplemente arrastramos y soltamos en el frame.

5
Instalar plugins
Podemos añadir más funcionalidades a nuestro Netbeans, ya sea descargados o desde Netbeans
directamente. Pinchamos en Herramientas -> plugins.

Elegimos los plugins que queremos instalar y después pinchamos en Install.

Si queremos añadir un plugin descargado, en la pestaña Descargados, elegimos el plugin y lo instalamos.

Os dejo la página de plugins oficial de Netbeans: [Link]

Personalizar paneles
Los paneles de Netbeans son muy adaptables, podemos mover pestañas de lugar o quitar paneles. Solo hay
que arrastrar y soltar.
Podemos personalizar la vista de ventanas en el menu Ventanas.

PROGRAMACIÓN BÁSICA
Variables Primitivas De Java
Antes de empezar, las variable son estructuras de datos que pueden variar durante la ejecución de un
programa.
Declarar variables significa indicar el tipo de dato que almacenara las variables que participan en el
programa.

6
En Java, se reserva una zona de memoria que la máquina virtual Java gestiona automáticamente.
Las variables primitivas engloban los tipos de datos más sencillos como puede ser un número, un carácter,
etc.

Antes de usar una variable debemos declararla y es recomendable iniciarla. La primera vez que se usa debe
declararse, el resto de veces no se debe hacer, es importante que el valor asignado sea compatible con el
tipo de variable.

Por ejemplo, si declaramos una variable de tipo numérico, esta no puede contener una cadena de caracteres.
La sintaxis de una declaración de una variable es: tipo_variable nombre_variable; Por ejemplo, int
num; pero como hemos dicho antes es recomendable iniciar estas variables con un numero genérico como
uno o cero o según la ocasión.

Hay una serie de reglas a la hora de escribir el nombre de las variables:

• Los nombres de las variables no pueden comenzar por números, pero si puede formar parte del
nombre.
• El nombre de una variable no puede tener espacios.
• El nombre de la variable no puede estar formado por operadores como +, -, !, etc.
• No puede haber dos variables que se llamen igual, aunque sean de distintos tipos, en el mismo ámbito
(ya explicaremos esto mas tarde).
• No pueden tener el nombre de palabras reservadas, en eclipse estas palabras se colorean.
• Java es «case sensitive», es decir, que diferencia entre mayúsculas y minúsculas. A es distinto
que a.

Por convención, se suele escribir el nombre de las variables en minúscula, si hay mas de una palabra en la
variable podemos separarlo con un _ o colocar la primera letra de la nueva palabra en mayúscula, por
ejemplo, variablePrueba.

Recuerda que al final de cada instrudccion debes colocar un ;

Vamos a ver los tipos de variables que hay:

7
Tipo Descripcion Ejemplo Rango valores

Long Representa a un número entero real. Usa 8 bytes. long a=40000000; -263 a 263-1
long b=646334578;
long c=-32356;

Int Representa a un número entero real. Usa 4 bytes. int a=-1; -231 a 231-1
Es el mas usado int b=5;
int c=30000;

Short Representa a un número entero real. Usa 2 bytes. short a=20; -32768 a 32767
short b=300;
short c=-30000;

Byte Representa a un número entero real. Usa 1 byte. byte a=30; -128 a 127
byte b=126;
byte c=-120;

Double Representa a un numero de coma flotante, es double a=5.5; -1,79 * 10308 a 1,79 *
compatible con una variable con un entero real double b=30; 10308
pero este no lo es con double. Usa 4 bytes. double c=30.0;

Float Representa a un número real, aceptando float a=4.55555; -3,4 · 1038 a 3,4 · 1038
decimales. Pasa igual que con double. Usa 4 float b=-1.8521;
bytes. float c=600.152;

Boolean Solo puede contener true o false. Se usa para boolean a=true; true o false
condiciones lógicas. Usa 2 bytes boolean b=false;

Char Representa un numero, letra o simbolo segun la char a='A'; Caracteres

tabla ASCII. Es compatible con un numero entero char b=97;
real. Si es un caracter, va entre comillas simples. (corresponde a la
Usa 2 bytes letra a de la tabla
ASCII)
char c='!';

8
Antes de seguir, quiero poneros un pequeño ejemplo de double, nosotros podemos almacenar en una
variable de tipo double la suma de un double y un int, pero si la suma se almacena en un int nos dará un
error al compilar, ya que un int no puede almacenar coma flotante (mas adelante, veremos como se puede
solucionar).
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int a=30;
6 double b=30.5;
7 double suma=a+b; //si fuera un int daria error
8 [Link](suma);
9 }
10}
Después de tener una variable declarada podemos operar con ella, para cambiar otra variable o para
incrementarla. Veamos un ejemplo con números:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int a=30;
6 int b=60;
7 short c=20;
8 int suma=a+b+c;
9 [Link](suma);
10 }
11}
Como vemos declaramos varias variables y usamos una de ellas (inicializada a 0) para almacenar la suma
de todas las anteriores. Si una de las variables a,b o c hubiera sido un long, nos indicaría un error (se podría
solucionar, lo veremos mas adelante).
También tenemos otra forma de declarar variables, si todas ellas son del mismo tipo se pueden declarar en
una linea, inicializandonos o no.

9
1public class PruebaApp {
2 public static void main(String[] args) {
3 int a=30, b=60, c=20;
4 int suma=a+b+c;
5 [Link](suma);
6 }
7}

Comentarios De Java
Los comentarios son instrucciones especiales que no se ejecutan es muy útil para los programadores en
cualquier lenguaje de programación, ya que nos permite insertar anotaciones que nos servirán para trozos de
código que pueden resultar confusos en un futuro. También es útil, si nuestro código lo manejan mas
personas.

Los comentarios en Java se pueden escribir de varias maneras:

• Si queremos que un comentario sea de una línea escribimos // y el comentario a continuación.
• Si queremos escribir un comentario de varias lineas, escribimos /* como apertura, el comentario va
a continuación, puede ocupar varias líneas y para cerrar usamos */
• Tenemos un tipo de comentario especial usado en Javadoc, que se usa para crear documentación
de la aplicación, se insertan antes de clases, métodos, constructores, etc. Su apertura es /** y se
cierra con */. Este tema lo abordaremos mas adelante en profundidad.
Aquí vemos un ejemplo:
1 /**
2 * Comentario especial Javadoc usado para la documentación
3 * @author Fernando
4 *
5 */
6 public class PruebaApp {
7
8 public static void main(String[] args) {
9
10 // Comentario de una linea

10
11
12 /*
13 * Esto es un comentario
14 * de varias lineas
15 */
16
17 }
18
19}
Por último, no es necesario hacer comentarios es cada línea, es recomendable hacerlos en aquellos trozos
de texto donde tu veas que sean necesarios.

Constantes En Java
Java. Las constantes son valores que no se modifican durante la ejecución del programa, si definimos
una constante y la intentamos modificar durante la ejecución, no nos dejara.

La mayor utilidad de las constantes es definir valores que siempre serán iguales y que en caso de que varíen
con el tiempo se pueden cambiar, el mejor ejemplo es el IVA.

En Java, cualquier tipo de dato puede ser una constante, para definir que sea una constante, debemos
escribir antes del tipo de dato final, para seguir la convención en java, escribiremos el nombre de
la constante en mayúsculas.

Imaginemos que tenemos un programa simple para saber el precio del IVA de un producto, este programa lo
tenemos hace tiempo cuando el IVA es de 18 %, cuando subió a 21% solo es necesario cambiar un valor.

En este pequeño ejemplo, parece que daría igual lo anterior, ya que con cambiar un par de cosas seria igual,
pero imaginemos que tenemos un programa enorme y que esa constante es utilizada muy a menudo, si
cambiara el IVA solo tendríamos que cambiar el valor de IVA y no todos los valores en todo el programa.
Veamos un ejemplo:
1 public class PruebaApp {
2

11
3 public static void main(String[] args) {
4
5 final double IVA = 0.18;
6 int producto=300;
7
8 double resultado=producto*IVA;
9
10 [Link]("El IVA del producto es "+resultado);
11 }
12
13}

Operadores En Java
Hay varios tipos de operadores:
• Asignación: asigna un valor a una variables. El operador de asignación es =, una vez asignado
podemos reasignar de nuevo otro valor. Por ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int a=30;
6 boolean exito=true;
7 a=40;
8 exito=false;
9 }
10
11}
Como vemos los iniciamos en un valor pero después, cambia su valor.

• Aritmético: permiten operar con números como sumar, restar, etc. Se pueden sumar variables que
almacenen números . Estos son los operadores:

12
 Operador Función

+ Suma dos valores. En String, significa concatenar dos cadenas.

- Resta dos valores.

* Multiplica dos valores.

/ Divide dos valores.

% Significa módulo, devuelve el resto de una división.

Ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int operador1 = 20;
6 int operador2 = 15;
7 int resultado=0;
8
9 resultado= operador1+operador2; //resultado = 35
10
11 resultado= operador1-operador2; //resultado = 5
12
13 resultado= operador2-operador1; //resultado = -5
14
15 resultado= operador1*operador2; //resultado = 300
16
17 resultado= operador1/operador2; //resultado = 1 (como es int no incluye decimales)
18
19 resultado= operador1%operador2; //resultado = 5 (el resto de la division)
20
21 }

13
22
23}
También podemos combinar los operadores de asignación y aritméticos. Se forman con la variable el operador
aritmético seguido del de asignación y por ultimo la otra variable. Por ejemplo: operador1 +=operador2. Es
equivalente a operador1=operador1+operador2. Puedes hacer lo mismo con los anteriores operadores
aritméticos.

• Unarios: requieren un solo operando, existe el operador ++ y –. Es similar a sumar o restar una
unidad a la variable. Tened en cuenta que el orden del operador es importante. Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int operador=10;
6 int x=0;
7 operador++; //operador = 11
8 operador++; //operador = 12
9 operador--; //operador = 11
10
11 x=operador++; //x = 11, operador = 12
12
13 x=++operador; //x = 13, operador = 13
14
15 }
16
17}
Como vemos el valor cambia según la localización del operador, la única diferencia es cuando incrementa el
valor, cuando esta antes de la variable se produce un pre-incremento, es decir, se incrementa antes de
asignar, cuando esta después se incrementa después de la asignación. No te preocupes si no lo entiendes
demasiado, lo mas usado es este ultimo.
• Relación: son operadores para comparar valores, de esta comparación se crea una variable
booleana. Estos son los operadores:

14
 Operador Descripción

== igual a

!= distinto a

> mayor que

< menor que

>= mayor o igual que

<= menor o igual que

Veamos un ejemplo:
1
2 public class PruebaApp {
3
4 public static void main(String[] args) {
5
6 int operador1=10;
7
8 int operador2=20;
9
10 int operador3=10;
11
12 boolean resultado;
13
14 resultado = operador1==operador2; // ¿10 es igual a 20? resultado = false
15
16 resultado = operador1==operador3; // ¿10 es igual a 10? resultado = true
17
18 resultado = operador1!=operador2; // ¿10 es distinto a 20? resultado = true
19
20 resultado = operador1>operador2; // ¿10 es mayor que 20? resultado = false
21

15
22 resultado = operador1>operador3; // ¿10 es mayor que 10? resultado = false (si no cumple la condicion
23sera falso)
24
25 resultado = operador1<operador2; // ¿10 es menor que 20? resultado = true
26
27 resultado = operador1<=operador3; // ¿10 es menor o igual que 10? resultado = true (ya que es igual)
28resultado = operador1>=operador2; // ¿10 es mayor o igual que 20? resultado = false
29
}

• Condicional: son operadores que permiten concatenar mas de una condición. Los operadores son:

Operador Descripción

&& Es equivalente a AND. Si se cumplen todas las condiciones, devuelve true. Si solo hay una
condición que no se cumple, devuelve falso.

|| Es equivalente a OR. Si se cumple alguna de las condiciones, devuelve true. Si todas las
condiciones son falsas, devuelve falso.

Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int op1=10;
6
7 int op2=20;
8
9 int op3=10;
10
11 boolean result;
12

16
13 result = op1==10 && op2<30;
14 // ¿Es 10 igual a 10 y es 20 menor que 30? resultado = true
15
16 result = op1!=30 || op3==15;
17 // ¿Es 10 distinto a 30 o es 10 igual a 10? resultado = true
18
19 result = op1==op3 && op2<=30 || op2>=15;
20 // ¿Es 10 igual que 10 y es 20 menor que 30 o es 10 mayor o igual que 15? resultado = true
21 // Aqui primero se evalua las condiciones con && y el resultado de esta se compara con ||
22
23 }
24
25}

Prioridad Operadores Java

Hola a todos, hoy os explicare las prioridades de los operadores en Java, algo ha tener en cuenta al hacer
formulas complicadas.

La prioridad de operadores es muy importante, ya que puede variar el resultado de una variable que tiene una
formula complicada.
La prioridad de operadores es la siguiente:

Nombre Simbolo

Paréntesis, Corchetes, Punto ( ), [ ], .

Signo negativo, Decremento, Incremento, Negacion -num, --, ++, !

Nuevo objeto new (tipo)

Multiplicación, División, Módulo *, /, %

Suma, Resta +, -

Mayor, Menor, Mayor o igual que, Menor o igual que >, <, =>, =<

17
 Nombre Simbolo

Igualación, Distinto ==, !=

AND &&

OR ||

Condicional ?:

Asignación =, +=, -=, *=, /=, %=

Veamos algún ejemplo, para entenderlo mejor:

1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int variable=10+5*5;
6
7 [Link](variable);
8
9 }
10}
Examinemos la formula anterior, en este caso el resultado sería 35, ya que primero multiplica 5*5 y después
se suma 10, porque la multiplicación tiene mas prioridad que la suma. Si quisiéramos que se sumara primero,
usaríamos un ( ).
Veamos como quedaría ahora:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int variable=(10+5)*5;
6
7 [Link](variable);
8

18
9 }
10}
Ahora el resultado cambia, ya que primero se suma 10+5 y luego se multiplica por 5. Lo mejor es usar
mensajes de traza para comprobar que el resultado es el que esperamos.

Convención De Nombres En Java

Hola a todos, hoy os explicare las convenciones de nombres en Java, es importante para lograr una unificación
en nuestros programas. Vamos a indicar las convenciones más comunes en Java, a la hora de escribir
nuestros programas:
• En las clases:
o La primera letra ira en mayúscula.
o Si esta formada por más de una palabra, la primera letra de la palabra estará en mayúscula.
o Si está clase contiene un main, haciendo que sea ejecutable, incluiremos al final App. Si no
tiene, no se incluye.
o Ejemplo: SalarioEmpleadoApp
• En los métodos o funciones:
o La primera letra ira en minúscula.
o Si esta formada por más de una palabra, la primera letra de la palabra estará en mayúscula.
o Ejemplo: calculaSueldo
• En las constantes:
o Todas las letras irán en mayúsculas.
o No pueden comenzar por números.
o Ejemplo: IVA
• En las variables:
o La primera letra ira en minúscula.
o Si esta formada por más de una palabra, la primera letra de la palabra estará en mayúscula.
También se pueden usar separadores como guiones bajos.
o No pueden comenzar por números.
o Ejemplo: sueldoEmpleado o sueldo_empleado
• En las interfaces:
o La primera letra ira en mayúscula.
o Si esta formada por más de una palabra, la primera letra de la palabra estará en mayúscula.

19
 o Normalmente, suelen acabar en -able.

Entrada Y Salida De Datos En Java

Hola a todos, hoy os explicare como podemos mostrar e introducir datos en Java con Eclipse, algo
fundamental para ver los valores que hemos procesado.

Podemos mostrar los datos de dos maneras, a través de la consola o mediante un cuadro de dialogo. Este
primero solo lo veremos si ejecutamos nuestro programa en Eclipse o en una ventana de comandos.

Para mostrar un mensaje en consola, escribimos [Link](«cadena»); dentro del paréntesis,

además de cadenas, podemos mostrar el valor de una variable, para ello, solo escribimos el nombre de la
variable sin comillas dobles, no importa el tipo de variable.

También se puede incluir una cadena de texto mas el valor de una variable, para ello escribimos la cadena
con comillas dobles, un signo + y el nombre de la variable, recuerda poner un espacio entre una variable y
una cadena de texto. Por ejemplo, [Link](«El valor de la variable num es
«+num); o [Link](«El precio final es «+precio+» euros»);

Incluso podemos escribir una formula y nos mostrara el resultado, debe estar entre paréntesis.
Si queremos que no de un salto de linea, simplemente escribimos [Link](«cadena»);
Veamos un ejemplo de cada tipo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precioProducto=300;
6
7 final double IVA=0.21;
8 [Link]("Informacion del producto");
9
10 [Link]("El precio del producto es "+precioProducto);

20
11
12 [Link]("El precio del producto, incluyendo el IVA, es
13"+(precioProducto+(precioProducto*IVA)));
14 }
15
}
Este es el resultado:

Sigamos mostrando datos pero esta vez con un cuadro de dialogo, lo mejor de esto es que se podrá ver en
cualquier sitio que lo ejecutemos.

Antes de escribir la línea de código, debemos importar el paquete necesario para poder utilizar la clase
necesaria para el cuadro de dialogo.

Antes de la linea public class «nombre_clase», escribimos import [Link]; después

dentro del main [Link](null, «cadena»); por lo de null, no os preocupéis, lo
entenderéis mas adelante y en la cadena podemos hacer lo mismo que hemos mostrado antes.

1
2 import [Link];
3 public class PruebaApp {
4
5 public static void main(String[] args) {
6
7 int precioProducto=300;
8
9 final double IVA=0.21;
10

21
11 [Link](null, "El precio del producto, incluido el IVA es
12"+(precioProducto+(precioProducto*IVA)));
13 }

}
Este es el resultado:

Hasta aquí para mostrar datos, ahora vamos a introducirlos nosotros. Usaremos la misma clase de antes pero
con otro método. Recuerda que debemos importar el paquete antes de la clase.
Escribimos [Link](«cadena»); se debe guardar en un String. Veamos un
ejemplo:
1 import [Link];
2 public class PruebaApp {
3
4 public static void main(String[] args) {
5
6 String nombre=[Link]("Introduce tu nombre");
7
8 [Link](null, "Bien, tu nombre es "+nombre);
9 }
10
11}
Esto es lo que nos muestra al ejecutar, debemos introducir un texto:

22
Una cosa a tener en cuenta, es que si introducimos un numero y queremos hacer operaciones con él, debemos
pasarlo a tipo numérico, ya que es un String cuando escribimos en la caja de texto. Para cambiar el tipo
escribiremos, después de la linea donde introducimos los datos,lo
siguiente: [Link](variable_texto); solo debemos colocar la variable String que almacenamos al
escribir en el cuadro de dialogo.
Veamos un ejemplo:
import [Link];
1 public class TestApp {
2
3 public static void main(String[] args) {
4
5 final double IVA=0.21;
6 String texto_num=[Link]("Introduce el precio del producto");
7
8 int precio=[Link](texto_num);
9 [Link](null, "EL producto tiene un precio de "+precio+" y su precio final es
10de "+(precio+(precio*IVA)));
11 }
12
13}
Este es el resultado, si introdujéramos 300:

Introducción De Datos Con Scanner En Java

Hola a todos, hoy os explicaré como podemos introducir datos con la clase Scanner en Java.
La clase Scanner nos permite que un usuario externo a nuestra aplicación inserte datos necesario para
nuestro programa, por ejemplo, pedir al usuario un número para calcular alguna formula.
Hay varias formas de usar esta clase pero nos centraremos en la introducción de datos. En otros posts, nos
centraremos en esas otras funciones.

23
La forma de crear un Scanner es la siguiente.
1 Scanner sn=new Scanner([Link]);
Ya teniendo el objeto creado, podemos usar los metodos que tiene. Recordar que tenemos que importar la
clase poniendo este import al principio del fichero.
1 import [Link];
Los que mas nos importa son los metodos next. Son los que devuelven el tipo de dato deseado. Por ejemplo:
1 import [Link];
2
3 public class ejemploScanner {
4
5 public static void main(String[] args) {
6
7 Scanner sn=new Scanner([Link]);
8
9 [Link]("Escribe un numero entero: ");
10 int num=[Link]();
11 [Link]("El numero entero escrito ha sido "+num);
12
13 [Link]("Escribe un numero decimal: ");
14 double numDouble=[Link]();
15 [Link]("El numero decimal escrito ha sido "+numDouble);
16
17 [Link]("Escribe una cadena: ");
18 String cadena=[Link]();
19 [Link]("El numero decimal escrito ha sido "+cadena);
20
21 [Link]("Escribe un booleano: ");
22 boolean booleano=[Link]();
23 [Link]("El booleano escrito es "+booleano);
24
25 }
26}

24
Hay que tener en cuenta que sino se pone un dato correcto nos saltara una excepcion
InputMismatchException.
import [Link];
1 import [Link];
2
3 public class ejemploScanner {
4
5 public static void main(String[] args) {
6
7 Scanner sn=new Scanner([Link]);
8
9 try{
10 [Link]("Escribe un numero entero, si escribes otra cosa que no sea un numero saltara
11la excepcion: ");
12 int numero=[Link]();
13 [Link]("El numero decimal escrito ha sido "+numero);
14 }catch(InputMismatchException e){
15 [Link]("Error, ha introducido un valor incorrecto");
16 }
17 }
18}
También una cosa más, por defecto, si nosotros ponemos en cualquier dato un espacio (por ejemplo en una
cadena un nombre compuesto), este considerará que el que va despues del espacio es el siguiente next que
haya en el programa (si lo hay). La forma de solucionarlo es con nextLine(). Por ejemplo:
1 import [Link];
2
3 public class ejemploScanner {
4
5 public static void main(String[] args) {
6
7 Scanner sn=new Scanner([Link]);
8

25
9 [Link]("Escribe una cadena con espacio: ");
10 String cadena=[Link]();
11 [Link]("El numero decimal escrito ha sido "+cadena);
12
13 }
14}

Métodos Y Funciones JOptionPane De Java

JOptionPane es una clase que nos permite mostrar un dialogo gráfico con el que podemos interactuar para
introducir o mostrar la información que queramos.
Esta clase se encuentra en el paquete [Link].

Vamos a ver los métodos mas usados y útiles, hay muchos mas:
• showInputDialog: nos permite introducir información que usaremos en la aplicación, este método
devuelve un String con lo que hayamos escrito. Alguno de sus métodos sobrescritos son:
o showInputDialog(Object message): permite mostrar un simple mensaje al dialogo, este
sera una cadena.
o showInputDialog(parentComponent, message, title, messageType): nos permite
personalizar aun más el dialogo, con un titulo y un icono (error, información, advertencia,
pregunta o plano). Por ejemplo, [Link](null, «Introduce un dato»,
«Titulo», JOptionPane.INFORMATION_MESSAGE);

También se puede cambiar el icono a

error (JOptionPane.ERROR_MESSAGE), advertencia (JOptionPane.WARNIG_MESSAGE), pregunta
(JOptionPane.QUESTION_MESSAGE) o plano (JOptionPane.PLAIN_MESSAGE).

26
• showMessage: nos permite mostrar información, es como [Link]. Alguno de sus
métodos sobrescritos son:
o showMessage(parentComponent, message): es la forma simple de mostrar un mensaje.
Por ejemplo, [Link](null, «Muestra de informacion»);

o showMessageDialog(parentComponent, message, title, messageType): nos permite

personalizar aun más la muestra de información, como su titulo y el icono. Por
ejemplo, [Link](null, «Error», «Error»,
JOptionPane.ERROR_MESSAGE);

27
Las constantes de información y advertencia, son iguales que el anterior método.
• showConfirmDialog: nos permite elegir una opción. Devuelve
un código numérico que están definidos como constantes. Alguno métodos sobrescritos son:
o showConfirmDialog(parentComponent, message): muestra un mensaje con las
opciones Si, No y Cancelar, cada una de las opciones están definidas con una constantes
(nos ayuda a indicar la opción sin saber que numero devuelve), recuerda que debes invocar
las constantes con JOptionPane:
▪ YES_OPTION: lo devuelve cuando pulsamos en si.
▪ NO_OPTION: lo devuelve cuando pulsamos en no.
▪ CANCEL_OPTION: lo devuelve cuando pulsamos en cancelar.
▪ OK_OPTION: lo devuelve cuando pulsamos en aceptar.
o showConfirmDialog(parentComponent, message, title, optionType): nos permite
personalizar el dialogo, indicándole un titulo y su tipo de opción (definido como constante).
Las constantes son:
▪ OK_CANCEL_OPTION: muestra la opción aceptar y cancelar.
▪ YES_NO_CANCEL_OPTION: muestra la opción si, no y cancelar.
▪ YES_NO_OPTION: muestra la opción si y no.
o showConfirmDialog(parentComponent, message, title, optionType, messageType): es
igual que el anterior pero indicándole el tipo de mensaje (advertencia, error o información),
se definen igual que en el primer método que hemos visto.

Veamos algún ejemplo de este último método:

1int codigo=[Link](null, "¿Quieres un euro para una buena causa?", "Donacion",
2JOptionPane.YES_NO_OPTION, JOptionPane.PLAIN_MESSAGE);
3 if (codigo==JOptionPane.YES_OPTION){
4 [Link]("Has pulsado en SI");
5 }else if(codigo==JOptionPane.NO_OPTION){
6 [Link]("Has pulsado en NO");

28
 }

ESTRUCTURAS CONDICIONALES EN JAVA

Las estructuras condicionales nos permiten ejecutar una serie de instrucciones si cumple una
determinada condición que nosotros le indiquemos. Es importante recordar que la condición debe dar un
resultado booleano, por lo que lo mas normal es usar operadores relacionales y condicionales.
Tenemos varios tipos de estructuras condicionales:
• if: le indicamos una condición si esta es verdadera se ejecuta, sino no se ejecuta las instrucciones de
dentro. Se suele traducir como «Si se cumple esta condición haz esto». Su sintaxis es:
1if (condición){
2 instrucciones
3}
Por ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precio=300;
6
7 if (precio>100){
8 [Link]("El precio es mayor que 100");
9 }
10 }
11
12}
Donde colocamos la condición, podemos colocar una variable booleana, ya que su valor puede ser true o
false.
• if – else: es como el anterior solo que después de cerrarse la llave de if, se añade else sin indicarle
ninguna condición. Esto sirve para que si la condición del if no es verdadera, ejecute otras
instrucciones que estarán dentro de else. Se suele traducir como «Si se cumple esta condición haz
esto y sino haz esto».

29
Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precio=50;
6
7 if (precio>100){
8 [Link]("El precio es mayor que 100");
9 }else{
10 [Link]("El precio es menor que 100");
11 }
12 }
13
14}
En este caso, se ejecutara lo que hay en else ya que no cumple la condición.
• if -elseif: esta estructura es como una mezcla de los anteriores, esto nos permite, que si no se cumple
la condición podamos indicar otra condición para hacerlo aún mas especifico. Se suele traducir
como «Si se cumple esta condición haz esto y sino si cumple esta condición haz esto».
Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precio=50;
6
7 if (precio>100){
8 [Link]("El precio es mayor que 100");
9 }else if(precio>80){
10 [Link]("El precio es mayor que 80");
11 }else{

30
12 [Link]("El precio es menor que 80");
13 }
14 }
15}
El ejemplo anterior es equivalente al siguiente, esto es lo que se conoce como if anidados, podemos anidar
tantos como queramos:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int precio=50;
6
7 if (precio>100){
8 [Link]("El precio es mayor que 100");
9 }else {
10 if(precio>80){
11 [Link]("El precio es mayor que 80");
12 }else{
13 [Link]("El precio es menor que 80");
14 }
15 }
16 }
17}

• Switch: esta estructura condicional de selección múltiple, le damos un valor (puede ser una
variable) y una lista de casos y si cumple alguno de los casos ejecuta las instrucciones asociadas a
ella, en caso de que ninguna sea podemos indicarle que hace por defecto, normalmente se usa para
indicar de un error con un mensaje. Su sintaxis es:
1 switch (valor){
2 case caso1:
3 Instrucciones
4 break;

31
5 case caso2:
6 Instrucciones
7 break;
8 case caso N:
9 Instrucciones
10 break;
11 default:
12 Instrucciones
13}
Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 String dia="Lunes";
6
7 switch (dia){
8 case "Lunes":
9 [Link]("Hoy es "+dia);
10 break;
11 case "Martes":
12 [Link]("Hoy es "+dia);
13 break;
14 case "Miercoles":
15 [Link]("Hoy es "+dia);
16 break;
17 case "Jueves":
18 [Link]("Hoy es "+dia);
19 break;
20 case "Viernes":
21 [Link]("Hoy es "+dia);
22 break;

32
23 case "Sabado":
24 [Link]("Hoy es "+dia);
25 break;
26 case "Domingo":
27 [Link]("Hoy es "+dia);
28 break;
29 default:
30 [Link]("No has introducido un dia correcto");
31 }
32 }
33}

Como vemos en el caso anterior, como los valores son String debemos poner dobles comillas a los casos.
En caso de que sean números, se pondrán como tal, también podríamos usar constantes.
Una cosa más, si haya varios casos que tienen ejecuta las mismas instrucciones, podemos agruparlas.
Veamos un ejemplo:
1 import [Link];
2 public class PruebaApp {
3
4 public static void main(String[] args) {
5
6 String dia=[Link]("Introduce un dia de la semana");
7
8 switch(dia){
9 case "lunes":
10 case "martes":
11 case "miercoles":
12 case "jueves":
13 case "viernes":
14 [Link]("Es un dia laboral");
15 break;
16 case "sabado":

33
17 case "domingo":
18 [Link]("Es un dia festivo");
19 default:
20 [Link]("Introduce un dia de la semana");
21 }
22 }
23}

ESTRUCTURAS DE REPETICIÓN EN JAVA

Una estructura de repetición o bucle nos permite ejecutar un numero de veces determinado una serie de
instrucciones. La mayor utilidad es evitar la repetición de lineas de código iguales. Para salir del bucle, se
indica una condición, si esa condición no se cumple se sale del bucle.
Las estructuras de repetición son:
• while: indicamos una condición que se ejecutara hasta que la condición sea falsa, es importante que
la variable que este en la condición, varíe para que no se produzca un bucle infinito. Su sintaxis es:
1while (condicion){
2 instrucciones
3}
Veamos un ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 int num=1;
6
7 while (num<=5){
8 [Link](num);
9 num++;
10 }

34
11 }
12}
Como vemos, num vale 1 al principio, se comprueba la condición, como 1 es menor o igual que 5, entra en
el bucle y ejecuta las instrucciones, y así sucesivamente hasta que num vale 6, ya que 6 no es menor o
igual que 5. Si num no fuera modificado, nunca saldría del bucle.
• for: este tipo de bucle, es como el anterior pero ademas de la condición, incluye una inicialización
de una variable y un incremento o decremento de esa variable, en principio, no es necesario que
incluya las 3 partes, se pueden inicializar o incrementar varias varias separadas por comas. Cada
parte se separa con un ; . NOTA: cuando salimos del bucle, la variable inicializada no existe. Su
sintaxis:
1for(inicializacion;condicion;incremento){
2 instrucciones
3}
Si nos fijamos, es como en while pero todo se define en el bucle. Veamos un ejemplo:
1public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 for (int num=1; num<=5; num++){
6 [Link](num);
7 }
8 }
9}
Es el mismo ejemplo de antes pero mas reducido.
• do-while: esta estructura repetitiva, tiene algo especial y es que como mínimo las instrucciones
dentro de la estructura repetitiva al menos una vez, mientras que el while sus instrucciones pueden
ejecutarse 0 o N veces. Se sale del bucle cuando la condición del while no se cumple, si esto pasa
empieza desde el do. Se utiliza para la validación de datos. Su sintaxis es:
1do{
2 intrucciones
3}while(condicion);
Veamos un ejemplo:

35
1 import [Link];
2 public class PruebaApp {
3
4 public static void main(String[] args) {
5 int num;
6 do{
7 String texto=[Link]("Introduce un numero entre 0 y 10");
8 num=[Link](texto);
9 }while(num>=10 || num<0);
10 [Link]("El numero introducido es "+num);
11 }
12}
Tenemos que pensar bien la condición de salida. En nuestro caso, si insertamos un 5 (5>=10 or
5<0) devolvería falso, si insertáramos un -1 (-1>=10 or 5<o) devolvería verdadero, haciendo que vuelva a
pedir un numero.

INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS EN JAVA

La programación orientada a objetos es un paradigma de la programación que descompone el código de

una clase en unidades llamados objetos.

Un objeto en Java es una entidad existente en la memoria del ordenador que tiene unas propiedades,
llamados atributos, y unas operaciones disponibles específicas, llamados métodos.

Estos objetos vienen de clases, en realidad hasta ahora hemos usado una clase, solo que esta clase tenía
un método ejecutable. Podemos crear una clase directamente en Eclipse. Al crear una clase desmarcamos la
opción public static void main(String[] args)

Recuerda que por convención de nombres en Java, las clases no ejecutables deben escribirse la primera
letra en mayúscula, si tiene más de una palabra la primera letra se escribirá en mayúsculas y no se escribe al
final App.
Por ejemplo, crearemos una clase empleado:

36
1 public class Empleado {}

Como hemos dicho, un objeto tiene unas propiedades, en el ejemplo anterior las propiedades podrían ser el
nombre, el apellido, edad y sueldo, estas propiedades son llamados atributos en Java y se declaran igual que
una variable, veremos que en Eclipse lo colorea de azul. No se inicializan. Veamos un ejemplo:
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 * @author Fernando
6 * @version 1.0
7 */
8 public class Empleado {
9 //Atributos
10
11 /**
12 * Nombre del empleado
13 */
14 private String nombre;
15 /**
16 * Apellido del empleado
17 */
18 private String apellido;
19 /**
20 * Edad del empleado
21 */
22 private int edad;
23 /**
24 * Salario del empleado
25 */
26 private double salario;
27

37
28}
No te preocupes por lo de private, lo veremos mas adelante con detalle.

También hemos comentado, que podían realizar unas acciones con los objetos, llamados métodos. Se definen
igual como hemos visto hasta ahora, excepto por static, también lo explicaremos mas adelante con detalle.
Veamos un ejemplo de un método que incluya un plus al sueldo si tiene mas de 40 años:
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */<br />public class Empleado {
9 //Atributos
10 /**
11 * Nombre del empleado
12 */
13 private String nombre;
14 /**
15 * Apellido del empleado
16 */
17 private String apellido;
18 /**
19 * Edad del empleado
20 */
21 private int edad;
22 /**
23 * Salario del empleado
24 */
25 private double salario;
26 //Metodos

38
27 /**
28 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
29 * @param sueldoPlus
30 *
31 */
32 public boolean plus (double sueldoPlus){
33 boolean aumento=false;
34 if (edad>40){
35 salario+=sueldoPlus;
36 aumento=true;
37 }
38 return aumento;
39 }
40}
Como vemos, le pasamos por parámetro el plus, pero ¿por que no le pasamos la edad o el salario
por parámetro? Esto es debido a que desde la propia clase puede acceder a todos sus atributos.
Solo nos falta crear un constructor, este es un método especial en las clases, que es el invocado al crear un
nuevo objeto de esa clase, normalmente se suele usar para inicializar los atributos, también puede ejecutar
métodos.

Si no definimos un constructor Java, nos construye uno por defecto, que no hace nada al crear el
objeto. NOTA: si definimos un constructor, el constructor por defecto desaparece.
Para crear un constructor, escribiremos public nombre_clase (parámetros). Sigamos con el ejemplo:
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Empleado {

39
10 //Atributos
11 /**
12 * Nombre del empleado
13 */
14 private String nombre;
15 /**
16 * Apellido del empleado
17 */
18 private String apellido;
19 /**
20 * Edad del empleado
21 */
22 private int edad;
23 /**
24 * Salario del empleado
25 */
26 private double salario;
27 //Metodos
28 /**
29 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
30 * @param sueldoPlus
31 *
32 */
33 public boolean plus (double sueldoPlus){
34 boolean aumento=false;
35 if (edad>40){
36 salario+=sueldoPlus;
37 aumento=true;
38 }
39 return aumento;
40 }
41 //Constructores

40
42 /**
43 * Constructor por defecto
44 */
45 public Empleado(){
46 [Link]="";
47 [Link]="";
48 [Link]=0;
49 [Link]=0;
50 }
51 /**
52 * Constructor con 4 parametros
53 * @param nombre nombre del empleado
54 * @param apellido nombre del empleado
55 * @param edad edad del empleado
56 * @param salario salario del empleado
57 */
58 public Empleado(String nombre, String apellido, int edad, double salario){
59 [Link]=nombre;
60 [Link]=apellido;
61 [Link]=edad;
62 [Link]=salario;
63 }
64}
Vemos que vemos una palabra nueva, this, lo veremos con más detalle más adelante.
Lo más normal es que se defina un constructor por defecto, es decir, sin parámetros donde se inicialicen los
parámetros con un valor por defecto (como una constante, por ejemplo) y uno o varios con parámetros que
nosotros le demos.

Ahora podemos crear un objeto de la clase Empleado, tantos como queramos. Debemos crear una nueva
clase en el mismo proyecto, que contenga un método main. Para nuestro caso, lo llamaremos EmpleadoApp.
Para crear un objeto de una clase, seguiremos la siguiente sintaxis:
nombre_clase nombre_objeto=new nombre_clase (parametros_constructor);

41
En nuestro caso, sería:
Empleado empleado1=new Empleado («Fernando», «Ureña», 23, 800);
Si quisiéramos invocar el método por defecto, seria igual pero sin parámetros.

Una vez creado el objeto, podemos acceder a los métodos y atributos de la clase, si tienen un private no se
podrá acceder a ellos.
Accedamos al método que hemos creado, usando el objeto creado, un punto y método o atributo:
1public class EmpleadoApp {
2 public static void main(String[] args) {
3 Empleado empleado1=new Empleado ("Fernando", "Ureña", 23, 800);
4 //Devolvera false
5 [Link]([Link](30));
6 }
7}

REFERENCIAS EN JAVA
Hola a todos, hoy os explicare que son y como debemos usar correctamente las referencias en Java.
Cuando creamos un objeto con new, estamos creando una referencia, esta indica donde está el objeto en
memoria. Podemos asignar una referencia a otro objeto. Veamos un ejemplo con arrays:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 //Definimos un array con 10 posiciones
6 int array1[]=new int [10];
7 array1[0]=3;
8
9 //El array no esta creado, con null indicamos que no apunta a nada.
10 int array2[]=null;
11
12 //copiamos la referencia, array1 y array2 apuntan al mismo array

42
13 array2=array1;
14
15 //Creamos una nueva referencia, array apunta a un array diferente no al que hemos creado al principio
16 array1=new int[20];
17
18 //array2 es el unico que apunta al primer array creado, podemos acceder a su contendo
19 [Link]("El primer valor del array2 es "+array2[0]);
20
21 //Ahora, array1 tiene otro valor que el asignado despues de crearlo
22 [Link]("El primer valor del array1 es "+array1[0]);
23 }
24
25}
Como vemos en el ejemplo anterior, hay una nueva palabra, null, sirve para indicar que no apunta nada para
que el recolector de basura limpie la memoria de aquello que no es necesario. Si lo queremos invocar
manualmente a este recolector, usamos [Link]();

Null también nos sirve para comprobar, por ejemplo, si un objeto apunta a alguna dirección de memoria, esto
suele ser útil en varios casos.

Las referencias se pueden comparar con el operador lógico == o !=, si dos referencias son iguales es que
apuntan a la misma zona de memoria. Por ejemplo:
1 public class PruebaApp {
2
3 public static void main(String[] args) {
4
5 //Definimos un array con 10 posiciones
6 int array1[]=new int [10];
7 array1[0]=3;
8
9 //El array no esta creado, con null indicamos que no apunta a nada.
10 int array2[]=null;

43
11
12 //copiamos la referencia, array1 y array2 apuntan al mismo array
13 array2=array1;
14
15 //Comparamos referencias
16 if (array1==array2){
17 [Link]("Los arrays apuntan a la misma dirección");
18 }
19
20 //Creamos una nueva referencia, array apunta a un array diferente no al que hemos creado al principio
21 array1=new int[20];
22
23 //Comparamos referencias
24 if(array1!=array2){
25 [Link]("Los arrays apuntan a distintas direcciones");
26 }
27 }
28
29}
Para objetos de nuestras propias clases la referencia funciona igual.

VARIABLE THIS EN JAVA

La variable this se usa para diferenciar un atributo de una variable normal y corriente dentro de una clase.
Veamos un ejemplo de un trozo de una clase:
1 //Constructores
2 /**
3 * Constructor por defecto
4 */
5 public Empleado(){
6 [Link]="";
7 [Link]="";
8 [Link]=0;

44
9 [Link]=0;
10 }
11 /**
12 * Constructor con 4 parametros
13 * @param nombre nombre del empleado
14 * @param apellido nombre del empleado
15 * @param edad edad del empleado
16 * @param salario salario del empleado
17 */
18 public Empleado(String nombre, String apellido, int edad, double salario){
19 [Link]=nombre;
20 [Link]=apellido;
21 [Link]=edad;
22 [Link]=salario;
23 }
Como vemos, los atributos deben diferenciarse de las variables que pasamos como parámetros.

También se usa para invocar métodos de una propia clase dentro de esta. Otro uso es invocar otro constructor
pasandole como parámetro, los parámetros del propio constructor. Veamos un ejemplo, de este ultimo uso:
1 //Constructores
2 /**
3 * Constructor por defecto
4 */
5 public Empleado(){
6 this ("", "", 0, 0);
7 }
8
9 /**
10 * Constructor con 4 parametros
11 * @param nombre nombre del empleado
12 * @param apellido nombre del empleado
13 * @param edad edad del empleado

45
14 * @param salario salario del empleado
15 */
16 public Empleado(String nombre, String apellido, int edad, double salario){
17 [Link]=nombre;
18 [Link]=apellido;
19 [Link]=edad;
20 [Link]=salario;
21 }
Como vemos, es como si llamáramos al constructor que tiene esos parámetros con esos tipos de datos.
MODIFICADORES DE ACCESO EN JAVA
Los modificadores de acceso nos permiten indicar la visibilidad de esos métodos o atributos fuera de la clase,
se ponen al principio del método o atributo. Los tipos son:
• public: el método o atributo es accesible por cualquiera.
• private: el método o atributo solo es accesible para la propia clase. Fuera de la clase, no se ven. Se
suelen usar en atributos y métodos que solo se usen dentro de la clase.
• protected: el método o atributo de una clase padre se podrá acceder desde las clases hijas de la
misma, es muy usado en herencia.
• friendly: este termino, en realidad, en Java no existe, por lo que se declara no poniendo ningún
modificador de acceso. El método o atributo solo puede ser visualizado por otras clases que estén
dentro del mismo paquete que la clase donde está declarado.
Veamos un ejemplo practico:
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Empleado {
10
11 //Atributos

46
12
13 /**
14 * Nombre del empleado
15 */
16 private String nombre;
17
18 /**
19 * Apellido del empleado
20 */
21 private String apellido;
22
23 /**
24 * Edad del empleado
25 */
26 public int edad;
27
28 /**
29 * Salario del empleado
30 */
31 private double salario;
32
33 //Metodos
34
35 /**
36 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
37 * @param sueldoPlus
38 * @return true: se suma el plus al sueld
39 * false: no se suma el plus al sueldo
40 */
41
42 public boolean plus (double sueldoPlus){
43

47
44 boolean aumento=false;
45
46 if (edad>40 && compruebaNombre()){
47 salario+=sueldoPlus;
48 aumento=true;
49 }
50
51 return aumento;
52 }
53
54 /**
55 * Comprueba que el nombre no este vacio
56 * @return true: el nombre es una cadena vacia
57 * false: el nombre no es una cadena vacia
58 */
59 private boolean compruebaNombre(){
60 if([Link]("")){
61 return false;
62 }
63
64 return true;
65 }
66
67 //Constructores
68
69 /**
70 * Constructor por defecto
71 */
72
73 public Empleado(){
74 [Link]="";
75 [Link]="";

48
76 [Link]=0;
77 [Link]=0;
78 }
79
80 /**
81 * Constructor con 4 parametros
82 * @param nombre nombre del empleado
83 * @param apellido nombre del empleado
84 * @param edad edad del empleado
85 * @param salario salario del empleado
86 */
87 public Empleado(String nombre, String apellido, int edad, double salario){
88 [Link]=nombre;
89 [Link]=apellido;
90 [Link]=edad;
91 [Link]=salario;
92 }
93}
Vemos que hemos puesto el atributo edad como public y un método publico y otro privado. Lo privado no se
vera cuando creemos el objeto y lo publico lo podremos invocar. Veamos un ejemplo:

Clase ejecutable
1 public class EmpleadoApp {
2
3 public static void main(String[] args) {
4
5 Empleado empleado1=new Empleado ("Fernando", "Ureña", 23, 800);
6
7 //Devolvera false, ya que 23 no es mayor que 40
8 [Link]([Link](30));
9
10 //Podemos acceder al atributo edad

49
11 [Link]+=20;
12
13 //Devolvera true, ya que ahora la edad es igual a 43, haciendo que aumente el salario 30 € mas
14 [Link]([Link](30));
15
16 //Nos saltara un error, ya que el metodo es privado
17 [Link]();
18
19 //Creamos un nuevo objeto con el nombre vacio
20 Empleado empleado2=new Empleado ("", "Lopez", 50, 1800);
21
22 //Devolvera false, ya que aunque la edad supere los 40 con el metodo privado definido, no nos permitira
23realizarlo
24 [Link]([Link](60));
25
26 //Nos saltara un error, ya que nombre no es accesible, es un atributo privado
27 [Link]="Fernando";
28 }
}
Lo mas normal es que los atributos sean privados (lo anterior ha sido un ejemplo) para que no sean
modificados directamente desde fuera, ademas se suelen usar los métodos get and set para modificar y
mostrar el valor de atributos.

MÉTODOS GET Y SET EN JAVA

Los métodos get y set, son simples métodos que usamos en las clases para mostrar (get) o modificar (set)
el valor de un atributo. El nombre del método siempre sera get o set y a continuación el nombre del atributo,
su modificador siempre es public ya que queremos mostrar o modificar desde fuera la clase. Por
ejemplo, getNombre o setNombre.
Esta es la sintaxis de cada uno:

public tipo_dato_atributo getAtributo (){

return atributo;

50
}

public void setAtributo (tipo_dato_atributo variable){

[Link] = variable;
}

Si usamos Eclipse tenemos una manera aún mas sencilla de generarlos automáticamente. Pinchamos
en Source -> Generate Getters and Setters, nos aparecerá una ventana donde elegiremos que atributos
generar su get o set, al pinchar en OK nos lo generara automáticamente estos métodos.

Veamos un ejemplo:
Clase
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando

51
7 * @version 1.0
8 */
9 public class Empleado {
10
11 //Atributos
12 /**
13 * Nombre del empleado
14 */
15 private String nombre;
16 /**
17 * Apellido del empleado
18 */
19 private String apellido;
20 /**
21 * Edad del empleado
22 */
23 private int edad;
24 /**
25 * Salario del empleado
26 */
27 private double salario;
28
29 //Metodos publicos
30
31 /**
32 * Devuelve el nombre del empleado
33 * @return nombre del empleado
34 */
35 public String getNombre() {
36 return nombre;
37 }
38

52
39 /**
40 * Modifica el nombre de un empleado
41 * @param nombre
42 */
43 public void setNombre(String nombre) {
44 [Link] = nombre;
45 }
46
47 /**
48 * Devuelve la edad de un empleado
49 * @return edad del empleado
50 */
51 public int getEdad() {
52 return edad;
53 }
54
55 /**
56 * Modifica la edad de un empleado
57 * @param edad
58 */
59 public void setEdad(int edad) {
60 [Link] = edad;
61 }
62
63 /**
64 * Devuelve el salario de un empleado
65 * @return salario del empleado
66 */
67 public double getSalario() {
68 return salario;
69 }
70

53
71 /**
72 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
73 * @param sueldoPlus
74 * @return <ul>
75 * <li>true: se suma el plus al sueldo</li>
76 * <li>false: no se suma el plus al sueldo</li>
77 * </ul>
78 */
79 public boolean plus (double sueldoPlus){
80 boolean aumento=false;
81 if (edad>40 && compruebaNombre()){
82 salario+=sueldoPlus;
83 aumento=true;
84 }
85 return aumento;
86 }
87
88 //Metodos privados
89
90 private boolean compruebaNombre(){
91 if([Link]("")){
92 return false;
93 }
94 return true;
95 }
96
97 //Constructor
98 /**
99 * Constructor por defecto
100 */
101 public Empleado(){
102 [Link]="";

54
103 [Link]="";
104 [Link]=0;
105 [Link]=0;
106 }
107
108 /**
109 * Constructor con 4 parametros
110 * @param nombre nombre del empleado
111 * @param apellido nombre del empleado
112 * @param edad edad del empleado
113 * @param salario salario del empleado
114 */
115 public Empleado(String nombre, String apellido, int edad, double salario){
116 [Link]=nombre;
117 [Link]=apellido;
118 [Link]=edad;
119 [Link]=salario;
120 }
121}
Clase ejecutable
1 public class EmpleadoApp {
2
3 public static void main(String[] args) {
4
5 Empleado empleado1=new Empleado ("Fernando", "Ureña", 23, 800);
6
7 Empleado empleado2=new Empleado ("", "Lopez", 50 ,1800);
8
9 //Mostramos el valor actual del salario del empleado1
10 [Link]("El salario del empleado1 es "+[Link]());
11
12 //Modificamos la edad del empleado1

55
13 [Link](43);
14
15 [Link](100);
16
17 //Mostramos el salario de nuevo, ahora tendra 100 mas
18 [Link]("El salario actual del empleado1 es "+[Link]());
19
20 //Modificamos el nombre del empleado2
21 [Link]("Antonio");
22
23 [Link](100);
24
25 //Mostramos el salario de nuevo, ahora tendra 100 mas
26 [Link]("El salario del empleado2 es "+[Link]());
27
28 }
29
30}

USO DE CONSTANTES EN CLASES JAVA

El uso de constantes tanto en una aplicación ejecutable como en una clase, siempre es útil.

En una clase, el mejor uso que tiene es definir valores por defecto de nuestros atributos, no es necesario
hacer una constante para cada atributo. Al crearla, debemos darle algún valor. Veamos un ejemplo:
/**
* El salario por defecto
*/
private final static double SALARIO_DEF=600;

Como vemos, se define igual que hemos visto, incluyendo static, esto se debe ya que sera igual siempre en
todos los objetos que creemos, lo explicaremos con mas detalle con los método y variables estáticas. Cuando
creemos un empleado, sin parámetros, el empleado tendrá un salario de 600. Veamos un ejemplo completo:

56
–Clase
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Empleado {
10
11 //Constantes
12
13 /**
14 * El salario por defecto
15 */
16 private final static double SALARIO_DEF=600;
17 //Atributos
18
19 /**
20 * Nombre del empleado
21 */
22 protected String nombre;
23 /**
24 * Apellido del empleado
25 */
26 protected String apellido;
27 /**
28 * Edad del empleado
29 */
30 protected int edad;
31 /**

57
32 * Salario del empleado
33 */
34 protected double salario;
35
36 //Metodos publicos
37
38 /**
39 * Devuelve el nombre del empleado
40 * @return nombre del empleado
41 */
42 public String getNombre() {
43 return nombre;
44 }
45
46 /**
47 * Modifica el nombre de un empleado
48 * @param nombre
49 */
50 public void setNombre(String nombre) {
51 [Link] = nombre;
52 }
53
54 /**
55 * Devuelve la edad de un empleado
56 * @return edad del empleado
57 */
58 public int getEdad() {
59 return edad;
60 }
61
62 /**
63 * Modifica la edad de un empleado

58
64 * @param edad
65 */
66 public void setEdad(int edad) {
67 [Link] = edad;
68 }
69
70 /**
71 * Devuelve el salario de un empleado
72 * @return salario del empleado
73 */
74 public double getSalario() {
75 return salario;
76 }
77
78 /**
79 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
80 * @param sueldoPlus
81 * @return</pre>
82 <ul>
83 <ul>*
84 <li>true: se suma el plus al sueldo</li>
85 </ul>
86 </ul>
87 &nbsp;
88 <ul>
89 <ul>*
90 <li>false: no se suma el plus al sueldo</li>
91 </ul>
92 </ul>
93 &nbsp;
94 <ul>*</ul>
95 <pre>

59
96 */
97 public boolean plus (double sueldoPlus){
98 boolean aumento=false;
99 if (edad>40 && compruebaNombre()){
100 salario+=sueldoPlus;
101 aumento=true;
102 }
103 return aumento;
104 }
105
106 //Metodos privados
107 /**
108 * Comprueba que el nombre no este vacio
109 * @return</pre>
110<ul>
111<ul>*
112 <li>true: el nombre es una cadena vacia</li>
113</ul>
114</ul>
115&nbsp;
116<ul>
117<ul>*
118 <li>false: el nombre no es una cadena vacia</li>
119</ul>
120</ul>
121&nbsp;
122<ul>*</ul>
123<pre>
124 */
125 private boolean compruebaNombre(){
126 if([Link]("")){
127 return false;

60
128 }
129 return true;
130 }
131
132 //Constructores
133 /**
134 * Constructor por defecto
135 */
136 public Empleado(){
137 this ("", "", 0, SALARIO_DEF);
138 }
139
140 /**
141 * Constructor con 4 parametros
142 * @param nombre nombre del empleado
143 * @param apellido nombre del empleado
144 * @param edad edad del empleado
145 * @param salario salario del empleado
146 */
147 public Empleado(String nombre, String apellido, int edad, double salario){
148 [Link]=nombre;
149 [Link]=apellido;
150 [Link]=edad;
151 [Link]=salario;
152 }
153}
–Clase ejecutable
1 public class EmpleadoApp {
2
3 public static void main(String[] args) {
4
5 //Creamos un objeto a traves del constructor por defecto

61
6 Empleado empleado1=new Empleado();
7
8 //Vemos cual es el salario del empleado
9 [Link]("El salario es "+[Link]());
10
11 }
12
13}
Puede ser publica o privada, según nos convenga.
SOBRECARGA DE MÉTODOS Y CONSTRUCTORES EN JAVA
La sobrecarga de métodos significa tener varios métodos con el mismo método, pero con
distintos parámetros. Si has probado alguna de las clases de Java, habrás visto que un mismo método esta
repetido pero con distinto parámetros.
Veamos un ejemplo:
1 /**
2 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
3 * @param sueldoPlus
4 * @return true: se suma el plus al sueldo, false: no se suma el plus al sueldo
5 */
6 public boolean plus (double sueldoPlus){
7 boolean aumento=false;
8 if (edad>40 && compruebaNombre()){
9 salario+=sueldoPlus;
10 aumento=true;
11 }
12 return aumento;
13 }
14
15 /**
16 * Suma un plus al salario aplicandole una retencion del empleado si el empleado tiene mas de 40 años
17 * @param sueldoPlus
18 * @param retencion

62
19 * @return true: se suma el plus al sueldo, false: no se suma el plus al sueldo</li>
20 *
21 */
22 public boolean plus(double sueldoPlus, double retencion){
23 boolean aumento=false;
24 if (edad>40 && compruebaNombre()){
25 salario+=sueldoPlus-(sueldoPlus*retencion);
26 aumento=true;
27 }
28 return aumento;
29 }
Como vemos, tenemos dos métodos iguales, pero uno con un parámetro más, esto es la sobrecarga de
métodos. Es muy importante tener en cuenta, que si dos métodos tienen el mismo tipo de dato
como parámetros y distinto tipo de dato devuelto, esto nos indicara error. Por ejemplo:

1 /**
2 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
3 * @param sueldoPlus
4 * @return true: se suma el plus al sueldo, false: no se suma el plus al sueldo
5 */
6 public boolean plus (double sueldoPlus){
7 boolean aumento=false;
8 if (edad>40 && compruebaNombre()){
9 salario+=sueldoPlus;
10 aumento=true;
11 }
12 return aumento;
13 }
14
15 /**
16 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
17 * @param sueldoPlus

63
18 */
19 public void plus (double sueldoPlus){
20
21 if (edad>40 && compruebaNombre()){
22 salario+=sueldoPlus;
23 }
24 }
Este ejemplo anterior daría error.

Con los constructores pasa exactamente igual, podemos sobrecargar los constructores de la misma forma.
Veamos un ejemplo:
1 /**
2 * Constructor por defecto
3 */
4 public Empleado(){
5 this ("", "", 0, SALARIO_DEF);
6 }
7
8 /**
9 * Constructor con 2 parametros
10 * @param nombre nombre del empleado
11 * @param apellido nombre del empleado
12 */
13public Empleado(String nombre, String apellido){
14 this (nombre, apellido, 0, SALARIO_DEF);
15}
16
17/**
18 * Constructor con 3 parametros
19 * @param nombre nombre del empleado
20 * @param apellido nombre del empleado
21 * @param edad edad del empleado

64
22 */
23public Empleado (String nombre, String apellido, int edad){
24 this (nombre, apellido, edad, SALARIO_DEF);
25}
26/**
27 * Constructor con 4 parametros
28 * @param nombre nombre del empleado
29 * @param apellido nombre del empleado
30 * @param edad edad del empleado
31 * @param salario salario del empleado
32 */
33public Empleado(String nombre, String apellido, int edad, double salario){
34 [Link]=nombre;
35 [Link]=apellido;
36 [Link]=edad;
37 [Link]=salario;
38}

MÉTODOS Y ATRIBUTOS ESTÁTICOS

Si has seguido mis posts desde el principio, seguro que te suena esta palabra static, vamos a explicar para
que se usa.

Una variable o método estático es aquel es igual en todas las clases, es decir, que aunque creemos distintos
objetos en todos sera igual. Se define escribiendo static en la definición del método o del atributo.
Vamos a ver un ejemplo, tenemos una clase Empleado con un atributo salarioBase que es estático.
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0

65
8 */
9
10 public class Empleado {
11
12 //Atributos
13
14 /**
15 * Nombre del empleado
16 */
17 private String nombre;
18
19 /**
20 * Apellido del empleado
21 */
22 private String apellido;
23
24 /**
25 * Edad del empleado
26 */
27 private int edad;
28
29 /**
30 * Salario del empleado
31 */
32 private static double salarioBase=1000;
33
34 //Metodos publicos
35
36 /**
37 * Devuelve el nombre del empleado
38 * @return nombre del empleado
39 */

66
40 public String getNombre() {
41 return nombre;
42 }
43
44 /**
45 * Modifica el nombre de un empleado
46 * @param nombre
47 */
48 public void setNombre(String nombre) {
49 [Link] = nombre;
50 }
51
52 /**
53 * Devuelve la edad de un empleado
54 * @return edad del empleado
55 */
56 public int getEdad() {
57 return edad;
58 }
59
60 /**
61 * Modifica la edad de un empleado
62 * @param edad
63 */
64 public void setEdad(int edad) {
65 [Link] = edad;
66 }
67
68 /**
69 * Devuelve el salarioBase
70 * @return salarioBse
71 */

67
72 public double getSalarioBase() {
73 return salarioBase;
74 }
75
76 /**
77 * Modifica el salarioBase de los empleados
78 * @param salarioBase
79 */
80 public static void setSalarioBase(double salarioBase) {
81 [Link] = salarioBase;
82 }
83
84 /**
85 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
86 * @param sueldoPlus
87 * @return true: se suma el plus al sueldo y false: no se suma el plus al sueldo
88 */
89 public boolean plus (double sueldoPlus){
90 boolean aumento=false;
91
92 if (edad>40 && compruebaNombre()){
93 salarioBase+=sueldoPlus;
94 aumento=true;
95 }
96
97 return aumento;
98 }
99
100 //Metodos privados
101
102 /**
103 * Comprueba que el nombre no este vacio

68
104 * @return true: el nombre es una cadena vacia y false: el nombre no es una cadena vacia
105 */
106 private boolean compruebaNombre(){
107
108 if([Link]("")){
109 return false;
110 }
111
112 return true;
113 }
114
115 //Constructores
116
117 /**
118 * Constructor por defecto
119 */
120 public Empleado(){
121 this ("", "", 0);
122 }
123
124 /**
125 * Constructor con 4 parametros
126 * @param nombre nombre del empleado
127 * @param apellido nombre del empleado
128 * @param edad edad del empleado
129 */
130 public Empleado(String nombre, String apellido, int edad){
131 [Link]=nombre;
132 [Link]=apellido;
133 [Link]=edad;
134 }
135}

69
Como vemos, el salarioBase es 1000, lo que significa que cuando creamos un objeto el salarioBase es de
1000, si en un momento cambiamos el salarioBase afectara a todas los objetos. Veamos un ejemplo:
1 public class EmpleadoApp {
2
3 public static void main(String[] args) {
4
5 //Creamos los objetos, el salarioBase = 1000
6 Empleado empleado1=new Empleado();
7 Empleado empleado2=new Empleado();
8
9 //Modificamos el salario base a 1200
10 [Link](1200);
11 //Mostramos el salarioBase de los Empleados, ahora es 1200
12 [Link]("Salario base del empleado 1: "+[Link]());
13 [Link]("Salario base del empleado 2: "+[Link]());
14
15 //Modificamos el salario base a 1500
16 [Link](1500);
17
18 //Mostramos el salarioBase de los Empleados, ahora es 1500
19 [Link]("Salario base del empleado 1: "+[Link]());
20 [Link]("Salario base del empleado 2: "+[Link]());
21 }
22}
Para acceder a un método o atributo estático (también depende de su visibilidad), no es necesario crear un
objeto, para ello escribimos nombre_clase.metodo_estatico(parámetros); por ejemplo,
[Link](salario);
Debemos tener en en cuenta que si un método es estático, los atributos que estén dentro del método deben
ser estáticos también, si hay alguno que no lo es, saltara un error.

70
HERENCIA JAVA
La herencia en Java consiste en la creación de clases a partir de otras ya existentes. Tenemos lo que
llamamos una clase padre (superclase) y clases hijas (clases derivadas), que heredan los métodos y
atributos de su clase padre.

Vamos a ver un ejemplo, tenemos una clase empleado que sera una superclase y las clases hijas serán el
tipo de empleados que puede haber como comerciales o repartidores.

La idea es que los empleados sean del tipo que sean tienen atributos o métodos comunes y para optimizar
las clases creamos una clase padre que contenga todo lo común a todas las hijas y en las hijas, ademas de
los atributos del padre pueden tener sus propios atributos o métodos.
Una buena forma de ver la herencia es con la frase «es un». Por ejemplo, un Comercial «es un» Empleado o
un Repartidor «es un» Empleado.

Ahora lo vemos de forma práctica:

–Clase padre Empleado
1 /**
2 * Clase Empleado
3 *
4 * Contiene informacion de cada empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Empleado {
10
11 //Atributos
12
13 /**
14 * Nombre del empleado
15 */
16 protected String nombre;

71
17 /**
18 * Apellido del empleado
19 */
20 protected String apellido;
21 /**
22 * Edad del empleado
23 */
24 protected int edad;
25 /**
26 * Salario del empleado
27 */
28 protected double salario;
29
30 //Metodos publicos
31
32 /**
33 * Devuelve el nombre del empleado
34 * @return nombre del empleado
35 */
36 public String getNombre() {
37 return nombre;
38 }
39
40 /**
41 * Modifica el nombre de un empleado
42 * @param nombre
43 */
44 public void setNombre(String nombre) {
45 [Link] = nombre;
46 }
47
48 /**

72
49 * Devuelve la edad de un empleado
50 * @return edad del empleado
51 */
52 public int getEdad() {
53 return edad;
54 }
55
56 /**
57 * Modifica la edad de un empleado
58 * @param edad
59 */
60 public void setEdad(int edad) {
61 [Link] = edad;
62 }
63
64 /**
65 * Devuelve el salario de un empleado
66 * @return salario del empleado
67 */
68 public double getSalario() {
69 return salario;
70 }
71
72 /**
73 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
74 * @param sueldoPlus
75 * @return <ul>
76 * <li>true: se suma el plus al sueldo</li>
77 * <li>false: no se suma el plus al sueldo</li>
78 * </ul>
79 */
80 public boolean plus (double sueldoPlus){

73
81 boolean aumento=false;
82 if (edad>40 && compruebaNombre()){
83 salario+=sueldoPlus;
84 aumento=true;
85 }
86 return aumento;
87 }
88
89 //Metodos privados
90 /**
91 * Comprueba que el nombre no este vacio
92 * @return <ul>
93 * <li>true: el nombre es una cadena vacia</li>
94 * <li>false: el nombre no es una cadena vacia</li>
95 * </ul>
96 */
97 private boolean compruebaNombre(){
98 if([Link]("")){
99 return false;
100 }
101 return true;
102 }
103
104 //Constructores
105 /**
106 * Constructor por defecto
107 */
108 public Empleado(){
109 this ("", "", 0, 0);
110 }
111
112 /**

74
113 * Constructor con 4 parametros
114 * @param nombre nombre del empleado
115 * @param apellido nombre del empleado
116 * @param edad edad del empleado
117 * @param salario salario del empleado
118 */
119 public Empleado(String nombre, String apellido, int edad, double salario){
120 [Link]=nombre;
121 [Link]=apellido;
122 [Link]=edad;
123 [Link]=salario;
124 }
125}
–Clase hija Comercial
1 /**
2 * Clase Comercial
3 *
4 * Contiene información de un comercial, un tipo de empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Comercial extends Empleado{
10
11 //Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre
12
13 /**
14 * Comision por venta del comercial
15 */
16 private double comision;
17
18 /**

75
19 * Constructor por defecto
20 */
21 public Comercial(){
22 [Link]=0;
23 }
24
25 /**
26 * Constructor con 5 parametros
27 * @param nombre nombre del comercial
28 * @param apellido apellido del comercial
29 * @param edad edad del comercial
30 * @param salario salario del comercial
31 * @param comision comision del comercial
32 */
33 public Comercial(String nombre, String apellido, int edad, double salario, double comision) {
34 super(nombre, apellido, edad, salario);
35 [Link]=comision;
36 }
37}
–Clase hija Repartidor
1 /**
2 * Clase Repartidor
3 *
4 * Contiene información de un repartidor, un tipo de empleado
5 *
6 * @author Fernando
7 * @version 1.0
8 */
9 public class Repartidor extends Empleado{
10
11 //Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre
12

76
13 /**
14 * Zona del repartidor
15 */
16 private String zona;
17
18 /**
19 * Constructor por defecto
20 */
21 public Repartidor(){
22 [Link]="";
23 }
24
25 /**
26 * Constructor con 5 parametros
27 * @param nombre nombre del repartidor
28 * @param apellido apellido del repartidor
29 * @param edad edad del repartidor
30 * @param salario salario del repartidor
31 * @param zona zona del repartidor
32 */
33 public Repartidor(String nombre, String apellido, int edad, double salario, String zona) {
34 super(nombre, apellido, edad, salario);
35 [Link]=zona;
36 }
37}
Vayamos por partes, en la clase padre, vemos que los atributos en lugar de private usamos protected,
haciendo que los atributos se hereden a las clases hijas.

En las clases hijas, vemos que después del nombre de la clase escribimos extends nombre_clase_padre,
también tienen sus propios atributos.

77
Debemos tener en cuenta varios aspectos, los constructores de la clase hija siempre llaman al constructor por
defecto (el que no tiene parámetros) de la clase padre, también podemos indicar que constructor debe de
llamar, se indica con super(parametros);, después podemos hacer lo queramos. Si no indicamos nada es
como si escribiéramos super();.

También debemos tener en cuenta que los métodos no son necesario que los heredemos, ya que
con public las clases hijas podrán acceder a los métodos de la clase padre.

También podemos llamar métodos de la clase padre con super.nombre_método(parámetros) podemos

usarlo para que llame a un método que necesitamos para un método de la clase hija. Nos ahorrara trabajo,
es mejor que copiar y pegar código.
Ahora vamos a ver un ejemplo de crear objetos de estas clases heredadas:
1 public class EmpleadoApp {
2
3 public static void main(String[] args) {
4
5 //Creamos objetos de las clases hijas
6 Comercial comercial1=new Comercial("Antonio", "Lopez", 24, 600, 50);
7 Repartidor repartidor1=new Repartidor("Fernando", "Ureña", 43, 400, "Este");
8
9 //Invocamos los metodos de la clase padre
10 [Link](300);
11 [Link](300);
12
13 //Mostramos los atributos, usando los metodos get de la clase padre
14 [Link]("El salario actual del comercial es "+[Link]());
15 [Link]("El salario actual del repartidor es "+[Link]());
16
17 }
18
19}

78
Por último, recuerda que que la herencia va de arriba a abajo, es decir, que una clase padre no podrá acceder
la clase hija pero si al revés. Ademas solo podemos heredar una sola clase.

POLIMORFISMO JAVA
El polimorfismo permite que las clases hijas implementen un método de la clase padre de forma distinta.
Para realizar el polimorfismo, debemos crear un método con el mismo nombre, mismos parámetros y tipo
devuelto en la clase hija. Al llamar el método, usando un objeto de la clase hija, este llamara al suyo propio
y no al de la clase padre.

Veamos un ejemplo:
–Método de la clase Empleado
1 /**
2 * Suma un plus al salario del empleado si el empleado tiene mas de 40 años
3 * @param sueldoPlus
4 * @return <ul>
5 * <li>true: se suma el plus al sueldo</li>
6 * <li>false: no se suma el plus al sueldo</li>
7 * </ul>
8 */
9 public boolean plus (double sueldoPlus){
10 boolean aumento=false;
11 if (edad>40 && compruebaNombre()){
12 salario+=sueldoPlus;
13 aumento=true;
14 }
15 return aumento;
16 }
–Método de la clase Comercial (hija de empleado)
1 /**
2 * Suma un plus al salario del empleado si el empleado tiene una comision menor que 50
3 * @param sueldoPlus
4 * @return <ul>

79
5 * <li>true: se suma el plus al sueldo</li>
6 * <li>false: no se suma el plus al sueldo</li>
7 * </ul>
8 */
9 public boolean plus (double sueldoPlus){
10 boolean aumento=false;
11 if (comision<50){
12 salario+=sueldoPlus;
13 aumento=true;
14 }
15 return aumento;
16 }
Como vemos, la definición de los métodos es igual pero hace cosas distintas.
Recuerda que podemos sobrescribir los métodos como ya vimos en las clases.
INTRODUCCIÓN APLICACIONES GRÁFICAS EN JAVA

Como Diseñar Aplicaciones Gráficas Con NetBeans

Con NetBeans, es muy sencillo diseñar aplicaciones gráficas, haciéndonos gastar menos tiempo en
programar.

Cuando creamos un elemento gráfico, un JFrame por ejemplo, nos aparece una pestaña llamada diseño,
donde podemos añadir, eliminar y editar propiedades de controles (textbox, label, etc).

Como vemos, tenemos a un lado los controles y en el otro el JFrame, que sería como un «lienzo». Para añadir
un control, simplemente elegimos un control, arrastramos y soltamos en el frame donde queremos colocarlo.
Los más comunes están en la categoría Swing controls.

80
Una vez insertados, podemos adaptar sus dimensiones como nosotros queramos. Solo tenemos que usar el
ratón para para aumentar o disminuir la altura, anchura o ambas.
Cuando tenemos muchos elementos, lo suyo es que cada uno tenga su propio nombre, ya que por defecto
usa nombres predefinidos. Para ello, seleccionamos el control y con el botón derecho, elegimos la
opción Cambiar nombre variable…

81
Yo se recomienda poner nombres reconocibles y con un prefijo indicando el tipo de control, por ejemplo:
• Label: lbl
• Button: btn
• TextBox: txt o tbx
• radiobutton: rdb
• checkbox: ckb
• etc
Por ejemplo, si tenemos un botón que lo que hace es generar algo, lo podemos llamar btnGenerar. O podemos
ser más específicos, esto ya es cosa vuestra.

También podemos programar los eventos de una forma fácil, pinchamos con el botón secundario a un control
y elegimos el menú Eventos. Veremos lo siguiente:

82
Cuando seleccionemos el evento, aparecerá en nuestro código, la definición del evento aparecerá y podremos
programar lo que queramos en él.

Para añadir menús, abrimos la categoria Swing Menus y elegimos primero el control Menu Bar, con esta
barra podemos añadir nuestros menús y menuItems (submenús).

83
Podemos personalizar muchas propiedades para cada control, simplemente con el botón secundario elegimos
propiedades. Veremos un diálogo con todos los datos disponibles a personalizar.

TIPOS DE COMPONENTES GRÁFICOS EN JAVA

Como hemos visto hasta ahora, podemos insertar varios tipos de componentes, vamos a ver algunos
ejemplos.
Usaremos la forma simple de crearlos, si quieres más detalles puedes consultar el API de Java, buscando la
clase dentro del paquete [Link].

También pueden tener métodos específicos, si hay alguno especial que debas saber, te lo diremos. Recuerda
que lo normal para insertar un componente será crear un objeto de esa clase, situarlo en una posición del
panel y añadirlo al panel.

Este es un ejemplo de una aplicación gráfica, puedes ayudarte del plugin de Eclipse Windows builder:
1 import [Link].*;

84
2
3 public class AplicacionGrafica extends JFrame{
4
5 /**
6 * Panel de la aplicacion
7 */
8 private JPanel contentPane;
9 public AplicacionGrafica(){
10
11 //Añade un titulo, no es estrictamente necesario
12 setTitle("Titulo de la ventana");
13
14 /*
15 * Coordenadas x y de la aplicacion y su altura y longitud,
16 * si no lo indicamos aparecera una ventana muy pequeña
17 */
18 setBounds(400, 200, 607, 448);
19
20 /*
21 * Indica que cuando se cierre la ventana se acaba la aplicacion,
22 * si no lo indicamos cuando cerremos la ventana la aplicacion seguira funcionando
23 */
24 setDefaultCloseOperation(EXIT_ON_CLOSE);
25
26 //Hace visible la ventana, si no lo hacemos no veremos la aplicacion
27 setVisible(true);
28
29 //Creamos el panel
30 contentPane =new JPanel();
31
32 //Indicamos su diseño
33 [Link](null);

85
34
35 //asigno el pannel a la ventana
36 setContentPane(contentPane);
37
38 }
39
40 public static void main(String[] args) {
41 AplicacionGrafica ventana=new AplicacionGrafica();
42
43 }
44
45}
Estos tipos son los mas comunes:
• Etiqueta: se crean con la clase JLabel, le pasamos como parámetro una cadena que sera el contenido
de la etiqueta. Veamos un ejemplo.
1JLabel etiqueta=new JLabel("¡Hola mundo!");
[Link](60, 20, 100, 20);
[Link](etiqueta);

• Campo de texto: se crean con la clase JTextField, nos permite que el usuario introduzca un texto,
que podemos utilizar para nuestra aplicación. Veamos un ejemplo:
1textField = new JTextField();
[Link](43, 67, 86, 26);
[Link](textField);

86
 • Botón: se crea con la clase JButton, le pasamos una cadena como parámetro el nombre
que contendrá el botón. Veamos un ejemplo:
1JButton btnPulsame = new JButton("Pulsame");
[Link](43, 133, 89, 23);
[Link](btnPulsame);

• Botón radio: se crea con la clase JRadioButton, le pasamos una cadena para indicar su nombre,
también le podemos pasar un booleano, indicando si esta marcado por defecto. NOTA: es importante
agrupar estos botones para formen parte de uno, es decir, que no podamos marcar mas de dos, para
ello creamos un objeto ButtonGroup y con el metodo add vamos añadiendo botones. Veamos un
ejemplo:

87
1 JRadioButton rdbtnOpcion= new JRadioButton("Opcion 1", true);
2 [Link](43, 194, 109, 23);
3 [Link](rdbtnOpcion);
4
5 JRadioButton rdbtnOpcion_1 = new JRadioButton("Opcion 2", false);
6 rdbtnOpcion_1.setBounds(43, 220, 109, 23);
7 [Link](rdbtnOpcion_1);
8
9 JRadioButton rdbtnOpcion_2 = new JRadioButton("Opcion 3", false);
10 rdbtnOpcion_2.setBounds(43, 246, 109, 23);
11 [Link](rdbtnOpcion_2);
12
13 ButtonGroup bgroup = new ButtonGroup();
14 [Link](rdbtnOpcion);
15 [Link](rdbtnOpcion_1);
16 [Link](rdbtnOpcion_2);
• Botón checkbox: se crean con la clase JCheckBox, le pasamos como parámetro una cadena para
indicar su nombre, también un booleana indicando su estado inicial, recuerda que pueden estar varios
marcados. Veamos un ejemplo:
1 JCheckBox chckbxOpcion = new JCheckBox("Opcion1", true);
2 [Link](43, 305, 97, 23);
3 [Link](chckbxOpcion);
4
5 JCheckBox chckbxNewCheckBox = new JCheckBox("Opcion 2", true);
6 [Link](43, 325, 97, 23);
7 [Link](chckbxNewCheckBox);
8
9 JCheckBox chckbxOpcion_1 = new JCheckBox("Opcion3", false);
10chckbxOpcion_1.setBounds(43, 346, 97, 23);
[Link](chckbxOpcion_1);

88
 • Texto de área: se crea con la clase JTextArea, le podemos pasar como parámetro una cadena con
el texto que aparecerá por defecto. Si queremos que se baje la palabra al terminar la linea, usaremos
el método setLineWrap(true); invocado desde el objeto TextArea. Si queremos que cuando que
cuando baje lo haga la palabra entera en lugar de caracteres sueltos, usaremos el
método setWrapStyleWord(true);. Veamos un ejemplo:
1JTextArea textArea = new JTextArea("prueba");
[Link](189, 18, 141, 117);
[Link](true);
[Link](true);
[Link](textArea);
Si ejecutas hasta aquí, veras que al escribir demasiado baja y ya no vemos lo que escribimos, por eso
podemos añadir un scroll (clase JScrollPane) para que nos aparezca un scroll cuando se pase. Escribiremos
lo siguiente:
1JScrollPane scroll = new JScrollPane(textArea); //Objeto
[Link](189, 18, 141, 117); //Misma coordenadas y tamaño que el objeto
[Link](scroll);

89
 • Campo de password: se crea con la clase JPasswordField, le podemos pasar una cadena con el
texto por defecto. El texto que insertemos aparecerán puntos, muy usados para contraseñas. Veamos
un ejemplo:

1JPasswordField pwd = new JPasswordField("fernando");

[Link](189, 171, 139, 20);
[Link](pwd);

90
 • Menú de selección: se crea con la clase JComboBox, esta es una clase parametrizada por lo que
es recomendable indicar el tipo de dato a almacenar. Para añadir elementos, usaremos el método
addItem(«elemento»); donde elemento sera lo que queremos introducir en el combobox. Veamos un
ejemplo:
1JComboBox comboBox = new JComboBox<>();
[Link](189, 221, 141, 22);
[Link](comboBox);
4
[Link]("Fernando");
[Link]("Alberto");
[Link]("Arturo");

• Interruptor: se crea con la clase JToggleButton, nos permite usarlo como si fuera un interruptor, si
esta pulsado es true y si no lo esta es false. Le podemos pasar una cadena con el texto por defecto,
también un booleano para indicar si esta pulsado o no por defecto.
1JToggleButton tglbtnNewToggleButton = new JToggleButton("Interruptor", true);
[Link](189, 291, 121, 23);
[Link](tglbtnNewToggleButton);

91
 • JSpinner: se crea con la clase JSpinner, nos sirve para llevar un contador, podemos aumentar o
disminuir una cantidad. Veamos un ejemplo:
1JSpinner spinner = new JSpinner();
[Link](371, 20, 29, 20);
[Link](spinner);

92
 • Lista: se crea con la clase JList, es una clase parametrizada por lo que es recomendable indicar el
tipo de dato a almacenar. Hay varias formas de construir este componente, pero lo mas sencillo, es
pasandole un array de objetos, por ejemplo, un array de String. También le añadiremos un scroll,
como vimos antes. Veamos un ejemplo:
//Arrays de String
1String pelis[]={"Star wars: la venganza de los siths", "El señor de los anillos: el retorno del rey", "Guerra
2mundial Z", "Revolution", "007: Todo o Nada"};
3
4JList list = new JList<>(pelis);
[Link](371, 72, 86, 80);
[Link](list);

Si usas Windows Builder, es posible que aparezca un error al colocar el diseño de nuevo, se debe a
parametrizar un componente JList, si lo dejas sin parametrizar podrás volver a acceder, aunque este
parametrizada si ejecutas el programa, funciona.

Hay muchos más componentes, alguno de ellos, lo comentaremos en otros posts con más profundidad.
Os dejo el ejemplo completo:

93
1 import [Link];
2 import [Link].*;
3
4 public class EjemploWindowsBuilder extends JFrame {
5
6 private JPanel contentPane;
7 private JTextField textField;
8
9 /**
10 * Launch the application.
11 */
12 public static void main(String[] args) {
13 [Link](new Runnable() {
14 public void run() {
15 try {
16 EjemploWindowsBuilder frame = new EjemploWindowsBuilder();
17 [Link](true);
18 } catch (Exception e) {
19 [Link]();
20 }
21 }
22 });
23 }
24
25 /**
26 * Create the frame.
27 */
28 public EjemploWindowsBuilder() {
29 //Añade un titulo, no es estrictamente necesario
30 setTitle("Titulo de la ventana");
31
32 /*

94
33 * Coordenadas x y de la aplicacion y su altura y longitud,
34 * si no lo indicamos aparecera una ventana muy pequeña
35 */
36 setBounds(400, 200, 607, 448);
37
38 /*
39 * Indica que cuando se cierre la ventana se acaba la aplicacion,
40 * si no lo indicamos cuando cerremos la ventana la aplicacion seguira funcionando
41 */
42 setDefaultCloseOperation(EXIT_ON_CLOSE);
43
44 //Hace visible la ventana, si no lo hacemos no veremos la aplicacion
45 setVisible(true);
46
47 //Creamos el panel
48 contentPane =new JPanel();
49
50 //Indicamos su diseño
51 [Link](null);
52
53 //asigno el pannel a la ventana
54 setContentPane(contentPane);
55
56 //Creacion de componentes
57
58 //Etiqueta
59 JLabel etiqueta=new JLabel("¡Hola mundo!");
60 [Link](60, 20, 100, 20);
61 [Link](etiqueta);
62
63 //Campo de texto
64 textField = new JTextField();

95
65 [Link](43, 67, 86, 26);
66 [Link](textField);
67
68 //Boton
69 JButton btnPulsame = new JButton("Pulsame");
70 [Link](43, 133, 89, 23);
71 [Link](btnPulsame);
72
73 //Boton de radio
74 JRadioButton rdbtnOpcion= new JRadioButton("Opcion 1", true);
75 [Link](43, 194, 109, 23);
76 [Link](rdbtnOpcion);
77
78 JRadioButton rdbtnOpcion_1 = new JRadioButton("Opcion 2", false);
79 rdbtnOpcion_1.setBounds(43, 220, 109, 23);
80 [Link](rdbtnOpcion_1);
81
82 JRadioButton rdbtnOpcion_2 = new JRadioButton("Opcion 3", false);
83 rdbtnOpcion_2.setBounds(43, 246, 109, 23);
84 [Link](rdbtnOpcion_2);
85
86 //Agrupamos los botnones de radio
87 ButtonGroup bgroup = new ButtonGroup();
88 [Link](rdbtnOpcion);
89 [Link](rdbtnOpcion_1);
90 [Link](rdbtnOpcion_2);
91
92 //Checkboxes
93 JCheckBox chckbxOpcion = new JCheckBox("Opcion1", true);
94 [Link](43, 305, 97, 23);
95 [Link](chckbxOpcion);
96

96
97 JCheckBox chckbxNewCheckBox = new JCheckBox("Opcion 2", true);
98 [Link](43, 325, 97, 23);
99 [Link](chckbxNewCheckBox);
100
101 JCheckBox chckbxOpcion_1 = new JCheckBox("Opcion3", false);
102 chckbxOpcion_1.setBounds(43, 346, 97, 23);
103 [Link](chckbxOpcion_1);
104
105 //TextArea
106 JTextArea textArea = new JTextArea("pruebaaaa");
107 [Link](171, 18, 141, 117);
108 [Link](true);
109 [Link](true);
110 [Link](textArea);
111
112 //Scrollpane asociado a textarea
113 JScrollPane scroll = new JScrollPane(textArea); //Objeto
114 [Link](189, 18, 141, 117); //Misma coordenadas y tamaño que el objeto
115 [Link](scroll);
116
117 //Campo de password
118 JPasswordField pwd = new JPasswordField("fernando");
119 [Link](189, 171, 139, 20);
120 [Link](pwd);
121
122 //Menu de opciones
123 JComboBox comboBox = new JComboBox<>();
124 [Link](189, 221, 141, 22);
125 [Link](comboBox);
126
127 //Añadimos opciones
128 [Link]("Fernando");

97
129 [Link]("Alberto");
130 [Link]("Arturo");
131
132 //Boton interruptor
133 JToggleButton tglbtnNewToggleButton = new JToggleButton("Interruptor", true);
134 [Link](189, 291, 121, 23);
135 [Link](tglbtnNewToggleButton);
136
137 //Contador
138 JSpinner spinner = new JSpinner();
139 [Link](371, 20, 29, 20);
140 [Link](spinner);
141
142 //Arrays de String
143 String pelis[]={"Star wars: la venganza de los siths", "El señor de los anillos: el retorno del rey",
144"Guerra mundial Z", "Revolution", "007: Todo o Nada"};
145
146 //Lista
147 JList list = new JList<>(pelis);
148 [Link](371, 72, 86, 80);
149 [Link](list);
150
151 //Scroll asociado a la lista
152 JScrollPane scroll2 = new JScrollPane(list); //Objeto
153 [Link](371, 72, 86, 80); //Misma coordenadas y tamaño que el objeto
154 [Link](scroll2);
155 }
}
Recordar que también podéis hacerlo con el IDE Netbeans. Es más sencillo de usar.

98
EVENTOS Y LISTENERS EN JAVA
Los eventos son las acciones que puede realizar el usuario, al realizar un evento se produce una serie de
acciones. Por ejemplo, si el usuario pulsa un botón llamado «Salir» cerrara la aplicación. Otro ejemplo muy
usado es para validar texto que introduzcamos en un campo de texto.

Los Listeners (oyentes o escuchadores en español) se encargan de controlar los eventos, esperan a que el
evento se produzca y realiza una serie de acciones. Según el evento, necesitaremos un Listener que lo
controle.

Cada Listener tiene una serie de métodos que debemos implementar obligatoriamente, aunque solo
queramos usar uno solo de ellos.
Los Listeners que usaremos estarán en el paquete [Link].
Vamos a ver los distintos Listeners que existen, la definición de sus métodos y los eventos que controlan:

Nombre Listener Descripción Métodos Eventos

ActionListener Se produce al hacer public void • JButton: click o pulsar Enter con
click en un componente, actionPerformed( el foco activado en él.
también si se pulsa ActionEvent e) • JList: doble click en un elemento
Enter teniendo el foco de la lista.
en el componente. • JMenuItem: selecciona una
opción del menú.
• JTextField: al pulsar Enter con el
foco activado.

KeyListener Se produce al pulsar public void Cuando pulsamos una tecla, segun el
una tecla. según el keyTyped(KeyEve Listener:
método cambiara la nt e) • keyTyped:al pulsar y soltar
forma de pulsar la tecla. la tecla.
public void • keyPressed: al pulsar la
keyPressed(KeyE tecla.
vent e) • keyReleased: al soltar la
tecla.

99
Nombre Listener Descripción Métodos Eventos

public void
keyReleased(Key
Event e)

FocusListener Se produce cuando un public void Recibir o perder el foco.

componente gana o focusGained(Focu
pierde el foco, es decir, sEvent e)
que esta seleccionado.
public void
focusLost(FocusE
vent e)

MouseListener Se produce cuando public void Según el Listener:

realizamos una acción mouseClicked(Mo • mouseCliked: pinchar y
con el ratón. useEvent e) soltar.

public void • mouseEntered: entrar en un

mouseEntered(Mo componente con el puntero.
useEvent e)

public void • mouseExited: salir de un

mouseExited(Mous componente con el puntero
eEvent e)

public void
• mousePressed: presionar
mousePressed(M
el botón.
ouseEvent e)

public void
• mouseReleased: soltar el
mouseReleased(
botón.
MouseEvent e)

100
 Nombre Listener Descripción Métodos Eventos

MouseMotionListene Se produce con el Según el Listener:

r movimiento del mouse.
public void • mouseDragged: click y
mouseDragged(M arrastrar un componente.
ouseEvent e)

public void • mouseMoved: al mover el

mouseMoved(Mo puntero sobre un elemento
useEvent e)

Estos son los más comunes, otros eventos los veremos con más profundidad en posteriores posts
Para añadir un evento, seguiremos la siguiente sintaxis:

[Link]"tipo evento"(new "tipo evento"(){

metodos del evento
});

Otra forma es:

"Tipo evento" "nombre"= new "tipo evento"{

metodos del evento
};
[Link]"Tipo evento"("nombre");

Por ejemplo:
[Link](new ActionListener(){
2 public void actionPerformed (){
3 //Acciones
4 }
5});

101
De la segunda manera seria así:
1ActionListener al=new ActionListener(){
2 public void actionPerformed (){
3 //Acciones
4 }
5};
[Link](al);

Es posible que algún que otro componente nos convenga que sea un atributo.
Ejemplo completo con distintos tipos de eventos:
1 import [Link];
2 import [Link].*;
3 import [Link].*;
4
5 public class EjemploEvento extends JFrame {
6
7 private JPanel contentPane;
8 private JTextField textField;
9 private JTextField textField_1;
10 private JTextField textField_2;
11 private JComboBox<String> comboBox;
12 private JRadioButton rdbtnOpcion;
13 private JRadioButton rdbtnOpcion_1;
14 private JRadioButton rdbtnOpcion_2;
15 private JLabel lblEstasSobreLa;
16
17 /**
18 * Launch the application.
19 */
20 public static void main(String[] args) {
21 [Link](new Runnable() {
22 public void run() {

102
23 try {
24 EjemploEvento frame = new EjemploEvento();
25 [Link](true);
26 } catch (Exception e) {
27 [Link]();
28 }
29 }
30 });
31 }
32
33 /**
34 * Create the frame.
35 */
36 public EjemploEvento() {
37
38 //Añade un titulo, no es estrictamente necesario
39 setTitle("Titulo de la ventana");
40
41 /*
42 * Coordenadas x y de la aplicacion y su altura y longitud,
43 * si no lo indicamos aparecera una ventana muy pequeña
44 */
45 setBounds(400, 200, 655, 520);
46
47 /*
48 * Indica que cuando se cierre la ventana se acaba la aplicacion,
49 * si no lo indicamos cuando cerremos la ventana la aplicacion seguira funcionando
50 */
51 setDefaultCloseOperation(EXIT_ON_CLOSE);
52
53 //Hace visible la ventana, si no lo hacemos no veremos la aplicacion
54 setVisible(true);

103
55
56 //Creamos el panel
57 contentPane =new JPanel();
58
59 //Indicamos su diseño
60 [Link](null);
61
62 //asigno el pannel a la ventana
63 setContentPane(contentPane);
64
65 //Componentes
66
67 //Etiquetas
68
69 JLabel lblEscribeElNombre = new JLabel("Escribe el nombre el nombre de una persona sin digitos");
70 [Link](369, 32, 229, 25);
71 [Link](lblEscribeElNombre);
72
73 JLabel lblEligeUnaOpcin = new JLabel("Elige una opci\u00F3n:");
74 [Link](176, 32, 109, 14);
75 [Link](lblEligeUnaOpcin);
76
77 JLabel lblPulsaElBoton = new JLabel("Pulsa el boton");
78 [Link](47, 32, 85, 14);
79 [Link](lblPulsaElBoton);
80
81 lblEstasSobreLa = new JLabel("Estas sobre la ");
82 [Link](158, 224, 192, 14);
83 [Link](lblEstasSobreLa);
84
85 JLabel lblSoloSePuede = new JLabel("Solo se puede escribir digitos");
86 [Link](371, 208, 193, 14);

104
87 [Link](lblSoloSePuede);
88
89 JLabel lblNombreElegido = new JLabel("Nombre Elegido");
90 [Link](175, 124, 110, 14);
91 [Link](lblNombreElegido);
92
93 //Campo de texto
94
95 textField = new JTextField();
96 [Link](371, 68, 193, 26);
97 [Link](textField);
98
99 textField_1 = new JTextField();
100 textField_1.setEditable(false);
101 textField_1.setBounds(175, 150, 141, 20);
102 [Link](textField_1);
103
104 textField_2 = new JTextField();
105 textField_2.setBounds(371, 247, 126, 20);
106 [Link](textField_2);
107
108 //Botones
109
110 JButton btnPulsame = new JButton("Pulsame");
111 [Link](43, 70, 89, 23);
112 [Link](btnPulsame);
113
114 JButton btnAnadir= new JButton("A\u00F1adir");
115 [Link](371, 124, 89, 23);
116 [Link](btnAnadir);
117
118 //Botones de radio

105
119
120 rdbtnOpcion= new JRadioButton("Opcion 1");
121 [Link](43, 194, 109, 23);
122 [Link](rdbtnOpcion);
123
124 rdbtnOpcion_1 = new JRadioButton("Opcion 2");
125 rdbtnOpcion_1.setBounds(43, 220, 109, 23);
126 [Link](rdbtnOpcion_1);
127
128 rdbtnOpcion_2 = new JRadioButton("Opcion 3");
129 rdbtnOpcion_2.setBounds(43, 246, 109, 23);
130 [Link](rdbtnOpcion_2);
131
132 //Agrupamos los botnones de radio
133 ButtonGroup bgroup = new ButtonGroup();
134 [Link](rdbtnOpcion);
135 [Link](rdbtnOpcion_1);
136 [Link](rdbtnOpcion_2);
137
138 //Menu de opciones
139 comboBox = new JComboBox<>();
140 [Link](175, 70, 141, 22);
141 [Link](comboBox);
142
143 //Añadimos opciones
144 [Link]("Fernando");
145 [Link]("Alberto");
146 [Link]("Arturo");
147
148 //Eventos
149
150 [Link](new ActionListener(){

106
151 public void actionPerformed (ActionEvent e){
152 [Link](contentPane, "¡Me has pulsado!");
153 }
154 });
155
156 //En este caso hemos debido de converir el componente en un atributo
157 [Link](new ActionListener(){
158 public void actionPerformed (ActionEvent e){
159 textField_1.setText([Link]([Link]()));
160 }
161 });
162
163 [Link](new KeyListener(){
164 public void keyTyped (KeyEvent e){
165 //Si el caracter introducido es un digito...
166 if ([Link]([Link]())){
167 //... no lo escribe
168 [Link]();
169 }
170 }
171 public void keyReleased(KeyEvent e){
172
173 }
174 public void keyPressed(KeyEvent e){
175
176 }
177 });
178
179 [Link](new ActionListener(){
180 public void actionPerformed (ActionEvent e){
181 [Link]([Link]());
182 [Link]("");

107
183 [Link](contentPane, "Nombre Añadido");
184 }
185 });
186
187 [Link](new MouseListener(){
188 public void mouseClicked(MouseEvent e){
189
190 }
191 public void mouseEntered(MouseEvent e){
192 [Link]([Link]()+[Link]());
193 }
194 public void mouseExited(MouseEvent e){
195 [Link]("Estas sobre la ");
196 }
197 public void mousePressed(MouseEvent e){
198
199 }
200 public void mouseReleased(MouseEvent e){
201
202 }
203 });
204
205 rdbtnOpcion_1.addMouseListener(new MouseListener(){
206 public void mouseClicked(MouseEvent e){
207
208 }
209 public void mouseEntered(MouseEvent e){
210 [Link]([Link]()+rdbtnOpcion_1.getText());
211 }
212 public void mouseExited(MouseEvent e){
213 [Link]("Estas sobre la ");
214 }

108
215 public void mousePressed(MouseEvent e){
216
217 }
218 public void mouseReleased(MouseEvent e){
219
220 }
221 });
222
223 rdbtnOpcion_2.addMouseListener(new MouseListener(){
224 public void mouseClicked(MouseEvent e){
225
226 }
227 public void mouseEntered(MouseEvent e){
228 [Link]([Link]()+rdbtnOpcion_2.getText());
229 }
230 public void mouseExited(MouseEvent e){
231 [Link]("Estas sobre la ");
232 }
233 public void mousePressed(MouseEvent e){
234
235 }
236 public void mouseReleased(MouseEvent e){
237
238 }
239 });
240
241 textField_2.addKeyListener(new KeyListener(){
242 public void keyTyped (KeyEvent e){
243 //Si el caracter introducido no es un digito...
244 if ()){
245 //... no lo escribe
246 [Link]();

109
247 }
248 }
249 public void keyReleased(KeyEvent e){
250
251 }
252 public void keyPressed(KeyEvent e){
253
254 }
255 });
256
257 }
258}
Con netBeans, simplemente hacemos click derecho en un elemento (en la parte de diseño) y elegimos en el
menú Eventos, el evento queremos programar y nos aparecera por separado en el código.

EL COMPONENTE JFILECHOOSER EN UNA APLICACIÓN GRÁFICA EN JAVA

La clase JFileChooser nos permite acceder a nuestro sistema de ficheros y seleccionar ficheros. Esto nos
puede ser útil para abrir fichero que contengan alguna información útil para nuestra aplicación o incluso para
guardar información en ficheros.

Vamos a ver cómo funciona paso a paso, primero vamos a crear una ventana simple con un campo de texto,
un botón y un área de texto (con scroll).

Código:
1 import [Link];
2 import [Link];
3 import [Link];
4 import [Link].*;
5 import [Link].*;
6
7 public class EjemploJFileChooser extends JFrame {
8

110
9 private JPanel contentPane;
10 private JTextField textField;
11 private JTextArea textArea;
12
13 /**
14 * Launch the application.
15 */
16 public static void main(String[] args) {
17 [Link](new Runnable() {
18 public void run() {
19 try {
20 EjemploJFileChooser frame = new EjemploJFileChooser();
21 [Link](true);
22 } catch (Exception e) {
23 [Link]();
24 }
25 }
26 });
27 }
28
29 /**
30 * Create the frame.
31 */
32 public EjemploJFileChooser() {
33
34 //Parametros asociados a la ventana
35 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
36 setBounds(100, 100, 450, 300);
37 contentPane = new JPanel();
38 [Link](null);
39 setContentPane(contentPane);
40

111
41 textField = new JTextField();
42 [Link]("Inserta la ruta del fichero de audio");
43 [Link](52, 26, 209, 20);
44 [Link](textField);
45 [Link](10);
46
47 JButton btnSeleccionar = new JButton("Seleccionar...");
48 [Link](288, 25, 109, 23);
49 [Link](btnSeleccionar);
50
51 textArea = new JTextArea();
52 [Link](true);
53 [Link](true);
54 [Link](52, 76, 360, 156);
55
56 JScrollPane scroll=new JScrollPane(textArea);
57 [Link](52, 76, 360, 156);
58 [Link](scroll);
59
60 [Link](new ActionListener(){
61 public void actionPerformed (ActionEvent e){
62
63 }
64 });
65
66 }
67}

Así quedaría:

112
Los siguientes bloques de código que veras, son para copiar en el evento del botón, ya que veremos muchas
versiones. Primero crearemos un objeto de JFileChooser, lo podemos crear sin parámetros o una ruta por
defecto indicada con un String o un File.

Después invocamos el método showOpenDialog(contentPane) que nos devolverá un int, para saber que
opción realiza el usuario. Tenemos las siguientes constantes:
• JFileChooser.CANCEL_OPTION: Si el usuario pulsa en cancelar.
• JFileChooser.APPROVE_OPTION: Si el usuario pulsa en aceptar
• JFileCHooser.ERROR_OPTION: Si ocurre algún error.

La que nos interesa es JFileChooser.APPROVE_OPTION, después podemos copiar la ruta de ese fichero
con el método getSelectedFile(); se guardara en un objeto File.

Esta ruta la podríamos guardar en el campo de texto, también podríamos hacer que escribiera el contenido
del texto en el textarea.

Veamos como queda de momento:

1 //Creamos el objeto JFileChooser
2 JFileChooser fc=new JFileChooser();
3
4 //Abrimos la ventana, guardamos la opcion seleccionada por el usuario
5 int seleccion=[Link](contentPane);
6
7 //Si el usuario, pincha en aceptar

113
8 if(seleccion==JFileChooser.APPROVE_OPTION){
9
10 //Seleccionamos el fichero
11 File fichero=[Link]();
12
13 //Ecribe la ruta del fichero seleccionado en el campo de texto
14 [Link]([Link]());
15
16 try(FileReader fr=new FileReader(fichero)){
17 String cadena="";
18 int valor=[Link]();
19 while(valor!=-1){
20 cadena=cadena+(char)valor;
21 valor=[Link]();
22 }
23 [Link](cadena);
24 } catch (IOException e1) {
25 [Link]();
26 }
27}

En el caso anterior, solo funcionaria con ficheros legibles, no con otros tipos de ficheros, si queremos que solo
se puedan seleccionar los ficheros legibles como los txt, deberemos crear un objeto de la
clase FileNameExtensionFilter, le pasaremos un String con la descripción del filtro y después las
extensiones en forma de string, un String por extensión. Este código lo añadimos, después de crear el objeto
JFileChooser:
1//Creamos el filtro
2FileNameExtensionFilter filtro = new FileNameExtensionFilter("*.TXT", "txt");
3
4//Le indicamos el filtro
[Link](filtro);
Así es como lo vemos:

114
Por defecto, JFileChooser solo nos permite elegir ficheros, si queremos elegir solo directorios o ambos,
usaremos el método setFileSelectionMode(int mode), también tenemos constantes para ello:
• JFileChooser.FILES_ONLY: solo ficheros.
• JFileChooser.DIRECTORIES_ONLY: solo directorios.
• JFileChooser.FILES_AND_DIRECTORIES: ficheros y directorios.

Por ejemplo:
1 //Creamos el objeto JFileChooser
2 JFileChooser fc=new JFileChooser();
3
4 //Indicamos lo que podemos seleccionar
5 [Link](JFileChooser.FILES_AND_DIRECTORIES);
6
7 //Creamos el filtro
8 FileNameExtensionFilter filtro = new FileNameExtensionFilter("*.TXT", "txt");
9
10//Le indicamos el filtro
[Link](filtro);
12
13//Abrimos la ventana, guardamos la opcion seleccionada por el usuario

115
14int seleccion=[Link](contentPane);
15
16//Si el usuario, pincha en aceptar
17if(seleccion==JFileChooser.APPROVE_OPTION){
18
19 //Seleccionamos el fichero
20 File fichero=[Link]();
21
22 //Ecribe la ruta del fichero seleccionado en el campo de texto
23 [Link]([Link]());
24
25 try(FileReader fr=new FileReader(fichero)){
26 String cadena="";
27 int valor=[Link]();
28 while(valor!=-1){
29 cadena=cadena+(char)valor;
30 valor=[Link]();
31 }
32 [Link](cadena);
33 } catch (IOException e1) {
34 [Link]();
35 }
36}
También podemos seleccionar una serie de ficheros con el método setMultiSelectionEnabled(true); lo
insertaremos después de crear el objeto. Debemos tener en cuenta, que para almacenar los seleccionados
usaremos un array de Files y en lugar de usar el método getSelectedFile(); usaremos el
método getSelectedFiles();.

Cambiaremos algunas cosas ahora, el campo de texto no lo usaremos:

1 //Creamos el objeto JFileChooser
2 JFileChooser fc=new JFileChooser();
3

116
4 //Indicamos que podemos seleccionar varios ficheros
5 [Link](true);
6
7 //Indicamos lo que podemos seleccionar
8 [Link](JFileChooser.FILES_AND_DIRECTORIES);
9
10//Creamos el filtro
11FileNameExtensionFilter filtro = new FileNameExtensionFilter("*.TXT", "txt");
12
13//Le indicamos el filtro
[Link](filtro);
15
16//Abrimos la ventana, guardamos la opcion seleccionada por el usuario
17int seleccion=[Link](contentPane);
18
19//Si el usuario, pincha en aceptar
20if(seleccion==JFileChooser.APPROVE_OPTION){
21
22 //Seleccionamos el fichero
23 File[] ficheros=[Link]();
24
25 for(int i=0;i<[Link];i++){
26 try(FileReader fr=new FileReader(ficheros[i])){
27 String cadena="";
28 int valor=[Link]();
29 while(valor!=-1){
30 cadena=cadena+(char)valor;
31 valor=[Link]();
32 }
33 [Link](cadena+"\n");
34 } catch (IOException e1) {
35 [Link]();

117
36 }
37 }
38}
Por último, veremos como guardar texto en lugar de abrirlo, el campo de texto no lo usaremos, el textarea
contendrá el texto del fichero. Usaremos el método showSaveDialog(contentPane); para guardar el fichero,
recuerda escribir el nombre del fichero.

1 //Creamos el objeto JFileChooser

2 JFileChooser fc=new JFileChooser();
3
4 //Abrimos la ventana, guardamos la opcion seleccionada por el usuario
5 int seleccion=[Link](contentPane);
6
7 //Si el usuario, pincha en aceptar
8 if(seleccion==JFileChooser.APPROVE_OPTION){
9
10 //Seleccionamos el fichero
11 File fichero=[Link]();
12
13 try(FileWriter fw=new FileWriter(fichero)){
14
15 //Escribimos el texto en el fichero
16 [Link]([Link]());
17
18 } catch (IOException e1) {
19 [Link]();
20 }
21
22}
En netBeans, tendreis que hacer lo mismo. También hay un componente por si lo quereis poner directamente
en un JFrame.

118
CREAR PESTAÑAS CON LA CLASE JTABBEDPANE EN JAVA
Es posible que queramos hacer otro tipo de aplicación, en lugar de como lo hemos hasta ahora con un solo
Panel, podemos hacer una aplicación con varios paneles y cambiaremos entre paneles por las pestañas que
iremos creando.

Vamos a ver como lo podemos programar nosotros mismos y después con Windows Builder.
Como hemos dicho, vamos a hacer la ventana de una forma distinta, no tendremos un atributo JPanel
contentPane. Lo primero es heredar nuestra clase con JFrame como ya vimos, recuerda de importar la clase
necesaria y definir el constructor.
1import [Link].*;
2
3public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 }
Colocaremos los parámetros asociados a la ventana como el tamaño, la visibilidad, etc.
1 import [Link].*;
2
3 public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 //Parametros asociados a la ventana
8 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 setExtendedState(MAXIMIZED_BOTH);
10 setVisible(true);
11 setTitle("Ejemplo JTabbedPane");
12 }
13}
Ahora creamos un objeto de la clase JTabbedPane, se puede crear sin parámetros.

119
1 import [Link].*;
2
3 public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 //Parametros asociados a la ventana
8 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 setExtendedState(MAXIMIZED_BOTH);
10 setVisible(true);
11 setTitle("Ejemplo JTabbedPane");
12
13 //Creamos el conjunto de pestañas
14 JTabbedPane pestañas=new JTabbedPane();
15 }
16}
Ahora creamos un objeto de la clase JPanel, tampoco es necesario insertar parámetros. Después, podemos
añadir los componentes que queramos como ya vimos en varios posts anteriores y después usamos el
método addTab(String tituloPestaña, Panel); del objeto de JTabbedPane.
1 import [Link].*;
2
3 public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 //Parametros asociados a la ventana
8 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 setExtendedState(MAXIMIZED_BOTH);
10 setVisible(true);
11 setTitle("Ejemplo JTabbedPane");
12
13 //Creamos el conjunto de pestañas

120
14 JTabbedPane pestañas=new JTabbedPane();
15
16 //Creamos el panel y lo añadimos a las pestañas
17 JPanel panel1=new JPanel();
18
19 //Componentes del panel1
20 JLabel et_p1=new JLabel("Estas en el panel 1");
21 [Link](et_p1);
22
23 //Añadimos un nombre de la pestaña y el panel
24 pestañ[Link]("Panel 1", panel1);
25
26 }
27}
Con el resto de paneles haremos lo mismo.
1 import [Link].*;
2
3 public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 //Parametros asociados a la ventana
8 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 setExtendedState(MAXIMIZED_BOTH);
10 setVisible(true);
11 setTitle("Ejemplo JTabbedPane");
12
13 //Creamos el conjunto de pestañas
14 JTabbedPane pestañas=new JTabbedPane();
15
16 //Creamos el panel y lo añadimos a las pestañas
17 JPanel panel1=new JPanel();

121
18
19 //Componentes del panel1
20 JLabel et_p1=new JLabel("Estas en el panel 1");
21 [Link](et_p1);
22
23 //Añadimos un nombre de la pestaña y el panel
24 pestañ[Link]("Panel 1", panel1);
25
26 //Realizamos lo mismo con el resto
27 JPanel panel2=new JPanel();
28 pestañ[Link]("Panel 2", panel2);
29
30 //Componentes del panel2
31 JLabel et_p2=new JLabel("Estas en el panel 2");
32 [Link](et_p2);
33
34 JPanel panel3=new JPanel();
35
36 //Componentes del panel3
37 JLabel et_p3=new JLabel("Estas en el panel 3");
38 [Link](et_p3);
39
40 pestañ[Link]("Panel 3", panel3);
41
42 JPanel panel4=new JPanel();
43
44 //Componentes del panel4
45 JLabel et_p4=new JLabel("Estas en el panel 4");
46 [Link](et_p4);
47 pestañ[Link]("Panel 4", panel4);
48 }
49

122
Ahora, añadiremos las pestañas al panel. Para ello usaremos el método getContentPane().add(objeto
JTabbedPane);

Por último, creamos un método main creando un objeto de la clase que hemos construido antes. Así se
quedara el código al final:
1 import [Link].*;
2
3 public class EjemploJTabbedPaneSinWB extends JFrame{
4
5 public EjemploJTabbedPaneSinWB(){
6
7 //Parametros asociados a la ventana
8 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 setExtendedState(MAXIMIZED_BOTH);
10 setVisible(true);
11 setTitle("Ejemplo JTabbedPane");
12
13 //Creamos el conjunto de pestañas
14 JTabbedPane pestañas=new JTabbedPane();
15
16 //Creamos el panel y lo añadimos a las pestañas
17 JPanel panel1=new JPanel();
18
19 //Componentes del panel1
20 JLabel et_p1=new JLabel("Estas en el panel 1");
21 [Link](et_p1);
22
23 //Añadimos un nombre de la pestaña y el panel
24 pestañ[Link]("Panel 1", panel1);
25
26 //Realizamos lo mismo con el resto
27 JPanel panel2=new JPanel();

123
28 pestañ[Link]("Panel 2", panel2);
29
30 //Componentes del panel2
31 JLabel et_p2=new JLabel("Estas en el panel 2");
32 [Link](et_p2);
33
34 JPanel panel3=new JPanel();
35
36 //Componentes del panel3
37 JLabel et_p3=new JLabel("Estas en el panel 3");
38 [Link](et_p3);
39
40 pestañ[Link]("Panel 3", panel3);
41
42 JPanel panel4=new JPanel();
43
44 //Componentes del panel4
45 JLabel et_p4=new JLabel("Estas en el panel 4");
46 [Link](et_p4);
47
48 pestañ[Link]("Panel 4", panel4);
49
50 getContentPane().add(pestañas);
51 }
52
53 public static void main(String[] args) {
54
55 EjemploJTabbedPaneSinWB ventana=new EjemploJTabbedPaneSinWB();
56
57 }
58
59}

124
Esto es lo que veremos.

Ahora lo vamos a ver como se haría con Windows Builder.

Creamos un JFrame, cambiamos el Layout a CardLayout, después abrimos la pestaña Containers y
seleccionamos JTabbedPane y lo insertamos. Asi quedara:

Ahora seleccionamos un JPanel en el mismo lugar de antes y lo añadimos a la ventana. Asi lo vemos:

125
Si queremos añadir mas pestañas, seleccionamos de nuevo JPanel y lo insertamos al lado de la pestaña,
veremos que aparecerá una barra roja, cuando soltemos tendremos una nueva pestaña.

Podemos modificar el contenido de cada panel pinchando dos veces en la pestaña.

Fuente de consulta:
[Link]

126