Seminario de JAVA - XP

Seminario de JAVA
Your First Cup of Java
.http://java.sun.com/j2se/
Seminario de Java
1
Dept. LSI
Introducción a Java: Historia
(1990) Inicialmente denominado oak y asociado al
proyecto Green de Sun Microsystems, por el
investigador James Gosling.
Razones que llevaron a crear Java:
1. Necesidad de interfaces mucho más cómodas e
intuitivas.
2. Fiabilidad del código y facilidad de desarrollo.
3. Enorme diversidad de controladores electrónicos para
la programación de calculadoras, microondas,
televisión interactiva...
(1993) Tras la llegada de Van Hoff y Shaiao al
equipo de Java, se empieza a pensar en la
posibilidad de habilitar Java para Internet.
Seminario de Java
2
Dept. LSI
Introducción a Java: ¿Por qué Java?
(1995) Bill Joy juzgó que Internet podría llegar a ser el
campo adecuado para disputar a Microsoft su primacía
en el terreno del software, y vio en Java el instrumento
idóneo para llevar a cabo estos planes.
Algunas de las razones que llevaron a Bill Joy a pensar
que Java podría llegar a ser rentable son:
Simple. Ofrece la funcionalidad de otros lenguajes eliminando
características complejas como aritmética de punteros, macros,...
Orientado a Objetos. Todos los datos en Java son objetos.
Robusto. Realiza verificaciones en busca de problemas tanto en
tiempo de compilación como en tiempo de ejecución.
Arquitectura neutra. Compila el código fuente en un código
neutro independiente de la máquina.
Seminario de Java
3
Dept. LSI
Introducción a Java: ¿Por qué Java?
Distribuido. Facilita la interconexión entre maquinas a través
de las librerías.
Seguro. Elimina problemas de seguridad de otros lenguajes
como accesos directos a memoria, casting implícitos, ...
Portable. Los tipos de datos son los mismos
independientemente de la plataforma y máquina.
Interpretado. El código neutro es interpretado por la máquina
virtual de Java en tiempo de ejecución.
Multitarea. Incluye de modo nativo en el lenguaje mecanismos
para la ejecución de múltiples tareas y su sincronización
(threads, objetos de sincronización, ...).
Dinámico. Los módulos y librerías se conectan en tiempo de
ejecución.
Seminario de Java
4
Dept. LSI
Introducción a Java: ¿Por qué Java?
Java y otros lenguajes de programación
Extraido: “Learning Java” Pat Niemeyer et al. O'Reilly, 2000
Seminario de Java
5
Dept. LSI
Introducción a Java: El entorno
Editor
xx.java
Disco
(1)
Compilador
(1)
xx.class
Disco
(2)
(2)
Cargador
MEMORIA PRINCIPAL
(2)
Verificador
(2)
Interprete
.
.
.
(1) javac xx.java
(2) java xx/appletviewer xx.html
Seminario de Java
6
Dept. LSI
Introducción a Java: El entorno
Un programa Java puede ser:
Una aplicación: Programa que se ejecuta
independientemente de cualquier browser.
Un applet: Programa incluido dentro de un
documento html. Su ejecución se realiza cuando
un web browser carga la página web que contiene
el applet, o cuando se utiliza un visualizador de
applets (appletviewer).
<applet code="Clase.class" width="34" height="10">
</applet>
Un programa tiene una estructura u otra en función
de que sea una aplicación o un applet.
Seminario de Java
7
Dept. LSI
Introducción a Java: El entorno
Estructura de un applet
¡mport java.awt.Graphics; // importar la clase Graphics;
import javax.swing.JApplet; // importar la clase JAppelt
public class EjemploApplet extends Applet
{
... // definición de los elementos de la interfaz de usuario
public void init(){ // inicialización del applet, se invoca automáticamente una única
vez
....
}
public void start() { // Se invoca cade vaz que se visualiza el applet
...
}
public void paint( Graphics g){ // Muestra los resultados
...
}
.... // metodos manejadores de eventos
public void stop(){ // Se invoca cuando dejemos de visualizar un applet
...
}
public void destroy() { // Se invoca cuando deja de usarse el applet para liberar
recursos
...
}
}
Seminario de Java
8
Dept. LSI
Introducción a Java: El entorno
Estructura mínima de una aplicación
public class EjemploAplicación
{
... // definición de las variables de instancia.
....// definición de los métodos de instancia de la clase.
public static void main(String args[])
{
...
}
}
Seminario de Java
9
Dept. LSI
Introducción a Java: El
Introducción
El lenguaje
lenguaje
1. Propiedades básicas.
4. Ocultar la implementación.
1. Variables y tipos de datos.
2. Los operadores.
3. El flujo de control.
2. Objetos y clases.
1. Las Interfaces.
2. Los paquetes.
5. Contenedores de objetos.
1. Concepto y tipos de
contenedores.
1. El concepto de objeto y clase.
2. Definición de una clase.
3. Construcción, uso y destrucción de
objetos.
4. Las clases Array y String.
3. Herencia y polimorfismo.
2. Taxonomía de los
contenedores.
3. Funcionalidad de las
colecciones.
4. Funcionalidad de los Map.
1. Reutilización de código.
2. Concepto de herencia.
3. Definición de un jerarquía de
herencia.
4. Conceptos asociados a la herencia.
5. Concepto de polimorfismo.
Seminario de Java
6. Entrada/Salida desde terminal.
7. Manejo de excepciones.
10
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.1.Variables y tipos de datos
Las variables almacenan objetos o “valores puros”.
Tipos de datos.
Tipos primitivos (valores puros).
Tipos referencia (objetos).
Toda declaración de variable debe tener su nombre y su
tipo.
tipo variable (inicialización).
String s = new String('abc'); // se crea la referencia s
y se construye un objeto String que es almacenado en
el montículo(heap) y es referenciado por s.
int x =20; // se crea la variable automática x y se
guarda en la pila(stack) junto con su valor.
Seminario de Java
11
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.1.Variables y tipos de datos
A) Tipos primitivos
Tipo primitivo
Tamaño/formato
Descripción
boolean
--true o false
char
16 bit (Unicode)
un carácter simple
byte
8 bit c.2
entero
short
16 bit c.2
entero
int
32 bit c.2
entero
long
64 bit c.2
entero
float
32 bit SP
punto flotante
double
64 bit DP
punto flotante
char c = 'x';
Character c1 = new Character(c);
Character c1 = new Character('x');
char c = c1.charValue();
Seminario de Java
12
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.1.Variables y tipos de datos
B) Ámbito de variables y vida de los objetos
El ámbito es trozo de código desde el que la variable
puede ser accedida.
{
String s = new String(“abc”);
.... s...
} // fin del ámbito de s
El objeto creado y almacenado en el montículo sigue
existiendo pero no puede ser accedido desde s.
¿Cuándo deja de existir el objeto? Cuando actúe el
recolector de basura.
Seminario de Java
13
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.1.Variables y tipos de datos
C) Categorías de variables según su ámbito
Variables miembro de clase o de objeto, declaradas en la
clase.
class A
{ private int x;
...
} // x es accesible desde el código de la clase (métodos)
Variables locales declaradas dentro de un método o
bloque de código (ejemplo pag. 13).
Parámetros de los métodos (argumentos formales).
void func(String s)
{ String s1 = new String(s); // s1 variable local
...s ...
} // fin del ámbito de s
Seminario de Java
14
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.2. Los operadores.
Un operador realiza alguna función entre operandos (uno o
dos)
Tipo de operador
Unario
Aritméticos
Relacional
Lógicos (y de bit)
Condicional ternario
Asignación
Seminario de Java
Operador
+ - ++ -* / % + - << >>
> < >= <= == !=
! && || & | ^ ~
?: (A>B? X:Y)
= (y asignaciones compuestas *=, ..)
15
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3. El flujo de control.
Tipo estamento
Toma de decisión
Iteraciones
Otros
if (expresión condicional)
sentencia;
if (expresión condicional)
sentencia;
else
sentencia;
Seminario de Java
Estamento
if-else, switch
While, do-while, for
Return, break, continue
If (x >5)
if( y >5)
System.out.println(“x >5; y > 5”);
else
System.out.println(“x >5; y<=5”);
if (x >5)
{if( y >5)
System.out.println(“x >5; y > 5”);}
else
System.out.println(“x <=5”);
16
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3. El flujo de control.
switch(selector){
case valor1: sentencia1; break;
case valor2: sentencia2; break;
...
default: sentencia3;
}
if(selector== valor1)
sentencia1;
else
if (selector ==valor2)
sentencia2;
....
else
sentencia 3;
switch (dia) {
case 1: System.out.println(“lunes”); break;
case 2: System.out.println(“martes”); break;
case 3: System.out.println(“miercoles”); break;
case 4: System.out.println(“jueves”); break;
case 5: System.out.println(“viernes”); break;
case 6: System.out.println(“sabado”); break;
case 7: System.out.println(“domingo”); break;
default: System.out.println(“dia ilegal”); break;
}
Seminario de Java
17
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3.El flujo de control.
while(Expresión-condicional)
sentencia;
public class PruebaWhile {
public static void main(String [] args)
{
int count = 1;
while (count<=10){
System.out.println(count %2 == 1? "*****": "-----");
count++;
}
}
}
Seminario de Java
18
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3.El flujo de control.
do
sentencia;
while(Expresión-condicional);
public class PruebaDoWhile {
public static void main(String [] args)
{
int count = 1;
do {
System.out.println(count %2 == 1? "*****": "-----");
count++;
}while (count<=10);
}
}
Seminario de Java
19
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3.El flujo de control.
for (inicialización; expresión-condicional; incremento)
sentencia;
public class TablaMultiplicar {
public static void main (String [] args){
for (int x = 1; x <=9;x++)
System.out.print("\t" + x);
System.out.println();
System.out.println();
for (int x= 1; x<=9; x++){
System.out.print(x);
for (int y= 2; y<=9; y++)
System.out.print("\t" + x*y);
System.out.println();
}
}
}
Seminario de Java
20
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3.El flujo de control.
return expresión
// indica devolución de control y de objetos, cuando
// no es void, en los métodos
public class PruebaReturn {
public static int prueba (int i, int j){
if (i<j) return 1;
else if(i>j) return -1;
else return 0;
}
public static void main (String [] args){
Random aleatorio = new Random();
int k,l;
l = aleatorio.nextInt() % 100;
k = aleatorio.nextInt() % 100;
System.out.println(prueba(l,k));
}
}
Seminario de Java
21
Dept. LSI
Java (El lenguaje):Propiedades básicas
1.3.El flujo de control.
break; // salida de un bucle a la siguiente sentencia de fin de iteración
continue; // salida de un iteración al principio del bucle para
// comenzar la siguiente iteración
public class PruebaBreakContinue {
public static void main (String [] args){
int i=0;
while (true){
i++;
if (i == 10) break;
if (i%2==1) continue;
System.out.println(i);
}
}
}
Seminario de Java
22
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.1 El concepto de objeto y clase.
Objeto: Entidad software con capacidad de procesamiento,
el cual se caracteriza por una identidad, un estado y un
funcionamiento.
Estado
Funcionamiento
Seminario de Java
23
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.1 El concepto de objeto y clase.
Los objetos se relacionan entre si: El estado de un objeto
puede estar definido por el estado de otros objetos que
forman parte de él.
Otro objeto ...
Seminario de Java
24
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.1 El concepto de objeto y clase.
Los objetos se comunican entre si a través del envío de
mensaje.
Ob1
Ob2
Ob2.ope2()
Objeto emisor
Seminario de Java
Objeto receptor
25
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.1 El concepto de objeto y clase.
Una Clase es la especificación de un conjunto de objetos
que poseen las mismas características: mismos atributos
que definen su estado y misma capacidad de procesamiento
que define su funcionamiento.
Las clases en Java son plantillas que nos definen a un
conjunto de objetos que cumplen con lo especificado en la
clase.
En Java la unidad de programación es la clase.
Para la construcción de objetos (unidad de procesamiento
en Java) se recurre a la instanciación de la clase.
String s = new String(“abc”);
Seminario de Java
26
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
La definición de una clase se compone de dos partes:
declaración { cuerpo}
La declaración tiene la siguiente sintaxis:
[public][abstract|final] class NomClase
[extends NomSuperClase]
[implements NomInterface, ...]
public: clase que puede ser usada fuera del paquete en el
que está definida.
abstract: clase que no puede ser instanciada, no pueden
construirse objetos de esa clase.
final: clase no puede tener subclases en una relación de
herencia.
extends: define la relación de herencia.
implements: indica la interface que implementa la clase.
Seminario de Java
27
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
El cuerpo de la clase se compone de:
Declaración de variables miembro.
Implementación de los métodos miembro.
Sintaxis de una declaración de variable miembro:
[especificadorAcceso][static][final] tipo nomVar [=inicialización];
especificadorAcceso: Definen el acceso a la variable.
static: Variable miembro de clase.
final: Variable que es una constante.
inicialización: valor que toma esa variable en su
definición.
Seminario de Java
28
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
Implementación de los métodos miembro.
declaración {cuerpo}
Sintaxis de la declaración:
[especificadorAcceso] [static] [abstract|final] returnType
nomMetodo ([listParametros]) [throws listaExcepciones];
especificadorAcceso: Definen el acceso al método.
static: Método miembro de clase.
abstract: Método sin implementación.
final: Método que no puede ser redefinido.
throws: especificación del tipo de excepciones que
puede lanzar el método.
Seminario de Java
29
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
El cuerpo contiene el código Java que implementa el
método, en particular:
Declaración e inicialización de variable locales.
Envío de mensajes a otros objetos, que sean visibles
desde ese método.
Dentro del código de un método, se puede hacer uso de
las pseudovaribles this y super. Tanto this como super
referencia al objeto receptor del mensaje.
this.oper(); // envío de mensaje al propio objeto receptor.
super.oper(); // igual que this salvo que oper() debe
// buscarse a partir de la superclase.
Seminario de Java
30
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
Especificador de acceso
private
.package
.protected
.public
La clase La subclaseEl paquete La demás
X
X
X
X
X
X
X
X
X
X
Valor por defecto del modificador de acceso es package
Seminario de Java
31
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
Devolución de objetos por un método
(returnType)
Tipo del dato u objeto que se devuelve o void si no se
devuelve nada.
En la implementación del método se usa el operador
return para devolver un objeto.
Cuando se devuelve un tipo interface, el objeto devuelto
debe pertenecer a alguna de la clases que implementa la
interface.
Se devuelve una refencia al objeto.
Seminario de Java
32
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
Nombre del método
(nomMetodo)
Sobrecarga de métodos: Múltiples métodos dentro de la
misma Clase con el mismo nombre, se diferencian por el
número y tipo de los argumentos.
Los constructores:
Encargados de la construcción e inicialización de
objetos.
Deben tener el mismo nombre de la clase.
Sólo son llamados con el operador new.
Pueden estar sobrecargados.
Una clase puede redefinir métodos heredados,
manteniendo su nombre, el tipo devuelto, y la lista de
parámetros.
Seminario de Java
33
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
Paso de información en los envíos de mensajes.
En los envíos de mensaje, llamada a métodos de un objeto,
los objetos son pasados por valor.
Los valores de tipos primitivos no cambian su valor fuera
del ámbito del método.
En un envío de mensaje, a los objetos pasados como
parámetros, no se le podrá cambiar la referencia, pero sí
modificar el estado del objeto usando sus métodos.
Seminario de Java
34
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
.package ejemplo1;
import java.lang.*;
// Clase Punto
public class Punto {
private float x; // coordenada x
private float y; // coordenada y
//Constructor
public Punto(float xValue, float
yValue) {
x=xValue;
y=yValue;
}
public Punto(Punto p0){
x = p0.getX();
y = p0.getY();
}
Seminario de Java
// Modificadores
public void setX(float xValue) {
x=xValue;
}
public void setY(float yValue) {
y=yValue;
}
// Consultores
public float getX() {
return x;
}
public float getY() {
return y;
}
public String toString() {
return "[" + getX() + "," + getY() + "]";
}
35
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
package ejemplo1;
import java.lang.*;
// Clase Rectangulo
public class Rectangulo {
private Punto esqSupDer;// esquina superior derecha
private Punto esqInfIzq; // esquina inferior izquierda
//Constructores
public Rectangulo(float x1, float y1, float x2, float y2) {
esqSupDer = new Punto(x1,y1);
esqInfIzq = new Punto(x2,y2);
}
public Rectangulo(Punto p1, Punto p2){
esqSupDer = new Punto(p1);
esqInfIzq = new Punto(p2);
}
Seminario de Java
36
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
// Modificadores
public void trasladar(Punto p0) {
esqSupDer.setX(p0.getX() +esqSupDer.getX());
esqSupDer.setY(p0.getY() +esqSupDer.getY());
esqInfIzqr.setX(p0.getX() +esqInfIzq.getX());
esqInfIzqr.setY(p0.getY() +esqInfIzq.getY());
}
public void setEsqSup(Punto p0){
esqSupDer.setX(p0.getX());
esqSupDer.setY(p0.getY());
}
public void setEsqInf(Punto p0){
esqInfIzqr.setX(p0.getX());
esqInfIzqr.setY(p0.getY());
}
Seminario de Java
37
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.2. Definición de una clase.
// Consultores
public float altura() {
return esqSupDer.getY() - esqInfIzq.getY();
}
public float anchura(){
return esSupDer.getX() - esqInfIzq.getX();
}
public float area(){
return this.altura() * this.anchura();
}
public float perimetro(){
return (this.altura()) *2 + ((this.anchura()) * 2;
}
public String toString() {
return esqInfIzq.toString() + " , " +
esqSupDer.toString();
}
Seminario de Java
38
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construcción, uso y destrucción de objetos.
Orden en el proceso de construcción/inicialización de
Objetos.
1. La primera vez que se referencia una clase, el
interprete de Java la busca y la carga en memoria.
2. Se ejecutan (una única vez) todos sus inicializadores
de sus variables estáticas (static).
3. Cuando se construye un objeto de la clase, se guarda
suficiente espacio en la memoria dinámica
(montículo) para almacenar el objeto.
4. Se inicializan todas sus variables miembro de forma
automática.
5. Se ejecutan la inicialización indicada en la definición
de sus variables miembro.
6. Se ejecuta el constructor (inicializador).
Seminario de Java
39
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construcción, uso y destrucción de objetos.
Class A1 {
A1(int valor)
{
System.out.println("Constructor A1 con " +
valor);
}}
class B1 {
RESULTADO
A1 a1 = new A1(1);
B1 () {
Antes de construir b de B1
System.out.println("Entrada constructor B1");
Constructor A1 con 0
a2 = new A1(3);
System.out.println("Salida constructor B1"); Constructor A1 con 1
Constructor A1 con 2
}
Entrada Constructor de B1
A1 a2 = new A1(2);
Constructor A1 con 3
static A1 as = new A1(0);
Salida constructor B1
}
Despues de construir b de B1
public class C1 {
public static void main(String[] args) {
System.out.println("Antes de construir b de B1");
B1 b = new B1();
System.out.println("Despues de construir b de
B1");
}}
Seminario de Java
40
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construción, uso y destrucción de objetos.
Class A1 {
A1(int valor)
{
System.out.println("Constructor A1 con " +
valor);
}}
class B1 {
RESULTADO
A1 a1 = new A1(1);
B1 () {
System.out.println("Entrada constructor B1"); Constructor A1 con 0
Antes de construir b de B1
a2 = new A1(3);
System.out.println("Salida constructor B1"); Constructor A1 con 1
Constructor A1 con 2
}
A1 a2 = new A1(2);
Entrada Constructor de B1
static A1 as = new A1(0);
Constructor A1 con 3
}
Salida constructor B1
public class C1 {
Despues de construir b de B1
public static void main(String[] args) {
A1 a = B1.as;
System.out.println("Antes de construir b de B1");
B1 b = new B1();
System.out.println("Despues de construir b de
B1");
}}
Seminario de Java
41
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construcción, uso y destrucción de objetos.
El uso de un objeto es siempre a través del envío de mensaje a
ese objeto.
a.mens(parametros)
En un momento determinado de la ejecución del programa
tenemos dos estructuras (grafos dirigidos):
una que contiene la relaciones estructurales entre
objetos (estructura estática),
y otra que contiene las relaciones de uso a través del
envío de mensaje (estructura dinámica).
La destrucción de un objeto se realiza de forma automática por
parte del recolector de basura. Cuando un objeto deja de ser
referenciado, el recolector de basura lo elimina de la memoria
dinámica. (B. Eckel 2002, p-147-150).
Un objeto deja de estar referenciado cuando la variable deja de
estar en su ámbito o cuando se le asigna otro objeto.
Seminario de Java
42
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construcción, uso y destrucción de objetos.
Class A1 {
A1(int valor)
{
}
public void fA1 (String c){
System.out.println("control en " + c + " de A1 con
fA1");
}}
class B1 {
A1 a1 = new A1(1);
static A1 as = new A1(0);
public void fB1(String c) {
System.out.println("control en " + c + " de B1 con
fB1");
A1 alocal = new A1(6);
a1.fA1("a1");
RESULTADO
alocal.fA1("alocal");
}}
control en b de B1 con fB1
public class C1 {
control en a1 de A1 con fA1
public static void main(String[] args) {
control en alocal de A1 con fA1
A1 localMain = B1.as;
control en localMain de A1 con fA1
B1 b = new B1();
b.fB1("b");
localMain.fA1("localMain");
}}
Seminario de Java
43
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.3. Construcción, uso y destrucción de objetos.
Estructura estática
Estructura dinámica
.b
.a1
C1
.llocalMain
B1
Seminario de Java
.aLocal
.as
44
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
La clase Array es una clase Contenedora de objetos del mismo
tipo, accedidos a través de un índice y de tamaño (cantidad de
objetos que puede almacenar) fijo.
Declaración de variable de tipo Array y construcción de objetos.
Sin inicialización explícita:
int[] arr1 = new int[tamaño]
Con inicialización explicita de sus elementos:
int[] arr2 = {1, 2, 3, 4}
En general, para objetos de tipo A:
A[] a1 = new A[tamaño] // inicializados a null
A[] a1 ={new A(,..), new A(,..),...}
Seminario de Java
45
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Funcionalidad de los objetos Array.
Consultor del numero de elemento de un objeto Array.
A[] a = new A[tamaño];
int longitud = a.length ;
Operador de acceso, [], a sus elementos:
A a1 = a[i] // consultor con 0<=i <tamaño;
a[i] = a1; // modificador;
Seminario de Java
46
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Ejemplos de Array
public class SumArray {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9};
int total = 0;
for (int i = 0; i<arr.length; i++)
total += arr[i];
System.out.println("total = " + total);
}
}
Seminario de Java
47
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
import javax.swing.*;
import java.lang.*;
public static void bubbleSort(int arr[]){
for( int j = 1; j< arr.length; j++) {
for(int k =0; k<arr.length-1; k++) {
if (arr[k] > arr[k+1])
this.swap(arr,k,k+1);
}
}
}// fin del método bubbleSort
public class BubbleSort {
public static void main(String args[]) {
JTextArea areaSalida = new JTextArea();
String salida = "array antes de ordenar \n";
int[] array ={3,2,4,20,5,50,1,6,8,2,0,50};
for(int i=0; i<array.length; i++)
salida += " " + array[i];
public static void swap(int ar[], int pr, int se)
{
int inter;
inter =ar[pr];
ar[pr]= ar[se];
ar[se]= inter;
}// fin del método swap
bubbleSort(array);
salida += "\n\narray despues de ordenados
\n";
for(int i=0; i<array.length; i++)
salida += " " + array[i];
areaSalida.setText(salida);
JoptionPane.showMessageDialog(null,
outputArea, "ordenar array",
JOptionPane.INFROMATION_MESSAGE);
} // fin del main
Seminario de Java
48
}// fin de la clase
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
import javax.swing.*;
import java.lang.*;
import java.awt.*;
Public void bubbleSort(int arr[]){
for( int j = 1; j< arr.length; j++) {
for(int k =0; k<arr.length-1; k++) {
if (arr[k] > arr[k+1])
this.swap(arr,k,k+1);
}
}
}// fin del método bubbleSort
public class BubbleSort extends JApplet {
public void init() {
JTextArea areaSalida = new JTextArea();
Container container = getContentPane();
container.add(areaSalida);
String salida = "array antes de ordenar \n";
int array[] ={3,2,4,20,5,50,1,6,8,2,0,50};
for(int i=0; i<array.length; i++)
salida += " " + array[i];
this.bubbleSort(array);
salida += "\n\narray despues de ordenados
\n";
public void swap(int ar[], int pr, int se){
int inter;
inter =ar[pr];
ar[pr]= ar[se];
ar[se]= inter;
}// fin del método swap
}// fin de la clase
for(int i=0; i<array.length; i++)
salida += " " + array[i];
areaSalida.setText(salida);
} // fin del init
Seminario de Java
49
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Array bidimensionales
Columna 0 Columna 1 Columna2 Columna 3
Fila 0
Fila 1
A[0][0]
A[1][0]
A[2][0]
A[0][1]
A[1][1]
A[2][1]
A[0][2]
A[1][2]
A[2][2]
A[0][3]
A[1][3]
A[2][3]
ClaseA A[][] =new ClaseA[3][4];
ClaseA A[][] = {{1,2,3,4},{5,6,7,8},{9,0,10,11}};
Columna 0Columna 1Columna2 Columna 3
Fila 0
A[0][0]
A[0][1]
Fila 1
A[1][0]
A[1][1]
A[0][2]
A[0][3]
ClaseA A[][] =new ClaseA[][];
A[0]= new ClaseA[4]; A[1] =new ClaseA[2];
Seminario de Java
50
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
import javax.swing.*;
import java.lang.*;
public class bidimensional {
public static void main(String[] args) {
String salida = "\t0 \t1 \t2 \n";
int arr[][] = new int[3][3];
for (int i = 0; i< arr.length; i++)
for (int j= 0; j< arr[0].length; j++)
arr[i][j] = i*j;
for (int k =0; k < arr.length; k ++)
{salida += k + "\t";
for(int l =0; l<arr[0].length; l++)
salida += arr[k][l] + "\t";
salida += "\n";
};
JTextArea areaSalida = new JTextArea();
areaSalida.setText(salida);
JOptionPane.showMessageDialog(null, areaSalida, "bidimensional prueba",
JoptionPane.INFORMATION_MESSAGE);
}}
Seminario de Java
51
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
La clase String es una clase que modela objetos de tipo cadena de
caracteres.
Declaración de variable de tipo String y construcción de objetos.
Sin inicialización explícita:
String s1 = new String();
Con inicialización explícita de sus elementos:
String s2 = new String(s);
String s3 = ''un string'';
Seminario de Java
52
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Funcionalidad de la clase String.
Consultores
String s1 = new String(''prueba de los String'');
Longitud de un String: length
int l = s1.length;
Obtener un carácter: charAt(int)
char c = s1.charAt(i)
Obtener un rango de caracteres: getChars(int,int,char[],
int)
char[] arrChar = new char[6];
s1.getChars(0,5,arrChar,0);
Seminario de Java
53
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Comparando String
String s1 = new String(''un string'');
String s2 = ''hola'';
String s3 = new String(''hola'');
Igualdad de objetos:
s2.equals(s3) // true
s2.equalsIgnoreCase(''Hola'') // true
s1.compareTo(s2) // 1
s2.compareTo(s1) // -1
s2.compareTo(s3) // 0
Identidad de objetos: == String
s2 == s3 // false
s2 == ''hola'' // true
Seminario de Java
54
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Localizando caracteres y substring.
String s1 = ''dekjfdhf dejsfaou sahoun string'';
s1.indexOf('d') // 0
s1.lastIndexOf('d') // 8
s1.indexOf('y') // -1
s1.indexOf(''de'') // 0
s1.lastIndexOf(''de'') //9
s1.lastIndexOf(''yyy'') // -1
Extraer substring:
s1.substring(25) // ''tring''
s1.substring(2,6) // ''kjfd''
Concatenar String
String s1= ''buenos '';
String s2 = ''dias'';
String s3 = s1.concat(s2) // ''buenos dias''
Seminario de Java
55
Dept. LSI
Java (El lenguaje):Los objetos y las clases.
2.4. Las clases Array y String.
Modificadores
String s1 = ''hola''
s1.replace('h','H') // ''Hola''
s1.toUpperCase() // ''HOLA''
s1.toLowerCase() // ''hola''
char[] arrChar = s1.toCharArray() // ['h','o','l','a']
Convertir tipos primitivos a String: El método static
valueOf de la clase String.
String.valueOf(tipoPrimitivo);
String.valueOf(73); // ''73''
Seminario de Java
56
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.1. Reutilización de código.
Dos forma de reutilización de código:
La composición: Creación y uso de objetos ya
definidos dentro de la clase que estamos definiendo
(reutilización de la funcionalidad del código).
Ejemplo, en la definición del Rectángulo el uso de
Punto.
La herencia: Definición de una clase a partir de otra
que ya existe, añadiéndole nuevas propiedades.
NuevaClase = ClaseExistente + nuevas propiedades
Añadiendo algo de código podemos tener un objeto
con estado y funcionalidad más compleja que el
objeto base.
Seminario de Java
57
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.2. Concepto de herencia.
La herencia es el mecanismo que nos proporcionan los
lenguajes de programación para modelar la relación
''es-un''.
Cuando podemos expresar con facilidad que la clase “B
es un A” entonces debemos hacer uso de la herencia
para implementar esa relación.
A la clase B se le denomina subclase y a A superclase.
La herencia puede ser:
Simple: una subclase sólo tiene una superclase.
Múltiple: una subclase puede tener más de una
superclase.
Seminario de Java
58
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de una jerarquía de herencia en Java.
Cuando tengamos definidas todas las relaciones ''es-un'' en
nuestro programa tendremos definida una jerarquía de
herencia que se podrá representar mediante un Grafo
dirigido sin ciclos (herencia múltiple) o mediante un árbol
(herencia simple). En Java tenemos herencia simple.
Figura2D
Rectángulo
Elipse
Point
Seminario de Java
59
Cuadrado
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de un jerarquía de herencia en Java.
public abstract class Figura2D {
public abstract double area();
public abstract double perimetro();
public abstract void trasladar(Point p0);
}
class Rectangulo extends Figura2D {
...
}
class Point {
...
}
Seminario de Java
60
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de un jerarquía de herencia en Java.
public class Elipse extends Figura2D {
private Point centro; // centro de la elipse
private double radio1; // radio menor
private double radio2; // radio mayor
public Elipse(float x1, float y1, double r1, double r2) {
centro = new Point(x1, y1);
radio1 = r1;
radio2 = r2;
}
public Elipse(Point p1, double r1, double r2) {
centro = new Point(p1);
radio1= r1;
radio2 = r2;
}
Seminario de Java
61
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de un jerarquía de herencia en Java.
Public void trasladar(Point p0) {
centro = new Point(p0);
}
public void setRadio1(double r) {
radio1 = r;
}
public void setRadio2 (double r) {
radio2 =r;
}
public double getRadio1() {
return radio1;
}
public double getRadio2() {
return radio2;
}
Seminario de Java
62
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de un jerarquía de herencia en Java.
public double area() {
return Math.PI*radio1*radio2;
}
public double perimetro() {
return Math.PI*2*
Math.sqrt((Math.pow(radio1,2)+Math.pow(radio2,2))/2);
}
public String toString() {
return centro.toString()+" , radio 1= "+radio1+"radio 2
="+radio2;
}
}
Seminario de Java
63
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.3. Definición de un jerarquía de herencia en Java.
public final class Cuadrado extends Rectangulo {
private double lado;
+l));
public Cuadrado(Point p0, double l)
{
super (new Point(p0), new Point(p0.getX()+l,p0.getY()
}
lado =l;
}
Algunos de los métodos heredados de Cuadrado pueden
ser redefinidos por eficiencia
Seminario de Java
64
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.4. Conceptos asociados a la herencia.
Acceso protegido a miembros (protected)
Todos los miembros de una clase definidos como
protected pueden ser accedidos desde la subclase.
Cuando son definidos como privados son heredados
pero no accesibles.
Métodos redefinidos
Método heredado que es nuevamente implementado
en la subclase, anulando al de la superclases.
No confundir redefinición con sobrecarga.
En la redefinición se mantiene la interfaz del
método.
En la sobrecarga se mantiene el nombre del
método.
Seminario de Java
65
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.4. Conceptos asociados a la herencia.
Clases y métodos abstractos.
Método abstracto (abstract): Método sin
implementación.
Clase abstracta (abstract): Clase sin instancias.
Cuando en una clase hay métodos abstractos la clase
debe ser abstracta.
Clases y métodos finales.
Clase final (final): Clase que no puede tener subclases.
Método final (final): Método que no puede ser
redefinido.
Seminario de Java
66
Dept. LSI
Java (El lenguaje):Herencia y polimorfismo.
3.5. Concepto de polimorfismo.
Polimorfismo: variable que referencia a objetos de
distintas clases a lo largo de la ejecución de un
programa.
RESULTADO
El Area del rectangolo es = 2.0
el rectangulo es((1.0,1.0) , (2.0,3.0))
el perimetro del rectangulo es = 6.0
El Area de la elipse es = 18.8495559
El Area del cuadrado es = 9.0
public class PruebaHerencia {
public static void main(String[] args) {
Point p1 = new Point(1,1);
Point p2 = new Point(2,3);
Figura2D fig;
fig = new Rectangulo(p1,p2);
System.out.println("El Area del rectangolo es = " + fig.area());
System.out.println("el rectangulo es" + ((Rectangulo)fig).toString());
System.out.println("el perimetro del rectangulo es = " + fig.perimetro());
fig = new Elipse(p1,2,3);
System.out.println("El Area de la elipse es = " + fig.area());
fig = new Cuadrado(p1,3);
System.out.println("El Area del cuadrado es = " + fig.area());
}
}
Seminario de Java
67
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.1 Las interfaces.
Una interfaz describe el comportamiento de alguna entidad,
indicando la definición de sus operaciones. Una interfaz no
incluye ni la implementación de esas operaciones ni los
atributos de esa entidad.
Una interfaz para poder ser usada debe estar implementada en
una clase.
<<interface>> IntA
ClaA
oper1();
oper2();
Interface IntA{
public void oper1();
public void oper2();
}
Seminario de Java
atrib
operA()
Class ClaA implements IntA{
private int atrib;
public void operA() {...}
public void oper1() {...}
public void oper2() {...}
}
68
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.1 Las interfaces.
Una interfaz puede ser usada en cualquier definición de
tipo, cuando ese elemento va a ser usado tiene que haber
un objeto de alguna de las clases que implementan la
interfaz.
Cuerda
<<interface>>Instrumento
void tocar()
String que()
void ajustar()
void tocar()
String que()
void ajustar()
Viento
Percusión
void tocar()
String que()
void ajustar()
void tocar()
String que()
void ajustar()
Madera
Metal
String que()
String que()
Seminario de Java
69
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.1 Las interfaces.
interface Instrumento {
void tocar();
String que();
void ajustar();
}
public class Cuerda implements Instrumento
{
public void tocar(){
System.out.println("doooo.reeeee");
}
public String que(){
return "Cuerda";
}
public void ajustar(){
System.out.println("do.re");
}
}
Seminario de Java
public class Percusion implements Instrumento
{
public void tocar(){
System.out.println("miiiiiii.faaaaa");
}
public String que(){
return "Percusin";
}
public void ajustar(){
System.out.println("mi.fa");
}
}
70
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.1 Las interfaces.
abstract public class Viento implements Instrumento {
public void tocar() {
System.out.println("solllll.laaaa.siiiii");
}
abstract public String que();
public void ajustar(){
System.out.println("sol.la.si");
}
}
public class Madera extends Viento {
Public class Metal extends Viento{
public String que(){
return "Viento.Madera";
public String que(){
return "Viento.Metal";
}
}
}
Seminario de Java
}
71
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.1 Las interfaces.
public class Concierto {
public static void main(String[] args) {
Instrumento[] orquesta = new Instrumento[4];
int i =0;
orquesta[i++] = new Cuerda();
orquesta[i++] = new Percusion();
orquesta[i++] = new Metal();
orquesta[i++] = new Madera();
// composicin de la orquesta
for (i=0; i< orquesta.length; i++)
System.out.println(orquesta[i].que());
// afinar la orquesta
for (i=0; i< orquesta.length; i++)
orquesta[i].ajustar();
// concierto
for (i=0; i< orquesta.length; i++)
orquesta[i].tocar();
RESULTADO
Cuerda
Percusion
Viento.Metal
Viento.Madera
do.re
mi.fa
sol.la.si
sol.la.si
doooo.reeeee
miiiiiii.faaaaa
solllll.laaaa.siiiii
solllll.laaaa.siiiii
}
}
Seminario de Java
72
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.2 Los paquetes.
La unidad básica de construcción en Java es la Clase. Un
conjunto de clases(biblioteca de componentes) pueden ser
agrupadas formando una unidad cohesiva, para ello se usa
el término package. Para usar algún elemento de esa
unidad hay que importarlo, para ello se usa el término
import.
package miPaquete;
public class MiClase {
...
}
package miPaquete;
public class TuClase {
...
}
Seminario de Java
import miPaquete;
public class ClasePrueba {
...
// Uso de todos las propiedades definidas
// en miPaquete como públicas
...
}
73
Dept. LSI
Java (El lenguaje):Ocultar la implementación.
4.2 Los paquetes.
La clase La subclaseEl paquete Las demás
X
private
X
X
X
protected
X
X
.package
X
X
X
X
.public
B
A
A1
A2
B1
B2
<<import>>
Seminario de Java
74
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.1 Concepto y tipos de contenedores
Un contenedor de objetos puede almacenar cualquier
clase de objetos, el comportamiento del contenedor
viene determinado por el tipo de contenedor que se use.
Un contenedor no puede almacenar datos de tipo
primitivo, tan sólo objetos.
Tipos generales de contenedor:
Colección (Collection): Grupo de objetos individuales
que se agrupan siguiendo una determinada regla.
Mapa (Map): Grupo de pares de objetos clave-valor
(diccionario).
Seminario de Java
75
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.1 Concepto y tipos de contenedores
import java.util.*;
public class Contenedores1 {
static Collection rellenar(Collection c){
RESULTADO
c.add("perro");
[perro, gato]
c.add("gato");
{1=perro, 2=gato}
return c;
}
static Map rellenar(Map m){
m.put("1","perro");
m.put("2","gato");
return m;
}
public static void main(String [] args){
System.out.println(rellenar(new ArrayList()));
System.out.println(rellenar(new HashMap()));
}
}
Seminario de Java
76
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.2 Taxonomía de los contenedores.
Map
Collection
List
Set
ArrayList LinkedList
HashSet
Seminario de Java
77
HashMap
TreeMap
TreeSet
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.2 Taxonomía de los contenedores.
List
Colección de elementos con un orden determinado.
ArrayList
Una List implementada con un array.
LinkedList
Una List con implementación optimizada para eliminar
e insertar en cualquier posición.
Set
Colección de elementos sin orden y sin duplicados.
HashSet
Un Set implementado mediante una tabla hash.
TreeSet
Un Set implementado mediante un tree.
Map
Colección de pares de:(clave, valor) sin duplicados
de clave.
Seminario de Java
78
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
.boolean add(Object)
Añade un objeto a la colección, devuelve false si no lo añade
boolean addAll(Collection)
Añade una colección de objetos a la colección, devuelve false si no
la añade
void clear()
Elimina todos los objetos de la colección.
.boolean contains(Object)
Devuelve true si el objeto está en la colección, false en caso
contrario
.boolean containsAll(Collection)
Devuelve verdadero cuando todos los objetos de la colección están
incluidos en nuestra colección.
.boolean isEmpty()
Devuelve true si la colección no tiene elementos, false en caso
contrario
Seminario de Java
79
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
Iterator iterador()
Devuelve un iterador que puede ser usado para recorrer los
elementos de la colección
.boolean remove(Object)
Elimina un objetos de la colección, devuelve true si es eliminado,
y false en caso contrario
.boolean removeAll(Collection)
Elimina los elementos de la colección que se encuentren en nuestra
coleccion, devuelve true si se ha eliminado alguno.
.boolean retainAll(Collection)
Mantiene sólo los elementos de la colección que se encuentren
en nuestra colección, devuelve true si hubo cambios.
.int size()
Devuelve el número de elementos de la colección.
Object[] toArray()
Devuelve un Array con todos los elementos de la colección.
Seminario de Java
80
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
import java.util.*;
import java.awt.Color;
public class Contenedores2 {
private static final String colores[] = {"rojo","verde","azul"};
}
public Contenedores2(){
List lista = new ArrayList();
lista.add(Color.MAGENTA);
for(int i=0; i<colores.length; i++)
lista.add(colores[i]);
System.out.println(" la lista completa es: ");
Iterator itList= lista.iterator();
while(itList.hasNext())
System.out.println(itList.next() + ", ");
}
RESULTADO
public static void main(String [] args){
la lista completa es:
new Contenedores2();
java.awt.Color[r=255,g=0,b=255]
}
rojo
Seminario de Java
verde
azul
81
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
import java.util.*;
import java.awt.Color;
public class Contenedores3 {
private static final String colores1[] = {"rojo","verde","azul"};
private static final String colores2[] = {"blanco", "negro", "gris"};
public void print(List l){
ListIterator itList = l.listIterator();
System.out.println("LISTA:");
while(itList.hasNext())
System.out.print(itList.next()+ " ");
System.out.println();
}
public static void main(String [] args)
{
new Contenedores3();
}
Seminario de Java
82
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
.public Contenedores3(){
List lista1 = new LinkedList();
List lista2 = new LinkedList();
RESULTADO
for(int i=0; i<colores1.length; i++){ LISTA:
lista1.add(colores1[i]);
rojo verde azul blanco negro gris
lista2.add(colores2[i]);}
LISTA:
lista1.addAll(lista2);
rojo verde azul blanco negro negro gris
print(lista1);
LISTA:
lista1.add(4,"negro");
rojo verde azul blanco negro gris
print(lista1);
LISTA:
lista1.remove("negro");
rojo verde azul
print(lista1);
LISTA:
lista1.removeAll(lista2);
azul verde rojo
print(lista1);
ListIterator itL = lista1.listIterator(lista1.size());
System.out.println("LISTA:");
while(itL.hasPrevious())
System.out.print(itL.previous() + " ");
System.out.println();
}
}
Seminario de Java
83
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar colecciones
import java.util.*;
public class Sort1 {
private static final String cartas[] = { "Oros", "Copas", "Espadas", "Bastos" };
private void printElements() {
List list = new LinkedList( Arrays.asList( cartas ) );
System.out.println( "Elementos desordenados:\n" + list );
Collections.sort( list ); // sort ArrayList
System.out.println( "Elementos ordenados ascendentemente:\n" + list );
Collections.sort(list,Collections.reverseOrder());
System.out.println( "Elementos ordenados descendentemente:\n" + list );
}
public static void main( String args[] ){
new Sort1().printElements();
RESULTADO
}
Elementos desordenados:
[Oros, Copas, Espadas, Bastos]
}
Elementos ordenados ascendentemente:
[Bastos, Copas, Espadas, Oros]
Elementos ordenados descendentemente:
[Oros, Espadas, Copas, Bastos]
Seminario de Java
84
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar colecciones
import java.util.*;
public class Sort3 {
public void printElements() {
List list = new ArrayList();
RESULTADO
Elementos desordenado:
[06:24:34, 18:14:05, 12:07:58]
Elementos ordenados:
list.add( new Time2( 6, 24, 34 ) );[06:24:34, 12:07:58, 18:14:05]
list.add( new Time2( 18, 14, 05 ) );
list.add( new Time2( 12, 07, 58 ) );
System.out.println( "Elementos desordenado:\n" + list );
Collections.sort( list, new TimeComparator() );
System.out.println( "Elementos ordenados:\n" + list );
}
public static void main( String args[] ) {
new Sort3().printElements();
}
Seminario de Java
85
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar colecciones
private class TimeComparator implements Comparator {
int hourCompare, minuteCompare, secondCompare;
Time2 time1, time2;
public int compare( Object object1, Object object2 ){
time1 = ( Time2 ) object1;
time2 = ( Time2 ) object2;
hourCompare = new Integer( time1.getHour() ).compareTo(
new Integer( time2.getHour() ) );
if ( hourCompare != 0 ) return hourCompare;
minuteCompare = new Integer( time1.getMinute() ).compareTo(
new Integer( time2.getMinute() ) );
if ( minuteCompare != 0 )
return minuteCompare;
secondCompare = new Integer( time1.getSecond() ).compareTo(
new Integer( time2.getSecond() ) );
return secondCompare; // return result of comparing seconds
}
} // fin de la clase TimeComparator
} // fin de la clase Sort3
Seminario de Java
86
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar colecciones
import java.util.*;
class Card {
private String palo;
private String numero;
public Card( String iniPalo, String iniNumero ){
palo = iniPalo;
numero = iniNumero;
}
public String getPalo() {
return new String(palo);
}
public String getNumero() {
return new String(numero);
}
public String toString() {
StringBuffer buffer = new StringBuffer( numero + " de " + palo );
buffer.setLength( 30 );
return buffer.toString();
}
} // end class Card
Seminario de Java
87
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar
public class Juego {
colecciones
}
private static final String palos[] = { "Oros", "Copas", "Espadas", "Bastos" };
private static final String numeros[] = { "Uno", "Dos", "Tres",
"Cuatro", "Cinco", "Seis", "Siete", "Sota", "Caballo", "Rey"};
private List list;
public Juego() {
Card baraja[] = new Card[ 40 ];
for ( int count = 0; count < baraja.length; count++ )
baraja[ count ] = new Card(palos[ count / 10 ], numeros[ count % 10 ]);
list = Arrays.asList( baraja ); // get List
Collections.shuffle( list ); // shuffle deck
}
public void printCards() {
int half = list.size() / 2 - 1;
for ( int i = 0, j = half + 1; i <= half; i++, j++ )
System.out.println( list.get( i ).toString() +"\t\t\t" + list.get( j ) );
}
public static void main( String args[] ) {
new Juego().printCards();
}
Seminario de Java
88
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Ordenar colecciones
RESULTADO
Tres de Espadas
Sota de Oros
Sota de Espadas
Cuatro de Bastos
Seis de Oros
Cinco de Bastos
Rey de Oros
Tres de Bastos
Dos de Bastos
Caballo de Copas
Rey de Bastos
Dos de Oros
Sota de Copas
Tres de Copas
Caballo de Bastos
Cinco de Oros
Cuatro de Oros
Uno de Oros
Rey de Espadas
Cuatro de Copas
Uno de Espadas
Siete de Bastos
Cinco de Espadas
Siete de Espadas
Sota de Bastos
Seis de Espadas
Dos de Copas
Siete de Copas
Seis de Copas
Seis de Bastos
Uno de Bastos
Siete de Oros
Cinco de Copas
Caballo de Oros
Dos de Espadas
Rey de Copas
Cuatro de Espadas
Caballo de Espadas
Uno de Copas
Tres de Oros
Seminario de Java
89
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones: Búsqueda de elementos
import java.util.*;
public class Contenedores4B {
private static final String colores[] = {"rojo","verde","azul","blanco", "negro", "gris"};
public static void main(String [] args){
List lista = new ArrayList(Arrays.asList(colores));
Collections.sort(lista);
int result = 0;
result = Collections.binarySearch(lista, colores[0]);
System.out.println("RESULTADO DE LA BÚSQUEDA DE "+ colores[0] + " ES: " + (result >=0?
" encontrado en el indice " + result : " elemento no encontrado "));
result = Collections.binarySearch(lista, "verde");
System.out.println("RESULTADO DE LA BUSQUEDA DE " + "verde" + " ES: " + (result >=0?
" encontrado en el indice " + result : " elemento no encontrado "));
result = Collections.binarySearch(lista, "coblan");
System.out.println("RESULTADO DE LA BUSQUEDA DE "+ "coblan" + " ES: " + (result >=0?
"encontrado en el indice" + result : "elemento no encontrado"));
}
}
RESULTADO
RESULTADO DE LA BÚSQUEDA DE rojo ES: encontrado en el indice 4
RESULTADO DE LA BUSQUEDA DE verde ES: encontrado en el indice 5
RESULTADO DE LA BUSQUEDA DE coblan ES: elemento no encontrado
Seminario de Java
90
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
import java.util.*;
public class Contenedores6 {
private Set conjunto;
public Contenedores6(){
conjunto = new TreeSet();
for (int i=0; i<=5; i++)
conjunto.add(new MiTipo(i));
conjunto.add(new MiTipo(5));
}
RESULTADO
El conjunto es :[5, 4, 3, 2, 1, 0]
public void printSet(){
System.out.println("El conjunto es :" + conjunto);
}
public static void main(String [] args){
new Contenedores6().printSet();
}
Seminario de Java
91
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.3 Funcionalidad de las colecciones
class MiTipo implements Comparable {
private int i;
public MiTipo(int n){i=n;}
public boolean equals (Object o){
return (i ==((MiTipo)o).i);
}
public int hashCode(){
return i;
}
public String toString() {return i + "";}
public int compareTo(Object o){
int i2 = ((MiTipo)o).i;
return (i2<i ? -1 :(i2 ==i ? 0:1));
}
} // fin de la clase MiTipo
}// fin de la clase Contenedores6
Seminario de Java
92
Dept. LSI
Java (El lenguaje):Contenedores de objetos.
5.4 Funcionalidad de los Map (diccionarios).
import java.util.*;
import java.io.*;
public class Contenedores5 {
}}
RESULTADO
Introducir frase:la que la que tu
Resultado : {que=2, la=2, tu=1}
Resultado de la búsqueda:2
public static void main(String [] args) throws IOException {
Map conTerminos = new HashMap();
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Introducir frase");
String s = in.readLine();
StringTokenizer token = new StringTokenizer(s);
while (token.hasMoreTokens()){
String termino = token.nextToken().toLowerCase();
if(conTerminos.containsKey(termino)){
Integer count = (Integer) conTerminos.get(termino);
conTerminos.put(termino,new Integer(count.intValue()+1));
} else
conTerminos.put(termino,new Integer(1));
}
System.out.println("Resultado : " + conTerminos);
if(conTerminos.containsKey("la"))
System.out.println("Resultado de la búsqueda:" + conTerminos.get("la"));
Seminario de Java
93
Dept. LSI
Java (El lenguaje):Entrada/salida desde
terminal
Salidas:
System.out.print(“un string”)
System.out.println(“un string”)
Conversores de tipos a string
Integer.toString(int i)
Double.toString(double d)
Entradas:
BufferedReader in = new BufferedReader(
new InputStreamReader (System.in));
Lectura y conversión de String a otros tipos.
String s = in.readLine();
Double d = Double.valueOf(in.readLine());
Integer i = Integer.valueOf(in.readLine());
Seminario de Java
94
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
Objetivo: Controlar de forma explícita las excepciones
que se puedan producir en ejecución.
Para usar el manejador de excepciones hay que escribir
código:
Para lanzar la excepción y construir el objeto
excepción.
If(t==null) throw new NullPointerException(“t=null”)
Para manejar la excepción.
try {// código que podría generar la excepción
}catch (UnTipoDeExcepcion excepcion1){...
}catch (OtroTipoDeExcepcion excepcion2){...
}
...
finally {// actividades que se ejecutan siempre}
Seminario de Java
95
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
Estructura básica de Java para el manejo de excepciones
Throwable
Error
Exception
RunTimeException
Seminario de Java
IOException
96
OutOfMemoryError
Dept. LSI
...
Java (El lenguaje):Manejo de excepciones.
Ejemplo 1
public class UsingExceptions {
public static void main( String args[] ){
try {
throwException(); // call method throwException
} catch ( Exception exception ) {
System.err.println( "Excepcion manajada en main" );
}
doesNotThrowException(); }
RESULTADO
Método throwException
Excepción manajada en throwException
finally ejecutado en throwException
Excepción manejada en main
Método doesNotThrowException
finally ejecutado en doesNotThrowException
Fin del método doesNotThrowException
Seminario de Java
97
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public static void throwException() throws Exception{
try {
System.out.println( "Método throwException" );
throw new Exception(); // generate exception
} catch ( Exception exception ) {
System.err.println("Excepción manajada en throwException" );
throw exception; // rethrow for further processing
} finally {
System.err.println( "finally ejecutado en throwException" );
}
// cualquier código puesto aquí no se alcanzaría nunca.
} // end method throwException
RESULTADO
Método throwException
Excepción manajada en throwException
finally ejecutado en throwException
Excepción manejada en main
Método doesNotThrowException
finally ejecutado en doesNotThrowException
Fin del método doesNotThrowException
Seminario de Java
98
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public static void doesNotThrowException(){
try {
System.out.println( "Método doesNotThrowException" );
} catch( Exception exception ) {
System.err.println( exception );
} finally {
System.err.println( "finally ejecutado en doesNotThrowException"
}
System.out.println( "Fin del método doesNotThrowException" );
} // fin del método doesNotThrowException
} // fin de la clase UsingExceptions
RESULTADO
Método throwException
Excepción manajada en throwException
finally ejecutado en throwException
Excepción manejada en main
Método doesNotThrowException
finally ejecutado en doesNotThrowException
Fin del método doesNotThrowException
Seminario de Java
99
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
Ejemplo 2
class ListNode {
Object data;
ListNode nextNode;
ListNode( Object object ){
this( object, null );
}
ListNode( Object object, ListNode node ){
data = object;
nextNode = node;
}
Object getObject(){
return data; // return Object in this node
}
ListNode getNext(){
return nextNode; // get next node
}
} // end class ListNode
Seminario de Java
100
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public class List {
private ListNode firstNode;
private ListNode lastNode;
private String name; // string like "list" used in printing
public List() {
this( "list" );
}
public List( String listName ) {
name = listName;
firstNode = lastNode = null;
}
public void insertAtFront( Object insertItem ){
if ( isEmpty() )
firstNode = lastNode = new ListNode( insertItem );
else
firstNode = new ListNode( insertItem, firstNode );
}
public void insertAtBack( Object insertItem ) {
if ( isEmpty() )
firstNode = lastNode = new ListNode( insertItem );
else
lastNode = lastNode.nextNode = new ListNode( insertItem );
}
Seminario de Java
101
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public Object removeFromFront() throws EmptyListException {
if ( isEmpty() ) throw new EmptyListException( name );
Object removedItem = firstNode.data;
if ( firstNode == lastNode )
firstNode = lastNode = null;
else
firstNode = firstNode.nextNode;
return removedItem; // return removed node data
}
public Object removeFromBack() throws EmptyListException {
if ( isEmpty() ) throw new EmptyListException( name );
Object removedItem = lastNode.data; // retrieve data being removed
if ( firstNode == lastNode )
firstNode = lastNode = null;
else { // locate new last node
ListNode current = firstNode;
while ( current.nextNode != lastNode )
current = current.nextNode;
lastNode = current; // current is new lastNode
current.nextNode = null;
}
return removedItem; // return removed node data
}
Seminario de Java
102
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public boolean isEmpty() {
return firstNode == null; // return true if List is empty
}
public void print() {
if ( isEmpty() ) {
System.out.println( "Empty " + name );
return;
}
System.out.print( "The " + name + " is: " );
ListNode current = firstNode;
while ( current != null ) {
System.out.print( current.data.toString() + " " );
current = current.nextNode;
}
System.out.println();
}
} // end class List
Seminario de Java
103
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public class EmptyListException extends RuntimeException {
public EmptyListException()
{
this( "List" ); // call other EmptyListException constructor
}
public EmptyListException( String name )
{
super( name + " is empty" ); // call superclass constructor
}
} // end class EmptyListException
Seminario de Java
104
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
public class ListTest {
public static void main( String args[] ) {
List list = new List(); // create the List container
Boolean bool = Boolean.TRUE;
Character character = new Character( '$' );
Integer integer = new Integer( 34567 );
String string = "hello";
list.insertAtFront( bool );
list.print();
list.insertAtFront( character );
list.print();
list.insertAtBack( integer );
list.print();
list.insertAtBack( string );
list.print();
Seminario de Java
105
Dept. LSI
Java (El lenguaje):Manejo de excepciones.
try {
Object removedObject = list.removeFromFront();
System.out.println( removedObject.toString() + " removed" );
list.print();
RESULTADO
The list is: true
removedObject = list.removeFromFront();
The list is: $ true
System.out.println( removedObject.toString()+" removed" ); The list is: $ true 34567
list.print();
The list is: $ true 34567 hello
$ removed
The list is: true 34567 hello
removedObject = list.removeFromBack();
System.out.println( removedObject.toString()+" removed" ); true removed
The list is: 34567 hello
list.print();
hello removed
The list is: 34567
removedObject = list.removeFromBack();
34567 removed
System.out.println( removedObject.toString()+" removed" ); Empty list
list.print();
}catch ( EmptyListException emptyListException ) {
emptyListException.printStackTrace();
}
}
} // end class ListTest
Seminario de Java
106
Dept. LSI