JAVA

Mdulo 1
Fundamentals of the
Java Programming
Language
Profesional en Plataforma
JAVA
Contenido
Introduccin y Objetivos ........................................................................................................................................................... 1
Unidad 1. Entendiendo la tecnologa Java ................................................................................................................................. 2
Qu son los objetos?................................................................................................................................................... 2
Clases, Mensajes y Mtodos ....................................................................................................................................... 3
Unidad 2. Analizando un problema y diseando una solucin ................................................................................................... 6
Analizar un problema usando anlisis orientado a objetos .............................................................................. 6
Diseo de clases para crear objetos ...................................................................................................................... 10
Unidad 3. Desarrollando y probando programas con tecnologa JAVA .................................................................................... 12
Instalacin y configuracin del kit de desarrollo de Sun (JDK) .................................................................... 12
Procesos para crear un programa en Java .......................................................................................................... 15
Unidad 4. Declarando, Inicializando y usando variables .......................................................................................................... 20
Elementos bsicos del lenguaje y sintaxis de Java ........................................................................................... 20
Alcance de las variables ............................................................................................................................................. 24
Declarando variables .................................................................................................................................................. 26
Conversin entre tipos (casting) ............................................................................................................................. 30
Laboratorio: Casting entre tipos de datos. ........................................................................................................ 33
Unidad 5. Creando y usando Objetos ...................................................................................................................................... 35
Declarar, instanciar e inicializar variables de referencia de objeto ............................................................. 35
La clase String .............................................................................................................................................................. 41
Introduccin a los flujos o streams ........................................................................................................................ 44
Laboratorio: Validacin Email................................................................................................................................. 46
Unidad 6. Usando operadores y constructores........................................................................................................................ 49
Operadores y expresiones......................................................................................................................................... 49
Operadores Aritmticos (Suma, resta, multiplicacin, divisin, resto, incremento y decremento). 50
Operadores Relacionales. .......................................................................................................................................... 50
Operadores Condicionales. ....................................................................................................................................... 51
Operadores a nivel de bit .......................................................................................................................................... 51
Operadores de asignacin. ....................................................................................................................................... 51
Operador ternario if-then-else ................................................................................................................................. 52
Sentencias de excepcin, bloques try, catch, finally. ...................................................................................... 53
Laboratorio: Averiguar da de nacimiento de la semana. ............................................................................... 56
Unidad 7. Usando Loops ......................................................................................................................................................... 60
Sentencia if-else ........................................................................................................................................................... 60
Sentencia switch-case ................................................................................................................................................ 61
Sentencia while............................................................................................................................................................. 62
www.learning.es
Para uso exclusivo de los alumnos de LEARNING & TRAINING CLOUD, S.L.
Sentencia do-while ...................................................................................................................................................... 63
Sentencia for ................................................................................................................................................................. 64
Laboratorio: Conjetura Collatz................................................................................................................................. 66
Unidad 8. Desarrollando y usando mtodos ............................................................................................................................ 69
Mtodos (Funciones Miembro) ................................................................................................................................. 69
Laboratorio: Creacin del objeto Calculadora..................................................................................................... 77
Unidad 9. Implementando encapsulacin ............................................................................................................................... 83
Paquetes ......................................................................................................................................................................... 83
Modificadores de mbito ............................................................................................................................................ 85
Laboratorio: Creacin y uso de paquetes. ........................................................................................................... 91
Unidad 10. Creando y usando arreglos .................................................................................................................................... 95
Concepto de Array ....................................................................................................................................................... 95
Arrays Unidimensionales ........................................................................................................................................... 95
Arrays Multidimensionales ........................................................................................................................................ 99
Colecciones .................................................................................................................................................................. 103
Coleccin Set ............................................................................................................................................................... 105
Coleccin List ............................................................................................................................................................... 107
Coleccin Map ............................................................................................................................................................. 108
Laboratorio: Temperaturas Anuales .................................................................................................................... 108
Unidad 11. Implementando herencia .................................................................................................................................... 111
Herencia ........................................................................................................................................................................ 111
Laboratorio: Proyecto clases agenda................................................................................................................... 117
www.learning.es
Introduccin y Objetivos
Introduccin
Java es un lenguaje de programacin con el que podemos realizar cualquier tipo de desarrollo. Java
fue desarrollado por la compaa Sun Microsystems y est enfocado a cubrir las necesidades
tecnolgicas de empresas.
Uno de los conceptos ms interesantes de la tecnologa Java es que es un lenguaje independiente de
la plataforma. Esto quiere decir que si hacemos un programa en Java podr funcionar en cualquier
ordenador del mercado independientemente del sistema operativo en el que vayamos a utilizar el
desarrollo. Esta es la mayor ventaja de Java respecto a sus mximos competidores en lenguajes de
programacin y simplifica el trabajo del programador, pudiendo centrarse en un nico desarrollo
independiente de la plataforma dnde vaya a utilizarse dicho desarrollo. Esta capacidad del lenguaje
Java se consigue por la Mquina Virtual de Java. La mquina virtual de Java hace de puente entre
el sistema operativo y el programa de Java y permite que el sistema operativo comprenda todo tipo
de desarrollo.
Otra de las caractersticas del lenguaje Java son sus mltiples tipos de desarrollos. Existen
diferentes soluciones para los dispositivos dnde se vaya a implementar cada solucin, como pueden
ser mviles, agendas y en general, cualquier dispositivo que la tecnologa permita.
Objetivo
Explicar las caractersticas del lenguaje de programacin JAVA.
www.learning.es
Unidad 1. Entendiendo la tecnologa Java
Introduccin
Java es un lenguaje que utiliza P.O.O (Programacin orientada a objetos), dicho concepto se basa en
el modelo objeto, donde el elemento principal es el objeto, el cual es una unidad que contiene todas
sus caractersticas y comportamientos en s misma, lo cual lo hace como un elemento
independiente, pero que se interrelaciona con objetos de su misma clase o de otras clases, como
sucede en el mundo real.
Objetivo
Comprender el concepto y caractersticas del lenguaje de programacin Java.
Qu son los objetos?

Para aprender la relacin entre objetos del lenguaje de programacin Java debemos abstraernos y
pensar en trminos ajenos a la programacin, utilizando elementos de la vida real.
Un objeto es una persona, animal o cosa. La forma de distinguir cualquier objeto de otro es por
unas determinadas caractersticas y su utilidad como objeto para realizar unas acciones que no
puede realizar otro objeto diferente. Pongamos como ejemplo que no es lo mismo utilizar un coche
que una televisin, siendo los dos objetos, pero la clase de cada uno define sus acciones y
propiedades para lo que ha sido creado. Pues esto mismo es lo que realiza el lenguaje Java. Cada
objeto est pensado para realizar una serie de acciones y dependiendo de nuestra lgica que
deseemos aplicar, utilizaremos un objeto u otro de una clase diferente.
Utilizando el ejemplo del coche y la televisin. Un coche es un objeto. Tiene como caractersticas o
propiedades el nmero de puertas, la velocidad mxima, el color, la cilindrada, la altura o el peso. Y
tambin tiene una serie de acciones que podemos realizar sobre un coche, tales como arrancar,
frenar, girar, acelerar, cambiar de marcha, mover respaldo o abrir puertas.
Cada objeto se define en funcin de multitud de propiedades y se pueden realizar innumerables
operaciones sobre l. Los objetos pueden interactuar entre s o utilizarlos de forma nica.
Una televisin tiene otras caractersticas y acciones totalmente diferentes a un coche. Podemos
utilizar tanto un coche como una televisin de forma independiente. El coche para conducir y la
televisin para visualizar pelculas o series. Cada uno tiene su funcin especfica. Pero tambin
puedo combinar los dos objetos para poner una televisin porttil en el coche. De esa forma, estoy
combinando dos objetos diferentes para conseguir una funcionalidad especfica en mi lgica:
Visualizar pelculas en el coche. Todos estos conceptos son la base de cualquier lenguaje de
programacin orientado a objetos, y es lo que aprenderemos en el curso.
En trminos de programacin, la misin del programador ser determinar qu propiedades y
operaciones interesa utilizar sobre un objeto.
Por ejemplo, sobre el objeto coche pudiera ser que no necesitemos bajar la ventanilla en un viaje,
por lo que no ser necesario que apliquemos dicha funcionalidad sobre el objeto cuando lo
utilicemos. Dependiendo de la accin para la que hemos pensado utilizar el objeto, utilizaremos
unas funciones o propiedades u otras. Aunque el objeto tenga mil acciones, nosotros pensaremos
cuales son las que nos convienen en cada momento y cuales no.
En terminologa de programacin orientada a objetos (P.O.O), las caractersticas del objeto se les
denomina propiedades y a las acciones mtodos. Cada uno de estos mtodos es un procedimiento
o una funcin perteneciente a un objeto.
Un objeto est formado por una serie de caractersticas o datos (propiedades) y una serie de
operaciones (mtodos). No puede utilizarse nicamente en funcin de los datos o de las operaciones
sino en su conjunto.
www.learning.es
Clases, Mensajes y Mtodos
En la programacin orientada a objetos (POO) tenemos que diferenciar entre dos conceptos
estrechamente relacionados: la clase y el objeto.
Una clase define la forma y comportamiento de un objeto. Una clase es una plantilla para un objeto.
Define la estructura de un objeto y su interfaz funcional, en forma de mtodos y propiedades.
Cuando se ejecuta un programa en Java, el sistema utiliza definiciones de clase para crear instancias
de las clases, que son los objetos reales. Los trminos instancia y objeto se utilizan de manera
indistinta.
public class Coche
{
DECLARACION DE METODOS Y PROPIEDADES
}
De este modo se definira una clase de nombre Coche cuyas propiedades y mtodos son definidos en
su interior. Las caractersticas y acciones de una clase son las propiedades y mtodos declarados en
su interior y de los que van a disponer todos los objetos o instancias de la misma.
Las propiedades o miembros del objeto coche, definiran todos los datos que podemos recuperar o
utilizar en un objeto. Son variables definidas dentro del objeto y que nos permiten luego utilizar
dichas variables en nuestro programa.
public class Coche
{
public int velocidad;
public int numeropuertas;
}
Los mtodos son las acciones que un objeto nos permitira realizar sobre l. Existen dos tipos de
mtodos que posteriormente aprenderemos en profundidad, mtodos que devuelven valor y
mtodos de accin.
Los mtodos de accin son mtodos que no devuelven ningn tipo de informacin, son un conjunto
de acciones, y se definen con la palabra clave void.
Los mtodos que devuelven valor (tambin llamados funciones), son mtodos que realizan una serie
de acciones y que devuelven un valor cmo resultado de dichas acciones.
Un ejemplo de ello sera:
public class Coche
{
public void arrancarCoche()
{
ARRANCAR EL COCHE Y NO DEVUELVE NADA
}
public int acelerarCoche()
{
DEVOLVER VELOCIDAD ACTUAL
}
}
Cuando utilizamos el mtodo acelerarCoche() es conveniente saber la velocidad a la que hemos
acelerado, por lo que devolveramos informacin sobre el objeto.
El mtodo arrancarCoche() no devuelve ningn valor porque es una accin de la que no
necesitamos saber ningn tipo de informacin.
www.learning.es
Un objeto es una variable que utiliza las caractersticas y acciones de un objeto. Dependiendo de la
clase de la variable, tendr unas caractersticas u otras. A estas variables se las conoce como
referencias a objeto.
Si quisiramos utilizar un objeto de la clase Coche, primero habra que crearla, o mejor dicho,
instanciar un objeto de la clase PrimeraClaseJava. Para sta creacin de un objeto se utiliza el
constructor de una clase.
Las clases pueden implementar un mtodo especial llamado constructor. Un constructor es un
mtodo que inicia un objeto inmediatamente despus de su creacin. De esta forma nos evitamos el
tener que iniciar las variables explcitamente para su iniciacin.
El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber
ningn otro mtodo que comparta su nombre con el de su clase. Una vez definido, se llamar
automticamente al constructor al crear o instanciar un objeto de esa clase (al utilizar el operador
new).
El constructor no devuelve nada, es una accin. Su misin es iniciar o construir todo estado interno
de un objeto (sus propiedades), haciendo que el objeto sea utilizable inmediatamente; reservando
memoria para sus propiedades, iniciando sus valores, etc.
Ejemplo:
public class Coche
{
public Coche()
{
velocidad = 0;
numeropuertas = 5;
}
{
velocidad = 0;
}
{
velocidad = velocidad + 10;
}
}
Lo que acabamos de crear es una clase para la que todos sus objetos creados tendrn 5 puertas.
El operador new crea una instancia de una clase (un objeto) y devuelve una referencia a ese objeto.
Por ejemplo:
Coche objetocoche1 = new Coche();
De sta forma, el objeto es nuestra variable llamada objetocoche1 y sabemos que tiene 5 puertas
porque hemos construido la clase Coche de esa forma.
Si utilizsemos el objetocoche1 para averiguar el nmero de puertas, siempre nos devolvera el
nmero 5.
mostrar objetocoche1.numeropuertas dicha instruccin siempre mostrara 5
Tambin podemos cambiar las caractersticas de nuestro objeto de la clase Coche y establecer un
nmero de puertas diferente:
objetocoche1.numeropuertas = 3;
mostrar objetocoche1.numeropuertas dicha instruccin ahora mostrara 3
www.learning.es
Podemos crearnos otros objetos de la clase utilizando otras instancias de objeto, de esa forma, se
crean objetos con las mismas caractersticas, pero diferentes entre s.
objetocoche1.numeropuertas = 3;
mostrar objetocoche1.numeropuertas dicha instruccin ahora mostrara 3
mostrar objetocoche2.numeropuertas dicha instruccin siempre mostrara 5
Como podemos comprobar, los dos objetos pertenecen a la misma clase y tienen las mismas
propiedades y mtodos, pero son diferentes entre s. Aunque no hubisemos cambiado el atributo
numeropuertas, seguiran siendo objetos diferentes, con las mismas caractersticas y mtodos.
Llevado al concepto de la vida real, sera como sacar dos coches iguales de la fbrica, tienen los
mismos atributos, color, cilindrada, modelo, pero cada uno es diferente y cada uno se utilizar de
una forma diferente.
Ver Video: Tecnologa Java , en la Unidad 1, en el Mdulo 1,

en la plataforma elearning
Actividades
Recuerde que para un seguimiento ptimo de la unidad es imprescindible realizar
las actividades que encontrar en la unidad correspondiente de la plataforma
eLearning.
www.learning.es
Unidad 2. Analizando un problema y
diseando una solucin
Introduccin
Dentro de cualquier lgica en un programa podemos encontrarnos con diferentes formas de plantear
una solucin.
Con la tecnologa Java, existen una serie de caractersticas que nos pueden ayudar a simplificar el
problema. La programacin orientada a objetos permite simplificar la estructura de elementos en
una aplicacin, implementando los diferentes tipos de soluciones y llegando a un nivel mucho ms
ptimo en el momento de construir el anlisis que nos llevar a completar la aplicacin.
Objetivos
Conocer los objetivos de las aplicaciones Java.
Introducir al usuario en la programacin orientada a objetos, mostrando sus caractersticas y
cmo pueden ayudarnos a solucionar un problema lgico dentro del lenguaje Java.
Analizar un problema usando anlisis orientado a

objetos
Java es un lenguaje considerado Orientado a Objetos (P.O.O). Todo lenguaje orientado a objetos
tendr las siguientes caractersticas:
HERENCIA
ENCAPSULACION
POLIMORFISMO
ABSTRACCION
Antes de empezar a estudiar en detalle el lenguaje Java, es imprescindible conocer los conceptos y
caractersticas particulares de la programacin orientada a objetos (POO). ste punto es importante
porque define cualquier lenguaje que utiliza POO.
La programacin orientada a objetos es una evolucin lgica de la programacin estructurada, en la
que el concepto de variables locales a un procedimiento o funcin, que no son accesibles a otros
procedimientos y funciones, se hace extensible a los propios subprogramas que acceden a estas
variables.
Pero la programacin orientada a objetos va mucho ms all. En realidad, cambia la concepcin de
la metodologa de diseo de los programas. En la programacin orientada a objetos, se definen
objetos que conforman una aplicacin. Estos objetos estn formados por una serie de caractersticas
y operaciones que se pueden realizar sobre los mismos. Estos objetos no estn aislados en la
aplicacin, sino que se comunican entre ellos.
Herencia
Es una de las principales ventajas de la POO. Esta caracterstica permite definir clases descendentes
a partir de otras, de forma que la nueva clase (la clase descendente) hereda de la clase antecesora
todas sus propiedades y mtodos.
La nueva clase puede definir nuevas propiedades y mtodos, adems puede redefinir propiedades y
mtodos ya existentes. Es la forma natural de definir objetos en la vida real.
Si nos posicionamos en el ejemplo de la clase Coche, podremos visualizar las ventajas de utilizar
herencia. En la vida real, todo coche tiene las mismas caractersticas: ruedas, puertas, asientos,
www.learning.es
velocidad, marchas, cilindradas. Tambin todo coche tiene las mismas acciones: arrancar, frenar,
acelerar, girar, cambiar marchas, etc.
Hasta ah podemos definir cualquier vehculo que podamos pensar. Tenemos un coche base o
inicial, pero existen multiples tipos de coche, todo terrenos, utilitarios, deportivos, formula 1, etc.
Para crearnos un 4X4, debemos utilizar las mismas caractersticas de un coche y cambiarlo o
implementarlo para adaptarlo al nuevo tipo de vehculo. Los ingenieros que vayan a disear el 4X4
no vuelven a investigar la creacin de un coche desde cero, pensando en cmo arrancar o frenar,
sino que utilizan la tecnologa ya creada del coche para mejorarlo, utilizando todo lo que tiene un
coche y aadiendo caractersticas a su nuevo objeto. No comienzan desde cero, sino que ya tienen
una base desde la que trabajar. Ese es el concepto de Herencia en POO.
Vemos el concepto desde el ejemplo anterior de la clase Coche, incluyendo una propiedad llamada
velocidadmaxima:
public class Coche
{
public Coche()
{
velocidad = 0;
numeropuertas = 5;
velocidadmaxima = 180;
}
public int velocidadmaxima;
{
velocidad = 0;
}
{
velocidad = velocidad + 10;
}
}
En el constructor de la clase hemos definido que la nueva propiedad velocidadmaxima ser de
180, de forma que cualquier Coche podr acelerar, arrancar, mostrar la velocidad o un nmero de
puertas.
Si deseamos crearnos un deportivo, podemos afirmar correctamente que un deportivo es un Coche,
por lo que no tenemos que volver a definir las caractersticas del coche ni tenemos que volver a
escribir sus mtodos. Bastara con comenzar desde nuestra clase Coche y mejorarlo:
public class Deportivo: Coche
{
public int numeromarchas;
public Deportivo ()
{
numeromarchas = 7;
velocidadmaxima = 270;
}
}
Los dos puntos a continuacin del nombre de la clase indican que la clase Deportivo hereda de la
clase Coche, lo que quiere decir que un deportivo tendr las mismas caractersticas que un coche,
pero con una velocidad mxima superior. Adems nos hemos creado una propiedad que indica que
un Deportivo contiene siete marchas.
Con todo ste concepto lo que podemos afirmar que un Deportivo es un Coche, pero mejorado.
www.learning.es
Encapsulacin
La encapsulacin consiste en la propiedad que tienen los objetos de ocultar sus propiedades o los
mtodos, a otras partes del programa u otros objetos. La forma natural de construir una clase es la
de definir una serie de caractersticas que, en general, no son accesibles fuera del mismo objeto,
sino que nicamente pueden modificarse a travs de los mtodos que son definidos como accesibles
desde el exterior de esa clase.
En realidad, el concepto de encapsulacin se puede definir coloquialmente como no permitir
visualizar caractersticas del objeto que no deseo que sean utilizadas.
A modo de mundo real, podemos pensar en un coche. Cualquier coche nos permite utilizar una
serie de caractersticas para su funcionamiento, tales como arrancar o frenar. Pero si queremos
realizar algunas acciones sobre un coche, tenemos que ponernos en contacto con el fabricante o el
taller mecnico constructor del coche, ya que no son accesibles para utilizar el coche. Por
ejemplo, el motor de un coche no es accesible a nosotros como conductores, si queremos realizar
acciones como cambiar la correa de distribucin, dicha caracterstica est dentro del coche, pero no
ha sido expuesta para que nosotros la manejemos, sino que forma parte del coche pero est
oculta a nuestros ojos.
Para poder encapsular propiedades o mtodos dentro del lenguaje Java se utilizan las palabras clave
public o prvate entre otras, pero que nos servirn para aprender el concepto en estos momentos.
public: indica que una propiedad o mtodo ser accesible y ser visualizada al acceder al
objeto.
private: indica que una propiedad o mtodo slo ser visible desde el propio objeto,
impidiendo que sea utilizada por otros objetos.
Podemos poner como ejemplo la misma clase Coche anteriormente utilizada en nuestra explicacin.
public class Coche
{
private int Motor;
{
}
private void cambiarCorreaDistribucion()
{
}
}
Segn acabamos de escribir en nuestra clase, cualquier objeto que instanciemos de la clase Coche
podr utilizar el mtodo arrancarCoche() y la propiedad velocidad, pero no podr utilizar el mtodo
cambiarCorreaDistribucion() ni la propiedad Motor.
Esto se debe a que son propiedades o mtodos que no deseamos que alguien que utiliza nuestro
objeto sea capaz de modificar o utilizar.
De forma que si ahora intentamos utilizar las acciones, nos aparecera una excepcin al compilar la
clase:
mostrar objetocoche1.velocidad _
nos permitira visualizar la velocidad del objeto)
objetocoche1.arrancarCoche(); Nos permite acceder al mtodo del objeto)
mostrar objetocoche1.Motor _
Excepcin porque no es accesible esa propiedad, est encapsulada en la clase Coche.)
objetocoche1.cambiarCorreaDistribucion(); _
Excepcin porque no es accesible el mtodo,_
www.learning.es
est encapsulado en la clase Coche y slo podemos utilizarlo _
dentro del cdigo de dicha clase.)
Polimorfismo
El polimorfismo permite que un mismo mensaje enviado a objetos de clases distintas haga que estos
se comporten tambin de forma distinta, objetos distintos pueden tener mtodos con el mismo
nombre o incluso un mismo objeto puede tener nombres de mtodos idnticos pero con distintos
parmetros o acciones.
Si lo llevamos a la vida real, podemos comprobar fcilmente el concepto. Dos objetos de clases
diferentes tienen el mismo nombre de mtodo, pero al realizar la misma accin sobre ellos, se
comportan de forma diferente dependiendo del objeto.
Por ejemplo, una ventana tiene la accin abrir y un fichero de un sistema operativo tambin tiene
la funcin abrir, pero todos sabemos perfectamente que no es lo mismo abrir un fichero que abrir
una ventana, es la misma accin aplicada a objetos de clases diferentes y que cada uno se comporta
o se utiliza de una forma diferente.
Tambin existe el polimorfismo aplicado a un mismo objeto, el concepto es sencillo, misma accin
sobre un objeto, pero que dependiendo de las acciones que realicemos sobre el mtodo, se
comporta de una forma o de otra totalmente distinta o similar. Por ejemplo, podemos pensar en el
pedal del freno de un coche, no es lo mismo frenar a tope, que frenar poco a poco. Dependiendo
como accionemos el pedal del freno, el coche se comporta de una forma diferente, siendo la misma
accin sobre el objeto. No se ponen varios pedales para el freno (uno para cada tipo de frenada),
sino que se utiliza la misma accin de formas diferentes. Eso es polimorfismo, la sobrecarga de un
mtodo con el mismo nombre, pero con diferentes paramtros.
Podemos verlo claramente en nuestro ejemplo:
public class Coche
{
public void frenarCoche()
{
velocidad = velocidad 10;
}
public void frenarCoche(int presion)
{ velocidad = velocidad presion;
}
}
En nuestro ejemplo hemos sobrecargado del mtodo frenarCoche(). Tenemos dos mtodos con el
mismo nombre, pero la accin ser diferente dependiendo del valor que le enviemos al mtodo.
objetocoche1.frenarCoche() _
sta accin reducir la velocidad del vehculo en 10
objetocoche1.frenarCoche(30) es la misma accin de frenar, pero en ste caso,_
frenar la velocidad del coche en 30.
Abstraccin
La abstraccin consiste en aislar un elemento de su contexto o del resto de los elementos que lo
acompaan hasta encontrar similitudes con otros mismos objetos de su entorno.
Con todo objeto podemos abstraernos hasta encontrar similitudes con otro objeto, para definirlo o
localizarlo.
Por ejemplo, un barco y un coche no tienen ningn elemento en comn al mismo nivel, el barco es
un objeto creado para ser utilizar en agua y navegar, mientras que un coche est creado para ser
www.learning.es
utilizado en tierra y conducir. Pero si nos abstraemos, podemos ser capaces de encontrar
similitudes entre los dos objetos, no al mismo nivel, pero si en otros niveles diferentes.
Un barco y un coche son diferentes entre s, pero si subimos niveles de abstraccin encontraremos
coincidencias que nos harn ser capaces de ponerlos en el mismo grupo, como por ejemplo medios
de transporte o locomocin.
Tambin podemos definir la abastraccin entre niveles parecidos, por ejemplo un formula 1 es una
especie de coche, pero tiene caractersticas diferentes a un coche, pero al ver un formula 1 podemos
afirmar que es un tipo de coche, por las caractersticas en comn que contiene a partir de un
elemento base: el coche.
Diseo de clases para crear objetos

Dentro de cualquier concepto de la realidad expuesto anteriormente, podemos diferenciar los
objetos por familias a las que pertenecen. Dichas familias son conjuntos a los que pertenece cada
objeto y que los diferencia de otras familias. Por ejemplo, los objetos son diferentes pero se pueden
agrupar en un conjunto: los coches, barcos, bicicletas, motos o aviones son objetos diferenciados
entre s, pero que podemos incluir dentro de la familia de los medios de transporte. Lo mismo
ocurrira con los mp3, las televisiones, los dvd o los aparatos de tdt, podemos incluirlos dentro de la
familia de aparatos electrnicos del hogar, por ejemplo.
Cuando estamos diseando una aplicacin, debemos decidir los objetos que vamos a utilizar en
dicha aplicacin segn nuestra lgica. A partir de ese momento, cada objeto que vayamos a utilizar
est en una familia que debemos utilizar para poder trabajar con el objeto. Es lo mismo que en un
supermercado, si deseamos comprar fruta iremos a la seccin de frutera y si deseamos comprar
leche iremos a la seccin de alimentacin.
A estas familias dnde se encuentran las clases para utilizar objetos se les llama paquetes. Cada
paquete contiene un conjunto de clases que estn relacionados con el tipo de paquete que vayamos
a utilizar. Por ejemplo, si queremos trabajar con ficheros, debemos incluir en nuestra aplicacin el
paquete java.io, que es el paquete que contiene todas las clases para trabajar con ficheros.
La ventaja de utilizar los paquetes depende del rendimiento y jerarqua de clases. Imaginad que
vais al supermercado y encontrais todos los productos revueltos y no todo definido en cada seccin.
Habra que estar buscando dentro de todo el conjunto cada uno de los objetos que deseemos
comprar. Por el contrario, si todo est ordenado por secciones, podremos ir perfectamente a las
secciones que necesitamos sin necesidad de utilizar o recorrer las otras.
Sucede lo mismo en la programacin orientada a objetos de Java, cada clase est definida dentro de
un paquete, y si queremos utilizar una funcionalidad especfica (ficheros por ejemplo) bastara con ir
y utilizar esa seccin, sin necesidad de utilizar otras secciones, llamadas paquetes.
En el lenguaje de programacin Java existen multitud de clases ya definidas y utilizables
establecidas dentro de paquetes.
Las bibliotecas estndar (llamadas paquetes) ms utilizadas en Java son las siguientes:
java.lang: tipos de dato primitivos, nmeros, strings, objetos, compilador, runtime,
seguridad y threads (es el nico paquete que se incluye automticamente en todo programa
Java al iniciar cualquier aplicacin)
java.io: clases que manejan entradas y salidas, utilizan lectura y escritura de ficheros.
java.util: Estructuras genricas, utilizacin de fechas, horas, determinados strings o
colecciones.
java.net: Clases para soportar redes: URL, TCP, UDP, IP, etc.
java.awt: Clases para manejar la interface grfica de Java en aplicaciones de escritorio,
tales como ventanas, mensajes de alerta y objetos que tienen que ver con todo tipo de
aplicaciones de escritorio.
java.awt.image: Clases para el manejo de imgenes.
java.swing: Es la evolucin de clases grficas awt, podemos definirlo como la siguiente
versin grfica de Java. Permite crear objetos para aplicaciones de escritorio con un diseo y
caractersticas mejorados.
www.learning.es
java.applet: Clases para la creacin de applets y recursos para reproduccin de audio.
Ver Video: Anlisis de Aplicaciones , en la Unidad 2, en el

Mdulo 1, en la plataforma elearning
Actividades
eLearning.
www.learning.es
Unidad 3. Desarrollando y probando
programas con tecnologa JAVA
Introduccin
Para poder realizar cualquier desarrollo sobre Java es necesario conocer todos los elementos que
conforman la configuracin.
Para probar dichos ficheros de desarrollo, debemos configurar todo el kit JDK de Sun Microsystems y
conocer todos los detalles para probar aplicaciones de Java.
Se puede utilizar cualquier editor de texto para completar el desarrollo de Sun (Bloc de notas),
tambin se pueden utilizar editores especficos de Java que permiten una cierta ayuda en el
momento de desarrollar.
Objetivo
Aprender a instalar el software necesario para poder utilizar los programas de Java en
desarrollo.
Conocer los diferentes ficheros de accin que Java nos ofrece, as cmo la configuracin del
entorno de desarrollo de trabajo.
Instalacin y configuracin del kit de desarrollo de Sun

(JDK)
Para poder desarrollar software con Java necesitamos una serie de herramientas que nos
proporciona Sun a travs de su JDK (Java Development Kit).
Existen otras empresas, como IBM y Microsoft, que tambin tienen entornos de programacin
para Java. Salvo el de Microsoft, todos son compatibles al 100% con las especificaciones que
estableci Sun para su lenguaje de programacin.
Instalacin del JDK de Sun.

Lo primero ser descargarnos la herramienta de desarrollo JDK (Java Development Kit) de la
siguiente direccin:
http://java.sun.com/
Tras la ejecucin del programa de instalacin, obtendremos en el directorio que hayamos
especificado para tal fin, la siguiente estructura de directorios:
A continuacin, describimos los directorios y ficheros ms importantes:
www.learning.es
Directorios
bin: En este directorio se encuentran todos los ficheros ejecutables del JDK. En su interior se
encuentran los ficheros ms importantes para el desarrollo de la tecnologa Java. Los ms
importantes son:
- javac.exe Es el compilador de Java, permite compilar los ficheros con extensin java y crear
clases para el desarrollo.
- java.exe Intrprete (JVM). Permite poder ejecutar los ficheros compilados (extensin class)
y ejecutarlos.
- javadoc.exe Generador de documentacin para las clases y libreras de Java.
- jdb.exe Depurador.
Los programas de ste directorio los usaremos conforme los vayamos necesitando.
demo: En este directorio hay una serie de ejemplos que Sun ha desarrollado con propsitos
didcticos. En concreto encontraremos ejemplos sobre:
- Applets.
- JFC --> Java Foundation Classes. En la plataforma Java 2 (ltima versin de Java), Sun.
docs: En este directorio est la documentacin del API de Java. No viene por defecto con el JDK y
hay que instalarlo por separado.
lib: En este directorio se encuentran las clases de Java proporcionadas por Sun, y que conforman el
API que utilizaremos en nuestros programas. las clases que nos interesan estn comprimidas en un
fichero que se llama:
tools.jar
jre: Java Run Environment. Entorno de Ejecucin de Java proporciona las herramientas bsicas para
la ejecucin de aplicaciones Java, sin incluir todas las herramientas que se proporcionan para su
desarrollo (compilador, depurador, ...).
b) Configuracin del sistema.
El JDK no necesita ninguna configuracin especfica, sin embargo, si queremos que nuestras
aplicaciones funcionen debemos configurar unas variables de entorno que dependern del
sistema operativo sobre el que estemos trabajando. Vamos a configurar las variables de entorno
para el sistema operativo Windows:
PATH: En esta variable debemos poner el camino hasta los ejecutable del JDK
El propsito de hacer esto es el poder ejecutar los ficheros ejecutables (javac, java) desde
cualquier directorio.
CLASSPATH: Debe aparecer el camino hasta las clases que importemos en nuestros programas. En
concreto debe aparecer el fichero tools.jar (toda la ruta al directorio).
El propsito es que el compilador (javac) encuentre las clases que importemos en nuestros
programas.
No olvidar introducir tambin el propio directorio (.) de lo contrario tendremos errores.
Vamos a mostrar como instalar y configurar las variables de entorno de Java para poder utilizar el
kit de desarrollo de Java.
Lo primero ser instalarnos el kit de desarrollo de Java:
www.learning.es
A continuacin, vamos a Mi PC y con el botn derecho, entramos en Propiedades.
Una vez dentro, entramos en Opciones Avanzadas y pulsamos sobre Variables de entorno:
Modificamos la variable de entorno PATH para poder ejecutar todos los comandos incluidos en el
directorio BIN de java. (Compilador, Intrprete)
Debemos incluir al final del todo la ruta dnde se ha instalado nuestra herramienta JDK y el
directorio bin. Debemos separar cada elemento con punto y coma:
;C:\Archivos de Programa\Java\jdk1.5.0_22\bin
www.learning.es
Ahora debemos creamos una nueva variable llamada CLASSPATH. sta variable llamar a tools.jar
ubicado en el directorio LIB. Este archivo es el comprimido que contiene todas las clases que utiliza
java. Incluimos un punto para poder utilizar llamadas a las clases independientemente de la
ubicacin de nuestro proyecto.
.;C:\Archivos de Programa\Java\jdk1.5.0_22\lib\tools.jar
Procesos para crear un programa en Java

Antes de explicar el proceso de creacin de un programa, conviene explicar que en Java vamos a
manejar tres tipos de aplicaciones:
- Aplicacin en modo texto: En este tipo de aplicaciones la interaccin con el usuario (entrada
de datos y presentacin de resultados) se realiza en modo texto (no existirn cajas de texto,
botones,...). El ratn no tendr uso en estas aplicaciones. Son las aplicaciones que realizaremos
en el primer bloque donde nuestro objetivo ser aprender los conceptos bsicos de Java.
Tambin es interesante cuando realizamos los prototipos de nuestros programas debido a que la
depuracin es ms sencilla.
- Aplicacin en modo grfico: En este tipo de aplicaciones la interaccin con el usuario se
realiza en modo grfico. Estas aplicaciones pueden ser de todo tipo y no hay que pensar slo en
Internet:
o Procesador de texto, bases de datos, entorno de programacin, tratamiento de grficos...
- Miniaplicaciones (applets): Pequeos programas que no pueden ejecutarse de forma
independiente sino que necesitan el soporte de un navegador. Estas programas estn pensados
para que sean invocados desde una pgina HTML, viajen a travs de la red y se ejecuten el la
mquina del cliente.
Proceso para crear una aplicacin Java

Crear el cdigo fuente: Para crear el cdigo fuente de Java podemos utilizar:
o Un editor de texto plano como el Bloc de Notas.
o El editor de algn entorno de desarrollo.
o El fichero con el cdigo fuente se guardar con extensin ".java"
Compilar el cdigo fuente: La compilacin del cdigo fuente se realizar a travs del
compilador proporcionado por Sun en su JDK (Java Development Kit). El compilador se llama
javac.exe y la sintaxis bsica es:
C:\javac.exe FicheroFuente.java
www.learning.es
NOTA: El fichero llamado FicheroFuente.java debe llamarse igual que la clase y es imprescindible
poner la extensin .java en el momento de escribir en la lnea de comandos. Veremos el ejemplo
prctico ms adelante para entender el concepto de clase.
La compilacin se realiza desde una ventana de MS-DOS o desde el propio entorno que estemos
usando, el cual nos ocultar la ejecucin de javac. El proceso de compilacin requiere que el sistema
tenga configurada adecuadamente las variables de entorno para el correcto funcionamiento del
comando anterior. Como resultado de la compilacin obtenemos el fichero de bytecodes que tiene
extensin ".class".
Ejecutar la aplicacin: Para ejecutar el fichero de bytecodes es necesario pasarlo por el
intrprete adecuado. El intrprete depende del tipo de programa java que hayamos
implementado:
o Miniaplicaciones (applets) Es el navegador el intrprete y nosotros tenemos que

preocuparnos tan slo de incluir el applet en una pgina HTML.
o Aplicacin (texto o grfica) Utilizaremos el intrprete proporcionado por el JDK de Sun

que se llama java.exe. Su sintaxis es:
C:\java.exe FicheroBytecodes.class
NOTA: Cuando llamamos al interprte java.exe y al fichero .class no escribiremos el nombre de la
extensin class, solamente debemos escribir el nombre del fichero compilado, pero manteniendo la
diferencia entre maysculas y minsculas.
Utilizando la ventana MS-DOS para compilar aplicaciones Java

JAVAC es el compilador, debemos indicarle toda la ruta y el nombre del fichero con extensin
.java que deseamos compilar. Diferenciacin entre maysculas y minsculas.
JAVA es el intrprete de archivos con extensin class, debemos decirle toda la ruta y el nombre del
archivo .class pero sin la extensin. Diferenciacin de maysculas y minsculas.
NOTA: Para poder probar ste primer ejemplo debemos tener configuradas las variables de entorno
que nos llevan al JDK de java y nos permiten compilar los ficheros.
Todos los ficheros de Java son clases. Dentro de dichas clases escribiremos el cdigo para crear
nuestra solucin a un problema que hayamos planteado.
Para comenzar, utilizaremos un mtodo llamado main que es el arranque de las clases no grficas
de Java. Simplemente esto quiere decir que toda lgica tiene un entorno y un lugar para probar
dicho entorno, por ejemplo, si queremos hacer una pgina Web, el entorno para dicha clase web
sera un navegador de Internet. Pues en nuestro caso, nuestro entorno ser la ventana de Ms-Dos y
para probar las aplicaciones necesitamos crearnos un mtodo main para arrancar dicho entorno y
generar nuestr lgica en la clase.
Como podemos comprobar, vamos a hacer un ejemplo sencillo para visualizar nuestra primera
aplicacin de Java y comprobar que tenemo todo listo para continuar.
Esqueleto de una clase

CDIGO JAVA
public class ClaseJava
{
public static void main(String args[])
{
System.out.println("MI PRIMERA APLICACION");
}
}
www.learning.es
Vamos a abrir un bloc de notas y escribiremos el cdigo de nuestra primera clase.
Debemos recordar que Java es un lenguaje de programacin Case Sensitive, es decir, diferencia
entre maysculas y minsculas, por lo que escribiremos literalmente el contenido de nuestro primer
ejemplo en el bloc de notas.
A continuacin vamos a guardar el fichero de nuestro bloc de notas con la extensin .java en la
ubicacin que vayamos a probar nuestros ejemplos. Es recomendable crearnos una carpeta para
poder ubicar todas nuestras prcticas. Podemos utilizar cualquier otro editor de caracteres, pero es
imprescindible que slo almacene texto, no nos valdran editores de texto del estilo Word o
WordPad, ya que almacenan ms informacin adems del texto escrito, un ejemplo de estos
editores puede ser UltraEdit o algn bloc de notas free que existen por internet y que tienen ms
caractersticas que el bloc de notas tradiciones de Windows.
El nombre de nuestro fichero java debe tener el mismo nombre que nuestra clase, incluida la
diferenciacin de maysculas y minsculas, en nuestro ejemplo debemos llamarlo ClaseJava.java.
Voy a crear una carpeta en la unidad C:\ llamada PracticasJava y almacenar las prcticas en dicha
ubicacin. En el bloc de notas seleccionaremos como Tipo: Todos los archivos y escribiremos la
extensin .java para nuestra primera clase.
NOTA: Podremos guardar las prcticas en cualquier ubicacin, pero es conveniente guardarlas en
alguna ruta fcilmente accesible ya que posteriormente tendremos que escribir dicha ruta en
nuestra ventana de comandos de Ms-Dos.
A continuacin abriremos una nueva ventana de comandos de Ms-dos. Para ello nos iremos al Inicio
de Windows y pulsaremos sobre Ejecutar y escribiremos el comando cmd.exe. Esto depende del
sistema operativo en el que estemos trabajando. Se nos abrir una nueva ventana de comandos.
Ahora debemos tener unas nociones bsicas de Ms-Dos para trabaja y poder compilar nuestras
clases de Java.
Sobre la ventana de comandos escribimos:
cd C:\PracticasJava
Con el comando cd de Ms-Dos podremos entrar en cualquier directorio, segn nuestra prctica yo
he almacenado el fichero java de nuestra clase en dicha ubicacin. Debemos posicionarnos en
dicha ubicacin. Tambin podemos escribir cd.. o cd\ para ir a la raz dnde hayamos
almacenado los ficheros. Si queremos cambiar de unidad, bastara con escribir la letra de la unidad
seguida de dos puntos: D:. Con el comando dir veremos todos los ficheros que existen dentro
de un directorio, aunque podemos complementar nuestras prcticas con las ventanas propias de
Windows.
Ya estamos posicionados sobre el lugar dnde tenemos almacenada la clase .java, ahora debemos
utilizar el compilador javac.exe para poder compilar la clase. Escribiremos la llamada al compilador
desde la ventana de comandos.
www.learning.es
C:\PracticasJava>javac.exe ClaseJava.java
Si no existen errores en la clase, no nos dar ningn mensaje y simplemente volver a aparecer el
smbolo de la unidad dnde estemos ubicados.
Ahora veremos que nos ha creado un fichero con extensin .class, que es el resultado de un
fichero compilado con extensin .java, podemos verlo fcilmente si nos posicionamos en Windows
dentro de nuestra carpeta de prcticas.
Tambin podemos escribir el comando dir desde la ventana de comandos de Ms-Dos.
Es el momento de utilizar el intrprete de ficheros .class, nuestro intrprete es el comando

java.exe. Para poder ejecutarlo debemos escribir desde la ruta dnde se encuentre la clase
compilada la siguiente instruccin:
java.exe ClaseJava
Ahora ya podremos visualizar la lgica que tengamos dentro de la clase compilada:
www.learning.es
Ver Video: Configuracin entorno Java, en la Unidad 3, en el
Actividades
eLearning.
www.learning.es
Unidad 4. Declarando, Inicializando y usando
variables
Introduccin
Dentro de cualquier lgica de negocio necesitamos almacenar informacin para poder realizar una
aplicacin. Dicha informacin se almacena en variables, que son espacios en la memoria y que
permiten asignar y recuperar valores.
Para trabajar con variables existen mltiples tipos de datos, dependiendo de lo que necesitemos
realizar, pudiera ser que necesitemos realizar operaciones, por lo que almacenaramos nmeros, o
pudiera ser que nuestro dato sea un nombre, por lo que almacenaramos textos. Existen varios
tipos de datos primitivos que aprenderemos a lo largo del mdulo.
Una variable tambin puede hacer referencia a un objeto, pudiendo acceder a todos los miembros
que hayamos declarado en dicho objeto.
Objetivo
Conocer los tipos de datos primitivos de Java y su utilizacin en los programas.
Aprender la sintaxis de Java para la declaracin y uso de variables en el cdigo.
Elementos bsicos del lenguaje y sintaxis de Java
Comentarios en el programa
Java tiene como todos los lenguajes de programacin sus propias caractersticas para describir
cdigo, es decir sus propios comentarios y herramientas del lenguaje.
Un elemento importante en el momento de crear una clase es comentar las acciones que estamos
realizando. Dichos comentarios nos van a servir para dos propsitos, comprender las acciones que
estamos realizando y documentar dichas acciones.
Imaginemos que no trabajamos en un proyecto en un ao y tenemos que retomarlo para
implementar algunas caractersticas. Si no hemos puesto comentarios de las acciones que estamos
realizando, la tarea de volver a revisar las acciones o de saber para que sirve cada accin puede
llevarnos mucho tiempo.
Otra de las ventajas de incluir comentarios se debe a que podemos encontrarnos con un cdigo que
otro programador ha realizado y no sabemos cmo ha hecho la funcionalidad de las acciones ni en
que orden. Si el programador ha documentado su cdigo, nos ser mucho ms sencillo adaptarnos
a un cdigo que no es nuestro para poder implementarlo.
Para poner comentarios en nuestro cdigo fuente java tenemos tres opciones:
Una lnea de comentario que empiece por //
// Esto es un comentario
System.out.println ("Hola mundo");
Varias lneas encerradas entre /* y */
/* Todo esto
tambin es un
comentario */
System.out.println ("Hola mundo");
www.learning.es
Por ltimo, podemos hacer varias lneas de comentario entre /** y */
/** Todo esto
es un
comentario de documentacin */
public void miMedodo (int parametro) {
CODIGO DEL MTODO
}
La diferencia entre el comentario que empieza por /** y el que empieza por /* es que el primero
sale en la documentacin generada por javadoc y en la mayora de herramientas que hacen
documentacin a partir del cdigo. El comentario que empieza por /* no sale en la documentacin y
es slo para el programador.
Hay unos detalles, sin embargo, que hay que tener en cuenta para comentarios que van a salir en la
documentacin. Conviene poner uno de estos comentarios delante de cada clase, cada mtodo y
cada atributo, de esta forma, en la documentacin aparecern convenientemente documentados las
clases, mtodos y atributos. El siguiente cdigo nos sirve como ejemplo:
package Mates;
/**
Clase con funciones matemticas.
Realiza operaciones trigonomtricas, ecuaciones diferenciales
e integrales */
public class ClaseMatematicas
{
/** Constante PI.
Valor de PI=3.141618 */
public static final double PI = 3.1416;
/** Devuelve el seno del ngulo que se le pasa como parmetro.
El ngulo debe estar en radianes y es un double. */
public double senoAngulo(double angulo)
{
return 19.21;
}
}
Una vez que tenemos la clase escrita, podemos utilizar la herramienta javadoc para crear la
documentacin con el comando:
javadoc.exe ClaseMatematicas.java
Veremos que nos ha creado en el directorio dnde hemos creado la clase, una serie de pginas html
y css que copia el formato de documentacin de la API de Java.
www.learning.es
Si pulsamos sobre el fichero ClaseMatematicas.html, veremos la documentacin ya creada:
Es importante tener en cuenta que dentro de cada comentario, la primera frase -hasta el primer
punto- saldr como resumen de la clase, mtodo o atributo. Conviene, por tanto, que esa frase
tenga sentido por s sola.
Los comentarios de documentacin, colocados inmediatamente antes de una declaracin de variable
o funcin, indican que ese comentario ha de ser colocado en la documentacin que se genera
automticamente cuando se usa la herramienta javadoc.exe.
Identificadores
Los identificadores nombran variables, funciones, clases y objetos, cualquier cosa que el
programador necesite identificar.
En la siguiente tabla se muestran las caractersticas de los identificadores:
Primer caracter Una letra, subrayado ( _ ) o el smbolo de dlar ($).
Siguientes caracteres Pueden ser letras, nmeros o smbolos.
Longitud No hay una longitud mxima establecida.
Maysculas / Minsculas Se distinguen las maysculas de las minsculas.
No se pueden usar Palabras clave del lenguaje Java
Palabras reservadas
En la siguiente tabla tenemos las palabras claves proporcionadas por la documentacin de SUN.
abstract double Int static
Boolean else Interface super
Break extends Long switch
Byte final Native synchronized
Case finally New this
Catch float Null throw
Char for Package throws
Class goto * Private transient
Const * if Protected try
Continue implements Public void
Default import Return volatile
Do instanceof Short while
Separadores
www.learning.es
Normalmente definen la forma y funcin del cdigo.
En la siguiente tabla se especifican sus funciones.
Separador Funcin
Parntesis - ( ) Para contener listas de parmetros en la definicin y llamada a
mtodos.
Definir precedencia en expresiones, contener expresiones para el
control de flujo y realizar conversiones de tipo.
Llaves - { } Contener valores de matrices inicializadas automticamente.
Definir bloques de cdigo para clases, mtodos y mbitos locales.
Corchetes - [ ] Para declarar matrices y referenciar elementos de la matriz.
Punto y coma - ; Separar sentencias.
Coma - , Separa identificadores consecutivos en una declaracin de variables,
Para encadenar sentencias dentro de un bucle
Punto - . Para separar nombres de paquetes, subpaquetes y clases.
Separar una variable o mtodo de una variable de referencia.
Nombres de las clases, variables y mtodos

Existe un convenio, no obligatorio, a la hora de nombrar las clases, las variables y mtodos:
Clases Poner en mayscula la primera letra de cada palabra con

significado que forme el nombre de la clase.
Mtodos Mismo regla que en clases pero poniendo con minscula la primera
letra.
Constantes En maysculas.
Variables En minsculas.
Tipos de datos primitivos y variables

Java utiliza cinco tipos de elementos para abarcar todos los posibles datos que podemos
necesitar en el desarrollo de una aplicacin.
Enteros, reales en coma flotante, booleanos, caracteres y cadenas.
La siguiente tabla lista los tipos de datos primitivos soportados por Java, sus tamaos y su
formato.
Tipo Tamao/Formato Descripcin

Byte 8-bit en complemento a 2 Entero con un byte de longitud.
Short 16-bit en complemento a 2 Entero corto (de 16 bits)
Int 32-bit en complemento a 2 Entero.
Long 64-bit en complemento a 2 Entero largo.
Float 32-bit IEEE 754 Coma flotante de simple precisin.
Double 64-bit IEEE 754 Coma flotante de doble precisin.
Char Caracter Unicode de 16 bits Un nico caracter.
Boolean true o false Un valor booleano (true or false).
Nombres de las variables
Al definir una variable se debe indicar su tipo y se deben respetar las siguientes normas con
respecto al nombre que elijamos:
www.learning.es
Norma Comentario
Debe ser un identificador Java legal que Unicode es un sistema de codificacin de
contenga una serie de caracteres Unicode. caracteres diseado para soportar texto escrito
en varias lenguas. Permite la codificacin de
hasta 65536 caracteres de los cuales 34168
estn siendo usados actualmente
No debe ser una palabra clave ni reservada. Ver la tabla presentada ms arriba.
Tampoco un valor booleano (true y false)
No puede tener el mismo nombre que otra Lo detectar el compilador. Ver el siguiente
variable que se encuentre en el mismo punto.
mbito.
Vamos a ver un ejemplo prctico sobre declaracin e inicializacin de variables.

Nos vamos a declarar una serie de variables e imprimiremos el resultado en una ventana de Ms-Dos.
public class EjemploVariables
{
{
byte b=-128;
short s=32767;
int i=-2147483648;
long l=9223372036854775807L;
System.out.println("El valor de b es: " + b);
System.out.println("El valor de s es: " + s);
System.out.println("El valor de i es: " + i);
System.out.println("El valor de l es: " + l);
}
}
Podremos comprobar el resultado de asignar diferentes tipos de datos en variables:
Alcance de las variables

El alcance de una variable viene acotado por la zona entre llaves { } en la cual se ha definido la
variable. El siguiente dibujo lo representa:
www.learning.es
Dependiendo dnde voy a declarar una variable, la variable tendr una visibilidad u otra.
Vamos a ver un ejemplo en el que declararemos una variable en la clase y otra en el mtodo main:
public class ClaseAmbitoVariables
{
int i = 25;
{
int i=19;
System.out.println("El valor de i es " + i);
}
}
Podemos comprobar que las dos variables pueden coexistir a pesar de que su nombre sea el mismo
debido a que estn declaradas en diferentes secciones o mbitos de la clase.
Si declarsemos la misma variable dentro del mismo mtodo main producira una excepcin
indicndonos que la variable ya se ha declarado dentro del mismo mtodo.
public class ClaseAmbitoVariables

{
{
int i = 25;
int i=19;
System.out.println("El valor de i es " + i);
}
}
www.learning.es
Declarando variables
Al declarar una variable de un tipo e inicializarla con un valor, el compilador normalmente sabe de
qu tipo se trata. Sin embargo, hay ocasiones en la que el tipo es ambiguo y hay que guiar al
compilador proporcionndole informacin adicional. Estos casos se reflejan en la siguiente tabla:
Caso Ejemplo
Para inicializar una variable con un dato en char c= 0xffff;
hexadecimal se debe poner 0x... byte b= 0x7A;
Para inicializar una variable con un dato en octal int i= 0177;
se pone un 0 delante.
Se puede colocar una letra (mayscula o float f= 1F;
minscula) al final del valor para indicar su tipo. long l= 100L;
L para long, F para float y D para Double. double d= 1d;
La exponenciacin se indica con la letra e, float f= 1e-45f;
tomando como referente la base 10. Hay que verlo como 1.3 x 10-45
El compilador normalmente codifica estos
nmeros como double aunque se definan como
float.
No existe representacin para nmero binarios
Antes de usar una variable en Java, debemos declararla, especificando su tipo.

A continuacin se indica cmo se declaran las variables en Java:
tipodato nombre = valor;

Ahora, podemos ver cmo se declara una variable de tipo int, es decir, contiene un entero:
public class PrimeraClase
(
public static void main(String[] args)
{
int dias = 31;
System.out.println(Numero de dias: + dias);
}
}
Declaracin de variables de tipo entero

Java utiliza cuatro tipos de datos para almacenar enteros, cada uno con su propio nmero de
bytes alojados en memoria: byte (un byte), short (dos bytes), int (cuatro bytes) y long (ocho
bytes).
Utilizar un tipo de dato entero u otro depende de los valores de datos que deseamos almacenar, as
como de otras consideraciones, como cunta memoria hay disponible.
www.learning.es
Vamos a mostrar un ejemplo prctico en el que utilizamos todos los tipos de datos enteros y
posteriormente mostramos su valor por pantalla:
public class PruebaVariables
{
{
byte byte1;
short short1;
int int1;
long long1;
byte1 = 1;
short1 = 100;
int1 = 10000;
long1 = 100000000;
System.out.println("Valor de byte1 = " + byte1);
System.out.println("Valor de short1 = " + short1);
System.out.println ("Valor de int1 = " + int1) ;
System.out.println("Valor de long1 = " + long1);
}
}
Y el resultado de la aplicacin:
Declaracin de variables de coma flotante

Java incluye dos tipos de variables en coma flotante, cada uno con su propio nmero de bytes
para aljcar en memoria. Los dos tipos que tenemos son float (cuatro bytes) y double (ocho bytes).
Vamos a visualizar un ejemplo en el que vamos a declararnos los tipos de datos float y double para
mostrarlos por pantalla.
{
{
float float1;
double double1;
float1 = 21.1231157111;
double1 = 19.11437687311E+9;
System.out.println("Valor de float1 = " + float1);
www.learning.es
System.out.println("Valor de double1 = " + double1);
}
}
Resultado de la compilacin:
Podremos comprobar que en la compilacin nos aparece una excepcin que indica que podemos
perder precisin en los datos. Esto sucede porque en Java todos los tipos de datos con decimales
son double. Si queremos especificar un tipo de dato float, debemos hacerlo con F al final del
nmero a asignar.
{
{
float float1;
double double1;
float1 = 21.1231157111F;
double1 = 19.11437687311E+9D;
System.out.println("Valor de float1 = " + float1);
System.out.println("Valor de double1 = " + double1);
}
}
Resultado de la aplicacin ya compilada:
Declaracin de variables de tipo carcter char

Se pueden declarar variables de tipo carcter con la palabra reservada char.
Los posibles valores que se pueden almacenar en una variable char son caracteres Unicode del 0 al
65535, pero el cdigo ASCII slo tiene caracteres dentro del rango de 0 a 255.
Para asignar un dato carcter a un char, se realiza mediante el smbolo de la comilla simple.
Vamos a comprobar una aplicacin en la que asignaremos valores de tipo carcter e int a un tipo de
datos char. Comprobaremos que el resultado es la traduccin del cdigo ASCII a una
representacin de letra en la aplicacin.
{
www.learning.es
{
char char1, char2;
char1 = 88;
char2 = 'B';
System.out.println("Valor de char1 (Entero ASCII) = " + char1);
System.out.println("Valor de char2 (Letra) = " + char2);
}
}
Y vemos que como resultado de la compilacin muestra el carcter X como resultado del valor del
cdigo ASCII 88.
Declaracin de variables de tipo boolean

Las variables de tipo verdadero o falso se declaran con la palabra clave boolean.
En Java, las variables de tipo booleano slo pueden tener dos valores: verdadero o falso, no
pudiendo guardar valores numricos como 0 o 1 como sucede en otros lenguajes de programacin.
Dichas variables se utilizan para almacenar informacin y poder realizar un anlisis de nuestro
cdigo dependiendo del resultado de verdadero o falso. Se utilizan para realizar bifurcaciones en
nuestro cdigo, de forma que el cdigo no sea lineal, sino que entre por alguna de las bifurcaciones.
Los valores de true o false en la asignacin a stas variables deben ir en minscula.
Vamos a visualizar un ejemplo en el que asignaremos valores a dos variables de tipo boolean:
{
{
boolean boolean1, boolean2;
boolean1 = true;
boolean2 = false;
System.out.println("Valor de boolean1 = " + boolean1);
System.out.println("Valor de boolean2 = " + boolean2);
}
}
Y el resultado de la compilacin es:
www.learning.es
Conversin entre tipos (casting)
Java permite convertir un variable de un tipo de dato a otro. A esta conversin se le conoce como
"casting".
Se permite la conversin de un tipo primitivo a cualquier otro tipo primitivo, excepto en el caso de
los booleanos.
Para forzar la conversin de un tipo a otro se utiliza la siguiente sintaxis:
variable_tipo_A= (tipo_A) variable_tipo_B;
Dependiendo del tipo de dato, podremos utilizar varios tipos de conversin, con mtodos estticos
desde la clase o con casting.
Java es un lenguaje muy robusto en cuanto a los tipos, y como consecuencia de ello, con frecuencia
nos enfrentamos a la situacin de asignar una variable de un tipo a una variable de otro. Para
realizar dicha accin se realiza lo que se denomina casting.
Existen dos formas de hacerlo: contando con una conversin automtica y haciendo explcitamente
un cast de tipos.
Conversin automtica de tipos de dato
Cuando asigna un tipo de dato a una variable de otro tipo, Java convertir el dato al nuevo tipo de
variable de forma automtica si se cumplen las siguientes condiciones:
Los tipos del dato y de la variable son compatibles.
El tipo de destino tiene un rango mayor que el de origen.
Poniendo un ejemplo, se puede asignar un valor de tipo byte a una variable int, ya que byte e int
son tipos compatibles y las variables int tienen un rango mayor que los valores byte. Por lo tanto,
no se perder ningn dato en la conversin de tipos.
Esto es un ejemplo:

{
{
byte byte1 = 19;
int int1;
int1 = byte1;
System.out.println("Valor de int1 = " + int1);
System.out.println("Valor de byte1 = " + int1);
}
}
Y el resultado de la compilacin es:
www.learning.es
El compilador de Java hace la conversin de tipos automticamente. Este tipo de conversiones, en
las que se convierte a un tipo de datos que tiene mayor rango, se llaman extensin de
conversiones. En ellas, los tipos numricos, como entero o coma flotante, son compatibles entre s.
En cambio, los tipos char y boolean no son compatibles entre s y tampoco con los tipos numricos.
Casting entre tipos de datos

Si se est asignando un valor que es de un tipo con un rango mayor que la variable a la que se le
est asignando, se est ejecutando lo que se denomina estrechamiento de conversiones.
El compilador de Java no las ejecuta automticamente, debido a que perderiamos la precisin en
la asignacin del valor de las variables..
Si deseamos hacer un estrechamiento de conversiones, debemos usar explcitamente un casting,
que tiene la siguiente sintaxis:
Variable Destino = (Tipo de dato destino) valor a asignar;
Vamos a hacer un ejemplo en el que intentaremos convertir un tipo de dato int a un tipo de datos
byte, por lo que tiene menos precisin y debera de darnos una excepcin en la compilacin.
{
{
byte byte1;
int int1 = 21;
byte1 = int1;
System.out.println("Valor de conversion de byte1 = " + byte1);
}
}
Como podemos comprobar, existe una prdida de precisin, ya que los dos tipos de datos son
compatibles entre s, pero un valor de tipo int es superior a un tipo de datos byte, por lo que la
conversin no se realiza de forma automtica y tenemos que utilizar un casting:
www.learning.es
{
{
byte byte1;
int int1 = 21;
byte1 = (byte) int1;
}
}
El resultado ya es satisfactorio:
Como podemos comprobar ahora, el resultado de la compilacin es diferente y ya nos permite

visualizar los datos, otro tipo de problema sera que almacensemos un nmero mayor del que
permite byte, por lo que nos dara una excepcin, pero en tiempo de ejecucin:

{
{
byte byte1;
int int1 = 222222;
byte1 = (byte) int1;
}
}
Como podemos visualizar, nos permite la conversin, pero perdemos el valor de la variable al perder
la precisin entre tipos de datos.
Strings (Cadenas)
Un string o cadena es una secuencia de caracteres almacenados en memoria y accesibles como una
unidad.
www.learning.es
Aunque existen diversas formas que veremos ms adelante, aqu definiremos e inicializaremos los
strings de la siguiente manera:
String mensaje="Hola Mundo";
Es muy importante manejar esta clase de datos debido a que los entornos grficos recogen y
presentan los datos en este formato.
Ver Video: Tipos de Casting, en la Unidad 4, en el Mdulo 1,

Laboratorio: Casting entre tipos de datos.

Objetivos
Comprender el funcionamiento del concepto de casting, asi como los mtodos estaticos de las clases
para conversin entre tipos de datos y objetos.
Enunciado
Realizaremos una aplicacin en la que mostraremos los diferentes tipos de conversin posibles entre
objetos, de forma automtica o utilizando los mtodos static de las clases, tales como String.valueOf
o Integer.parseInt.
Podremos modificar el ejemplo y visualizar que sucedera en el caso de convertir un conjunto de
caracteres doubl a un int. O por ejemplo aadir un char e intentar convertirlo a int, y a la
inversa.
Solucin:
CDIGO JAVA
public class CastingObjetos
{
{
System.out.println("Casting entre objetos");
String texto;
int numero = 25;
double decimal = 19.21;
byte bit = (byte)255;
float f = 65.55F;
boolean valor = true;
texto = "22";
numero = Integer.parseInt(texto);
www.learning.es
System.out.println("Convertido String a int: " + numero);
numero = 4567;
texto = String.valueOf(numero);
System.out.println("Convertido int a String: " + texto);
numero = (int) decimal;
System.out.println("Convertido double a int: " + numero);
System.out.println("Perdida de precision de double: " + decimal);
texto = String.valueOf(decimal);
System.out.println("Convertido double a String: " + decimal);
decimal = f;
System.out.println("conversion automatica float a double: " + decimal);
f = (float)decimal;
System.out.println("Convertido double a float: " + f);
System.out.println("Perdida de precision de float: " + decimal);
texto = String.valueOf(f);
System.out.println("Convertido float a String: " + texto);
texto = String.valueOf(valor);
System.out.println("Convertido boolean a String: " + texto);
System.out.println("-----------------------------------------");
System.out.println("Fin de programa");
}
}
Actividades
eLearning.
www.learning.es
Unidad 5. Creando y usando Objetos
Introduccin
Como hemos ido aprendiendo a lo largo del mdulo, podemos declararnos variables para almacenar
valores simples (nmeros, letras, decimales). Pero el problema lo podemos encontrar si deseamos
almacenar algo ms complejo, por ejemplo, los datos de una factura o los datos de un determinado
registro de compra.
Dentro de dicho supuesto, una factura est compuesta por mltiples valores simples que conforman
un conjunto, el precio, el iva, el descuento, el destinatario
Gracias a la tecnologa de Java, podemos declararnos objetos, llamados Clases, que nos permiten
almacenar gran cantidad de objetos simples desde un mismo lugar, o lo que es lo mismo, nos
permite definir un objeto compuesto para manejar y utilizar sus objetos simples.
A lo largo del mdulo vamos a aprender a crearnos objetos propios y a manejar un objeto ya creado
como es la clase String, con sus mtodos y miembros de objeto.
Objetivo
Conocer la diferencia entre los tipos de datos primitivos de Java y la creacin de un objeto y
uso de sus clases.
Utilizacin de la clase String dentro del lenguaje de Java.
Declarar, instanciar e inicializar variables de referencia

de objeto
Una clase es una agrupacin de datos (miembros o campos) y de funciones (mtodos) que operan
sobre esos datos.
La definicin de una clase se hace de la siguiente forma:
public class NombreClase
{
// definicin de variables y mtodos
}
La palabra public es opcional, si no se pone, la clase tiene la visibilidad por defecto, esto significa
que slo es visible para las dems clases del package. Todos los mtodos y variables deben ser
definidos dentro de las llaves bloque {...} de la clase.
Un objeto es un elemento concreto para usar de una clase.
Las clases son la definicin de los elementos de un objeto, mientras que los objetos son variables
concretas de un tipo determinado de una clase.
NombreClase MiObjeto;
Vamos a enumer algunas caractersticas importantes de las clases:
Todas las variables y funciones de Java deben pertenecer a una clase. No hay variables y
funciones globales para todo el entorno.
Si una clase deriva de otra, hereda todas sus variables y mtodos.
Java tiene una jerarqua de clases estndar de la que pueden derivar las clases que crean
los usuarios.
www.learning.es
Una clase slo puede heredar de una nica clase (en Java no existe herencia mltiple). Si
al declarar una clase no se especifica de qu clase deriva, por defecto dicha clase hereda
de Object. La clase Object es la base de toda la jerarqua de clases de Java.
En un fichero se pueden definir varias clases, pero en un fichero no puede existir ms que
una clase public. Dicho fichero se debe nombrar como la clase public que contiene con
extensin *.java. Con algunas excepciones, lo normal es escribir una sola clase por
fichero.
Si una clase incluida en un fichero no contiene el mbito public, no es imprescindible que
el fichero se nombre como la clase.
Los mtodos de una clase pueden referirse de modo global al objeto de esa clase al que
se aplican por medio de la palabra clave this. Dicha palabra clave hace referencia al
objeto sobre el que se est creando la clase.
Las clases se pueden unir en packages, incluyendo una sentencia al principio del fichero
(package NombrePaquete;). Esta unin en packages est relacionada con la jerarqua de
directorios y ficheros en la que se almacenan las clases.
Todos estos conceptos nos llevan a la creacin de objetos de referencia, dichos objetos de referencia
son clases creadas con unos mtodos y caractersticas concretas.
Para crearnos objetos de referencia no se realiza sobre la propia clase Factura, digamos que la clase
Factura es una definicin de clase y para su utilizacin se realiza sobre cualquier otra clase de Java.
Para visualizar un objeto de referencia vamos a mostrar un ejemplo y su utilizacin. Nos vamos a
crear una nueva clase llamada Factura. Una factura est compuesta por un nombre de titular, un
concepto, un precio, el iva y el total de la factura.
public class Factura
{
public String NombreTitular;
public String ConceptoFactura;
public double Precio;
public double Total;
public double Iva;
}
Acabamos de crearnos una clase en la que podemos almacenar una serie de datos primitivos en su
conjunto. Dicha clase contiene una serie de miembros que almacenar cada objeto creado de ese
tipo concreto de clase.
Cada objeto Factura, es decir cada instancia de la clase, tiene su propia copia de las variables
miembro. Las variables miembro de una clase (tambin llamadas campos) pueden ser de tipos
primitivos (boolean, int, long, double) o referencias a objetos de otra clase (composicin).
En nuestro ejemplo, hemos creado cinco variables miembro de la clase factura, dichas variables
miembro son elementos que pertenecen a la clase Factura y slo pueden ser utilizadas por objetos
de la clase Factura. Cada Factura que creemos tendr unos valores diferentes para cada miembro.
public class UtilizacionFactura
{
{
Factura f1 = new Factura();
f1.NombreTitular = "Adrian Ramos";
f1.ConceptoFactura = "IPad";
f1.Precio = 540;
f1.Iva = 30;
f1.Total = 570;
System.out.println("Datos de la factura numero 1");
System.out.println("Nombre Titular: " + f1.NombreTitular);
www.learning.es
System.out.println("Concepto Factura: " + f1.ConceptoFactura);
System.out.println("Precio: " + f1.Precio);
System.out.println("Iva: " + f1.Iva);
System.out.println("Total: " + f1.Total);
System.out.println("-------------------------------------");
f2.NombreTitular = "Lucia Serrano";
f2.ConceptoFactura = "PSP";
f2.Precio = 169;
f2.Iva = 15;
f2.Total = 184;
System.out.println("Datos de la factura numero 2");
}
}
Como podemos comprobar, cada objeto referenciado de la clase factura contiene unos datos
diferentes para cada elemento. Es decir, cada miembro de la instancia de Factura almacena unos
datos diferentes en cada objeto.
Un aspecto muy importante del correcto funcionamiento de los programas es que no haya datos sin
inicializar. Por eso las variables miembro se inicializan siempre de modo automtico, incluso antes
de llamar al constructor. Sin embargo, lo ms adecuado es inicializar las variables miembro dentro
del constructor.
Un contructor, como veremos ms adelante, es un mtodo de inicio de la clase. Cuando llamamos a
la palabra clave new al crear la instancia, estamos llamando al constructor de la clase sobre la que
estamos instanciando un objeto.
Un constructor se define con el mismo nombre de la clase y es el primer lugar que el cdigo lee en
una clase. Vamos a comprobarlo modificando el ejemplo Factura:
Para hacer referencia a los objetos que pertenecen a la clase sobre la que estamos escribiendo se
utiliza la palabra clave this. Dicha palabra hace referencia a todos los cualquier elemento declarado
en la clase.
www.learning.es
{
public double Iva;
//CONSTRUCTOR DE FACTURA
public Factura()
{
//VAMOS A INICIALIZAR LOS MIEMBROS DE LA CLASE
this.NombreTitular = "sin titular";
this.ConceptoFactura = "sin concepto";
this.Precio = 0.0;
this.Iva = 0.0;
this.Total = 0.0;
}
}
Si ahora utilizamos un objeto de la clase Factura, solamente instanciando un objeto, los valores
iniciales se han creado desde el constructor.
{
{
System.out.println("Datos de la factura CONSTRUIDA");
}
}
Como resultado vemos los valores iniciales creados desde el constructor:
Variables static de clase

Una clase puede tener variables propias de la clase y no de cada objeto. A estas variables se les
llama variables de clase o variables static. Las variables static se suelen utilizar para definir
constantes comunes para todos los objetos de la clase o variables que slo tienen sentido para toda
la clase.
Las variables de clase se crean anteponiendo la palabra static a su declaracin. Para llamarlas se
utiliza el nombre de la clase.
www.learning.es
public static int VariableEstatica;
Las variables static se llaman desde la clase y no pueden hacer referencia al objeto, es decir, no
pueden utilizar la palabra this, debido a que todas las instancias de la clase tendrn el mismo valor.
Como ejemplo, podemos visualizarlo fcilmente incluyendo una variable static dentro de nuestro
ejemplo de factura:
{
public static String TipoIva = "Iva del 16%";

}
Ahora vamos a utilizar la clase Factura:
{
{
f1.NombreTitular = "Adrian Ramos";
f2.NombreTitular = "Lucia Serrano";
System.out.println("Nombre Titular Factura 1: " + f1.NombreTitular);
System.out.println("Nombre Titular Factura 2: " + f2.NombreTitular);
System.out.println("Tipo Iva: " + Factura.TipoIva);
Factura.TipoIva = "Iva 18%";
System.out.println("Tipo Iva: " + Factura.TipoIva);
}
}
Como podemos comprobar, las variables miembro tienen un valor diferente para cada instancia del
objeto, mientras que la variable static TipoIva no hace referencia a ninguno de los dos objetos (f1 y
f2), sino que hace referencia directamente sobre la clase, lo que quiere decir que todos los objetos
de la clase Factura tendrn el mismo valor. Si modificamos el contenido de la variable static, se
modifica para toda la clase.
Las variables miembro static se crean en el momento en que pueden ser necesarias: cuando se va a
crear el primer objeto de la clase, en cuanto se llama a un mtodo static o en cuanto se utiliza una
variable static de dicha clase. Lo importante es que las variables miembro static se inicializan
siempre antes que cualquier objeto de la clase.
Variables final o constantes

Una variable de un tipo primitivo declarada como final no puede cambiar su valor a lo largo de la
ejecucin del programa, es una constante.
www.learning.es
Java permite separar la definicin de la inicializacin de una variable final. La inicializacin puede
hacerse ms tarde, en tiempo de ejecucin, llamando a mtodos o en funcin de otros datos.
La variable final definida es constant, pero no tiene por qu tener el mismo valor en todas las
ejecuciones del programa, pues depende de cmo haya sido inicializada.
Adems de las variables miembro, tambin las variables locales y los propios argumentos de un
mtodo pueden ser declarados como final.
Para declarar una variable constante, bastara con incluir la palabra final en la declaracin de la
variable:
public final int NombreConstante;
Vamos a mostrar un ejemplo:
{
public static String TipoIva = "Iva del 16%";
public final double PI;
public double Iva;
//CONSTRUCTOR DE FACTURA
public Factura()
{
//VAMOS A INICIALIZAR LOS MIEMBROS DE LA CLASE
this.PI = 3.1416;
this.NombreTitular = "sin titular";
this.ConceptoFactura = "sin concepto";
this.Precio = 0.0;
this.Iva = 0.0;
this.Total = 0.0;
}
}
Como podemos comprobar, hemos declarado una variable final y la hemos inicializado en el
constructor, lo que no podemos hacer es cambiar su valor posteriormente, ni en el uso de un objeto
Factura, ni en la propia clase factura.
{
{
System.out.println("Valor de la constante PI: " + f1.PI);
}
}
www.learning.es
La clase String
Un String es una variable referenciada asociada a un objeto de la clase java.lang.String. Se emplea
para almacenar conjuntos de caracteres.
Las Strings tienen una caracterstica que las diferencia del resto de objetos: son inmutables, es
decir, cuando se intenta modificarlas, por ejemplo al aplicarles un mtodo, no se modifican sino que
se crea otra instancia con un objeto de la clase String nuevo.
Dicho concepto se llama inmutabilidad. Para comprender mejor dicho concepto vamos a crear un
ejemplo prctico:
public class EjemploString
{
{
String texto = "Clase String";
System.out.println(texto);
texto += " Java";
}
}
Inicialmente, la variable texto se crea con el valor Clase String. Cuando se ejecuta la instruccin
texto += Java, se crea un nuevo objeto de la clase String cuyo contenido es Clase String Java y
se destruye el antiguo objeto. Estamos creando dos instancias de objeto sobre la misma variable.
Podremos observar que siendo una String una variable referenciada no se emplea constructor para
crearla sino que se siguen las mismas pautas que en las variables primitivas. Cuando veamos los
constructores de String se explicar el motivo.
Dentro de un objeto de la clase String, el lenguaje Java crea un array de caracteres. A este array se
accede a travs de las funciones o mtodos miembros de la clase.
Los strings u objetos de la clase String se pueden crear explcitamente o implcitamente. Para crear
un string implcitamente bastara poner una cadena de caracteres entre comillas dobles. Por
ejemplo, cuando escribimos la instruccin:
System.out.println("Primer programa Java");
Java crea un objeto de la clase String automticamente de forma implicita.
Para crear un string explcitamente debemos acceder al constructor de la clase, como por ejemplo:
String texto=new String("Primer programa Java");
Tambin se puede escribir, alternativamente
String texto ="Primer programa Java";
Para crear un string nulo se puede hacer de varias formas:
String texto ="";
www.learning.es
String texto =new String();
Un string nulo es aqul que no contiene caracteres, pero es un objeto de la clase String sin
contenido, pero creado o instanciado. Sin embargo, si escribimos sta instruccin:
String texto;
Estamos declarando un objeto texto de la clase String, pero an no se ha creado ningn objeto de
esta clase.
La clase String incluye mtodos para examinar caracteres individuales de la secuencia, para
comparar diferentes cadenas, para encontrar textos en una cadena, para extraer subcadenas o para
convertir textos en maysculas o minsculas por ejemplo.
El smbolo para concatenar cadenas es el smbolo +. Tambin puede servir para convertir otro tipo
de objetos a string y unirlos en un nuevo objeto de la clase.
La conversin de objetos a la clase String se realiza mediante el mtodo toString(), definido en
todas las clases Java.
El paquete dnde se encuentra la clase String es java.lang.String.
Constructores de la clase String

Constructor Summary
- String()
Crea una nueva instancia del objeto String que representa una cadena de caracteres vaca.
- String(byte[] bytes)
Construye un nuevo String decodificando los bytes del array en un conjunto de caracteres.
- String(byte[] bytes, int offset, int length)
Construye un nuevo objeto de la clase String decodificando el array de bytes en un conjunto de
caracteres, indicando el inicio del array de bytes y la longitude de caracteres que deseamos
construir.
- String(char[] value)
Construye un nuevo objeto String con la secuencia de caracteres que hay incluidos dentro del
array de caracteres.
- String(char[] value, int offset, int count)
Construye un nuevo objeto String con la secuencia de caracteres que hay incluidos dentro del
array de caracteres, indicando el inicio del array y la longitud de caracteres que deseamos incluir
en el nuevo objeto String.
- String(String original)
Construye un nuevo objeto String, a partir de otro objeto String indicado en constructor como
parmetro.
- String(StringBuffer buffer)
Construye un nuevo objeto String, a partir de un objeto StringBuffer indicado en constructor
como parmetro.
Mtodos de la clase String

Cada mtodo de la clase String realiza una accin sobre el objeto. Dependiendo del mtodo que
vayamos a utilizar, podemos realizar acciones como convertir a maysculas el String o recuperar un
carcter dentro de la cadena de caracteres.
Debemos de tener en cuenta que todas las cadenas de caracteres en Java comienzan en la posicin
cero y que nunca podremos sobrepasar la longitud de un texto.
- charAt(int index)
www.learning.es
Devuelve un char, el character ubicado dentro de la cadena en la posicin que indiquemos como
nmero.
- compareTo(Object o)
Compara un objeto String con otro objeto, devolviendo un int. Devuelve cero en el caso que
sean diferentes y uno en el caso de que coincidan.
- compareTo(String anotherString)
Compara un objeto String con otro objeto String lexicogrficamente, devolviendo un int.
Devuelve cero en el caso que sean diferentes y uno en el caso de que coincidan.
- compareToIgnoreCase(String str)
Compara un objeto String con otro objeto String lexicogrficamente sin tener en cuente las
diferencias entre maysculas y minsculas del texto. Devuelve un int. Devuelve cero en el caso
que sean diferentes y uno en el caso de que coincidan.
- concat(String str)
Concatena el objeto String enviado como parmetro al final del String sobre el que se realize la
accin. Devuelve un String con el conjunto como resultado.
- contentEquals(StringBuffer sb)
Devuelve verdadero solo si el String representa la misma secuencia de caracteres que el objeto
StringBuffer enviado como parmetro.
- copyValueOf(char[] data)
Mtodo static que devuelve un String que representa el conjunto de caracteres enviado como
parmetro en el array de char.
- copyValueOf(char[] data, int offset, int count)
Mtodo static que devuelve un String que representa el conjunto de caracteres enviado como
parmetro en el array de char, indicando el inicio de caracteres en el array y la longitud de
caracteres que deseamos recuperar.
- endsWith(String suffix)
Devuelve verdadero o falso si la cadena finalize con el texto enviado como parmetro.
- equals(Object anObject)
Compara si un String es igual a un object.
- equalsIgnoreCase(String anotherString)
Compara un String con otro String sin tener en cuenta la diferencia entre maysculas y
minsculas.
- getBytes()
Mtodo que devuelve un array de bytes a partir de la secuencia de caracteres contenida en el
objeto String.
- getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Mtodo que copia los caracteres del String dentro del array de caracteres que se enva como
parmetro. Debemos indicar la posicin de inicio y final del String y la posicin desde la que
deseamos copiar dentro del array de char.
- hashCode()
Devuelve el cdigo hash del String.
- indexOf(String str)
Mtodo que busca un texto dentro de la cadena y devuelve la posicin en la que se encuentra.
Busca la primera ocurrencia dentro del texto. Si no encuentra la cadena especificada devuelve -
1.
- indexOf(String str, int fromIndex)
Mtodo que busca un texto dentro de la cadena y devuelve la posicin en la que se encuentra,
indicando la posicin inicial a buscar. Busca la primera ocurrencia dentro del texto. Si no
encuentra la cadena especificada devuelve -1.
- lastIndexOf(String str)
www.learning.es
Mtodo que busca un texto dentro de la cadena y devuelve la posicin en la que se encuentra.
Busca la primera ocurrencia dentro del texto empezando desde el final. Si no encuentra la
cadena especificada devuelve -1.
- lastIndexOf(String str, int fromIndex)
Mtodo que busca un texto dentro de la cadena y devuelve la posicin en la que se encuentra,
indicando la posicin inicial a buscar. Busca la primera ocurrencia dentro del texto empezando
desde el final. Si no encuentra la cadena especificada devuelve -1.
- length()
Devuelve el nmero de caracteres que hay en la cadena.
- replace(char oldChar, char newChar)
Mtodo que devuelve un String como resultado de reemplazar todos los caracteres que existan
en la cadena por otro character indicado como parmetro en la cabecera del mtodo.
- split(String regex)
Devuelve un array de la clase String utilizando como separador los caracteres contenidos dentro
de la expresin enviada como parmetro.
- startsWith(String prefix)
Mtodo que devuelve verdadero o falso indicando si la cadena comienza por el texto enviado
como parmetro.
- startsWith(String prefix, int toffset)
Mtodo que devuelve verdadero o falso indicando si la cadena comienza por el texto enviado
como parmetro, indicando la posicin desde la que se va a comenzar a buscar.
- substring(int beginIndex)
Mtodo que devuelve una subcadena desde la posicin que indiquemos como inicio hasta el final
del texto.
- substring(int beginIndex, int endIndex)
Mtodo que devuelve una subcadena desde la posicin que indiquemos como inicio hasta la
posicin indicada como final.
- toCharArray()
Mtodo que convierte el String en un array de char.
- toLowerCase()
Mtodo que convierte los caracteres del String a minuscula.
- toUpperCase()
Mtodo que convierte los caracteres del String a mayscula.
- trim()
Mtodo que devuelve un String eliminando los espacios del texto tanto por la izquierda como por
la derecha.
- valueOf(int i)
Devuelve un string que es la representacin del tipo de dato enviado como argumento a una
cadena de caracteres. ste mtodo es esttico. Hay mtodos equivalentes donde el argumento
es un float, double, etc.
Introduccin a los flujos o streams

Los flujos surgen por la necesidad de las aplicaciones Java de interaccionar con el exterior de dos
posibles formas:
Generando salida a la consola del DOS, a un fichero, etc.
Capturando datos procedentes del teclado, de ficheros, de pginas web, etc.
Concepto de flujo: es como un ro. El agua en movimiento es el flujo, su contenido son los datos. Lo
que permite que esos datos viajen de un origen a un destino es el agua en movimiento, es decir, el
www.learning.es
flujo. En el caso de la captura desde un programa Java, de datos introducidos por un usuario
mediante teclado, el origen es el teclado, el destino, el programa Java y los datos, lo tecleado por el
usuario.
Java modela flujos mediante clases del paquete java.io. Este paquete se estudiar ms adelante en
el curso, por el momento se va a explicar cmo una aplicacin Java captura datos introducidos por el
usuario a travs del teclado y cmo realiza todo tipo de operaciones sobre los mismos.
Capturar datos desde teclado

Necesitamos los siguientes elementos en nuestra aplicacin:
Obtener un objeto que modele la fuente de entrada de datos "teclado" en un programa Java. Ms
adelante se estudiarn otras fuentes de entrada de datos como ficheros o conexiones a sockets.
Para ello, lo primero que debe tenerse presente es que el teclado es la entrada estndar de datos en
un PC.
A continuacin, debe tenerse en cuenta, que cualquier entrada genrica de datos a un programa
Java, se modela mediante un objeto de la clase abstracta java.io.InputStream.
Bueno, pues en la API se observa que un objeto de esta clase es lo que devuelve la variable de
campo esttica "in" de la clase java.lang.System. Adems, la explicacin API de esta variable nos
dice que representa la entrada estndar de datos de un programa Java.
En los cdigos que capturen datos procedentes del teclado, se emplear System.in para modelar el
teclado.
La salida estndar de datos en un PC es la consola del DOS. La salida genrica de datos de un
programa Java se modela mediante un objeto de la clase abstracta java.io.OutputStream.
En la API, se observa que un objeto PrintStream (hereda de OutputStream y, por tanto, es un objeto
OutputStream) es lo que devuelve la variable de campo esttica "out" de System. Adems, la
explicacin API de esta variable dice que representa la salida estndar de datos de un programa
Java.
En los cdigos que generen salida a travs de la consola del DOS, se emplear System.out para
modelar la consola del DOS.
Gracias a sta teora, podemos responder a la pregunta: Cmo se escribe en la consola?
Escribimos en la consola a travs de mtodos adecuados de PrintStream. Concretamente se han
empleado print(..) y println(..) para mostrar datos de salida en cualquier aplicacin que hemos
estado probando.
No es esta la nica forma de interaccionar con el exterior que tiene un cdigo Java. Ms adelante se
ver cmo se puede generar salida creando un fichero, por ejemplo.
Crear un flujo que permita al programador leer datos del teclado. Este flujo va a ser de entrada o
lectura de datos y va a modelarse con una objeto de la clase InputStreamReader.
El filtro para lectura de datos se modela con un objeto de la clase java.io.BufferedReader y el
mtodo de lectura adecuado va a ser String readLine() que genera una excepcin del tipo
IOException que debe ser gestionada correctamente en nuestra aplicacin. Inicialmente la
gestionaremos mediante la clusula throws IOException a continuacin del mtodo main.
Conclusin final:
El flujo u objeto InputStreamReader es lo que permite leer datos.
El System.in u objeto InputStream es el argumento del constructor de InputStreamReader y modela
el origen de los datos que se leen, es decir, el teclado.
www.learning.es
El filtro u objeto BufferedReader permite, mediante la utilizacin del mtodo String readLine(), leer
de forma ptima del flujo.
Vamos a visualizar un ejemplo prctico para poder leer datos del teclado enviados por el usuario.
Nos crearemos una clase que nos pida un nombre y devolveremos un saludo.
import java.io.*;
public class LecturaTeclado

{
public static void main(String[] args) throws IOException
{
System.out.println("Introduzca un nombre:");
BufferedReader lector=new BufferedReader(new
InputStreamReader(System.in));
String nombreusuario;
nombreusuario = lector.readLine();
System.out.println("Bienvenido a nuestra aplicacion: " + nombreusuario);
}
}
Resultado del programa:
Vemos que como resultado, hemos escrito el nombre de Lucia y hemos mostrado un mensaje.
La excepcin IOException que genera el mtodo readLine() la hemos capturado mediante la palabra
reservada throws, que veremos en capitulos posteriores del curso.
Ver Video: Analizar objeto String, en la Unidad 5, en el Mdulo

1, en la plataforma elearning
Laboratorio: Validacin Email.
Objetivo
Conocer las ventajas de los mtodos de la clase String y su uso como objeto.
Enunciado
Nos crearemos una clase en Java llamada ValidacionMail. Dicha clase tendr implementado en el
cdigo main la lgica para validar un email, teniendo en cuenta las siguientes restricciones de
validacin:
Un mail debe contener arroba
La arroba no puede estar ni al principio ni al final.
www.learning.es
No puede contener ms de una arroba
El correo debe contener un punto
No puede haber dos puntos seguidos
El punto y la arroba no pueden estar juntos ni por delante ni por detrs.
Email sin espacios
El dominio deber ser dos a cuatro caracteres como mximo.
Pediremos al usuario el email por teclado. Mostraremos mensajes informativos personalizados por
cada fallo que exista en el mail.
SOLUCIN
CDIGO JAVA
import java.io.*;
public class ValidacionEmail

{
{
String email;
System.out.println("Escriba su email para la validacion");
email = lector.readLine();
int posicionarroba, posicionpunto, longitud;
longitud = email.length();
posicionarroba = email.indexOf("@");
posicionpunto = email.indexOf(".");
if (posicionarroba == -1)
{
System.out.println("No hay arroba en el mail");
}
else if (posicionarroba == 0 || posicionarroba == longitud - 1)
{
System.out.println("La arroba no puede estar ni al principio ni al
final");
}
else if (posicionarroba != email.lastIndexOf("@"))
{
System.out.println("Existe mas de una @ dentro del mail");
}
else if (posicionpunto == -1)
www.learning.es
{
System.out.println("No hay punto en el mail");
}
else if (posicionpunto == 0 || posicionpunto == longitud - 1)
{
System.out.println("El punto no puede estar ni al principio ni al
final");
}
else if (email.indexOf("..") != -1)
{
System.out.println("No pueden existir dos puntos seguidos");
}
else if (email.indexOf("@.") != -1 || email.indexOf(".@") != -1)
{
System.out.println("El punto no puede ir seguido de la @");
}
else if (email.indexOf(" ") != -1)
{
System.out.println("Un email no puede contenter espacios");
}
else
{
String dominio;
int ultimopunto;
ultimopunto = email.lastIndexOf(".");
dominio = email.substring(ultimopunto + 1);
if (dominio.length() >=2 && dominio.length() <=4)
{
System.out.println("EMAIL CORRECTO");
}else
{
System.out.println("El dominio solo puede ser de 2 a 4
caracteres");
}
}
}
Actividades
eLearning.
www.learning.es
Unidad 6. Usando operadores y
constructores
Introduccin
Como cualquier lenguaje de programacin, Java proporciona una serie de operadores que nos
permiten llevar una lgica en el momento de realizar cualquier tipo de aplicacin.
Dichos operadores tienen una sintaxis especfica dentro del lenguaje y nos pueden permitir desde
preguntar por el estado de variables, hasta hacer un recorrido por todos los elementos de un
conjunto para visualizar paso a paso cada uno de los elementos.
Objetivos
Aprender los diferentes operadores que proporciona el lenguaje Java.
Conocer el significado de la palabra constructor en una clase y sus posibles utilizaciones.
Operadores y expresiones
Los operadores son un tipo de tokens o smbolos que indican una evaluacin o computacin para
ser realizada en objetos o datos, y en definitiva sobre identificadores, constantes o variables.
Adems de realizar la operacin, un operador devuelve un valor, ya que son parte fundamental de
las expresiones.
El valor y tipo que devuelve depende del operador y del tipo de sus operandos. Por ejemplo, los
operadores aritmticos devuelven un nmero como resultado de su operacin.
Los operadores realizan alguna funcin sobre uno, dos o tres operandos, dependiendo del tipo de
expresin en el que se utilicen.
Los operadores que requieren un operando son llamados operadores unarios. Por ejemplo, el
operador "++" es un operador unario que incrementa el valor de su operando en una unidad.
Los operadores unarios en Java pueden utilizar tanto la notacin prefija como la posfija.
La notacin prefija indica que el operador aparece antes que su operando.
++contador // Notacin prefija, se evala a: contador+1
La notacin posfija indica que el operador aparece despus de su operando:
contador++ // Notacin posfija, se evala a: contador
Los operadores que requieren dos operandos se llaman operadores binarios. Por ejemplo el operador
"=" es un operador binario que asigna el valor del operando del lado derecho al operando del lado
izquierdo.
Todos los operadores binarios en Java utilizan notacin infija, lo cual indica que el operador aparece
entre sus operandos.
operando1 operador operando2
Por ltimo, los operadores ternarios son aquellos que requieren tres operandos. El lenguaje Java
tiene el operador ternario, "?":, que es una sentencia similar a if-else.
Este operador ternario usa notacin infija; y cada parte del operador aparece entre operandos:
expresin ? operacin1 : operacin2
Los operadores de Java se pueden dividir en las siguientes cuatro categoras:
www.learning.es
Aritmticos.
Comparacin y relacionales.
A nivel de bits y lgicos.
Asignacin.
Operadores Aritmticos (Suma, resta, multiplicacin,

divisin, resto, incremento y decremento).
Los operadores aritmticos se usan para realizar clculos de aritmtica entre variables y el resultado
siempre ser un valor que devuelven cmo resultado de su operacin.
En la siguiente tabla tenemos las operaciones aritmticas que podemos realizar entre dos
operadores.
Operador Uso Descripcin
+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 y op1
* op1 * op2 Multiplica op1 y op2
/ op1 / op2 Divide op1 y op2
% op1 % op2 Obtiene el resto de la divisin de op1 y op2
Actan sobre enteros y nmeros en coma flotante.
El operador + tambin se utiliza para concatenar cadenas (strings).
En la siguiente tabla tenemos las operaciones aritmticas sobre un solo operando.
Operador Uso Descripcin
++ op++ Incrementa op en 1; evala el valor antes de
incrementar
++ ++op Incrementa op en 1; evala el valor despus de
incrementar
-- op-- Decrementa op en 1; evala el valor antes de
decrementar
-- --op Decrementaop en 1; evala el valor despus de
decrementar
Operadores Relacionales.
Con operador relacional entendemos la relacin que tiene un valor respecto a otro. Se basan en el
concepto de verdadero o falso y en todos los casos operan con slo dos estados diversos (0/1,
encendido/apagado, verdadero/falso).
Los operadores relacionales, como ya hemos dicho, producen un resultado 1 si la relacin es
verdadera, y 0 si la relacin es falsa. Es importante comprender que el resultado de salida est
constituido slo por dos valores a fin de evitar confusiones entre el operador de asignacin y el de
igualdad.
Operador Uso Devuelve true si
> op1>op2 op1 es mayor que op2
>= op1>=op2 op1 es mayor o igual que op2
op1op2 op1 es menor que op2
= op1=op2 op1 es menor o igual que op2
== op1==op2 op1 y op2 son iguales
!= op1!=op2 op1 y op2 son distintos
www.learning.es
Operadores Condicionales.
El operador condicional sirve para tomar decisiones entre dos o ms expresiones simples de
comparacin. Proporciona un resultado verdadero o falso entre dos o ms posibilidades en funcin
de una condicin.
Operador Uso Devuelve true si
&& op1 && op2 op1 y op2 son true (op2 lo evala si op1 es cierto)
|| op1 || op2 op1 o op2 es true (op2 lo evala si op1 es falso)
! ! op op es false
& op1 & op2 op1 y op2 son true, siempre evala op1 y op2
| op1 | op2 op1 o op2 es true, siempre evala op1 y op2
Operadores a nivel de bit

En determinadas ocasiones nos puede interesar manipular datos a nivel de bit; por ejemplo activar o
desactivar flags. Un flag es una variable' que puede tomar 2 valores, por lo que se suele
representar con un bit. Debido a que en la mayora de lenguajes de programacin no existen tipos
predefinidos de un bit, lo que se suele hacer es agrupar varios flags en una variable de tipo entero
(int' o el tipo que queramos).
Para acceder a estos flags o simplemente para activarlos es necesario utilizar operadores a nivel de
bit.
Operador Uso Operacin
>> op1 >> op2 Desplaza los bits de op1 a la derecha tantas veces como
indique op2. Rellena los huecos que queda con el bit de signo.
op1 op2 Desplaza los bits de op1 a la izquierda tantas veces como
indique op2. Rellena los huecos que queda con 0.
>>> op1 >>> op2 Desplaza los bits de op1 a la derecha tantas veces como
indique op2. Rellena los huecos que queda con 0.
& op1 & op2 funcin and
| op1 | op2 funcin or
^ op1 ^ op2 funcin xor
~ ~op2 complemento
Es interesante observar que la funcin AND a nivel de bits es igual que el operador condicional &. La
diferencia est en los tipos de datos con los que se usa (Sobrecarga de operadores).
- La funcin AND se usa con datos numricos.
- El operador condicional se usa sobre booleanos.
Operadores de asignacin.
Los operadores de asignacin cambian el valor de una variable o de un objeto a otro valor,
asignando o reasignndoles un nuevo valor.
En la siguiente tabla podemos visualizar los operadores de asignacin de Java.
Operador Uso Equivale a
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
www.learning.es
= op1 = op2 op1 = op1 op2
>>= op1 >>= op2 op1 = op1 >> op2
>>>= op1 >>>= op2 op1 = op1 >>> op2
Operador ternario if-then-else

Es un operador que permite realizar una pregunta verdadero o falso, realizando una accin para
cuando devuelve verdadero y otra accin para cuando devuelve falso.
Solamente se puede realizar una accin para cada valor devuelto en la expresin, es decir,
solamente puede haber una accin para verdadero y otra para falso.
Aunque su sintaxis es confusa:
Expresin ? sentencia 1 : sentencia 2
Su interpretacin es sencilla:
Si la expresin devuelve como resultado true entonces se ejecuta la sentencia 1, en caso contrario,
se ejecuta la sentencia 2.
Vamos a visualizar un ejemplo para comprender la expresin y su sintaxis. Compararemos un
nmero y mostraremos si el nmero es positivo o negativo utilizando ste operador ternario.
public class ClaseIfTernario
{
{
int i=5;
String mensaje;
mensaje = i>=5?"Positivo":"Negativo";
System.out.println("El mensaje es " + mensaje);
}
}
Comprobaremos que evalua la expresin y entra en la primera opcin debido a que el nmero es
positivo. Podremos comprobar que entra por el mensaje siguiente si cambiamos el valor de la
variable a negativo.
Precedencia entre operadores.

Los operadores de preferencia indican al compilador de Java cmo deseamos que se evale una
expresin utilizando los parntesis ( ).
Un ejemplo nos servir para aclarar el concepto:
Podriamos escribir:
x + y / 100
Si indicamos explcitamente al compilador el orden en el que queremos que se realicen las
operaciones, l decide basndose en la precedencia asignada a los operadores y otros elementos
que se utilizan dentro de una expresin.
www.learning.es
Los operadores con una precedencia ms alta se evalan primero. Por ejemplo, el operador divisin
tiene una precedencia mayor que el operador suma, por eso, en la expresin anterior x + y / 100, el
compilador evaluar primero el smbolo de divisin entre 100. As
x + y / 100
es equivalente a.
x + (y / 100)
pero si deseamos realizar otra operacin antes, debemos indicarla de forma explicita:
(x + y) / 100.
El orden de precedencia se refleja en la siguiente tabla (de ms prioritario a menos).
Operadores posfijos [] . (params) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creacion o cast new (type)expr
aritmeticos */%
Suma o resta +-
Comparacion >
Relacional > = >= instanceof
Igualdad == !=
AND &
negacin OR ^
OR |
AND logico &&
OR lgico ||
Condicional ?:
asignacin = += -= *= /= %= &= ^= |= =
>>= >>>=
Sentencia return
La sentencia return devuelve un valor desde un mtodo. Cuando el programa Java lee dicha
sentencia, inmediatamente finaliza la ejecucin de la accin para retornar el valor final del conjunto
de acciones.
Tambin sirve como sentencia para salir de un bucle. A diferencia de continue o break, la sentencia
return tambin nos permite salir de un mtodo o una funcin, elementos que no tienen ni break ni
continue en bucles.
for (int i=0; i<10; i++)
{
//ACCIONES
return;
}
En el caso de que la funcin o mtodo devuelva algn objeto o variable como resultado de una serie
de operaciones, ste valor de la variable se tendr que poner a continuacin de la sentencia return.
public int miMetodo()
{
int numero = 0;
//ACCIONES
return numero;.
}
Sentencias de excepcin, bloques try, catch, finally.

www.learning.es
Java incorpora en el propio lenguaje la gestin de errores mediante instrucciones de cdigo. El
mejor momento para detectar los errores es durante la compilacin.
Sin embargo prcticamente slo los errores de sintaxis son detectados en esta operacin. El resto de
problemas surgen durante la ejecucin de los programas.
En el lenguaje Java, una Exception es un cierto tipo de error o una condicin anormal que se ha
producido durante la ejecucin de un programa. Algunas excepciones son fatales y provocan que se
deba finalizar la ejecucin del programa. En este caso conviene terminar ordenadamente y dar un
mensaje explicando el tipo de error que se ha producido. Otras excepciones, como por ejemplo no
encontrar un fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el
programa debe dar al usuario la oportunidad de corregir el error (definiendo por ejemplo un nuevo
path del fichero no encontrado).
Los errores se representan mediante clases derivadas de la clase Throwable, pero los que tiene que
chequear un programador derivan de Exception (java.lang.Exception que a su vez deriva de
Throwable).
Existen algunos tipos de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el
uso de bloques try, catch y finally.
El cdigo dentro del bloque try est vigilado. Si se produce una situacin anormal y se lanza como
consecuencia una excepcin, el control pasa al bloque catch, que se hace cargo de la situacin y
decide lo que hay que hacer. Se pueden incluir tantos bloques catch como se desee, cada uno de los
cuales tratar un tipo de excepcin. Finalmente, si est presente, se ejecuta el bloque finally, que es
opcional, pero que en caso de existir se ejecuta siempre, sea cual sea el tipo de error.
En el caso en que el cdigo de un mtodo pueda generar una Exception y no se desee incluir en
dicho mtodo la gestin del error (es decir los bucles try/catch correspondientes), es necesario que
el mtodo pase la Exception al mtodo desde el que ha sido llamado. Esto se consigue mediante la
palabra throws seguida del nombre de la Exception concreta, despus de la lista de argumentos del
mtodo. A su vez el mtodo superior deber incluir los bloques try/catch o volver a pasar la
Exception. De esta forma se puede ir pasando la Exception de un mtodo a otro hasta llegar al
ltimo mtodo del programa, el mtodo main().
Vamos a visualizar las dos opciones que podemos incluir para controlar la excepcin en un mtodo:
public class ControlExcepciones
{
{
int num1, num2, resultado;
num1 = 12;
num2 = 0;
resultado = num1 / num2;
System.out.println("El resultado de la operacion es: " + resultado);
}
}
Vamos a lanzar una excepcin en el programa en el que estamos dividiendo un nmero entre cero.
Como podemos comprobar, el programa nos da una excepcin despus de haberlo compilado, en
ejecucin. La excepcin que debemos tratar en ste caso en concreto es ArithmeticException.
www.learning.es
Para controlar la excepcin podemos realizar el control de dos formas diferentes como hemos
aprendido en la teora.
Mediante bloques try/catch. Nos permiten controlar la excepcin y personalizar que deseamos
realizar en el caso de que la excepcin ocurra.

{
{
try
{
num1 = 12;
num2 = 0;
}catch (ArithmeticException ex)
{
System.out.println("No se puede dividir entre CERO");
System.out.println("Excepcion: " + ex);
}
}
}
La variable ex es una variable declarada nicamente para controlar la excepcin

ArithmeticException, en el caso de que suceda una excepcin, dicha variable contiene las
caractersticas de la excepcin y lgicamente, solo se puede utilizar dentro del bloque catch.
La otra forma de controlar la excepcin es mediante la clausula throws en el mtodo. Dicho control
de excepciones nos permite derivar excepciones, pero no nos permite personalizar la excepcin,
simplemente est capturada en el caso de que suceda.
{
public static void main(String[] args) throws ArithmeticException
www.learning.es
{
num1 = 12;
num2 = 0;
System.out.println("El resultado de la operacion es: " +
resultado);
}
}
El resultado de la compilacin es el mismo que si no controlamos la excepcin, la diferencia radica

en que si alguna clase utiliza nuestro mtodo main, deber controlar la excepcin
ArithmeticException. Es lo que se llama derivacin de excepciones.
Ver Video: Operadores Pares, en la Unidad 6, en el Mdulo 1,

Laboratorio: Averiguar da de nacimiento de la semana.
Objetivos
Aprender a manejar los operadores de Java.
Enunciado
Pedir una fecha al usuario para calcular el da de la semana que naci.
Tenemos que tener la tabla de das de la semana para la correspondencia comenzando en sbado:
DIA NMERO
Sbado 0
Domingo 1
Lunes 2
Martes 3
Mircoles 4
Jueves 5
Viernes 6
Debemos tener el da, el nmero de mes y el ao que el usuario haya nacido.

A partir de esto datos hay que calcular lo siguiente para averiguar el da de la semana de
nacimiento:
Ejemplo = 22/06/1983
Hay que tener en cuenta el mes para realizar el clculo, si el mes es Enero, el Mes ser 13 y
restaremos uno al ao.
Si el Mes es Febrero, el Mes ser 14 y restaremos uno al ao.
Para poder calcular las el nmero final de la semana debemos seguir los siguientes pasos:
1. Multiplicar el Mes ms 1 por 3 y dividirlo entre 5
((6 + 1) * 3) / 5 = 4
2. Dividir el ao entre 4
www.learning.es
1983 / 4 =495
1983 / 100 = 19
1983 / 400 = 4
5. Sumar el dia, el doble del mes, el ao, el resultado de la operacin 1, el resultado de la
operacin 2.
Restar el resultado de la operacin 3 y sumar finalmente la operacin 4 ms 2.
22 + (6 * 2) + 1983 + 4 + 495 - 19 + 4 + 2 = 2503
6. Dividir el resultado anterior entre 7.
2503 / 7 = 357
7. Restar el nmero del paso 5 con el nmero del paso 6 por 7.
2503 (357 * 7) = 4
8. Miramos la tabla y vemos que el nmero 4 corresponde a Mircoles
Solucin:
CDIGO JAVA
import java.io.*;
public class ClaseDiaNacimiento
{
{
System.out.println("Introduzca su fecha de nacimiento (dd/mm/yyyy)");
int mes, dia, anyo;
String datomes, datodia, datoanyo;
String fecha = lector.readLine();
int posicion = fecha.indexOf("/");
datodia = fecha.substring(0 , posicion);
fecha = fecha.substring(posicion + 1);
posicion = fecha.indexOf("/");
datomes = fecha.substring(0 , posicion);
fecha = fecha.substring(posicion + 1);
datoanyo = fecha;
dia = Integer.parseInt(datodia);
mes = Integer.parseInt(datomes);
anyo = Integer.parseInt(datoanyo);
if (mes == 1)
{
mes = 13;
anyo--;
www.learning.es
}
if (mes == 2)
{
mes = 14;
anyo--;
}
//Multiplicar el Mes ms 1 por 3 y dividirlo entre 5
int ope1, ope2, ope3, ope4, ope5, ope6, ope7;
ope1 = ((mes + 1) * 3) / 5;
System.out.println("Operacion 1: " + ope1);
//Dividir el ao entre 4
ope2 = anyo / 4;
ope3 = anyo / 100;
ope4 = anyo / 400;
//Sumar el dia, el doble del mes, el ao,
//el resultado de la operacin 1, el resultado de la operacin 2
//, menos el resultado de la operacin 3 ms la operacin 4 ms 2.
ope5 = dia + (mes * 2) + anyo + ope1 + ope2 + ope4 + 2 - ope3;
//Dividir el resultado anterior entre 7.
ope6 = ope5 / 7;
//Restar el nmero del paso 5 con el nmero del paso 6 por 7.
ope7 = ope5 - (ope6 * 7);

String resultado = "";
//Miramos la tabla y vemos que el nmero 4 corresponde a Mircoles
switch (ope7)
{
case 0:
resultado = "Sabado";
break;
case 1:
resultado = "Domingo";
break;
case 2:
resultado = "Lunes";
break;
case 3:
resultado = "Martes";
break;
case 4:
resultado = "Miercoles";
break;
case 5:
resultado = "Jueves";
break;
case 6:
resultado = "Viernes";
break;
www.learning.es
}
System.out.println("--------------------------------------------------------");
System.out.println("El dia de la semana de su nacimiento fue: " + resultado);

lector.readLine();
}
}
Actividades
eLearning.
www.learning.es
Unidad 7. Usando Loops
Introduccin
Dentro de cualquier lenguaje de programacin existen una serie de estructuras que nos permiten
poder definir una lgica no lineal para trabajar en la aplicacin.
En cualquier programa aparecen a menudo preguntas que necesitamos responder para que la
aplicacin realice una accin determinada u otra. Mediante las sentencias podemos realizar dicha
lgica y responder a las preguntas que vayan apareciendo dentro de un programa para hacer una
secuencia o una evaluacin de variables.
Objetivo
Manejar las sentencias condicionales que nos proporciona el lenguaje Java.
Utilizacin de sentencias iterativas para solucionar problemas de lgica en aplicaciones.
Sentencia if-else
Permite seleccionar la ejecucin de distintos fragmentos de cdigo dependiendo del resultado de la
valoracin de una expresin booleana.
Su sintaxis es la siguiente:
if (expresion_booleana 1) { // La expresin booleana expresa condiciones

...
// cdigo que se ejecuta si la expresin devuelve true
...
} else if (expresin boolean 2) {
...
// cdigo que se ejecuta si la expresin devuelve true
...
} else {
// cdigo que se ejecuta si la expresin devuelve false
}
El uso de else es opcional.

La expresin booleana puede contener operadores relacionales para encadenar condiciones.
Vamos a visualizar un ejemplo prctico en el que compararemos el valor de una variable utilzando
If, Else y Else If:
public class ClaseIfElse
{
{
int i=0;
String mensaje="";
if (i>0)
{
mensaje = "Positivo";
}else if (i<0)
{
mensaje = "Negativo";
}else
{
mensaje = "Cero";
www.learning.es
}
System.out.println("El valor de i es " + mensaje);
}
}
Comprobaremos que entra en el ltimo IF debido a que ya ha evaluado el resto de expresiones que
hemos escrito en las condiciones del cdigo.
Sentencia switch-case
Se utiliza cuando se quieren analizar muchas posibilidades de una nica variable o expresin.
Su sintaxis es la siguiente:
switch (expresin)
{
case valor1:
sentencias1;
break;
case valor2:
sentencias2;
break;
case valor3:
sentencias3;
break;
case valor4:
sentencias4;
break;
default:
sentencias_default
break;
}
La expresin puede devolver cualquier tipo bsico, y cada uno de los valores especificados en las
sentencias case debe ser un tipo compatible.
La sentencia default es opcional y se ejecutar en todos los casos en el que el valor devuelto por
expresin no coincida con los especificados en los case.
La sentencia break (sin etiqueta) hace que se salga del dominio de la sentencia switch. Con ello se
evita que se valoren todas las opciones que quedan una vez que se ha encontrado la correcta. Es
opcional.
Se leeran todas las sentencias en cascada hasta que encuentre un break para cortar la ejecucin de
las acciones.
Vamos a visualizar un ejemplo en el evaluaremos una variables entera y mostraremos un mensaje
dependiendo del valor obtenido en los diferentes casos que escribamos en el programa.
public class EjemploSwitch
www.learning.es
{
{
String mensaje="";
int i=2;
switch (i)
{
case 0:
mensaje = "El nmero es cero";
break;
case 1:
mensaje = "El nmero es uno";
break;
case 2:
mensaje = "El nmero es dos";
break;
case 3:
mensaje = "El nmero es tres";
break;
case 4:
case 5:
case 6:
mensaje = "El nmero es cuatro, cinco o seis";
break;
default:
mensaje = "El nmero es otro no evaluado";
}
System.out.println("He salido del Switch");
System.out.println("El mensaje es " + mensaje);
}
}
Como resultado de la aplicacin visualizaremos:
Podremos ir cambiando el valor de la variable para ir visualizando las diferentes opciones y el

comportamiento de la expresin condicional switch.
Sentencia while
Ejecuta repetidamente un conjunto de sentencias mientras una expresin booleana sea verdadera.
Su sintaxis es:
www.learning.es
while (Expresin_booleana) { //Condicin de permanencia
...
sentencias;
...
}
Dentro del bucle se deber alterar la variable que controla el bucle de lo contrario nunca se dejar
de cumplir la condicin.
Se puede realizar un bucle infinito si no se incluye una salida dentro del bucle para finalizar su
ejecucin.
Para visualizar el comportamiento del bucle while vamos a crearnos un ejemplo prctico en el que
incrementaremos una variable entera.
public class EjemploWhile
{
{
String mensaje="";
int i=0;
while (i <= 10)
{
i++;
System.out.println("Valor de i: " + i);
}
}
}
Podemos comprobar que la ejecucin del programa permanece en el bucle hasta que la variable
alcanza la condicin deseada.
Sentencia do-while
Igual que la sentencia while, pero las sentencias se ejecutan al menos una vez antes de valorar las
expresin, eso nos permite saber que al menos se ejecutar la sentencia del bucle una vez,
permitindonos evaluar posteriormente.
Su sintaxis:
www.learning.es
do {
...
sentencias;
...
} while (Expresin_booleana);
Vamos a realizar un ejemplo prctico para visualizar el comportamiento de ste tipo de sentencia.
Lo que haremos ser crearnos una variable con valor superior a la condicin del bucle y podremos
comprobar que primero entra en el bucle y despus evalua el valor de la variable creada.
public class EjemploDoWhile
{
{
String mensaje="";
int i=20;
System.out.println("Estoy al inicio del bucle");
do
{
i++;
}while (i <= 10);
System.out.println("Fin del bucle");
}
}
La accin se realiza al menos una vez, que es la principal caracterstica de ste tipo de bucle.
Sentencia for
Este bucle permite establecer la inicializacin de la variable que controla el bucle, su variacin y la
condicin de permanencia, en la propia definicin del for.
Es un bucle numrico, por lo que su condicin de salida se establece en el nmero de veces que
estar dentro del bucle, permitindonos controlar totalmente el nmero exacto de repeticiones en
las que se realizar una misma accin.
Su sintaxis:
www.learning.es
for (inicializacin; condicin de permanencia; variacin){
...
sentencias
...
}
La inicializacin hace referencia a la variable de control del bucle.
La condicin de permanencia es una expresin booleana donde debe encontrarse la variable de

control.
La actualizacin hace referencia a la variable de control.
Vamos a visualizar un ejemplo en el que mostraremos los nmeros pares que hay entre 0 y 20.
Para ello utilizaremos un bucle contador debido a que sabemos el nmero exacto de veces que tiene
que repetir la accin:
public class EjemploFor

{
{
System.out.println("Numeros pares");
for (int i=0; i<20;i++)
{
if (i%2==0)
{
}
}
}
}
Existen mltiples combinaciones, tambin podramos cambiar el incremento del bucle para que
realice la accin de dos en dos y no evalue el valor de la variable.
public class EjemploFor

{
{
www.learning.es
System.out.println("Numeros pares");
for (int i=0; i<20;i+=2)
{
}
}
}
Podremos comprobar que la ejecucin es la misma en el programa:
Ver Video: Validar ISBN, en la Unidad 7, en el Mdulo 1, en la

plataforma elearning
Laboratorio: Conjetura Collatz

Objetivo
Aprender a manejar las sentencias condicionales y los bucles.
Enunciado
Crear una aplicacin en la que validaremos la secuencia de Collatz. Pediremos un nmero al usuario
y debemos representar todos la secuencia de nmeros de Collatz para comprobar que es correcta.
La conjetura de Collatz es una regla matemtica y su teora es la siguiente:
Todo nmero entero mediante una secuencia llegar a ser 1.
Si el nmero entero es par, lo divideremos entre 2.
Si el nmero entero es impar, lo multiplicaremos por 3 y le sumaremos uno al resultado.
Siguiendo sta secuencia, debemos llegar al nmero uno para todo nmero entero.
Debemos pedir nmeros al usuario hasta que introduzca por teclado un valor numrico, si introduce
una letra, debemos pedirle de nuevo otro nmero hasta que nos ofrezca un valor correcto.
www.learning.es
Solucin: CDIGO JAVA
Imports System.Threading
import java.io.*;
public class ConjeturaCollatz
{
{
boolean esnumero = false;
int numero = 1;
do
{
try
{
System.out.println("Introduzca un numero....");
BufferedReader lector=new BufferedReader(new InputStreamReader(System.in));
String dato = lector.readLine();
numero = Integer.parseInt(dato);
esnumero = true;
}catch (Exception ex)
{
esnumero = false;
}
}while (esnumero==false);
System.out.println("SECUENCIA DE COLLATZ");
System.out.println("--------------------------");
while (numero!=1)
{
if (numero%2==0)
{
numero = numero / 2;
}else{
numero = (numero * 3) + 1;
}
System.out.println(numero);
}
}
}
Actividades
www.learning.es
eLearning.
www.learning.es
Unidad 8. Desarrollando y usando mtodos
Introduccin
Los mtodos son acciones que se realizan sobre un objeto determinado. Son una parte muy
importante en el momento de utilizar o crear cualquier objeto.
Si ponemos como ejemplo cualquier objeto del mundo real, descubriremos que tiene unos mtodos
que accionamos y que realizan acciones. Poniendo el ejemplo de un coche, dicho objeto contiene las
acciones de arrancar, frenar o girar. Esos mtodos nos llevan a poder controlar el objeto y
manejarlo.
En programacin y en el lenguaje Java sucede lo mismo con cualquier objeto que necesitemos,
podremos realizar acciones sobre l para controlar la actividad de nuestra aplicacin.
Objetivos
Aprender el concepto de mtodo dentro del lenguaje Java.
Conocer las ventajas de aplicar mtodos en las clases, as como realizar llamadas a mtodos
creados en clases referenciadas y static.
Mtodos (Funciones Miembro)

Los mtodos son acciones que se realizan sobre una clase o sobre un objeto, dependiendo de la
declaracin del mtodo.
Normalmente los mtodos se pueden dividir en aquellos que son usados internamente dentro de la
propia clase, llamados mtodos privados (private), los que se utilizan fuera de la clase, llamados
mtodos pblicos (public) y los que son usados por la clase y las clases que heredan de ellos,
llamados mtodos protegidos (protected).
Los mtodos privados son, generalmente, llamados en el interior del objeto por otras partes del
mismo.
Una vez que se tiene un objeto que soporta mtodos, se pueden usar los mtodos de esos objetos.
Mtodos de objeto
Los mtodos son funciones definidas dentro de una clase. Salvo los mtodos static o de clase, se
aplican siempre a un objeto de la clase por medio del operador punto . Dicho objeto es su
argumento implcito.
Los mtodos pueden tener otros argumentos explcitos que se introducen entre parntesis, a
continuacin del nombre del mtodo.
La primera lnea de la definicin de un mtodo se llama declaracin o cabecera; el cdigo
comprendido entre las llaves {} es el cuerpo o body del mtodo.
Podemos verlo claramente con un ejemplo de la clase Coche:
public string devolverModelo()
{ // header y comienzo del mtodo
return BMW; // body
} // final del mtodo
La cabecera consta del mbito de acceso (public,prvate o protected), del tipo del valor de
devolucin (un tipo de la clase string en este caso), del nombre del mtodo y de una lista de
www.learning.es
argumentos explcitos entre parntesis, separados por comas. Si no hay argumentos explcitos se
dejan los parntesis vacos (como en ste ejemplo exactamente).
Los mtodos tienen visibilidad directa de las variables miembro del objeto que es su argumento
implcito, es decir, pueden acceder a ellas sin definirlas con un nombre de objeto y el operador
punto (.). De todas formas, tambin se puede acceder a ellas mediante la referencia this.
El valor de devolucin puede ser un valor de un tipo primitivo o una referencia a otro objeto. En
cualquier caso no puede existir ms que un nico valor de retorno (que puede ser un objeto o un
array). Se puede devolver tambin una referencia a un objeto por medio de un nombre de variable.
Se puede devolver como valor de retorno un objeto de la misma clase que el mtodo o de una
subclase, pero nunca de una superclase.
Los mtodos pueden definir variables locales. Su visibilidad llega desde la definicin al final del
bloque en el que han sido definidas. No es necesario inicializar las variables locales en el punto en
que se definen, pero el compilador no permite utilizarlas sin haberles dado un valor inicial. A
diferencia de las variables miembro, las variables locales no se inicializan por defecto.
Vamos a visualizar un ejemplo en el que nos crearemos mtodos de objeto.
Tendremos varios mtodos que devuelven un valor y otro mtodo (void) que realizar una accin sin
almacenar su valor:
{
private double PI = 3.1416;
public int dividirnumero(int numero, int divisor)

{
int resultado;
resultado = numero / divisor;
return resultado;
}
public int devolverCuadrado(int numero)

{
int resultado;
resultado = numero * numero;
return resultado;
}
public int devolverCubo(int numero)

{
int resultado;
resultado = numero * numero * numero;
return resultado;
}
public void mostrarPI()

{
System.out.println("Numero PI: " + this.PI);
}
}
Ahora podemos probar los mtodos que hemos creado en una clase:
public class PruebaMetodos
{
{
ClaseMatematicas c = new ClaseMatematicas();
www.learning.es
int num = 4;
int resultado;
System.out.println("El numero inicial es: " + num);
resultado = c.dividirnumero(num, 2);
System.out.println("El numero dividido entre dos es: " +
resultado);
resultado = c.devolverCuadrado(num);
System.out.println("El cuadrado del numero es: " + resultado);
resultado = c.devolverCubo(num);
System.out.println("El cubo del numero es: " + resultado);
c.mostrarPI();
}
}
Como podemos comprobar, los mtodos que devuelven valor debemos almacenarlos en variables
que corresponden con el valor devuelto (en nuestro ejemplo int). Mientras que los mtodos void
son mtodos de accin y no es necesario almacenar su valor en ninguna variable.
Parmetros en los mtodos

En Java los argumentos de los tipos primitivos se pasan siempre por valor. El mtodo recibe una
copia del argumento actual. Si se modifica esta copia, el argumento original que se incluy en la
llamada no queda modificado. La forma de modificar dentro de un mtodo una variable de un tipo
primitivo es incluirla como variable miembro en una clase y pasar como argumento una referencia a
un objeto de dicha clase. Las referencias se pasan tambin por valor, pero a travs de ellas se
pueden modificar los objetos referenciados.
Dentro de un mtodo se pueden crear variables locales de los tipos primitivos o referencias. Dichas
variables locales dejan de existir al terminar la ejecucin del mtodo. Los argumentos formales de
un mtodo (las variables que aparecen en la cabecera del mtodo para recibir el valor de los
argumentos actuales) tienen mbito de variables locales del mtodo.
Si un mtodo devuelve this, es decir, un objeto de la clase o una referencia a otro objeto, ese objeto
puede encadenarse con otra llamada a otro mtodo de la misma o de diferente clase y as
consecutivamente.
Vamos a visualizar un ejemplo en el que enviaremos una variable a un mtodo y modificaremos su
valor, visualizando que el valor de dicha variable no cambiar, ya que estamos enviando el valor del
objeto, no la referencia.
Nos vamos a crear una clase llamada ClaseMatematicas e inlcuiremos un mtodo llamado multiplicar
que recibe un nmero como argumento. Lo que haremos ser multiplicar el nmero por dos.
www.learning.es
{
public void multiplicar(int numero)
{
numero = numero * 2;
}
}
A continuacin nos crearemos una clase que implemente dicho mtodo y le pasaremos un nmero
como valor para visualizar el resultado:
{
{
int num = 33;
c.multiplicar(num);
System.out.println("El doble del numero es: " + num);
}
}
Como podemos comprobar, el nmero enviado no se modifica, solamente es modificado su valor,

por lo que no se enva la referencia al objeto, sino su valor, lo que en realidad se est modificando y
multiplicando es la variable llamada numero de la clase ClaseMatematicas. Para solucionar el
problema, habra que crearse un mtodo que devolviese un valor:
{
public int multiplicar(int numero)
{
numero = numero * 2;
return numero;
}
}
Posteriormente, al utilizar el mtodo, guardaramos el valor de retorno dentro de una variable, en
nuestro ejemplo es la misma variable:
{
{
int num = 33;
System.out.println("El numero enviado es: " + num);
num = c.multiplicar(num);
System.out.println("El doble del numero es: " + num);
}
}
www.learning.es
Vemos que como resultado, la accin se realiza correctamente. Antes tambin estaba haciendo la
accin correctamente, pero habamos creado un mtodo void y no devolva ningn valor y la
variable nmero quedaba encapsulada dentro de la clase.
Mtodos sobrecargados (overloaded)

Java permite mtodos sobrecargados (overloaded), es decir, mtodos distintos que tienen el mismo
nombre, pero que se diferencian por el nmero y/o tipo de los argumentos.
A la hora de llamar a un mtodo sobrecargado, Java sigue unas reglas para determinar el mtodo
concreto que debe llamar:
Si existe el mtodo cuyos argumentos se ajustan exactamente al tipo de los argumentos de
la llamada (argumentos actuales), se llama ese mtodo.
Si no existe un mtodo que se ajuste exactamente, se intenta promover los argumentos
actuales al tipo inmediatamente superior (por ejemplo char a int, int a long, float a double,
etc.) y se llama el mtodo correspondiente.
Si slo existen mtodos con argumentos de un tipo ms restringido (por ejemplo, int en vez
de long), el programador debe hacer un cast explcito en la llamada, responsabilizndose de
esta manera de lo que pueda ocurrir.
El valor de retorno no influye en la eleccin del mtodo sobrecargado. En realidad es
imposible saber desde el propio mtodo lo que se va a hacer con l. No es posible crear dos
mtodos sobrecargados, es decir con el mismo nombre, que slo difieran en el valor de
retorno.
Diferente de la sobrecarga de mtodos es la redefinicin. Una clase puede redefinir (override) un

mtodo heredado de una superclase. Redefinir un mtodo es dar una nueva definicin.
En este caso el mtodo debe tener exactamente los mismos argumentos en tipo y nmero que el
mtodo redefinido.
La sobrecarga de mtodos es muy sencilla de visualizar en la prctica, es un mtodo que se llama
igual pero que tienen diferentes formas, expresadas en el nmero de argumentos y el tipo de
argumentos que recibe el mtodo.
Por ejemplo, vamos a realizar una sobrecarga del mtodo multiplicar de la clase matemticas:
{
public int multiplicar(int numero)
{
int resultado;
resultado = numero * 2;
return resultado;
}
www.learning.es
public int multiplicar(int numero, int multiplicador)
{
int resultado;
resultado = numero * multiplicador;
return resultado;
}
}
Tenemos dos mtodos con el mismo nombre, pero con diferentes argumentos. Cuando realicemos
la llamada al mtodo comprobaremos que entrar en el primer mtodo cuando slo reciba un
parmetro y en el segundo cuando reciba dos parmetros.
{
{
int num = 9;
System.out.println("El numero enviado es: " + num);
int resultado;
resultado = c.multiplicar(num);
System.out.println("Resultado de multiplicar con un parametro: "
+ resultado);
resultado = c.multiplicar(num, 9);
System.out.println("Resultado de multiplicar con varios
parametros: " + resultado);
}
}
Como podemos comprobar en la pantalla de resultado, la accin de la aplicacin leer cada mtodo
de la ClaseMatematicas dependiendo de los argumentos que se le enven en la llamada:
Mtodos de clase (static)

De la misma forma que existen mtodos de objeto, puede tambin haber mtodos que no acten
sobre objetos concretos a travs del operador punto. A estos mtodos se les llama mtodos de clase
o static.
Los mtodos de clase pueden recibir objetos de su clase como argumentos explcitos, pero no tienen
argumento implcito ni pueden utilizar la referencia this ni Me. Un ejemplo tpico de mtodos static
son los mtodos matemticos de la clase Math (sin(), cos(), abs(), pow(), etc.). El argumento de
estos mtodos ser de un tipo primitivo y se le pasar como argumento explcito. Estos mtodos no
tienen sentido como mtodos de objeto.
Los mtodos y variables de clase se crean anteponiendo la palabra static a la definicin del
mtodo, igual que hemos visto que sucede con las variables miembro de una clase. Para llamarlos
www.learning.es
se suele utilizar el nombre de la clase, en lugar del nombre de un objeto de la clase (por ejemplo,
Math.sin(ang), para calcular el seno de un ngulo).
Mtodos Constructores
Un punto clave de la Programacin Orientada Objetos es el evitar informacin incorrecta por no
haber sido correctamente inicializadas las variables. Java no permite que existan variables miembro
que no estn inicializadas
Java inicializa con valores por defecto las variables miembro de clases y objetos. El paso correcto
sera la inicializacin de objetos en los constructores.
Un constructor es un mtodo que se llama automticamente cada vez que se crea un objeto de una
clase. La principal misin del constructor es reservar memoria e inicializar variables miembro de la
clase.
Los constructores no tienen valores de devolucin y su nombre es el mismo que el de la clase. Su
argumento implcito es el objeto que se est creando.
Una clase puede contener varios constructores, que se diferencian por el tipo y nmero de sus
argumentos, al igual que sucede con los mtodos sobrecargados. Se llama constructor por defecto
al constructor que no tiene argumentos. El programador debe proporcionar en el cdigo valores
iniciales adecuados para todas las variables miembro.
Un constructor de una clase puede llamar a otro constructor previamente definido en la misma
clase por medio de la palabra this. En este contexto, la palabra this slo puede aparecer en la
primera sentencia de un constructor.
El constructor de una subclase puede llamar al constructor de su superclase por medio de la palabra
super, seguida de los argumentos apropiados entre parntesis. De esta forma, un constructor slo
tiene que inicializar por s mismo las variables no heredadas.
El constructor es tan importante que, si el programador no prepara ningn constructor para una
clase, el compilador crea un constructor por defecto, inicializando las variables de los tipos
primitivos a su valor por defecto, y los Strings y las dems referencias a objetos a null.
Al igual que los dems mtodos de una clase, los constructores pueden tener tambin los
modificadores de acceso public, private, protected. Si un constructor es private, ninguna otra clase
puede crear un objeto de esa clase. En este caso, puede haber mtodos public y static que llamen
al constructor y devuelvan un objeto de esa clase.
Dentro de una clase, los constructores slo pueden ser llamados por otros constructores o por
mtodos static. No pueden ser llamados por los mtodos de objeto de la clase.
Destruccin de objetos
En Java no existen destructores de memoria. El sistema se encarga automticamente de liberar la
memoria de los objetos que ya han perdido la referencia, es decir, objetos que ya no tienen ningn
nombre que permita acceder a ellos. Al llegar al final de un bloque en el que haban sido definidos,
porque a la referencia se le ha asignado el valor null o porque a la referencia se le ha asignado la
direccin de otro objeto. A esta funcionalidad de Java se le llama garbage collection, recoleccin de
basura.
En Java es normal que varias variables de tipo referencia apunten al mismo objeto. Java lleva
internamente un contador de cuntas referencias hay sobre cada objeto. El objeto podr ser borrado
cuando el nmero de referencias sea cero. Como ya se ha dicho, una forma de hacer que un objeto
quede sin referencia es cambiar sta a null, haciendo por ejemplo:
ObjetoReferenciado = null;
www.learning.es
En Java no se sabe exactamente cundo se va a activar el garbage collector. Si no falta memoria
es posible que no se llegue a activar en ningn momento.
Se puede llamar explcitamente al garbage collector con el mtodo System.gc(), aunque esto es
slo una sugerencia, ya que posteriormente, se le llamar de nuevo y no es conveniente realizar la
llamada, ya que sera hacer la misma accin dos veces, una por nuestra llamada y otra por la
llamada automtica.
Mtodos Finalizadores
Los finalizadores son mtodos que vienen a completar la labor del garbage collector. Un finalizador
es un mtodo que se llama automticamente cuando se va a destruir un objeto, justo antes de que
la memoria sea liberada de modo automtico por el sistema. Se utilizan para ciertas operaciones de
finalizacin distintas de liberar memoria, como podra ser cerrar ficheros que tengamos abiertos
para la aplicacin o cerrar conexiones de acceso a datos que hayamos abierto previamente.
Un finalizador es un mtodo de objeto sin valor de retorno, sin argumentos y que siempre se debe
denominar con el nombre de finalize(). Los finalizadores se llaman de modo automtico siempre
que hayan sido definidos por el programador de la clase. Para realizar su tarea correctamente, un
finalizador debera terminar siempre llamando al finalizador de su superclase.
Tampoco se puede saber el momento preciso en que los finalizadores van a ser llamados.
Definicin de mtodos heredados (override)

Una clase puede redefinir cualquiera de los mtodos heredados de su superclase que no estn
definidos como final. El nuevo mtodo sustituye al heredado para todos los efectos en la clase que
lo ha redefinido.
Los mtodos de la super-clase que han sido redefinidos pueden ser todava accedidos por medio de
la palabra super desde los mtodos de la clase derivada, aunque con este sistema slo se puede
subir un nivel en la jerarqua de clases.
Los mtodos redefinidos pueden ampliar los derechos de acceso de la superclase, como por
ejemplo ser public, en lugar de protected, pero nunca restringirlos.
Los mtodos de clase o static no pueden ser redefinidos en las clases derivadas.
Clases y mtodos abstractos

Una clase abstracta (abstract) es una clase de la que no se pueden crear objetos. Su utilidad es
permitir que otras clases deriven de ella, proporcionndoles un marco o modelo que deben seguir y
algunos mtodos de utilidad general. Las clases abstractas se declaran incluyendo la palabra
abstract antes de su definicin:
public abstract class ClaseAbstracta
{
}
Una clase abstracta puede contener mtodos definidos como abstract, en cuyo caso no se
implementa la accin del mtodo, solamente se define su cabecera. Si una clase tiene algn
mtodo abstracto es obligatorio que la clase sea abstract.
El hecho de definir un mtodo como abstract implica que cualquier clase que herede de mi clase,
deber sobreescribir dicho mtodo e implementarlo.
Una clase abstracta puede contener mtodos que no son abstractos. Dichos mtodos son mtodos
de objeto como cualquier clase, deben tener una definicin (cabecera) y una implementacin (accin
del mtodo).
Como los mtodos static no pueden ser redefinidos, un mtodo abstract no puede ser static.
Clases y mtodos finales
www.learning.es
Debemos recordar que los miembros (variables) declarados como final no pueden cambiar su valor
una vez que han sido inicializadas.
Una clase declarada final no puede tener clases derivadas, es decir, no puede ser heredada. Esto se
puede realizar por causas de seguridad y tambin por causas de eficiencia, debido a que cuando el
compilador reconoce que los mtodos no van a ser redefinidos puede hacer optimizaciones
adicionales.
Igualmente, un mtodo declarado como final no puede ser redefinido por una clase que derive de
su propia clase, es decir, no puede haber sobreescritura del mtodo en sus clase derivadas.
Ver Video: Tipos de mtodos, en la Unidad 8, en el Mdulo 1,

Laboratorio: Creacin del objeto Calculadora

Objetivos
Aprender los diferentes tipos de mtodos que existen en la programacin Java.
Conocer las diferencias entre los constructores, mtodos estticos y mtodos de objeto.
Enunciado
Realizar una aplicacin en la que podremos realizar operaciones sobre dos nmeros pedidos al
usuario.
Crearemos una clase llamada Calculadora que podr realizar todas las operaciones mediante
mtodos de objeto o estticos, dependiendo de su funcionalidad.
Las acciones como restar, multiplicar, sumar o dividir sern mtodos de objeto y utilizarn las
variables miembro de la Calculadora.
Las acciones como mostrar nmero aleatorio o averiguar el nmero mayor entre varios nmeros
sern mtodos static.
Tendremos una sobrecarga en el mtodo numero mayor que pedir tres nmeros.
Crearemos dos constructores dnde inicializaremos los nmeros miembros de la clase.
Un constructor inicializar los datos a cero, mientras que otro constructor tendr argumentos que
inicializarn los miembros internos de la clase.
Crearemos un mtodo privado de la clase que comprobar si los datos enviados son nmeros.
Crearemos un mtodo static para mostrar el men de la calculadora:
Menu Calculadora
1.- Sumar
2.- Restar
3.- Dividir
4.- Multiplicar
5.- Resto
6.- Mayor 2 numeros
7.- Mayor 3 numeros
8.- Potencia
9.- Numero aleatorio
0.- SALIR
Seleccione una opcin
www.learning.es
Crearemos una clase para comprobar que todo funciona y que los conceptos de mtodos sobre la
clase calculadora han quedado claros.
Solucin:
CDIGO JAVA
CODIGO DE LA CLASE CALCULADORA
public class Calculadora
{
public static final double PI = 3.141592;
public int numero1;
public int numero2;
public Calculadora()
{
numero1 = 0;
numero2 = 0;
}
public Calculadora(int num1, int num2)

{
numero1 = num1;
numero2 = num2;
}
public void setNumero1(String dato)

{
if (this.comprobarNumero(dato)==true)
{
this.numero1 = Integer.parseInt(dato);
}else
{
this.numero1 = 0;
}
}
public int getNumero1()

{
return this.numero1;
}
www.learning.es
public void setNumero2(String dato)
{
if (this.comprobarNumero(dato)==true)
{
this.numero2 = Integer.parseInt(dato);
}else
{
this.numero2 = 0;
}
}
public int getNumero2()

{
return this.numero2;
}
public int sumarNumeros()

{
return numero1 + numero2;
}
public int restarNumeros()

{
return numero1 - numero2;
}
public int dividirNumeros()

{
return numero1 / numero2;
}
public int multiplicarNumeros()

{
return numero1 * numero2;
}
public int restoNumeros()

{
return numero1 % numero2;
}
public int numeroMayor()

{
if (numero1 > numero2)
{
return numero1;
}else{
return numero2;
}
}
public static int numeroMayor(int num1, int num2, int num3)

{
if (num1 > num2 && num1 > num3)
{
return num1;
}else if (num2 > num1 && num2 > num3)
www.learning.es
{
return num2;
}else{
return num3;
}
}
public static int calcularPotencia(int num, int potencia)

{
int resultado = 0;
for (int i = 1; i < potencia; i++)
{
resultado += num * num;
}
return resultado;
}
public static int devolverAleatorio(int rangomaximo)

{
int resultado = (int)(Math.random() * rangomaximo);
return resultado;
}
public static void mostrarMenu()

{
System.out.println("Menu Calculadora");
System.out.println("1.- Sumar");
System.out.println("2.- Restar");
System.out.println("3.- Dividir");
System.out.println("4.- Multiplicar");
System.out.println("5.- Resto");
System.out.println("6.- Mayor 2 numeros");
System.out.println("7.- Mayor 3 numeros");
System.out.println("8.- Potencia");
System.out.println("9.- Numero aleatorio");
System.out.println("0.- SALIR");
System.out.println("Seleccione una opcion");
}
private boolean comprobarNumero(String dato)

{
try
{
int num = Integer.parseInt(dato);
return true;
}catch (Exception ex)
{
return false;
}
}
}
CODIGO DE LA CLASE PRUEBACALCULADORA
import java.io.*;
public class PruebaCalculadora
www.learning.es
{
{
BufferedReader lector=new BufferedReader(new InputStreamReader(System.in));
Calculadora c = new Calculadora();
System.out.println("Introduzca el numero 1");
String dato = lector.readLine();
c.setNumero1(dato);
System.out.println("Introduzca el numero 2");
dato = lector.readLine();
c.setNumero2(dato);
int opcion = 1;
int resultado = 0;
while (opcion != 0)
{
Calculadora.mostrarMenu();
opcion = Integer.parseInt(lector.readLine());
switch (opcion)
{
case 1:
resultado = c.sumarNumeros();
break;
case 2:
resultado = c.restarNumeros();
break;
case 3:
resultado = c.dividirNumeros();
break;
case 4:
resultado = c.multiplicarNumeros();
break;
case 5:
resultado = c.restoNumeros();
break;
case 6:
resultado = c.numeroMayor();
break;
case 7:
int num1, num2, num3;
System.out.println("Introduzca primer numero");
num1 = Integer.parseInt(lector.readLine());
System.out.println("Introduzca segundo numero");
System.out.println("Introduzca tercer numero");
resultado = Calculadora.numeroMayor(num1,num2,num3);
break;
case 8:
System.out.println("Introduzca primer numero");
System.out.println("Introduzca segundo numero");
resultado = Calculadora.calcularPotencia(num1,num2);
break;
case 9:
System.out.println("Introduzca el rango maximo del numero");
www.learning.es
resultado = Calculadora.devolverAleatorio(num1);
break;
}
System.out.println("---------------------------------");
}
System.out.println("---------------------------------");
System.out.println("Numero PI: " + Calculadora.PI);
}
}
Actividades
eLearning.
www.learning.es
Unidad 9. Implementando encapsulacin
Introduccin
La encapsulacin es un concepto muy simple. No dejaremos ver ningn elemento que no deseamos
que sea visualizado.
Dentro del mundo real tenemos muchos ejemplos que nos pueden llegar a hacer comprender dicho
concepto. Cuando utilizamos un mvil, todo el mundo sabe teclear los nmeros en la pantalla para
poder llamar a un nmero, pero la mayora no sabemos el proceso que se realiza internamente para
poder comunicarse con la otra persona a quin llamamos. Esto sucede porque quin ha creado el
mvil no vi necesario que supiramos los mecanismos internos que se necesitan para realizar una
llamada, solamente nos ofreci la forma de utilizar un mvil, no como funciona internamente ya
que no era necesario para nosotros.
El mismo concepto puede ser aplicado a la programacin. Mediante una serie de palabras clave y
conceptos, podemos ocultar al usuario cmo hemos realizado las acciones, simplemente le
dejaremos manejarlas, pero sin que conozca nuestro cdigo ni nuestros trucos.
Objetivos
Comprender los conceptos fundamentales de la programacin orientada a objetos con la
encapsulacin de miembros y mtodos.
Aplicar los conocimientos adquiridos durante el curso para proteger las variables y mtodos de
otras clases.
Paquetes
Un paquete es una coleccin de clases e interfaces relacionadas. El compilador de Java usa los
paquetes para organizar la compilacin y ejecucin. Es decir, un paquete es una biblioteca. De
hecho el nombre completo de una clase es el nombre del paquete en el que est la clase, punto y
luego el nombre de la clase. Es decir si la clase Coche est dentro del paquete mediotransporte, el
nombre completo de Coche es mediotransporte.Coche. A veces resulta que un paquete est dentro
de otro paquete, entonces habr que indicar la ruta completa a la clase, como si fuera un sistema de
archivos de un sistema operativo (para entrar en una subcarpeta, primero debemos pasar por la
primera carpeta, el hecho de abrir una carpeta no quiere decir que estemos visualizando los ficheros
que existen en alguna otra subcarpeta).
Mediante el comando import, se evita tener que colocar el nombre completo. El comando import se
coloca antes de definir la clase, fuera del cdigo de la clase como primera instruccin.
Por Ejemplo:
import mediotransporte.Coche;
Debido a esta instruccin para utilizar la clase Coche no hace falta indicar el paquete en el que se
encuentra, basta indicar slovCoche. Se puede utilizar el smbolo asterisco como comodn para
poder hacer referencia a todas las clase ubicadas dentro del paquete mediotransporte:
import mediotransporte.*;
Con sta instruccin no importa el contenido de los paquetes interiores a mediotransporte, (lo que
quiere decir que si la clase Coche est dentro del paquete mediotransporte motor, no sera
importada con esa instruccin, ya que el paquete motor no ha sido importado, s lo sera la clase
mediotransporte.BarcoDeVela). Por ello en el ejemplo lo completo sera
import mediotransporte.*;
import mediotransporte.Motor.*
www.learning.es
Cuando desde un programa se hace referencia a una determinada clase se busca sta en el paquete
en el que est colocada la clase y, sino se encuentra, en los paquetes que se han importado al
programa. Si ese nombre de clase se ha definido en un solo paquete, se usa. Si no es as podra
haber ambigedad por ello se debe usar un prefijo delante de la clase con el nombre del paquete.
Las clases son visibles en el mismo paquete a no ser que se las haya declarado con el modificador
private.
Para que una clase pertenezca a un determinado paquete, debemos incluir antes de la clase la
palabra reservada package.
package nombrepaquete;
public class MiClase
{
//CODIGO DE LA CLASE
}
Para poder compilar un paquete ser necesario crearnos un subdirectorio dentro del sistema de
ficheros con el mismo nombre de paquete que hayamos pensado.
Los paquetes se suelen escribir todos en minscula y las clases en Mayscula, es una buena prctica
hacerlo asi para mantener la coherencia del lenguaje de Java.
Veamos un ejemplo rpido:
package paqueteprueba;
public class PruebaPaquete
{
{
System.out.println("Estoy en el paqueteprueba");
}
}
Nos hemos creado una clase en el paquete denominado paqueteprueba. Debemos crearnos un
directorio llamado igual en nuestro sistema de ficheros.
Ahora para compilar, debemos situarnos en el directorio inmediatamente anterior (PracticasJava) y

ejecutar la siguiente sentencia:
javac paqueteprueba\PruebaPaquete.java
Se crear la clase con el paquete ya incluido:
www.learning.es
Ahora se nos ha generado el fichero class dentro del directorio paqueteprueba, solamente nos
quedara ejecutar la instruccin para visualizar la aplicacin ya compilada. Para ello, debemos
escribir el nombre del paquete seguido del nombre de la clase.
java paqueteprueba.PruebaPaquete
Y como vemos, el resultado es la clase compilada dentro de un paquete:
Modificadores de mbito
Los modificadores de mbito especifican la forma en que puede accederse a los mismos objetos
desde otras clases.
Estos modificadores de mbito son:
private
public
protected
sin especificar modificador
El modificador de mbito por defecto quiere decir que se declara la variable o mtodo sin indicar su
visibilidad para otros objetos.
Modificador private
El modificador de mbito private es el ms restrictivo de todos.
Todo elemento declarado como private, ya sea una clase, un mtodo o una propiedad es visible
nicamente dentro del mbito dnde se declara.
No existe ninguna forma de acceder al mismo si no es a travs de algn mtodo (no private) que
devuelva o modifique su valor.
Una buena metodologa de diseo de clases es declarar los atributos private siempre que sea
posible, ya que esto evita que algn objeto pueda modificar su valor si no es a travs de alguno de
sus mtodos diseados para ello.
Asi es como se crean lo que se llaman mtodos setter y getter. En realidad es cmo funcionan los
mtodos en java. Se accede a las variables miembros de la clase mediante mtodos get y set que
se llaman igual que el miembro de la clase.
www.learning.es
sta tcnica permite tambin controlar el acceso que se realiza sobre el valor de un miembro de la
clase y realizar acciones en el caso de que no nos guste el valor que se va a establecer para el
miembro.
Vamos a visualizar un ejemplo de las ventajas de utilizar acceso a las variables miembro a partir de
mtodos get y set.
Nos vamos a crear una clase Empleado:
public class Empleado
{
public String Nombre;
public String Apellidos;
public String NIF;
public int Salario;
public Empleado()
{
this.Nombre = "";
this.Apellidos = "";
this.NIF = "";
this.Salario = 0;
}
}
A continuacin vamos a utilizar la clase Empleado para introducir valores en sus miembros:
public class PruebaEncapsulacion
{
{
Empleado emp = new Empleado();
emp.Nombre = "Jose Maria";
emp.Apellidos = "Gutierrez Hernandez";
emp.NIF = "14141238G";
emp.Salario = -2000;
System.out.println("Nombre Empleado: " + emp.Nombre);
System.out.println("Apellidos Empleado: " + emp.Apellidos);
System.out.println("NIF Empleado: " + emp.NIF);
System.out.println("Salario Empleado: " + emp.Salario);
}
}
El resultado lo podemos comprobar cuando compilemos y ejecutemos la clase:
Todo est correcto y funciona perfectamente. Que sucede por ejemplo con el Salario?. Podemos
perfectamente dejarlo como est o podramos poner una condicin. En nuestro ejemplo el salario es
www.learning.es
negativo, pero puestos a pensar en la lgica de la aplicacin, un salario nunca podra estar en
negativo, al igual que el NIF debera de tener una coherencia y controlar que todo est correcto,
nmero de elementos o que la letra se corresponda.
Si nos planteamos el punto de vista de control de acceso a los miembros, no podemos hacer nada
tal y como tenemos planteada la aplicacin, ya que el acceso a la variable NIF o salario es inmediato
a travs de la clase Empleado.
En ese caso es dnde nacen los mtodos get y set. En realidad lo que se realiza es lo siguiente. Los
miembros de la clase son privados, mientras que los mtodos de acceso son pblicos, de forma que
podemos controlar los valores que el usuario nos proporciona desde el mtodo y decidir que hacer
en el caso que no nos gusten los valores adecuados para nuestro miembro.
El mtodo set establece el valor para el miembro y debe ser un mtodo de accin, por lo que lo
declararemos como void.
El mtodo get devuelve el valor del miembro, por lo que debe devolver el mismo tipo de dato que el
miembro que est manejando.
La sintaxis sera la siguiente:
private String Miembro;
public String getMiembro()
{
//Devolvemos el valor del miembro
return this.Miembro;
}
public void setMiembro(String valor)
{
//Asignamos el valor del miembro
this.Miembro = valor;;
}
Veamos el ejemplo tal y cmo sera correcto implementando la encapsulacin:
{
private String Nombre;
private String Apellidos;
private String NIF;
private int Salario;
public Empleado()
{
this.Nombre = "";
this.Apellidos = "";
this.NIF = "";
this.Salario = 0;
}
public String getNombre()

{
return this.Nombre;
}
public void setNombre(String nom)

{
this.Nombre = nom;
}
public String getApellidos()
www.learning.es
{
return this.Apellidos;
}
public void setApellidos(String ape)

{
this.Apellidos = ape;
}
public String getNIF()

{
return this.NIF;
}
public void setNIF(String nif)

{
this.NIF = nif;
}
public int getSalario()

{
return this.Salario;
}
public void setSalario(int sal)

{
if (sal > 0)
{
this.Salario = sal;
}else{
this.Salario = 800;
}
}
}
Ahora podemos utilizar de nuevo la clase Empleado, pero solamente nos est ofreciendo acceso
desde los mtodos set y get:

{
{
emp.setNombre("Jose Maria");
emp.setApellidos("Gutierrez Hernandez");
emp.setNIF("14141238G");
emp.setSalario(-2000);
System.out.println("Nombre Empleado: " + emp.getNombre());
System.out.println("Apellidos Empleado: " + emp.getApellidos());
System.out.println("NIF Empleado: " + emp.getNIF());
System.out.println("Salario Empleado: " + emp.getSalario());
}
}
Como podemos comprobar en la imagen, un Empleado nunca podr tener un Salario menor a cero,
si se diese el caso (como en el ejemplo -2000), automticamente, le cambiamos el valor del Salario
www.learning.es
a 800. Esto es un control de acceso a los miembros de la clase y es uno de los elementos ms
importantes dentro de la encapsulacin.
Modificador public
El modificador de acceso public es el menos restrictivo de todos. Un atributo public ser visible en
cualquier clase, propiedad o mtodo que desee acceder a l, simplemente anteponiendo el nombre
de la clase.
Las aplicaciones bien diseadas minimizan el uso del modificador de acceso public y maximizan el
uso del modificador private. La forma apropiada de acceder y modificar propiedades o mtodos es a
travs de propiedades privadas y mtodos public como ya hemos visto, de forma que se accede a
una propiedad a travs de mtodos que accedan a los mismos, aunque en ocasiones, para acelerar
el proceso de programacin, se declaran de tipo public y se modifican sus valores desde otras
clases, pero esto no es una buena praxis.
Modificador protected
Los atributosprotected pueden ser accedidos por las clases del mismo paquete (package) y por las
subclases del mismo paquete, pero no pueden ser accedidos por subclases de otro paquete, aunque
s pueden ser accedidas las variables protected.
Es muy sencillo, los miembros declarados como protected son accesibles desde las clases del mismo
paquete. Si nos situamos en otro paquete, solamente accedern los miembros que hereden
directamente de la clase en cuestin. Son miembros protegidos y es un modificador que sirve
bsicamente para la herencia.
Vamos a visualizarlo en un sencillo ejemplo prctico. Nos vamos a crear la clase Empleado. Nos
vamos a declarar una variable protected a la que llamaremos SalarioMinimo.
La clase empleado ir en el paquete llamado personasempresa.
Lo que haremos en la clase Empleado ser controlar que el usuario no pueda igualar un salario
inferior al salario minimo del empleado, en ste caso a 600.
package personasempresa;
{
private String Nombre;
private int Salario;
protected int SalarioMinimo;
public Empleado()
{
this.Nombre = "";
this.Salario = 0;
this.SalarioMinimo = 600;
}
{
www.learning.es
return this.Nombre;
}
{
this.Nombre = nom;
}
public int getSalario()
{
return this.Salario;
}
public void setSalario(int sal)
{
if (sal > 0)
{
this.Salario = sal;
}else if (sal < this.SalarioMinimo)
{
this.Salario = this.SalarioMinimo;
}
}
}
Ahora compilaremos la clase empleado y no deberamos tener ningn error. Debemos recordar que
tenemos que crearnos una carpeta con el mismo nombre del paquete y compilar la clase dentro de
dicha carpeta.
Una vez compilada la clase, lo que haremos ser crearnos otra clase que utilizar el paquete y la
clase empleado para intentar modificar el SalarioMinimo del empleado.
import personasempresa.*;
{
{
emp.SalarioMinimo = 200;
System.out.println("El salario minimo del empleado es: " +
emp.SalarioMinimo);
}
}
www.learning.es
Como podemos comprobar, el acceso al miembro SalarioMinimo nos indica que est protegido, por
lo que no podemos acceder a dicho miembro.
Para saber si podemos obtener acceso tenemos que hacernos una pregunta que nos resolver
muchas dudas de acceso a un miembro.
La clase PruebaEncapsulacion es un Empleado? La respuesta es NO. La clase PruebaEncapsulacion
utiliza un empleado.
Ahora lo que vamos a hacer ser crearnos una clase llamada Ejecutivo que heredar de la clase
Empleado, y veremos que aunque no se encuentre en el mismo paquete podr acceder al miembro
SalarioMinimo.
import personasempresa.*;
public class Ejecutivo extends Empleado
{
public Ejecutivo()
{
this.SalarioMinimo = 1250;
}
}
Compilamos la clase y veremos que no existe ningn error, por lo que nos permite el acceso al
miembro protegido SalarioMinimo.
Ahora si podemos plantearnos la pregunta de nuevo:
La clase Ejecutivo es un Empleado? La respuesta es SI. La clase Ejecutivo es un empleado y, por
lo tanto, puede utilizar el miembro SalarioMinimo.
Modificador por defecto de los atributos

Los atributos que no llevan ningn modificador de mbito pueden ser accedidos desde las clases del
mismo paquete, pero no desde otros paquetes.
ste cuadro representa un resumen de los diferentes modificadores que existen:
MODIFICADOR MISMA CLASE HERENCIA PAQUETE TODOS

public SI SI SI SI
private SI NO NO NO
protected SI SI SI NO
Por defecto SI NO SI NO
Ver Video: Paquetes getter y setter, en la Unidad 9, en el

Laboratorio: Creacin y uso de paquetes.
Objetivo
Conocer el funcionamiento de los paquetes en Java y su utilizacin.
www.learning.es
Enunciado
Vamos a realizar un laboratorio en el que conoceremos el uso de los paquetes y cmo podemos
implementarlos para utilizarlos con otras clases.
El concepto de ste ejemplo tiene ms que ver con las acciones y la creacin de los productos
compilados que con la propia creacin y la lgica de las clases.
Solucin:
Comenzaremos crendonos una clase inicial
package laboratoriopaquetes;
public class ClasePaquete1
{
protected int variableprotegida = 20;
public int variablepublica = 30;
private int variableprivada = 40;
}
En el momento de almacenar la clase, debemos crearnos una carpeta con el nombre del mismo
paquete que estamos almacenando y guardarla dentro. En nuestro ejemplo, crearemos una carpeta
con el nombre laboratoriopaquetes dentro de la carpeta PracticasJava y llamaremos a nuestro
fichero ClasePaquete1.
Nos crearemos otra clase y la situaremos al mismo nivel que la anterior, es decir, dentro del
directorio y paquete laboratoriopaquetes.
package laboratoriopaquetes;
{
}
A continuacin vamos a crearnos otro paquete ms interno, de forma que vamos a crear una
estructura en la que situaremos a otro nivel ms otra clase dentro de un paquete. Llamaremos al
paquete otropaquete y a la clase ClasePaquete3.
package laboratoriopaquetes.otropaquete;
{
}
Almacenaremos la nueva clase dentro del directorio laboratoriopaquetes, crendonos una carpeta
con el nombre del nuevo paquete otropaquete:
www.learning.es
Debemos tener la siguiente estructura de ficheros:
Ahora que tenemos una estructura ms o menos compleja de los elementos que deseamos crear,
debemos utilizar los paquetes creados para visualizar el correcto funcionamiento. Nos crearemos
una clase dentro del directorio PracticasJava que utilizar las clases contenidas dentro de los
paquetes creados:
import laboratoriopaquetes.*;
public class UsoPaquetes
{
{
ClasePaquete1 c1 = new ClasePaquete1();
System.out.println("Uso de Paquetes en Java");
}
}
Al utilizar la instruccin import, estamos accediendo a todos los objetos que estn dentro del nivel
de la primera carpeta, por lo que podemos acceder a la clase Paquete1 y Paquete2.
www.learning.es
Si visualizamos el error, podemos comprobar que nos est dando una excepcin cuando utilizamos
la clase Paquete3. Esto sucede porque el hecho de acceder a un nivel de paquetes, no implica que
accedamos al siguiente nivel. Dicho de otra forma, el hecho de que nos posicionemos dentro de la
carpeta laboratoriopaquetes no implica que veamos los archivos que existen dentro de la carpeta
otropaquete.
Si deseamos visualizar los ficheros de la carpeta otropaquete debemos entrar en ella, por lo que
debemos acceder mediante la instruccin import a dicho paquete tambin si deseamos utilizar las
clases contenidas dentro:
import laboratoriopaquetes.*;
import laboratoriopaquetes.otropaquete.*;
public class UsoPaquetes
{
{
System.out.println("Uso de Paquetes en Java");
}
}
Si compilamos con el nuevo cdigo y el import adecuado, veremos que todo compila y funciona
correctamente, ya que hemos ido siguiendo todos los pasos y accediendo a las diferentes
estructuras (niveles) para visualizar las clases y utilizarlas:
Actividades
eLearning.
www.learning.es
Unidad 10. Creando y usando arreglos
Introduccin
En mltiples ocasiones dentro de una aplicacin necesitamos almacenar mucha informacin de un
mismo tipo, como por ejemplo, todos los precios de una tienda o todas las notas de una clase.
Para almacenar sta informacin estn los arreglos, llamados arrays. Un array permite almacenar
informacin de muchos elementos en un solo objeto, pudiendo acceder a dichos elementos mediante
un ndice.
Adems del concepto de array, veremos en ste captulo el concepto de coleccin. Una coleccin es
igual que un array, un conjunto de elementos a los que se accede por un ndice, la diferencia est en
que un array contiene un nmero de elementos fijo, mientras que una coleccin puede contener
ms elementos y su capacidad cambia a medida que se agregan elementos a ese conjunto.
Objetivos
Aprender el manejo de arrays unidimensionales y bidimensionales.
Conocer el concepto de coleccin.
Diferenciar entre arrays y colecciones y aprender cuando utilizar un objeto o manejar otro
objeto.
Concepto de Array
Los arreglos son varios objetos en uno, pero que se accede a cada uno de los objetos almacenados
por medio de un ndice. Son un conjunto de elementos accesibles desde un nico objeto a partir de
una posicin especfica.
Las Matrices o arrays (llamados tambin arreglos) pueden ser unidimensionales o
multidimensionales.
Los arreglos son estticos, lo que quiere decir que no podemos redimensionar un array. Si
quisiramos redimiensionar un array sera destruido todo su contenido, perdiendo la informacin que
tuviramos almanenada en su interior.
Los elementos que pondremos en nuestro arreglo de datos deben estar definidos en cantidad, no en
valor.
Los arreglos tienen una cantidad de elementos especfica, todos comienzan en cero y su lmite
superior ser el nmero de elementos totales menos 1.
Los Arrays tienen una propiedad para averiguar el nmero de elementos que contiene en su interior.
Es la propiedad length.
Esta variable nos devuelve el nmero de elementos que posee el array. Hay que tener en cuenta
que es una variable de solo lectura, es por ello que no podremos realizar una asignacin a dicha
variable.
Tenemos que tener claro el atributo length nos devuelve el nmero de posiciones o huecos que
existen en el interior del array, el hecho que hayamos declarado un array con una capacidad
determinada, no indica que el contenido del array est creado, podremos comprobarlo a lo largo del
mdulo. Simplemente esto quiere decir que un array puede tener posiciones con contenido y
posiciones con valores por defecto en el caso de que sean tipos primitivos y valores nulos en el caso
de que sean objetos referenciados.
Arrays Unidimensionales
www.learning.es
Son el concepto que acabamos de explicar ahora mismo, un objeto compuesto por mltiples
elementos, dnde cada uno de los elementos tiene una posicin en el conjunto.
En Java un arreglo se representa por un objeto que tiene un lmite de elementos al ser definido, o
en alguna parte de nuestro programa le asignaremos un objeto arreglo de cierto tipo.
Por ejemplo, imaginemos que deseamos almacenar una lista de 6 textos, deberamos de crearnos
un array de 6 elementos, dnde el primer texto estara en la posicin cero y el ltimo texto estara
en la posicin 5.
Podemos visualizarlo en ste ejemplo grfico:
POSICION TEXTO ALMACENADO
0 En
1 Un
2 Lugar
3 De
4 La
5 Mancha
De forma que si queremos acceder a alguna posicin del array para acceder a algn elemento en
concreto deberamos escribir:
Nombrearray[posicin];
En nuestro ejemplo concreto, si nuestro array se llamase textos:
Textos[2] Devolvera el valor de Lugar.
Un array puede ser creado para que contenga cualquier tipo de dato, ya sea un conjunto de
elementos de tipos primitivos (int, double, string), o un conjunto de objetos referenciados (objetos
de clases existentes o creadas por el propio programador).
La sintaxis para crear un array e indicar al compilador que es un arreglo se realiza mediante
corchetes, dnde en la creacin del objeto es dnde indicaramos el nmero de elementos a
contener dentro del array.
Para declarar una array unidimensional se puede realizar de varias formas:
Creando el array sin contenido:
int numeros[] = new int[5];

Creando un array, e inicializando el nmero de elementos posteriormente en el cdigo.
int numeros[];
int numeroelementos = 5;
numeros = new int[numeroelementos];
Creando un array con contenido e inicializando los valores que deseamos que contenga en su
interior. Dos tipos de sintaxis:
int numeros[] = new int[] {2,5,6,7,8};

int numeros[] = {2,5,6,7,8};
En las dos primeras opciones, los elementos internos del array son inicializados a su valor vaco o
null. A diferencia de los objetos simples, cuando utilizamos arrays, los objetos de su interior son
inicializados y el compilador nos permite trabajar y ejecutar la aplicacin.
Para inicializar los valores de un array, tambin podemos hacer lo posteriormente por cdigo,
igualando el nombre del array y de la posicin que deseamos modificar por el valor que necesitamos
almacenar.
Nombrearray[posicin] = valor;
Llevado a cdigo sera la siguiente instruccin:
www.learning.es
int numeros[] = new int[];
numeros[0] = 2;
numeros[1] = 5;
numeros[2] = 6;
numeros[3] = 7;
numeros[4] = 8;
Veamos la diferencia entre una variable simple y un conjunto de variables simples (array):
Si escribimos el siguiente cdigo en una clase, declarndonos una variable nica del tipo int,
veremos que el compilador nos muestra una excepcin al querer compilar la clase:
public class PruebaArreglos
{
{
int numero;
System.out.println("El valor del numero es "+numero);
}
}
Vemos que como resultado, el programa de Java, impide al compilador utilizar variables que no
hayan sido inicializadas con un valor como hemos visto en temas anteriores.
Si ahora en cambio nos declaramos un array del mismo tipo, veremos que el resultado es
totalmente distinto, permitindonos compilar sin ningn tipo de excepcin:
{
{
int arraynumeros[] = new int[5];
System.out.println("El valor del numero es "+arraynumeros[2]);
}
}
El compilador nos permite generar el archivo class sin ningn problema, si ahora ejecutsemos el
cdigo para visualizar la lgica de la clase veremos lo siguiente:
www.learning.es
Lo que sucede es que el array al ser declarado como un tipo de datos primitivos (en nuestro ejemplo
int), los valores de los objetos internos se inicializan a un valor inicial, en ste ejemplo en concreto
al nmero cero.
Ahora vamos a visualizar que sucedera en el caso de trabajar con objetos referenciados.
Nos vamos a crear la siguiente clase, para posteriormente, crearnos un array con objetos de dicha
clase y acceder a sus atributos.
public class MiClasePrueba
{
public int num;
public String texto;
public MiClasePrueba()
{
num = 19;
texto = "clase de prueba para arrays";
}
}
Ahora vamos a utilizar el nuevo objeto creado, pero en un array. Primero declararemos una variable
simple para manejar un nico objeto referenciado y a continuacin un conjunto de objetos en un
array.
{
{
MiClasePrueba objetosimple = new MiClasePrueba();
System.out.println("Valor del Objeto Simple: "+objetosimple.texto);
MiClasePrueba objetos[] = new MiClasePrueba[5];
System.out.println("Valor del Objeto Compuesto "+objetos[2].texto);
}
}
Como podemos comprobar, el mensaje del objeto simple es visualizado despus de compilar la
clase, pero al llegar a utilizar el objeto compuesto nos ofrece una excepcin de la clase
NullPointerException, lo que quiere decir al final de todo es que estamos creando un conjunto de
elementos, pero dichos elementos no han sido creados en el interior del array, debemos hacer un
new sobre algn objeto del array que deseamos crear.
www.learning.es
El compilador no detecta sta excepcin, ya que no verifica el interior del contenido del objeto array,
sino que solamente detecta la creacin del conjunto por si ha sido creado correctamente e
inicializados sus valores para que sean utilizados.
La solucin de la excepcin sera creando un objeto en la posicin que deseamos utilizar:
{
{
MiClasePrueba objetosimple = new MiClasePrueba();
System.out.println("Valor del Objeto Simple: "+objetosimple.texto);
MiClasePrueba objetos[] = new MiClasePrueba[5];
objetos[2] = new MiClasePrueba();
System.out.println("Valor del Objeto Compuesto "+objetos[2].texto);
}
}
De forma que el valor resultante despus de la compilacin sera totalmente diferente y
accederamos al objeto creado:
Arrays Multidimensionales
Debemos pensar en ellos como una tabla, nos permiten almacenar ms de un ndice por cada
elemento. Para entender mejor el concepto, pensemos en un conjunto de personas, cada persona
contiene como dato un nombre y un dni. Son dos valores a almacenar, por un lado el nombre de la
persona y por otro el dni. En lugar de crearnos dos arrays, se utiliza un array nico con dos
dimensiones o posiciones, pudiendo acceder a cada elemento por su posicin en el conjunto y el
dato en cuestin. Para visualizarlo mejor, podemos visualizar la siguiente tabla:
Imaginemos un array compuesto por nombres llamado datos.
0 1 COLUMNAS
FILAS NOMBRE DNI
0 Nacho Llanos 12345678N
1 Andrea Serrano 23451235H
2 Lucia Gutierrez 98765432P
Segn nuestro cuadro, tenemos dos datos almacenados en cada una de las filas, de forma que
accederamos a ellos mediante posicin de fila y posteriormente, posicin de columna.
nombrearray[POSICION FILA] [POSICION COLUMNA]
De forma que si desesemos saber el DNI de Luca Gutierrez escribiriamos:
datos [2] [1] 98765432P
Para crearnos arrays multidimensionales sucede lo mismo que con arrays unidimensionales, existen
mltiples formas dependiendo de lo que deseemos realizar o almacenar sobre el array:
Declaracin y creacin de un array multidimensional sin contenido:
www.learning.es
int[][] arraymultidimensional = new int[2][3];
Estamos creando un array que contendra dos filas y tres columnas para cada fila.
Declarar un array multidimensional y crearlo posteriormente en el cdigo de la aplicacin:
int[][] arraymultidimensional;
int numerofilas = 2;
int numerocolumnas = 3;
arraymultidimensional = new int[numerofilas][numerocolumnas];
Declarar y crear un array multidimensional con elementos en su interior, asignados en la

creacin del objeto:
String [ ][ ] datos = { { "Nacho Llanos", "12345678N" } ,_

{ "Andrea Serrano" , "23451235H" } , { "Lucia Gutierrez" , "98765432P" } };
Declarar un array multidimensional y asignar los valores posteriormente:
String [ ][ ] arraymultidimensional = new String[2][2];

arraymultidimensional[0][0] = "Nacho Llanos";
arraymultidimensional[0][1] = "12345678N";
arraymultidimensional[1][0] = "Andrea Serrano";
arraymultidimensional[1][1] = "23451235H";
Vamos a ver un ejemplo para crearnos un recorrido sobre un array multidimensional que contenga
datos en su interior y cmo podemos recuperarlos para mostrarlos todos por pantalla:
{
{
String [ ][ ] arraymultidimensional = new String[3][2];
arraymultidimensional[0][0] = "Nacho Llanos";
arraymultidimensional[0][1] = "12345678N";
arraymultidimensional[1][0] = "Andrea Serrano";
arraymultidimensional[1][1] = "23451235H";
arraymultidimensional[2][0] = "Lucia Gutierrez";
arraymultidimensional[2][1] = "98765432P";
//Recorrido por el array multidimensional
for (int i = 0; i < arraymultidimensional.length; i++)
{ //Recorremos las filas
for (int z = 0; z < arraymultidimensional[i].length; z++)
{ //Recorremos las columnas
System.out.println("El dato en la fila " + i + ", _
columna " + z + " es: " + arraymultidimensional[i][z]);
}
}
}
}
Como resultado veremos que hemos recorrido las dos dimensiones del array.
www.learning.es
Para averiguar la longitud de las filas, bastara con utilizar la propiedad length sobre el objeto array:
arraymultidimensional.length
Si deseamos saber la longitud de las columnas de una fila, debemos aplicar el atributo length sobre
la fila en cuestin y contar el nmero de columnas existentes para esa fila:
arraymultidimensional[numerofila].length
Arrays de Caracteres
Los conjuntos de caracteres en Java son objetos de la clase String. La clase String contiene en su
interior un conjunto de elementos separados entre s cada uno de ellos por la clasechar, lo que
quiere decir que cada objeto String es un conjunto de elementos de la clase char.
A la inversa sucede exactamente lo mismo, un array de la clase char es convertido a un objeto de
la clase String que se puede representar graficmente como un conjunto de caracteres en un nuevo
objeto String.
Para comprobar ste concepto bastara con declararnos un array de la clase char e incluir en su
interior una serie de caracteres en cada posicin.
{
{
char[] letras = {'a', 'e', 'i', 'o', 'u'};
String texto = new String(letras);
System.out.println(letras);
System.out.println("Un elemento del conjunto CHAR: " + letras[1]);
System.out.println("Un elemento del conjunto STRING: " + texto.charAt(2));
}
}
www.learning.es
Debido a ello, podemos acceder a un nico elemento char en la clase String, al igual que podemos
acceder a un elemento dentro del array char.
Tambin podemos iniciar una array de tipos char con elementos enteros, debido a que cada carcter
tiene asociado un entero Unicode desde 0 a 65535. Recordando que los primeros 255 caracteres
pertenecen al cdigo ASCII.
char[] letras = {100, 105, 125, 157, 89};
Lo que dara como resultado: di}?Y
Vamos a crearnos un programa en el que almacenaremos todos los caracteres ASCII dentro de un
array de la clase char, para posteriormente mostrarlos por pantalla en la clase String o uno a uno
recorriendo cada uno de los caracteres.
import java.io.*;

{
static char[] caracteres = new char[255];
public static void main(String args[]) throws IOException
{
System.out.println("Almacenando caracteres ASCII...");
int opcion = 0;
int posicion = 0;
String datoteclado;
for (int i = 0; i < caracteres.length; i++)
{
caracteres[i] = (char)i;
}
System.out.println("Elementos almacenados...");
do
{
System.out.println("1.- Mostrar todos los caracteres");
System.out.println("2.- Seleccionar una posicion del ASCII");
System.out.println("3.- Salir");
System.out.println("Seleccione una opcion:");
datoteclado= lector.readLine();
opcion = Integer.parseInt(datoteclado);
switch (opcion)
{
case 1:
System.out.println(caracteres);
break;
case 2:
System.out.println("Introduzca una posicion:");
datoteclado= lector.readLine();
posicion = Integer.parseInt(datoteclado);
String letra = seleccionarLetra(posicion);
System.out.println("La letra ASCII de " + posicion + " es "
+ letra);
}
}while(opcion != 3);
System.out.println("Fin del programa");
}
public static String seleccionarLetra(int posicion)
www.learning.es
{
String letra = String.valueOf(caracteres[posicion]);
return letra;
}
}
Cmo podemos comprobar, el resultado de la ejecucin del programa nos permite acceder a cada
uno de los elementos del array mediante el objeto caracteres o acceder a todos los elementos
mediante un String creado en la instruccin System.out.println(caracteres).
Colecciones
Cuando las caractersticas de un array se quedan incompletas para la lgica del programador es
cuando se usan colecciones.
Las colecciones son objetos que contienen un conjunto de objetos a su vez, exactamente igual que
un array, adems se accede a cada uno de los elementos mediante un ndice para recuperar cada
uno de los elementos.
La diferencia entre un array una coleccin es simple. Un array es un objeto con una longitud de
elementos estticos. Es decir, un array al ser creado se le debe especificar el nmero de elementos
que va a contener en su interior, y dicho nmero de elementos no pueden ser modificado. Adems,
un array puede contener objetos nulos en su interior y no devolver el nmero real de elementos
que existen en su interior, sino solamente su capacidad, es decir, puede contener huecos en algunas
posiciones y datos en otras.
Una coleccin es un objeto con un conjunto de elementos dinmico. El nmero de elementos de la
coleccin puede crecer y decrecer. Una coleccin se dimensiona al nmero de elementos reales que
contiene. No puede contener huecos nulos en su interior a no ser que el programador lo haya
especificado mediante cdigo. Son objetos creados para una lgica en la que el programador no
sabe el nmero de elementos que va a tener que almacenar. Adems, una coleccin siempre
devolver el nmero de elementos que contiene, no la capacidad de elementos que puede
almacenar en su interior.
La librera para trabajar con colecciones est ubicada en el paquete java.util.
Los objetos que podemos almacenar en una coleccin son los mismo que en un array, desde tipos
primitivos hasta objetos referenciados.
www.learning.es
La gran desventaja en el uso de colecciones de Java es la prdida de la identidad del tipo de datos
almacenados cuando se coloca un objeto en su coleccin. Teniendo en cuenta querer hacer un
conjunto de elementos lo ms general posible, se hizo de forma que se manejase directamente
objetos de la clase object, independientemente del la clase o tipo de objeto almacenado en su
interior.
Con la versin de Java 1.5, ste problema se solucion. Se implementaron colecciones de forma
que se pueden declarar objetos de una determinada clase y solamente se pueden almacenar objetos
de dicha clase. La gran ventaja es que no tenemos que realizar casting para recuperar cualquier
objeto, sino que la referencia al objeto ya est escrita en la propia declaracin de la coleccin. La
desventaja radica en que no podemos almacenar cualquier clase de objeto, solamente del mismo
tipo, pero para ello existen multiples clases de colecciones que nos pueden solucionar un problema
lgico en concreto.
Podemos diferenciar las colecciones en dos grandes familias:
Coleccin (Collection): Son un grupo de elementos individuales. Es lo ms parecido que
existe a un array unidimensional.
Mapa (Map): Es un grupo de parejas de elementos, como un array bidimensional. Podriamos

realizar la misma accin con una coleccin de parejas, pero el modo de tratarlas dependera
de la sincronizacin que tuvisemos a la hora de almacenar los datos en cada ndice para que
coincidieran.
Las colecciones y los mapas pueden ser implementados de muy diversas manera, en funcin de las
necesidades de la programacin.
Dentro de stas dos familias que acabamos de nombrar, existen tres tipos de colecciones: Map, List
y Set, y solamente dos o tres implementaciones de cada una de ellas, por lo que podemos afirmar
que aprender el manejo de una coleccin implica saber el resto de colecciones. Es parecido al
mundo real, con saber conducir un coche, podemos conducir cualquier tipo de coche,
independientemente del tipo, ya que las caractersticas bsicas son las mismas para todos.
Todas las colecciones pueden producir un objeto Iterator invocando al mtodo Iterator(). Un
Iterator es un enumerador que permite recorrer cada uno de los elementos que existen dentro de la
coleccin hasta llegar al ltimo.
Vamos a visualizar los mtodos ms importantes dentro de las colecciones Set o List:
add(object): Incluye un nuevo elemento dentro de la coleccin.
addAll(Collection): Inserta todos los elementos que se pasan desde otra coleccin a la coleccin que
realiza la llamada.
clear(): Elimina todos los elementos de la coleccin, dejando el nmero de elementos a cero.
contains(object): Devuelve un boolean indicando si el objeto que se pasa como argumento existe
dentro de la coleccin.
isEmpty(): Devuelve un boolean indicando si la coleccin tiene algn elemento ya incluido o no.
iterator(): Devulve un Iterator que se utiliza para recorrer todos los elementos dentro de la
coleccin uno a uno.
remove(object): Elimina un objeto de la coleccin, pasando como argumento el propio objeto a
eliminar.
removeAll(Collection): Elimina todos los elementos que estn dentro de la coleccin que se enva
como argumento.
size(): Devuelve el nmero de elementos que existen dentro de la coleccin. Debemos de recordar
que siempre una coleccin va a devolver el nmero total de elementos que contiene.
www.learning.es
toArray(): Convierte la coleccin en un array y devuelve todos los elementos para poder ser
incluidos en ella.
Coleccin Set
Cualquier clase denominada Set implementa la interfaz Set de colecciones.
Las colecciones Set no permiten contener duplicados en su interior y lo que es ms importante, se
ordenan internamente a travs de SortedSet. La forma de ordenarlos es de forma ascendente.
Incluye diversos mtodos para acceder a sus elementos, adems de iterator para recorrer el
conjunto de sus elementos.
Los atributos ms importantes (adems de los tpicos de todas las colecciones) son:
first(): Devuelve el primer elemento dentro de la coleccin.
last(): Devuelve el ltimo elemento de la coleccin.
Vamos a visualizar un ejemplo para comprobar la utilidad y la facilidad de las colecciones Set. Nos
crearemos un objeto TreeSet que herada de la interfaz Set y comprobaremos todas las
caractersticas. La lgica del problema ser una clase que generar 10 nmeros aleatorios
comprendidos entre 0 y 10.
import java.util.*;
public class PruebaColecciones
{
{
Random rnd = new Random();
TreeSet numerosordenados = new TreeSet();
for (int i = 0; i < 10; i++)
{
int numeroaleatorio = (int)(rnd.nextDouble() * 10);
numerosordenados.add(numeroaleatorio);
}
Iterator item = numerosordenados.iterator();
while (item.hasNext())
{
System.out.println(item.next());
}
}
}
Como resultado veremos todos los elementos introducidos dentro de la coleccin:
www.learning.es
Si ejecutamos varias veces, veremos que el nmero de elementos dentro de la coleccin variar en
cada ejecucin. Esto se debe a que la coleccin no permite elementos repetidos, por lo que cada
vez que se repite un nmero en la secuencia entre 0 y 10, lo elimina directamente de la coleccin.
Si aumentamos el nmero de valores aleatorios (por ejemplo de 0 a 100), comprobaremos que la
coleccin se llena al completo y que los nmeros son ordenados automticamente.
for (int i = 0; i < 10; i++)
{
}
Como podemos comprobar, al aumentar el nmero de posibilidades de que no se repitan nmeros

dentro de la coleccin, se llena al completo (10 elementos) y se ordenan internamente dichos
elementos.
Existe una sintaxis nueva para recorrer los elementos dentro de una coleccin, sin necesidad de
declararnos un objeto de la clase Iterator. Esto nos permite ms claridad de cdigo, pero nos
impide realizar acciones sobre el objeto que estamos recorriendo.
La sintaxis es la siguiente:
for(Object elemento : COLECCION)
{
//ACCIONES SOBRE CADA ELEMENTO
}
Podemos visualizar la sintaxis dentro del anterior ejemplo:
import java.util.*;
public class PruebaColecciones
{
{
Random rnd = new Random();
TreeSet numerosordenados = new TreeSet();
for (int i = 0; i < 10; i++)
{
}
for(Object numero : numerosordenados)
www.learning.es
{
System.out.println(numero);
}
System.out.println("Primer numero Coleccion: " + numerosordenados.first());
System.out.println("Ultimo numero Coleccion: " + numerosordenados.last());
System.out.println("Elementos en la coleccion: " +

numerosordenados.size());
}
}
Coleccin List
Es una coleccin de objetos que implementa la Interfaz List. Dentro de la implementacin de sta
coleccin tenemos dos clases que son las ms importantes para ste tipo:
Vector: Coleccin que permite duplicados. Permite la referencia del objeto que vamos a
incluir en su interior.
ArrayList: Coleccin que permite duplicados. Slo se almacenan elementos object dentro de
su interior, por lo que tenemos que realizar Casting entre objetos para recuperar sus
elementos.
LinkedList: Coleccin en la que cada elemento tiene una referencia al anterior y posterior
elemento.
La diferencia que tiene una lista con un Set es que la lista mantiene un orden arbitrario de los
elementos y permite acceder a los elementos por dicho orden. Podramos decir que en una lista, el
orden es el dato. Es decir, el orden es informacin importante que la lista tambin nos est
almacenando. Dicho en otras palabras, el orden de una lista se establece por cada elemento que
hemos introducido, no se reordena, cada elemento que pongamos en su interior ir el ltimo.
A diferencia de un Set, una lista permite acceder a un nmero especfico de elemento. En un Set no
existe porque ni siquiera estamos seguros de que si volvemos a recorrer la coleccin los elementos
aparecern en el mismo orden. Una lista s debe permitir acceder al tercer elemento, por eso se
aaden los siguientes mtodos:
get(int posicion)
Obtiene el elemento en la posicin pasada como parmetro.
set(int posicion, v valor)
Pone al elemento v en la posicin enviada como parmetro.
Existen en Java principalmente dos implementaciones de List, las dos tiles en distintos casos. Una
de ellas es casi igual a los arreglos unidimensionales. Esta implementacin es ArrayList. La ventaja
de ArrayList por sobre un array comn es que es expansible, es decir que crece a medida que se le
aaden elementos (mientras que el tamao de un array es fijo desde su creacin). Lo bueno es que
el tiempo de acceso a un elemento en particular es mnimo. Lo malo es que si queremos eliminar un
elemento del principio, o del medio, la clase debe mover todos los que le siguen a la posicin
anterior, para quitar el agujero que deja el elemento removido y que no existan huecos en el
interior de la coleccin. Esto hace que quitar elementos del medio o del principio sea costoso.
Otra implementacin es LinkedList (lista enlazada). En sta, los elementos son mantenidos en una
serie de nodos atados entre s como eslabones de una cadena. Cada uno de estos nodos apunta a su
antecesor y al elemento que le sigue. Nada ms. No hay nada en cada uno de esos nodos que tenga
algo que ver con la posicin en la lista. Para obtener el elemento nmero n, esta implementacin
de List necesita entonces empezar desde el comienzo, desde el primer nodo, e ir avanzando al
siguiente n veces. Buscar el elemento 400 entonces implica 400 de esos pasos. La ventaja es que
www.learning.es
es posible eliminar elementos del principio de la lista y del medio de manera muy eficiente. Para
eliminar un elemento solamente hay que modificar a sus dos vecinos para que se conecten entre
s ignorando al elemento que se est borrando. Como en una cadena, se retira un eslabn abriendo
los eslabones adyacentes al que se elimin y cerrndolos de modo que lo excluyan. No es necesario
hacerle ningn cambio al resto de los elementos de la lista.
En ste tipo de lista hay que tener en cuenta algunas particularidades en cuanto a rendimiento. Su
mtodo get(posicion) es particularmente lento porque necesita recorrer todos los elementos
anteriores para llegar al elemento pedido.
Una coleccin LinkedList slo debe recorrerse mediante iteradores.
Coleccin Map
Un Map representa lo que en otros lenguajes se conoce como diccionario y que se suele asociar a
la idea de tabla hash (aunque no se implemente necesariamente con esa tcnica). Un Map es un
conjunto de valores, con el detalle de que cada uno de estos valores tiene un objeto extra asociado.
A los primeros se los llama claves o keys, ya que nos permiten acceder a los segundos.
Cuando se dice que las claves forman un conjunto, se dice en el sentido Java: Son un Set, en el
que no puede haber duplicados. En otros lenguajes existen estructuras parecidas que admiten la
existencia de claves duplicadas (a veces conocidos como multimap). La nica manera de lograr
esto en Java es haciendo que el map guarde listas de valores en vez de los valores sueltos.
Un Map no es una Collection ya que esa interfaz queda demasiado pequea. Podemos decir que
Collection es unidimensional, mientras que un Map es bidimensional. No hay una manera comn de
expresar un Map en una simple serie de objetos que podemos recorrer. S podramos recorrer una
serie de objetos si cada uno de ellos representase un par {clave, valor} (y de hecho eso es cmo se
debe hacer).
Algunos de los mtodos ms importantes de un Map son:
get(Object clave)
Obtiene el valor correspondiente a una clave. Devuelve null si no existe esa clave en el map.
put(K clave, V valor)
Aade un par clave-valor al map. Si ya haba un valor para esa clave, lo reemplaza.
Adems hay algunas funciones que son tiles a la hora de recorrer eficientemente el contenido de
un Map:
keySet()
Devuelve todas las claves(devuelve un Set, es decir, sin duplicados).
values()
Devuelve todos los valores (los valores s pueden estar duplicados, por lo tanto esta funcin
devuelve una Collection).
entrySet()
Todos los pares clave-valor (devuelve un conjunto de objetos Map.Entry, cada uno de los cuales
devuelve la clave y el valor con los mtodos getKey() y getValue() respectivamente).
Ver Video: Alumnos Vector, en la Unidad 10, en el Mdulo 1,

Laboratorio: Temperaturas Anuales

www.learning.es
Objetivo
Comprender el funcionamiento de los arrays unidimensionales en el lenguaje Java.
Enunciado:
Vamos a realizar una aplicacin en la que le pediremos al usuario que introduzca las temperaturas
para cada mes del ao.
Si el usuario no pone una temperatura para un mes, se lo volveremos a pedir hasta que rellene los
doce meses.
A continuacin, mostraremos, la temperatura mxima, la temperatura mnima y la media anual.
Solucin:
CDIGO JAVA
import java.io.*;
public class ClaseTemperaturasAnuales
{
{
System.out.println("Temperaturas anuales");
String[] meses = {"Enero", "Febrero", "Marzo", "Abril"
, "Mayo", "Junio", "Julio", "Agosto"
, "Septiembre", "Octubre", "Noviembre", "Diciembre"};
int[] temperaturas = new int[12];
int maximo, minimo;
double media = 0;
String dato = "";
www.learning.es
int contador = 1;
int temp;
while (contador <= 12)
{
System.out.println("Introduzca la temperatura para el mes de: " +
meses[contador - 1]);
dato = lector.readLine();
temp = Integer.parseInt(dato);
temperaturas[contador - 1] = temp;
contador++;
}
maximo = temperaturas[0];
minimo = temperaturas[0];
for (int i = 1; i < temperaturas.length; i++)
{
if (temperaturas[i] > maximo)

{
maximo = temperaturas[i];
}
if (temperaturas[i] < minimo)
{
minimo = temperaturas[i];
}
media += temperaturas[i];
}
media = media / 12;
System.out.println("Datos de las temperaturas anuales");
System.out.println("La temperatura maxima es: " + maximo);
System.out.println("La temperatura minima es: " + minimo);
System.out.println("La media anual es: " + media);
}
Actividades
eLearning.
www.learning.es
Unidad 11. Implementando herencia
Introduccin
Un objeto siempre pertenecer a una familia, ya estemos hablando dentro del concepto de
programacin o del concepto dentro del mundo real.
Si nos ponemos como ejemplo el mundo real, cualquier objeto que pensemos pertenece a una
familia y podemos ir ascendiendo niveles hasta encontrar puntos en comn con otro objeto, por muy
diferentes que sean, es decir, podemos englobar los objetos dentro de varios conjuntos.
Por ejemplo, si pensamos en un mvil y un mp3, los dos tienen caractersticas similares, pero dentro
del mismo nivel no podemos englobarlos. Un mp3 es un reproductor de msica, mientras que un
mvil nos permite realizar llamadas, pero si subimos niveles, podemos englobar los dos objetos
dentro del mismo conjunto, que puede ser los aparatos electrnicos de bolsillo, por ejemplo.
A ste concepto se le conoce como abstraccin y es una de las bases dentro de la herencia, saber
manejar cualquier objeto por sus similitudes con otros objetos. Dichas similitudes se basan en
familias o paquetes. Dentro de un mismo paquete podemos encontrar objetos que son similares
aunque tengan caractersticas diferentes y algunas en comn. Dichas similitudes corresponden a la
herencia.
Cualquier objeto que herede de otro, inmediatamente deriva todos sus mtodos y caractersticas,
pudiendo implementarlas.
Objetivo
Manejar el conjunto de clases para implementar la herencia entre objetos y su utilizacin dentro del
conjunto de la programacin orientada a objetos.
Herencia
En programacin orientada a objetos, la herencia indica que una clase es una extensin de otra. Es
decir, una clase es como otra y adems tiene algn tipo de caracterstica propia que la diferencia. A
ste concepto se le llama implementacin de una clase, y es bsicamente la herencia.
En Java todas las clases heredan de una clase superior. Aunque no implementemos el concepto
de herencia y no lo indiquemos de forma explicita, todas las clases heredan de object. La clase
object en Java es la clase super de cualquier clase y es el principio de la jerarqua de objetos de
Java, podemos afirmar que todos los objetos son objetos de la clase object.
Por ejemplo, si nos fijamos en el siguiente grfico de clases y objetos:
Podemos perfectamente diferenciar la herencia de forma grfica. La clase super es el coche, que es
de dnde derivan y van a heredar el resto de clases. Un coche puede contener una serie de
www.learning.es
caractersticas. Dichas caractersticas las contendrn todos los objetos que hereden de la clase
coche, es decir, todos los objetos por debajo de coche son un coche, pero mejorado. Un Todo
Terreno es un coche, pero adems se le han hecho una serie de modificaciones, pero dichas
modificaciones no cambian el concepto de coche, sino que lo mejoran para adaptarlo a un 4x4.
Dependiendo del nivel dnde nos encontremos, la herencia puede comenzar en un lugar o en otro
diferente. Por ejemplo, un Formula 1 es un coche. Pero un Formula 1 es ms bien, un deportivo
mejorado. Si heredamos de coche, tendramos que hacer lo mismo que con un deportivo, y
adems, implementar el Formula 1. Si heredamos directamente de deportivo (recuperamos todas
las caractersticas de un deportivo), solamente tendremos que implementar el Formula 1.
Podemos ver fcilmente sta representacin grfica en un ejemplo. Vamos a implementar la clase
coche para visualizar al completo toda la estructura de la herencia y cmo podemos cambiar la
lgica de los objetos implementando la herencia, para aprovechar todas sus virtudes.
Nos creamos la clase Coche:
public class Coche
{
protected int numeromarchas;
private String marca;
private String modelo;
protected int VelocidadMaxima;
private int velocidad;
public Coche()
{
this.numeromarchas = 5;
this.marca = "";
this.modelo = "";
this.VelocidadMaxima = 160;
this.velocidad = 0;
System.out.println("Construyendo un coche");
System.out.println("La velocidad mxima de un coche es: " + this.VelocidadMaxima);
}
public void setMarca(String m)
{
this.marca = m;
}
public String getMarca()
{
return this.marca;
}
public void setModelo(String m)
{
this.modelo = m;
}
public String getModelo()
{
return this.modelo;
}
public int getVelocidad(int vel)
{
return this.velocidad;
}
}
Como hemos visto a lo largo de otros mdulos, ponemos las variables miembro cmo privadas y
accedemos a los elementos mediante sus mtodos.
www.learning.es
Hemos dejado algunas variables cmo protected para que las clases que hereden de Coche puedan
modificar sus valores y adaptarlos a su nuevo cambio. Ah es dnde vamos a ver la clave y las
ventajas de la herencia.
Lo que vamos a hacer a continuacin ser crearnos dos mtodos de objeto para acelerar o frenar el
coche.
public void acelerarCoche()
{
if (this.velocidad < this.VelocidadMaxima)
{
this.velocidad += 40;
System.out.println("Su velocidad actual es: " + this.velocidad);
}else
{
System.out.println("Velocidad Mxima alcanzada: " + this.VelocidadMaxima);
this.velocidad = this.VelocidadMaxima;
}
}
public void frenarCoche()

{
if (this.velocidad > 0)
{
this.velocidad -= 40;
}else
{
System.out.println("El coche esta detenido");
this.velocidad = 0;
}
}
Lo que estamos implementando en el ejemplo es lo siguiente: Un coche no puede acelerar ms que
su VelocidadMaxima. Por lo tanto, podemos afirmar sin ningn tipo de duda que todos los coches no
pueden acelerar ms de 160 km/h, tal y cmo hemos puesto en el constructor de Coche:
A continuacin, nos vamos a crear un mtodo en la clase Coche para mostrar el men personalizado
para el conductor.
public void mostrarMenu()
{
System.out.println("-------------------------------");
System.out.println("1.- Acelerar");
System.out.println("2.- Frenar");
}
Ahora vamos a crearnos una clase que utilice el Coche llamada conductor, para visualizar que el
funcionamiento es correcto y que nuestro supuesto es correcto:
import java.io.*;
public class Conductor

{
www.learning.es
{
Coche c = new Coche();
int opcion = 0;
while (opcion != 3)
{
c.mostrarMenu();
switch (opcion)
{
case 1:
c.acelerarCoche();
break;
case 2:
c.frenarCoche();
break;
}
}
System.out.println("Hasta pronto");
}
}
Si utilizamos la clase conductor, visualizaremos el men y la velocidad mxima del Coche (160
km/h) nada ms construirlo.
Si ahora vamos seleccionando la opcin de acelerar, podremos comprobar que el funcionamiento es

correcto y que no podemos sobrepasar la velocidad mxima.
Con todo esto, hemos montado una lgica para poder conducir un coche. Lo que haremos a
continuacin ser crearnos un objeto Deportivo que heredar de Coche:
public class Deportivo extends Coche
{
public Deportivo()
{
www.learning.es
}
Con esta definicin un Deportivo es un Coche. Son exactamente iguales y no existe ningn rasgo
distintivo, el Deportivo hereda todas las caractersticas del Coche, incluida la velocidad mxima.
Para comprobarlo, bastara con ir a la clase Conductor y cambiar la siguiente lnea:
Coche c = new Coche();
por la siguiente declaracin:
Deportivo c = new Deportivo();
Si ahora utilizamos la clase conductor, el funcionamiento ser el mismo que con un coche.
Aprendido el concepto de herencia de miembros y mtodos, ahora vamos a implementar la clase
Deportivo. Un deportivo es ms veloz que un coche, por lo que tenemos que incrementar la
velocidad de un deportivo.
Una vez que tenemos claras esas cuestiones, debemos saber que un Coche es la clase superior
(super) del objeto Deportivo (clase base).
Para acceder a la clase superior desde la clase base, se utiliza la palabra clave super. Para
referirnos a los objetos de la clase base se utiliza la palabra clave this, tal y como hemos visto en
otros captulos.
Ahora que sabemos el concepto, vamos a continuar con el supuesto de la velocidad. Un deportivo
es ms veloz que un coche y siempre lo ser. Si la tecnologa avanza y el coche se vuelve ms
rpido, el Deportivo siempre ser ms rpido que un Coche.
Podriamos modificar la clase Deportivo, de forma que su velocidad mxima sea superior a la de un
Coche de la siguiente forma:
{
public Deportivo()
{
}
}
Si lo hacemos de la siguiente forma, estamos haciendo que un Deportivo sea ms veloz que un
coche, pero eso es algo temporal. Si incrementamos la velocidad de la clase Coche, no se
incrementa la velocidad de un Deportivo, sino que siempre ser la misma, no superior a la velocidad
de un coche.
Como el coche y el deportivo estn relacionados, debemos hacer que un Deportivo sea ms veloz
que el coche siempre. Eso lo hacemos con la palabra clave super. Si accedemos a la velocidad
mxima del coche y la incrementamos en deportivo, siempre un Deportivo ser ms rpido que un
Coche. Podemos visualizarlo de la siguiente forma:
{
public Deportivo()
{
super.VelocidadMaxima += 80;
}
}
Esto sera realmente lo correcto, si ahora modificasemos la velocidad mxima de la clase super
(coche), siempre se incrementara dicha velocidad mxima en 80, por lo que podemos afirmar de
forma rotunda que un Deportivo siempre ser ms veloz que un coche.
Otros conceptos que podemos realizar sobre el deportivo es la adaptacin de mtodos propios de la
clase Deportivo. Por ejemplo, en nuestro caso, puede que necesitemos implementar las
caractersticas de un deportivo, como pudiera ser un mtodo para cambiar marchas:
www.learning.es
public void cambiarMarcha()
{
System.out.println("Cambio de marcha en deportivo");
}
Si aadimos algo al deportivo, deberamos de poder ofrecrselo al conductor. El problema lo
tenemos con el men. Ahora mismo, el men de un Coche y un Deportivo son iguales, pero
necesitamos que el men del Deportivo sea diferente. No queremos modificarlo, sino que deseamos
cambiarlo. Dicho concepto en la herencia se llama sobreescritura de mtodos. Lo hemos visto en
otros captulos el concepto, ahora vamos a llevarlo a la prctica. Simplemente, bastara con escribir
el mtodo en la clase base (Deportivo) y modificar su contenido para adaptarlo a las nuevas
caractersticas.
public void mostrarMenu()
{
System.out.println("1.- Acelerar");
System.out.println("2.- Frenar");
System.out.println("3.- Cambiar Marcha");
}
Ahora son diferentes el men de coche y del deportivo. Siguen teniendo el mismo mtodo
mostrarMenu, pero cada uno es diferente en cada objeto.
Por ltimo, podemos adaptar el constructor del Deportivo a nuestra conveniencia.
public Deportivo()
{
this.numeromarchas = 6;
super.VelocidadMaxima += 80;
System.out.println("La velocidad maxima de un Deportivo es: " + this.VelocidadMaxima);
}
El constructor del objeto Coche seguir realizandose, debido a que para construir un Deportivo ser
necesario construir un Coche. Pero hemos adaptado las acciones del constructor para personalizar
el Deportivo.
Ahora podemos probar las caractersticas en el objeto Conductor, pero modificando un caso ms
para poder implementar el mtodo Cambiar Marcha.
import java.io.*;
public class Conductor

{
{
Deportivo c = new Deportivo();
int opcion = 0;
while (opcion != 4)
{
c.mostrarMenu();
switch (opcion)
{
case 1:
c.acelerarCoche();
www.learning.es
break;
case 2:
c.frenarCoche();
break;
case 3:
c.cambiarMarcha();
break;
}
}
System.out.println("Hasta pronto");
}
}
Como podemos comprobar, en el momento de construir un Deportivo, tambin se construye un

coche, por eso se visualizan los dos mensajes. Pero lo ltimo que quedara segn podemos ver es la
velocidad del objeto que estamos utilizando (240 km/h).
Otra de las ventajas de la herencia es la abstraccin. Gracias a lo que hemos realizado, podemos
manejar un Deportivo igual que un coche. Es decir, conducir un coche y un deportivo es lo mismo,
slo que un deportivo tiene ms caractersticas como la velocidad mxima o el cambio de marchas,
pero el funcionamiento es el mismo por parte del conductor.
Ver Video: Implementacin Herencia, en la Unidad 11, en el

Laboratorio: Proyecto clases agenda
Objetivos:
Manejar las colecciones y la interaccin de clases dentro de un proyecto.
Enunciado:
www.learning.es
Realizar un programa en el que controlaremos el listado de una agenda de contactos.
Mostraremos el siguiente Men:
Insertar Contacto
Mostrar Contacto
Buscar Contacto
Salir
Se realizarn las siguientes acciones:
1. Insertaremos el nombre del contacto, su telfono y su cdigo
2. Mostraremos todos los contactos de la agenda con sus datos personales
3. Buscaremos un contacto, con la posibilidad de buscar mediante el cdigo o el nombre. Una
vez encontrado, mostraremos sus datos asociados.
4. Salir del programa.
Crearemos una clase persona para recuperar desde un nico objeto las caractersticas del contacto.
(Nombre, Telfono y Cdigo)
Como reto, intentar realizar el mismo ejemplo pero con las opciones de eliminar y modificar
contacto, adems de crear mtodos para las acciones que en la solucin son repetitivas.
Solucin:
CODIGO JAVA
CLASE PERSONA
public class Persona
{
private String nombre;
private int telefono;
private short codigo;
{
return this.nombre;
}

{
this.nombre = nom;
}
public int getTelefono()
{
return this.telefono;
}
public void setTelefono(int tlf)

{
this.telefono = tlf;
}
public short getCodigo()
{
return this.codigo;
}
public void setCodigo(short cod)
{
www.learning.es
this.codigo = cod;
}
public Persona(String nombre,int telefono, short codigo)
{
this.nombre=nombre;
this.telefono=telefono;
this.codigo=codigo;
}
}
CLASE AGENDA CONTACTOS
import java.io.*;
import java.util.*;
public class Agenda
{
{
Vector<Persona> miagenda = new Vector<Persona>();
Persona contacto = null;
BufferedReader lector = new BufferedReader(new
int opcion = 0;
while (opcion != 4)
{
mostrarMenu();
System.out.println("Introduzca una opcion");
switch (opcion)
{
case 1:
String nom;
int tlf,cod;
System.out.println("Introduzca nombre:");
nom = lector.readLine();
System.out.println("Introduzca Telefono:");
tlf = Integer.parseInt(lector.readLine());
System.out.println("Introduzca Codigo:");
cod = Integer.parseInt(lector.readLine());
contacto=new Persona(nom,tlf,(short)cod);
miagenda.addElement(contacto);
break;
case 2:
for (int i=0; i< miagenda.size(); i++)
{
contacto = miagenda.elementAt(i);
System.out.println("Contacto: "+contacto.getNombre()+",
Telefono: "
+contacto.getTelefono()+", Codigo:
"+contacto.getCodigo());
}
break;
case 3:
int codigo=0;
String nombre="";
int seleccion;
System.out.println("Seleccione una opcion de busqueda");
System.out.println("\n1.-Nombre");
www.learning.es
System.out.println("2.- Codigo");
seleccion=Integer.parseInt(lector.readLine());
boolean encontrado = false;
switch (seleccion)
{
case 1:
System.out.println("Introduzca el NOMBRE a buscar");
nombre=lector.readLine();
{
if (contacto.getNombre().equals(nombre)==true)
{
encontrado = true;
break;
}
}
if (encontrado == true)
{
System.out.println("Contacto:
"+contacto.getNombre()+", Telefono: "
contacto.getTelefono()+", Codigo:
}else{
System.out.println("No se ha encontrado el contacto");

}
break;
case 2:
System.out.println("Introduzca el codigo a buscar");
codigo=Integer.parseInt(lector.readLine());
{
if (contacto.getCodigo() == (short)codigo)
{
encontrado = true;
break;
}
}
if (encontrado == true)
{
System.out.println("Contacto:
"+contacto.getNombre()+", Telefono: "
+contacto.getTelefono()+", Codigo:
}else{
System.out.println("No se ha encontrado el contacto");
}
break;
default:
System.out.println("Opcion Incorrecta");
}
break;
case 4:
System.exit(0);
break;
www.learning.es
default:
System.out.println("Opcion escrita incorrecta");
}
}
}
public static void mostrarMenu()
{
System.out.println("\n1.-Insertar Contacto");
System.out.println("2.-Mostrar Listin");
System.out.println("3.-Buscar Contacto");
System.out.println("4.-Salir\n");
}
}
Actividades
eLearning.
www.learning.es

JAVA

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

JAVA

Cargado por

Copyright:

Formatos disponibles

Mdulo 1

Qu son los objetos?

Ver Video: Tecnologa Java , en la Unidad 1, en el Mdulo 1,

Analizar un problema usando anlisis orientado a

Diseo de clases para crear objetos

Ver Video: Anlisis de Aplicaciones , en la Unidad 2, en el

Instalacin y configuracin del kit de desarrollo de Sun

Instalacin del JDK de Sun.

A continuacin, describimos los directorios y ficheros ms importantes:

Lo primero ser instalarnos el kit de desarrollo de Java:

Procesos para crear un programa en Java

Proceso para crear una aplicacin Java

o Miniaplicaciones (applets) Es el navegador el intrprete y nosotros tenemos que

o Aplicacin (texto o grfica) Utilizaremos el intrprete proporcionado por el JDK de Sun

Utilizando la ventana MS-DOS para compilar aplicaciones Java

Esqueleto de una clase

Sobre la ventana de comandos escribimos:

Tambin podemos escribir el comando dir desde la ventana de comandos de Ms-Dos.

Es el momento de utilizar el intrprete de ficheros .class, nuestro intrprete es el comando

Elementos bsicos del lenguaje y sintaxis de Java

Nombres de las clases, variables y mtodos

Clases Poner en mayscula la primera letra de cada palabra con

Tipos de datos primitivos y variables

Enteros, reales en coma flotante, booleanos, caracteres y cadenas.

Tipo Tamao/Formato Descripcin

Nombres de las variables

Vamos a ver un ejemplo prctico sobre declaracin e inicializacin de variables.

Podremos comprobar el resultado de asignar diferentes tipos de datos en variables:

Alcance de las variables

public class ClaseAmbitoVariables

Antes de usar una variable en Java, debemos declararla, especificando su tipo.

tipodato nombre = valor;

Declaracin de variables de tipo entero

Declaracin de variables de coma flotante

Resultado de la aplicacin ya compilada:

Declaracin de variables de tipo carcter char

Declaracin de variables de tipo boolean

Y el resultado de la compilacin es:

Para forzar la conversin de un tipo a otro se utiliza la siguiente sintaxis:

variable_tipo_A= (tipo_A) variable_tipo_B;

Conversin automtica de tipos de dato

Los tipos del dato y de la variable son compatibles.

El tipo de destino tiene un rango mayor que el de origen.

public class PruebaVariables

Casting entre tipos de datos

Variable Destino = (Tipo de dato destino) valor a asignar;

Como podemos comprobar ahora, el resultado de la compilacin es diferente y ya nos permite

public class PruebaVariables

Ver Video: Tipos de Casting, en la Unidad 4, en el Mdulo 1,

Laboratorio: Casting entre tipos de datos.

Declarar, instanciar e inicializar variables de referencia

Variables static de clase

Variables final o constantes

Constructores de la clase String

Mtodos de la clase String

Introduccin a los flujos o streams

Capturar datos desde teclado

public class LecturaTeclado

Resultado del programa:

Ver Video: Analizar objeto String, en la Unidad 5, en el Mdulo

public class ValidacionEmail

Operadores Aritmticos (Suma, resta, multiplicacin,

Operadores a nivel de bit

Operador ternario if-then-else