Está en la página 1de 285

METODOLOGA

DE
PROGRAMACIN
Versin 2.2 1 de 285
ndice de contenido
1 Clase.................................................................................................................................................8
1.1 Objetivos..................................................................................................................................8
1.2 Conocimiento previo................................................................................................................8
1.3 Conceptos de encapsulacin....................................................................................................8
1.4 Ejemplo..................................................................................................................................10
2 Clase...............................................................................................................................................14
2.1 Objetivos................................................................................................................................14
2.2 Conocimiento previo..............................................................................................................14
2.3 Wrapper (Envoltura)..............................................................................................................14
2.4 Boolean..................................................................................................................................15
2.5 Number..................................................................................................................................17
2.6 Double....................................................................................................................................18
2.7 Integer....................................................................................................................................19
2.8 Ejemplo..................................................................................................................................19
2.9 Trabajo 1................................................................................................................................21
3 Clase...............................................................................................................................................22
3.1 Objetivos................................................................................................................................22
3.2 Conocimiento previo..............................................................................................................22
3.3 Mtodos especficos...............................................................................................................22
3.4 Character................................................................................................................................22
3.5 IsDigit....................................................................................................................................22
3.5.1 isLetter............................................................................................................................22
3.5.2 isUpperCase....................................................................................................................23
3.6 ascii........................................................................................................................................23
3.7 String......................................................................................................................................24
3.7.1 charAt..............................................................................................................................24
3.7.2 concat..............................................................................................................................25
3.7.3 equals..............................................................................................................................25
3.7.4 indexOf............................................................................................................................25
3.7.5 substring..........................................................................................................................25
3.7.6 toLowerCase - toLowerCase...........................................................................................26
3.7.7 trim..................................................................................................................................26
3.8 Random..................................................................................................................................26
3.8.1 nextInt.............................................................................................................................26
3.8.2 nextDouble......................................................................................................................27
4 Clase...............................................................................................................................................28
4.1 Objetivos................................................................................................................................28
4.2 Conocimiento previo..............................................................................................................28
4.3 Manejo de objetos String.......................................................................................................28
4.4 Objetos Inmutables................................................................................................................31
4.5 StringBuffer - StringBuilder..................................................................................................32
4.6 BigDecimal - RoundingMode................................................................................................34
4.7 Trabajo 2................................................................................................................................37
5 Clase...............................................................................................................................................38
5.1 Objetivos................................................................................................................................38
5.2 Conocimiento previo..............................................................................................................38
5.3 Modelos de evaluacin 1.......................................................................................................38
6 Clase...............................................................................................................................................42
6.1 Objetivos................................................................................................................................42
Versin 2.2 2 de 285
6.2 Conocimiento previo..............................................................................................................42
6.3 Arreglos unidimensionales.....................................................................................................42
6.4 Declaracin de arreglos.........................................................................................................43
6.5 Recorrer un arreglo................................................................................................................44
6.6 Asignacin de arreglos...........................................................................................................45
6.7 Ejemplos................................................................................................................................45
7 Clase...............................................................................................................................................47
7.1 Objetivos................................................................................................................................47
7.2 Conocimiento previo..............................................................................................................47
7.3 Arreglos de objetos................................................................................................................47
7.4 Uso de parmetros tipo arreglo..............................................................................................48
7.5 La clase Arrays.......................................................................................................................49
7.6 Ejemplos................................................................................................................................49
7.7 Trabajo 3................................................................................................................................50
8 Clase...............................................................................................................................................51
8.1 Objetivos................................................................................................................................51
8.2 Conocimiento previo..............................................................................................................51
8.3 Arreglos Bidimensionales......................................................................................................51
8.4 Inicializacin de arreglos bidimensionales............................................................................52
8.5 Ejemplos................................................................................................................................52
8.6 Trabajo 4................................................................................................................................53
9 Clase...............................................................................................................................................54
9.1 Objetivos................................................................................................................................54
9.2 Conocimiento previo..............................................................................................................54
9.3 Modelo de evaluacin 2.........................................................................................................54
10 Clase.............................................................................................................................................57
10.1 Objetivos..............................................................................................................................57
10.2 Conocimiento previo............................................................................................................57
10.3 Uso de la herencia en la POO..............................................................................................57
10.4 UML.....................................................................................................................................58
10.5 Agregacin ..........................................................................................................................60
10.6 Composicin........................................................................................................................61
10.7 Asociacin............................................................................................................................62
10.8 Multiplicidad........................................................................................................................62
10.9 Herencia...............................................................................................................................63
10.10 Definiciones de herencia....................................................................................................65
10.11 Relacin es-uny tiene-un...........................................................................................68
10.12 Subclases............................................................................................................................68
11 Clase.............................................................................................................................................70
11.1 Objetivos..............................................................................................................................70
11.2 Conocimiento previo............................................................................................................70
11.3 extends.................................................................................................................................70
11.4 Sobrescribir mtodos...........................................................................................................70
11.5 Object...................................................................................................................................71
11.6 super.....................................................................................................................................72
11.7 Ejemplo 1.............................................................................................................................74
11.8 Ejemplo 2.............................................................................................................................76
11.9 Mtodos final.......................................................................................................................79
11.10 Clases final.........................................................................................................................79
11.11 Trabajo 5............................................................................................................................80
12 Clase.............................................................................................................................................81
Versin 2.2 3 de 285
12.1 Objetivos..............................................................................................................................81
12.2 Conocimiento previo............................................................................................................81
12.3 Clases abstractas..................................................................................................................81
12.4 Ejemplo 1.............................................................................................................................83
12.5 Interfaz.................................................................................................................................83
12.6 Polimorfismo.......................................................................................................................87
12.7 Ejemplo 2.............................................................................................................................90
13 Clase.............................................................................................................................................92
13.1 Objetivos..............................................................................................................................92
13.2 Conocimiento previo............................................................................................................92
13.3 Modelos de evaluacin 3.....................................................................................................92
14 Clase.............................................................................................................................................98
14.1 Objetivos..............................................................................................................................98
14.2 Conocimiento previo............................................................................................................98
14.3 Manejo de excepciones........................................................................................................98
14.4 Lanzar una excepcin..........................................................................................................99
14.5 Captura una excepcin.........................................................................................................99
14.6 Exception - Throwable.......................................................................................................100
14.7 Error ..................................................................................................................................102
14.8 try catch -finally .............................................................................................................102
14.9 throw .................................................................................................................................104
14.10 throws ..............................................................................................................................105
14.11 Ejemplos..........................................................................................................................105
14.12 Ejercicios..........................................................................................................................116
15 Clase...........................................................................................................................................118
15.1 Objetivos............................................................................................................................118
15.2 Conocimiento previo..........................................................................................................118
15.3 Colecciones........................................................................................................................118
15.4 Iterator................................................................................................................................119
15.5 Collection...........................................................................................................................120
15.6 List.....................................................................................................................................120
15.7 ArrayList............................................................................................................................121
15.8 Set......................................................................................................................................122
15.9 HashSet..............................................................................................................................123
15.10 TreeSet.............................................................................................................................125
16 Clase...........................................................................................................................................128
16.1 Objetivos............................................................................................................................128
16.2 Conocimiento previo..........................................................................................................128
16.3 Map....................................................................................................................................128
16.4 HashMap............................................................................................................................129
16.5 TreeMap.............................................................................................................................132
16.6 Vector.................................................................................................................................134
16.7 Trabajo semana 10.............................................................................................................135
17 Clase...........................................................................................................................................136
17.1 Objetivos............................................................................................................................136
17.2 Conocimiento previo..........................................................................................................136
17.3 Modelos de evaluacin 4...................................................................................................136
18 Clase...........................................................................................................................................141
18.1 Objetivos............................................................................................................................141
18.2 Conocimiento previo..........................................................................................................141
18.3 Colecciones Genricas.......................................................................................................141
Versin 2.2 4 de 285
18.4 Ejemplo de uso...................................................................................................................142
18.5 Iterator<>...........................................................................................................................143
18.6 Vector<>.............................................................................................................................143
18.7 ArrayList<>........................................................................................................................144
18.7.1 add...............................................................................................................................144
18.7.2 clear.............................................................................................................................146
18.7.3 contains remove..........................................................................................................146
18.7.4 size..............................................................................................................................148
18.7.5 isEmpty.......................................................................................................................148
18.7.6 indexOf lastIndexOf....................................................................................................148
18.7.7 get................................................................................................................................149
18.7.8 set................................................................................................................................150
18.8 Iterable<>...........................................................................................................................150
18.9 Collection...........................................................................................................................151
18.10 Set<>................................................................................................................................152
18.11 List<>...............................................................................................................................152
18.12 Map<,>.............................................................................................................................153
18.13 Implementacin...............................................................................................................153
19 Clase...........................................................................................................................................154
19.1 Objetivos............................................................................................................................154
19.2 Conocimiento previo..........................................................................................................154
19.3 SQL....................................................................................................................................154
19.3.1 Tabla............................................................................................................................154
19.3.2 MySql..........................................................................................................................154
19.3.3 PK................................................................................................................................161
19.3.4 Crear tabla...................................................................................................................161
19.3.5 insert............................................................................................................................163
19.3.6 update..........................................................................................................................164
19.3.7 delete...........................................................................................................................164
19.3.8 select............................................................................................................................164
19.4 JDBC..................................................................................................................................165
19.5 Qu hace la API de JDBC?..............................................................................................166
19.6 Conexin de Informacin general......................................................................................166
19.7 Establecer una conexin....................................................................................................166
19.8 Liberacin DBMS Recursos..............................................................................................166
19.9 Crear una conexin............................................................................................................167
19.10 Insertar datos....................................................................................................................167
19.11 Driver de Conexin..........................................................................................................171
20 Clase...........................................................................................................................................173
20.1 Objetivos............................................................................................................................173
20.2 Conocimiento previo..........................................................................................................173
20.3 JTextField...........................................................................................................................173
20.4 toolTipText.........................................................................................................................174
20.5 matches..............................................................................................................................174
20.6 JSlider................................................................................................................................180
20.7 JList....................................................................................................................................183
20.8 Cuadro de dilogo..............................................................................................................188
21 Clase...........................................................................................................................................193
21.1 Objetivos............................................................................................................................193
21.2 Conocimiento previo..........................................................................................................193
21.3 Modelos de evaluacin 5...................................................................................................193
Versin 2.2 5 de 285
22 Clase...........................................................................................................................................194
22.1 Objetivos............................................................................................................................194
22.2 Conocimiento previo..........................................................................................................194
22.3 JFormattedTextField..........................................................................................................194
22.4 PasswordField - Separator.................................................................................................197
22.5 JRadioButton.....................................................................................................................198
22.6 CheckBox...........................................................................................................................201
22.7 Spinner...............................................................................................................................203
22.8 JTabbedPane......................................................................................................................208
23 Clase...........................................................................................................................................219
23.1 Objetivos............................................................................................................................219
23.2 Conocimiento previo..........................................................................................................219
23.3 JTable.................................................................................................................................219
24 Clase...........................................................................................................................................228
24.1 Objetivos............................................................................................................................228
24.2 Conocimiento previo..........................................................................................................228
24.3 Evaluacin 6......................................................................................................................228
24.4 Evaluacin 7......................................................................................................................229
25 Clase...........................................................................................................................................231
25.1 Objetivos............................................................................................................................231
25.2 Conocimiento previo..........................................................................................................231
25.3 JMenu.................................................................................................................................231
25.4 JTree...................................................................................................................................237
25.5 JScrollPane.........................................................................................................................249
26 Adicionales.................................................................................................................................251
26.1 Objetivos............................................................................................................................251
26.2 Conocimiento previo..........................................................................................................251
26.3 Date....................................................................................................................................251
26.4 Calendar.............................................................................................................................251
26.5 SimpleDateFormat.............................................................................................................254
26.6 GregorianCalendar.............................................................................................................254
27 Adicionales 1..............................................................................................................................256
27.1 Objetivos............................................................................................................................256
27.2 Conocimiento previo..........................................................................................................256
27.3 Format................................................................................................................................256
27.4 Locate.................................................................................................................................256
27.5 MessageFormat..................................................................................................................259
27.6 ChoiceFormat.....................................................................................................................259
27.7 NumberFormat...................................................................................................................263
27.8 DecimalFormat..................................................................................................................263
27.9 DateFormat........................................................................................................................268
27.10 SimpleDateFormat...........................................................................................................269
28 Adicionales 2..............................................................................................................................272
28.1 Objetivos............................................................................................................................272
28.2 Conocimiento previo..........................................................................................................272
28.3 Argumentos variables .......................................................................................................272
28.4 Mtodo main......................................................................................................................272
29 Adicionales 3..............................................................................................................................274
29.1 Objetivos............................................................................................................................274
29.2 Conocimiento previo..........................................................................................................274
29.3 Ordenacin.........................................................................................................................274
Versin 2.2 6 de 285
29.4 Algoritmo de la burbuja.....................................................................................................274
29.5 algoritmo de ordenacin....................................................................................................276
29.6 Bsqueda en listas..............................................................................................................278
29.7 Bsqueda secuencial..........................................................................................................278
29.8 Bsqueda binaria................................................................................................................278
29.9 Ejercicios...........................................................................................................................279
30 Adicionales 4..............................................................................................................................280
30.1 Objetivos............................................................................................................................280
30.2 Conocimiento previo..........................................................................................................280
30.3 Caso de uso........................................................................................................................280
30.4 Normas de aplicacin.........................................................................................................280
30.5 Plantilla no adecuada.........................................................................................................281
30.6 Plantilla adecuada 1...........................................................................................................281
30.7 Plantilla adecuada 2...........................................................................................................282
31 Adicionales 4..............................................................................................................................283
31.1 Objetivos............................................................................................................................283
31.2 Conocimiento previo..........................................................................................................283
31.3 Base de datos.....................................................................................................................283
Versin 2.2 7 de 285
1 Clase
1.1 Objetivos
Encapsular datos.
Restringir el acceso a datos.
1.2 Conocimiento previo
Creacin de mtodos.
1.3 Conceptos de encapsulacin
En programacin modular, y ms especficamente en programacin orientada a objetos, se denomina
encapsulamiento al ocultamiento del estado, es decir, de los datos miembros, de un objeto de manera que
slo se puede cambiar mediante las operaciones definidas para ese objeto.
De esta forma, el usuario de la clase puede obviar la implementacin de los mtodos y propiedades
para concentrarse slo en cmo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado de
maneras imprevistas e incontroladas.
Otra definicin un tanto ms simple: La encapsulacin consiste en ocultar la complejidad de una
clase e impedir accesos no autorizados
Java, como lenguaje orientado a objetos puro que es, implementa la encapsulacin (o encapsulamiento)
perfectamente. Este concepto consiste en la ocultacin del estado, o lo que es lo mismo, de los datos
miembro de un objeto, de forma que slo es posible modificar los mismos mediante las operaciones
(mtodos, en Java) definidos para dicho objeto. Ms especficamente:
Para implementar la encapsulacin en java debemos:
Declara nuestras variable de instancia de la clase como private.
Inicializar las variables de instancias en sus valores por defecto o los convenientes para el
desarrollo.
Se debe declarar al menos el mtodo constructor de la clase sin parmetros.
Para cada variable declarar mtodos:
Accesadores (conocidos como mtodos get): Se utilizan de forma estndar para la recuperacin
de datos de un objeto.
Mutadores (conocidos como mtodos set): Se utilizan de forma estndar para la asignacin de
datos a un objeto, bajo ciertas restricciones.
Versin 2.2 8 de 285
Por ejemplo, si consideramos la clase estudiante con los atributos edad y nota, se tiene:
public class Estudiante {
private int edad=0; //Variable private e inicializada
private double nota =0.0; //Variable private e inicializada

public Estudiante(){ } //Mtodo constructor sin parmetros
//Mtodos accesadores y mutadores de las variables edad y nota
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public double getNota() {
return nota;
}
public void setNota(double nota) {
this.nota = nota;
}
}
Para la diagramacin de clases usaremos dia v0.97.1 que puedes bajar desde http://dia-installer.de/
-: Privado
+: Publico
Con estos mtodos se pueden incorporar restricciones a los valores ingresados. Por ejemplo, en el caso de
la edad se pueden permitir slo valores > 0 cero. As el mtodo sera ahora:
void setEdad(int edad){
if(edad <= 0)
this.edad = 0;
else
this.edad= edad;
}
Tambin se puede, por ejemplo, en el caso de la nota permitir slo valores entre 1.0 y 7.0, asignado 1.0 para
otros casos.
void setNota(double nota){
if (nota >=1.0 && nota <=7.0)
this.nota = nota;
else
this.nota = 1.0
}
Versin 2.2 9 de 285
1.4 Ejemplo
Crear un programa Java que sea capaz de manejar las ventas de un producto determinado. Para esto, se
deben enviar:
El cdigo del producto como parmetro de objeto de la clase que encapsula la informacin de
productos.
La cantidad a vender como parmetro del mtodo que calcular el total de la venta.
Considerar los siguiente productos:
Cdigo Nombre Precio unitario
AX10 Faldas 40000
AX20 Pantaln 30000
AX30 Blusa 50000
Se pide no efectuar ningn tipo de validacin y enviar los siguientes valores a proceso:
Cdigo Unidades vendidas
AX10 40
AX30 100
Se pide tambin, mostrar:
Cdigo del producto
Nombre del producto
Precio del producto
Total a pagar
Esta clase provee la encapsulacin de productos. Para el desarrollo de una venta se deber crear un objeto
de la clase usando su mtodo constructor que debe recibir el cdigo, nombre y precio del producto; usando
su mtodo aPagar() calcula el total a pagar por una venta.
package bean;
public final class Producto {
private String codigo = "";
private String nombre = "";
private int precio =0;
public Producto() {
}
public Producto(String codigo, String nombre, int precio) {
this.setCodigo(codigo);
this.setNombre(nombre);
this.setPrecio(precio);
}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
Versin 2.2 10 de 285
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getPrecio() {
return precio;
}
public void setPrecio(int precio) {
this.precio = precio;
}
public int aPagar(int cantidad){
int total = 0;
total = this.getPrecio() * cantidad;
return total;
}
}
Esta clase crea dos objetos que manejan independiente cada una de las ventas. Este concepto es
fundamental para el uso de la programacin orientada a objetos:
package view;
import bean.Producto;
public class Venta {
public static void main(String[] args) {
Producto obj1 = new Producto("AX10","Falda",40000);
int pago1 = obj1.aPagar(40);
System.out.println("Codigo: " + obj1.getCodigo());
System.out.println("Nombre: " + obj1.getNombre());
System.out.println("Precio: " + obj1.getPrecio());
System.out.println("A pagar: " + pago1);
System.out.println();

Producto obj2 = new Producto("AX30","Blusa",50000);
int pago2 = obj2.aPagar(100);
Versin 2.2 11 de 285
System.out.println("Codigo: " + obj2.getCodigo());
System.out.println("Nombre: " + obj2.getNombre());
System.out.println("Precio: " + obj2.getPrecio());
System.out.println("A pagar: " + pago2);
}
}
Una solucin ms ptima sera crear un mtodo de impresin en la clase Producto.
public void ver(){
System.out.println("Codigo: " + this.getCodigo());
System.out.println("Nombre: " + this.getNombre());
System.out.println("Precio: " + this.getPrecio());
}
En este caso se tendra:
package bean;
public final class Producto {
private String codigo = "";
private String nombre = "";
private int precio =0;
public Producto() {
}
public Producto(String codigo, String nombre, int precio) {
this.setCodigo(codigo);
this.setNombre(nombre);
this.setPrecio(precio);
}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
Versin 2.2 12 de 285
public int getPrecio() {
return precio;
}
public void setPrecio(int precio) {
this.precio = precio;
}
public int aPagar(int cantidad){
int total = 0;
total = this.getPrecio() * cantidad;
return total;
}
public void ver(){
System.out.println("Codigo: " + this.getCodigo());
System.out.println("Nombre: " + this.getNombre());
System.out.println("Precio: " + this.getPrecio());
}
}
Y la clase que gener el proceso de venta sera ahora:
package view;
import bean.Producto;
public class Venta {
public static void main(String[] args) {
Producto obj1 = new Producto("AX10","Falda",40000);
int pago1 = obj1.aPagar(40);
obj1.ver();
System.out.println("A pagar: " + pago1);
System.out.println();

Producto obj2 = new Producto("AX30","Blusa",50000);
int pago2 = obj2.aPagar(100);
obj2.ver();
System.out.println("A pagar: " + pago2);
}
}
Versin 2.2 13 de 285
2 Clase
2.1 Objetivos
Conversin de tipos de datos.
2.2 Conocimiento previo
Manejar los datos de tipo primitivos y el uso de mtodos
2.3 Wrapper (Envoltura)
Los tipos primitivos byte, short, int, long, float, double, son los nicos elementos de Java que no son objetos.
Esto tiene algunas ventajas desde el punto de vista de la eficiencia, pero algunos inconvenientes desde el
punto de vista de la funcionalidad. Por ejemplo, los tipos primitivos siempre se pasan como argumento a los
mtodos por valor, mientras que los objetos se pasan por referencia. De esta manera, no hay forma de
modificar en un mtodo un argumento de tipo primitivo y que esa modificacin se trasmita al entorno que
hizo la llamada.
Una forma de conseguir esto es utilizar un Wrapper, esto es un objeto cuya variable miembro es el
tipo primitivo que se quiere modificar. El API de Java incorpora las clases envoltorio (Wrapper class), que no
son ms que dotar a los datos primitivos con un envoltorio que permita tratarlos como objetos.
Versin 2.2 14 de 285
2.4 Boolean
En este ejemplo se aprecia como se inicializar este tipo de variables:
package view
public class Wrapper01 {
public static void main(String[] args) {
Boolean o1 = new Boolean("true");
Boolean o2 = new Boolean("TRUE");
if(o1.booleanValue()==true)
System.out.print("1");
if(o1.booleanValue()==Boolean.TRUE)
System.out.print("2");
if(o2.booleanValue()==true)
System.out.print("3");
if(o2.booleanValue()==Boolean.TRUE)
System.out.println("4");
}
}
Por ende, da lo mismo definir el valor con minscula que con mayscula.
Versin 2.2 15 de 285
Observar que es vlido tambin la combinaciones de letras minsculas y maysculas:
package view;
public class Wrapper02 {
public static void main(String[] args) {
Boolean o1 = new Boolean("True");
Boolean o2 = new Boolean("trUE");
if(o1.booleanValue()==true)
System.out.print("1");
if(o1.booleanValue()==Boolean.TRUE)
System.out.print("2");
if(o2.booleanValue()==true)
System.out.print("3");
if(o2.booleanValue()==Boolean.TRUE)
System.out.println("4");
}
}
La recomendacin es usar la siguiente inicializacin de este tipo de variables:
package view;
public class Wrapper03 {
public static void main(String[] args) {
Boolean o1 = true;
Boolean o2 = Boolean.TRUE;
if(o1.booleanValue()==true)
System.out.print("1");
if(o1.booleanValue()==Boolean.TRUE)
System.out.print("2");
if(o2.booleanValue()==true)
System.out.print("3");
if(o2.booleanValue()==Boolean.TRUE)
System.out.println("4");
}
}
Para transformar un objeto Boolean en un valor primitivo boolean:
public static void main(String[] args) {
Boolean a = Boolean.valueOf("false");
Boolean b = a.booleanValue();
}
Versin 2.2 16 de 285
Observar que no se pueden usar combinaciones de minsculas y maysculas en los casos indicados con
error. La recomendacin es usar Boolean.TRUE.
2.5 Number
Uno de los mayores uso de conversin es usando datos de la clase String. Por ejemplo, en las aplicaciones
de tipo web la mayora de los datos son recuperados como tipo String independientes que los datos sean
numricos.
En diagrama de clases de los datos tipo Objetos (o Wrapper). Podemos apreciar que existe una
clase comn Number y que despus cada uno de los tipos de datos tiene su propia implementacin en su
clase.
Versin 2.2 17 de 285
Number
BigDecimal BigInteger Byte Double Float Integer Long Short
Object
2.6 Double
Maneja objetos numricos tipo Double. Esta clase provee varios mtodos para convertir un double en un
String y viceversa.
Constructores: Double(double), Double(String)
double doubleValue( ): Retorna un valor primitivo double desde un objeto Double.
static double Double.parseDouble(String s): Retorna un valor primitivo double desde un objeto
String. Este es uno de los mtodos de mayor utilidad pues recibe un String y lo transforma en
double. En la jerga de la programacin se habla de parsear los datos.
static Double Double.valueOf(String s): Convierte el String s (dato de tipo objeto) en un objeto
Double.
String Double.toString( ): Retorna un String desde un objeto Double. Por ejemplo, 12.12 los
transforma en 12.12.
String Double.toString(double d): Retorna el String que representa al argumento dato primitivo
double.
package view;
public class Wrapper04 {
public static void main(String[] args) {
double val1 = 12.12;
Double val2 = new Double(22.22);
Double val3 = new Double("33.33");
String val4 = "44.44";
//Transforma en double desde Double
val1 = val2.doubleValue();
System.out.println("val1: " + val1);
//Transforma desde String a double. El ms importante de todos
Versin 2.2 18 de 285
val1 = Double.parseDouble(val4);
System.out.println("val1: " + val1);
//Transforma de String a Double. El segundo ms importante
val4 = "55.55";
val2 = Double.valueOf(val4);
System.out.println("val2: " + val2);
//Transforma de Double a String
val4 = val3.toString();
System.out.println("val4: " + val4);
//Transforma de double a String
val4 = Double.toString(val1);
System.out.println("val4: " + val4);
}
}
2.7 Integer
Los mtodos de Integer son anlogos a los de la clase Double. Para el mtodo parseInt existe un caso
particular:
String s1 = "123"; String s2 = "FF"; String s3 = "10001000";
int a1 = Integer.parseInt(s1, 10); //Base 10
int a2 = Integer.parseInt(s2, 16); //Base 16
int a3 = Integer.parseInt(s3, 2); //Base 2
System.out.println(a1 + " - " + a2 + " - " + a3);
2.8 Ejemplo
Considere que necesita crear una clase que desarrolle el simple ejercicio de sumar dos nmeros enteros;
pero esto son enviados como combinaciones de: String String
public class DatWrapper {
private String s1 = null;
private String s2 = null;
public DatWrapper(){ }
public DatWrapper(String s1, String s2){
this.setS1(s1);
this.setS2(s2);
}
public int sumaDosValores(){
int resul = 0;
if(s1 != null && s2 != null){
resul = Integer.parseInt(s1) + Integer.parseInt(s2);
}
return resul;
}
public String getS1() { return s1; }
public void setS1(String s1) { this.s1 = s1; }
public String getS2() { return s2; }
public void setS2(String s2) { this.s2 = s2; }
}
Versin 2.2 19 de 285
package dat;
public class DatWrapperView {
static DatWrapper o1 = new DatWrapper(new String("12"), new String("-20"));
public static void main(String[] args) {
System.out.println("Valores String: " + o1.sumaDosValores());
}
}
Resultado: Valores String: -8
Suponga que ahora el resultado debe ser double, pero siempre los valores con enviados como String. En
este caso, se debe modificar es mtodo:
public double sumaDosValores(){
double resul = 0;
if(s1 != null && s2 != null)
resul = Double.parseDouble(s1) + Double.parseDouble(s2);
return resul;
}
Suponga que ahora el resultado debe ser float, pero siempre los valores con enviados como String. En este
caso, se debe modificar es mtodo:
public float sumaDosValores(){
float resul = 0;
if(s1 != null && s2 != null)
resul = Float.parseFloat(s1) + Float.parseFloat(s2);
return resul;
}
Suponga que ahora el resultado debe ser String, pero los valores con enviados como Double. En este caso,
se debe modificar el mtodo:
package dat;
public class DatWrapperDouble {
private Double o1 = null;
private Double o2 = null;

public DatWrapperDouble(){ }

public DatWrapperDouble(Double o1, Double o2){
this.setO1(o1);
this.setO2(o2);
}
public Double getO1() {
return o1;
}
public void setO1(Double o1) {
this.o1 = o1;
}
public Double getO2() {
return o2;
}
public void setO2(Double o2) {
this.o2 = o2;
Versin 2.2 20 de 285
}

String sumaDosValores(){
String resul = "";
double valor = 0.0;
double d1 = o1.doubleValue();
double d2 = o2.doubleValue();
if(o1 != null && o2 != null)
valor = d1 + d2;
resul = String.valueOf(valor);
return resul;
}
}
package dat;
public class DatWrapperDoubleView {
static Double o11 = new Double(12.0);
static Double o12 = new Double(-22.0);
public static void main(String[] args) {
DatWrapperObject o1 = new DatWrapperObject(o11, o12);
System.out.println("Valores Double: " + o1.sumaDosValores());
}
}
2.9 Trabajo 1
Se necesita un programa java que sea capaz de manejar las ventas de los siguientes productos.
Cdigo del Producto Precio
AX10 10000
AX20 20000
AX30 50000
Se pide:
(a) Encapsular la informacin que interviene en el ejercicio.
(b) Crear un mtodo que devuelva un String, sin parmetros y que dado un producto y una cierta
cantidad vendida del producto, calcule y muestre el total a pagar.
(c) Crear un mtodo que reciba el total a pagar (tipo String) y calcule el descuento a aplicar (tipo int con
aproximacin de cantidades decimales al primer entero superior al nmero calculado) segn se
indica:
Un descuento de un 10% si el valor est entre 2.000.000 y 5.000.000
Un descuento de un 25% si el valor es mayor a 5.000.000
Un descuento de 0% en otro caso
Versin 2.2 21 de 285
3 Clase
3.1 Objetivos
Usar mtodos prediseados.
3.2 Conocimiento previo
Creacin de mtodos.
3.3 Mtodos especficos
Existen una serie de de mtodos en java que nos permiten desarrollar procesos. Sin embargo, esta cantidad
de mtodos no es tan cuantiosos como otros lenguajes de programacin.
3.4 Character
Esta clase maneja valores de tipo primitivos char como objetos.
3.5 IsDigit
Permite analizar si una variable de tipo char es un nmero.
public class FuncionesEspecificas {
public static void main(String[] args) {
char valor1 = '4';
char valor2 = 'e';
if(Character.isDigit(valor1)){
System.out.println("valor1 es dgito");
} else
{
System.out.println("valor1 no es dgito");
}
if(Character.isDigit(valor2)){
System.out.println("valor2 es dgito");
} else
{
System.out.println("valor2 no es dgito");
}
}
}
3.5.1 isLetter
Determina si el valor de caracteres especificado es una letra
public class Metodos1 {
public static void main(String[] args) {
System.out.println(Character.isLetter('c'));
System.out.println(Character.isLetter('5'));
}
}
Versin 2.2 22 de 285
3.5.2 isUpperCase
Determina si el carcter especificado en una letra mayscula. De la misma forma se tiene isUpperCase e
isWhitespace().
package view;
public class Metodos2 {
public static void main(String[] args) {
System.out.println(Character.isUpperCase('c'));
System.out.println(Character.isUpperCase('5'));
System.out.println(Character.isUpperCase('D'));
}
}
3.6 ascii
La siguiente tabla contiene los cdigos ascii.
Versin 2.2 23 de 285
3.7 String
La clase String representa cadenas de caracteres. Todos los literales de cadena en los programas Java,
como "abc", se implementan como instancias de esta clase.
Las variables String se inicializan en null. De esta manera, es lo mismo declara:
String nn;
String nn = null;Sin embargo, recordar que una variable no inicializada explcitamente no se puede usar.
3.7.1 charAt
Retorna el carcter para una posicin especfica en una cadena
public class FuncionesEspecificas01 {
public static void main(String[] args) {
String s = "123ABCabc";
for(int i=0;i<s.length();i++){
System.out.print(s.charAt(i));
}
}
System.out.println();
}
Con esta funcin se puede generar un validador de nmeros de slo nmeros enteros.
package dat;
public class FuncionesEspecificas02 {
public static void main(String[] args) {
System.out.println(isNumeric("Ab"));
System.out.println(isNumeric("23Ab"));
System.out.println(isNumeric("Ab23"));
System.out.println(isNumeric("23"));
System.out.println(isNumeric("23.23"));
System.out.println(isNumeric("23,23"));
System.out.println(isNumeric("-23"));
System.out.println(isNumeric("-23.23"));
System.out.println(isNumeric("-23,23"));
}
public static boolean isNumeric(String s){
for(int i=0;i<s.length();i++){
if(s.charAt(i) < '0' || s.charAt(i)> '9' ){
return false;
}
}
Versin 2.2 24 de 285
return true;
}
}
Observar que el mtodos se debe mejorar que validar nmeros con . Decimal y manejar diversos casos.
Para validaciones profesionales en java ver matches.
3.7.2 concat
String concat(String str): Concatena la cadena especificada stral final de otra cadena. El cdigo une
variables String.
public class B {
public static void main(String[] args) {
String nombre = "Juan";
String apellido = "Perez";
String espacio = " ";
//Concatena los caracteres
String ciudadano = nombre.concat(espacio).concat(apellido);
System.out.println(ciudadano);
}
}
3.7.3 equals
boolean equals(Object anObject) : Compara esta cadena para el objeto especificado.
3.7.4 indexOf
int indexOf(int ch): Devuelve el ndice dentro de esta cadena de la primera aparicin del carcter
especificado.
int indexOf(int ch, int fromIndex): Devuelve el ndice dentro de esta cadena de la primera aparicin del
carcter especificado, a partir de la bsqueda en el ndice especificado.
int indexOf(String str): Devuelve el ndice dentro de esta cadena de la primera aparicin de la subcadena
especificada.
int indexOf(String str, int fromIndex): Devuelve el ndice dentro de esta cadena de la primera aparicin de
la subcadena especificada, comenzando en el ndice especificado.
3.7.5 substring
String substring(int beginIndex): Devuelve una nueva cadena que es una subcadena de la cadena desde
la posicin indicada por el ndice. Este ndice comienza desde cero.
String substring(int beginIndex, int endIndex): Devuelve una nueva cadena que es una subcadena de la
cadena desde el ndice inicial hasta el final. La cantidad de caracteres rescatados es (endIndex-beginIndex).
El cdigo muestra ejemplos de uso del mtodo. Tener presente que el proceso no es el habitual de
la mayora de los lenguajes de programacin
public class C {
public static void main(String[] args) {
String nombre = "Juan Perez";
System.out.println(nombre.substring(0)); //Juan Perez
System.out.println(nombre.substring(8)); //ez
System.out.println(nombre.substring(0,1)); //J
System.out.println(nombre.substring(0,8)); //Juan Per
System.out.println(nombre.substring(1,2)); //u
System.out.println(nombre.substring(1,8)); //uan Per
System.out.println(nombre.substring(8,9)); //e
Versin 2.2 25 de 285
System.out.println(nombre.substring(8,nombre.length())); //ez
}
}
3.7.6 toLowerCase - toLowerCase
String toLowerCase(): Convierte todos los caracteres letras de String a minsculas utilizando las reglas de
la localizacin por defecto.
String toLowerCase(Locale locale): Convierte todos los caracteres letras de String a minsculas utilizando
las reglas dado por Locale.
String toUpperCase(): Convierte todos los caracteres letras de String a maysculas utilizando las reglas de
la localizacin por defecto.
String toUpperCase(Locale locale): Convierte todos los caracteres letras de String a maysculas
utilizando las reglas dado por Locale.
Locate: Un objeto Locale representa una determinada regin geogrfica, poltica o cultural. Por ejemplo, se
crea un objeto Locale para los Estados Unidos y China
Locale.US
Locate.CHINA
3.7.7 trim
String trim (): Devuelve una copia de la cadena, con espacios en blanco iniciales y finales omitido
(eliminados).
3.8 Random
La clase Random es parte de package java.util.Random y genera nmeros seudoaleatorios que tiene como
fin principal la simulacin.
3.8.1 nextInt
Devuelve un pseudoaleatorios, uniformemente distribuidos entero entre 0 (inclusive) y el valor especificado
(exclusivo). Por ejemplo, generar 10 nmeros aleatorios enteros entre 0 y 99.
package view;
import java.util.Random;
public class Metodos20 {
public static void main(String[] args) {
Random r=new Random();
for(int i=0; i<10; i++){
System.out.println(r.nextInt(100));
}
}
}
Versin 2.2 26 de 285
Posibles resultados, los cuales dependen de la veces que se ejecute el proceso.
Generar 10 nmeros aleatorios enteros entre 1 y 100.
package view;
import java.util.Random;
public class Metodos21 {
public static void main(String[] args) {
Random r=new Random();
for(int i=0; i<10; i++){
System.out.println(1+ r.nextInt(100));
}
}
}
3.8.2 nextDouble
Genera nmeros aleatorios entre 0 (incluido) y 1 (no incluido); o sea, en el intervalo [0,1).
package view;
import java.util.Random;
public class Metodos22 {
public static void main(String[] args) {
Random r=new Random();
for(int i=0; i<10; i++){
System.out.println(r.nextDouble());
}
}
}
Versin 2.2 27 de 285
4 Clase
4.1 Objetivos
Usar objetos de clases para procesos.
4.2 Conocimiento previo
Creacin de mtodos.
4.3 Manejo de objetos String
Para crear un objeto de una clase procedemos:
CGrados grados = new CGrados()
new crea una referencia a un nuevo objeto de CGrado que es almacenada en la variables grados que es de
tipo CGrados.
Tener presente que cada objeto de un clase crea su propia copia de las variables de ejemplar, pero que
entre los diversos objeto comparten los mismos mtodos
La referencia es la posicin de memoria donde se localiza un objeto y no el objeto. De esta manera,
lo que habitualmente se maneja es la referencia de los objetos.
CGrados obj1 = new CGrados();
CGrados obj2 = new CGrados();
CGrados obj3 = new CGrados();
Considere:
CGrados obj1, obj2;
CGrados obj1 = new CGrados();
obj2 = obj1;
Versin 2.2 28 de 285
Referencia
Variable grados
Objeto de
CGrados
Objeto referenciado
obj1 obj2 obj3 Referencias
Posiciones
de memoria
Ubicacin de objetos
Conclusin:
Conclusin: Ambas referencias obj1 y obj2 apuntan al mismo objeto.
As, accedern a las mismas variables de ejemplar las que son utilizadas en el proceso que
desarrollan los mtodos.
De esta manera, se obtiene los mismos resultados usando obj1 u obj2
Cuando java compila un literal, por ejemplo abc, aade un objeto String al rea de almacenamiento de
abc. De esta manera, si posteriormente aparece el mismo literal en cualquier otra parte del cdigo de la
clase, entonces java no agrega un nuevo objeto, sino que utiliza el que hay. Esto se genera nicamente
con la asignacin:
String obj1 = abc;
String obj2 = abc;
Sin embargo, en relacin a lo anterior si la asignacin es como sigue se tendr reas de memoria distintas
para el literal abc. Esto es debido al hecho que new crea una nueva rea de memoria.
String obj1 = new String(abc);
String obj2 = abc;
Con esto tenemos lo siguiente:
El operador == compara las referencias de los objetos.
El operador == no compara los contenidos de los objetos
Versin 2.2 29 de 285
obj1 obj2 Referencias
Posiciones
de memoria
Ubicacin de objetos
abc
obj1 obj2
Cada nueva referencia a
abc usar el mismo objeto
obj1 obj2
Cada nueva referencia a
abc usar el mismo objeto
abc abc
Tambin se tiene:
El operador equals compara las referencias de los objetos.
El operador equals compara los contenidos de los objetos
Como ejemplo podemos ver:
String obj1 = abc;
String obj2 = abc;
if( obj1.equals(obj2) ){ //resultado true }
if( obj1 = = obj2 ){ //resultado true }

String obj3 = new String(abc);
String obj4 = abc;
if( obj3.equals(obj4) ){
// resultado true
}
if( obj3 = = obj4 ){ //resultado false }

Versin 2.2 30 de 285


obj1
obj2
abc == true

obj1
obj2
abc
== false
x
abc
obj1
obj2
abc equals true

obj1
obj2
abc
equals true

abc
4.4 Objetos Inmutables
Un objeto String es inmutable. Por ejemplo, si se asigna un nuevo valor a una variable, entonces se crea un
nuevo objeto con el nuevo contenido.
Observar los resultados del siguiente ejemplo:
public class Procesa2 {
public static void main(String[] args) {
String obj1 = new String("123");
String obj2 = obj1;
System.out.println(obj1);
System.out.println(obj2);
if(obj1==obj2)
System.out.println("Iguales1==");
if(obj1.equals(obj2))
System.out.println("Iguales1Equal");
obj2 = "123"; //Crea un nuevo objeto en una posicin de memoria distinta a la inicial asignada a obj2
System.out.println(obj1);
System.out.println(obj2);
if(obj1==obj2)
System.out.println("Iguales2==");
if(obj1.equals(obj2))
System.out.println("Iguales2Equal");
}
}
Versin 2.2 31 de 285
4.5 StringBuffer - StringBuilder
Lo ms utilizado son sin duda objetos de tipo String, al proporcionar suficiente potencial para la
mayor parte de los casos.
La clase StringBuffer permite guardar cadenas que cambiarn en la ejecucin del programa (a
diferencia de los objetos String normales, que son inmutables).
Una clase parecida, StringBuilder, lleg con Java 5. Es idntica a la anterior salvo que no es
sncrona, lo que significa que puede haber problemas si es una variable a la que accedan diferentes
threads. Sin embargo, para la mayora de las aplicaciones (donde se ejecuta un solo hilo) supone
una mejora de rendimiento sobre StringBuffer.
Considerar el siguiente cdigo. Este cdigo crea dentro del bucle 99 objetos de tipo String, y en cada uno de
ellos va guardando el nuevo contenido. Esto por supuesto no es eficiente, un problema que podemos
resolver con StringBuffer
String cadena = new String(Cuenta: );
for (int i=0; i<100; i++) {
cadena += + i + ;
}
El siguiente cdigo usa StringBuffer. En esta ocasin slo se crea un objeto, al que se le van aadiendo las
cadenas con el mtodo append.
StringBuffer cadena = new StringBuffer(Cuenta: );
for (int i=0; i<100; i++) {
cadena.append( + i + );
}
Lgicamente esto tambin tiene un coste computacional, pero ste es inferior al que supone crear un nuevo
objeto. De todos modos podemos reservar un espacio inicial de forma que no sea necesario hacerlo en
cada iteracin del bucle, mejorando an ms el rendimiento.
// creamos espacio para 120 caracteres
StringBuffer cadena = new StringBuffer(120);
cadena.append(Cuenta: );
for (int i=0; i<100; i++) {
cadena.append(" " + i + " ");
}
Versin 2.2 32 de 285
Buena prctica;
Si el texto no va a cambiar, utilizar String.
Si va a cambiar, y la aplicacin va a tener un solo hilo de ejecucin, utilizar StringBuilder.
Si el texto cambia durante la ejecucin, y la aplicacin que accede a l es multi-thread, utilizaremos
StringBuffer.
Versin 2.2 33 de 285
4.6 BigDecimal - RoundingMode
Considerar el siguiente cdigo y el resultado. Como podemos ver el resultado no es el esperado.
package view;
public class Metodos14 {
public static void main(String[] args) {
double unCentavo = 0.01;
double suma = unCentavo + unCentavo + unCentavo + unCentavo + unCentavo + unCentavo;
System.out.println(suma);
}
}
Cuando usamos una variable float o double, estamos dejandole al microprocesador de la computadora el
trabajo de efectuar los clculos directamente (con su coprocesador matemtico) pero como las
computadoras "piensan" en binario, cometen errores de precisin diferentes a los nuestros. Para solucionar
lo anterior podemos proceder como sigue:
package view;
public class Metodos15 {
public static void main(String[] args) {
java.math.BigDecimal unCentavo = new java.math.BigDecimal("0.01");
java.math.BigDecimal suma =
unCentavo.add(unCentavo).add(unCentavo).add(unCentavo).add(unCentavo).add(unCentavo);
System.out.println(suma);
}
}
Versin 2.2 34 de 285
Si hacen sistemas financieros, los pequeos errores de calculo acumulados con varios centavos pueden
resultar en reportes cuyos clculos diferirn de las operaciones que normalmente realizamos los humanos.
Para resolver este problema, en Java se incluye la clase BigDecimal, que si bien realiza los clculos mas
lento que "Double/double" los realiza del mismo modo que los humanos (en base 10) y as evitamos el
problema.
Vamos a emplear esta clase para el desarrollo de aproximaciones:
Adems consideraremos la clase java.math.RoundingMode que permite el manejo de aproximaciones de
cifras decimales. Los valores posibles son:
HALF_DOWN
HALF_EVEN
Versin 2.2 35 de 285
HALF_UP
As debemos usar HALF_UP.
package view;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Metodos17 {
public static void main(String[] args) {
BigDecimal val1 = new BigDecimal("0.55400");
BigDecimal val2 = new BigDecimal("0.55500");
BigDecimal val3 = new BigDecimal("0.55600");
BigDecimal val4 = new BigDecimal("-0.55400");
BigDecimal val5 = new BigDecimal("-0.55500");
BigDecimal val6 = new BigDecimal("-0.55600");
val1 = val1.setScale(2,RoundingMode.HALF_UP);
val2 = val2.setScale(2,RoundingMode.HALF_UP);
val3 = val3.setScale(2,RoundingMode.HALF_UP);
val4 = val4.setScale(2,RoundingMode.HALF_UP);
val5 = val5.setScale(2,RoundingMode.HALF_UP);
val6 = val6.setScale(2,RoundingMode.HALF_UP);
System.out.println(val1);
System.out.println(val2);
System.out.println(val3);
System.out.println(val4);
System.out.println(val5);
System.out.println(val6);
}
}
Versin 2.2 36 de 285
Para operar con la clase se debe tener presente lo siguiente. Por ejemplo, se requiere dividir 3 / 243 con 6
decimales.
package view;
import java.math.BigDecimal;
public class Metodos18 {
public static void main(String[] args) {
BigDecimal numero = new BigDecimal("3").divide(new BigDecimal("243"));
System.out.println(numero);
}
}
Para eliminar la excepcin se debe proceder como sigue:
package view;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Metodos19 {
public static void main(String[] args) {
BigDecimal numero =
new BigDecimal("3").divide(new BigDecimal("243"),6, RoundingMode.HALF_UP);
System.out.println(numero);
}
}
4.7 Trabajo 2
Desarrolle un proceso mediante un mtodo que sea capaz de recibir una cadena de caracteres y muestre:
(a) El total de caracteres.
(b) El total de espacios entre palabras de la cadena.
(c) El total de letras minsculas.
(d) El total de letras maysculas.
Crear dos variables de tipo StringBuffer con los elementos:
{ABCDEFGHIJKLMNOPQRSTUVWXYZ}
{0123456789}
Cree un mtodo que, usando esta estructura, sea capaz de validar que el cdigo de un producto est
compuesto slo de dos letras maysculas al inicio y luego dos nmeros.
Versin 2.2 37 de 285
5 Clase
5.1 Objetivos
Presentar problemas tipo para la evaluacin 1. Valor 12.5% de la nota 1.
5.2 Conocimiento previo
Contenidos de las clases 1, 2, 4 y 3
5.3 Modelos de evaluacin 1
Problema 1
El cobro de intereses por la venta de un producto est asociado a la relacin en das entre la fecha de
vencimiento y la fecha de pago. Considerar los siguientes datos:
rut A pagar (en pesos) Fecha de vencimiento Fecha de pago real
14000000 100000 15/01/10 17/03/10
14100000 -200000 15/01/10 16/01/10
14000000 1000000 20/01/10 01/01/10
14200000 500000 20/01/10 31/01/10
Se pide crear un mtodo sin parmetros que sea capaz de calcular y mostrar el inters a pagar en pesos,
donde el inters depende de la cantidad de das de retraso en el pago:
1-30 das 2,00%
31-90 das 4,50%
>90 das 9,00%
Si el valor de A pagar (en pesos) es menor que cero, entonces el valor se transforma en 0.
Problema 2
Considerar una variable llamada dat de tipo String:
(a) Crear un mtodo que devuelva un String y que cuente la cantidad de caracteres que contiene la
variable dat.
(b) Crear un mtodo que devuelva un boolean, que recibe como parmetro la variable busca de tipo
String y que analiza si est contenida en la variable dat. Por ejemplo, si dat=Hola Mundo Java y
busca=mUndo, entonces el mtodo devuelve true.
(c) Considerar que variable dat contiene informacin de fecha en formato dd/mm/aaaa. Crear un
mtodo que transforme adecuadamente el contenido de la variable dat a un tipo de variable que
maneje fechas; el mtodo debe mostrar el da, el mes y el ao.
Problema 3
La variable rut se ha definido de tipo StringBuffer. Desarrollar mtodos particulares para cada uno de los
siguiente proceso; cada mtodo recibe como parmetro la variable rut y devuelve un boolean.
(a) Validar que la cantidad de caracteres sea menor o igual a 10, pero mayor o igual a 3.
(b) Validar que el ltimo carcter sea un nmero o una letra k minscula o mayscula.
(c) Validar que el carcter guin al centro (-) est antes del ltimo carcter.
(d) Validar que los caracteres ante del guin al centro (-) sean slo nmeros.
Versin 2.2 38 de 285
Problema 4
Desarrolle un mtodo que cmo parmetro recibe un cdigo el cual se debe validar. Las condiciones son:
(a) El cdigo debe contener exactamente 4 caracteres.
(b) Los dos primeros dgitos son letras maysculas.
(c) Los dos ltimos caracteres son nmeros.
(d) En caso de no ser vlido el cdigo se debe indicar en el mensaje de error todos las anomalas
producidas.
Problema 5
Cree un mtodo que sea capaz de recibir la cantidad de alumnos, simule sus notas de 1 a 7, calcule y
muestre el promedio de estas.
Problema 6
Considere una clase java que tiene las siguientes variables:
String a = Hola;
String b = ; //Un espacio
String c = Mundo!;
String d = Java
Se pide, generar el mensaje Hola Mundo! Java y almacenarlo en una variable tipo StringBuffer. Adems
usando esta variable calcular:
La cantidad de letras maysculas.
La cantidad de letras minsculas.
La cantidad de espacios.
Recuperar desde la variable la palabra Mundo y almacenarla en otra variable StringBuffer.
Agregar al final de la variable ....
Reemplazar la palabra Java por Curso de Java almacenando los datos en la misma variable.
Problema 7
Desarrolle un mtodo que cuente con un parmetro StringBuffer y que sea capaz de almacenar en otra
variable StringBuffer el valor numrico que produce la concatenacin de las cifras numricas enviadas en el
parmetro del mtodo. Por ejemplo, si el parmetro es Ub40Yu7L entonces se debe almacenar 407.
Desarrollar el mismo proceso pero almacenando el nmero en orden inverso. Para el ejemplo sera
704.
Solucin, problema 1
package view;
import java.util.Calendar;
import java.util.Date;
public class Cobro {
private String rut;
private int aPagar;
private Date vence;
private Date pago;
public Cobro() {
Versin 2.2 39 de 285
}
public Cobro(String rut, int aPagar, Date vence, Date pago) {
this.setRut(rut);
this.setaPagar(aPagar);
this.setVence(vence);
this.setPago(pago);
}
public int getaPagar() {
return aPagar;
}
public void setaPagar(int aPagar) {
if(aPagar <0){
this.aPagar=0;
} else {
this.aPagar = aPagar;
}
}
public Date getPago() {
return pago;
}
public void setPago(Date pago) {
this.pago = pago;
}
public String getRut() {
return rut;
}
public void setRut(String rut) {
this.rut = rut;
}
public Date getVence() {
return vence;
}
public void setVence(Date vence) {
this.vence = vence;
}
public int calculoInteresAPagar(){
int valor=0;
valor = (int) (diasCobro() * interes() * this.aPagar);
return valor;
}
public double interes(){
double valor=0.0;
if(diasCobro()>=1 && diasCobro()<=30) valor=0.02;
if(diasCobro()>=31 && diasCobro()<=90) valor=0.045;
if(diasCobro()>=90) valor=0.9;
return valor;
}
public int diasCobro(){
Calendar f1 = Calendar.getInstance();
Versin 2.2 40 de 285
f1.setTime(this.getVence());
Calendar f2 = Calendar.getInstance();
f2.setTime(this.getPago());
int dias = 0;
dias = f2.get(Calendar.DATE) - f1.get(Calendar.DATE) + 1;
return dias;
}
}
package view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Ver {
public static void main(String[] args) throws ParseException {
Cobro o1 = new Cobro("14000000", 100000, fechas("15/01/10"), fechas("17/03/10"));
System.out.println(o1.calculoInteresAPagar());

Cobro o2 = new Cobro("14100000", -200000, fechas("15/01/10"), fechas("16/01/10"));
System.out.println(o2.calculoInteresAPagar());
Cobro o3 = new Cobro("14000000", 1000000, fechas("20/01/10"), fechas("01/01/10"));
System.out.println(o3.calculoInteresAPagar());
Cobro o4 = new Cobro("14200000", 500000, fechas("20/01/10"), fechas("31/01/10"));
System.out.println(o4.calculoInteresAPagar());
}
static Date fechas(String a) throws ParseException{
String dateFormatString = "dd/MM/yyyy";
SimpleDateFormat format = new SimpleDateFormat(dateFormatString);
Date fe = format.parse(a);
return fe;
}
}
Versin 2.2 41 de 285
6 Clase
6.1 Objetivos
Manejar el concepto de arreglo unidimensional y aplicarlo en el uso de algoritmos.
6.2 Conocimiento previo
Contenidos de las clases 1, 2, 3 y 4.
6.3 Arreglos unidimensionales
Un arreglo es una lista de datos con:
1. Un nmero fijo de componentes.
2. Todos del mismo tipo, por ejemplo, todos los componentes del arreglo de tipo double.
3. Los que son referenciados o calificados mediante ndices o expresiones ordinales encerradas en
corchetes, que actan como prefijo al identificador del arreglo.
Por ejemplo, una lista con valores vlidos para el desarrollo de un examen.
double[] vValido = {12.0,12.5,13.0,13.5,14.0,14.5,15.0,15.5,16.0,16.5,17.0,17.5}
Algunas de sus caractersticas de los arreglos:
Se crean con el operador new seguido del tipo y nmero de elementos.
int a[ ] = new int[10]; int a[]=new int[]{1,2,3};
Se puede acceder al nmero de elementos de un array con la variable miembro implcita length. Por
ejemplo:
a.length; // resultado 10
Se accede a los elementos de un arreglo con los corchetes [ ] y un ndice que vara de 0 a length-1.
Los elementos de un array se inicializan al valor por defecto del tipo correspondiente:
Cero para valores numricos
La cadena vaca para String
False para boolean
null para referencias
Como todos los objetos, los arreglos se pasan como argumentos a los mtodos por referencia.
Versin 2.2 42 de 285
6.4 Declaracin de arreglos
Para inicializar el arreglo podemos emplear:
int primes[ ];
primes = new int[10];
primes[0]=1;
primes[1]=2;
primes[2]=3;
primes[3]=4;
primes[4]=5;
primes[5]=6;
primes[6]=7;
primes[7]=8;
primes[8]=9;
primes[9]=10;
Tambin es vlido para el caso anterior:
int primes[ ] = {1,2,3,4,5,6,7,8,9,10};
Una secuencia de datos del tipo String (cadena) se puede declarar como:
String datos[ ] = {"A1","A2"};
Tambin es vlido
String datos[2] = new String[ ];
datos[0]="A1";
datos[1]="A2";
Tambin es vlido
String datos[2] = new String[ ];
datos[0]=new String("A1");
datos[1]=new String("A2");
Versin 2.2 43 de 285
6.5 Recorrer un arreglo
Las siguientes estructuras son capaces de recorrer un arreglo unidimensional:
Con un for:
public class RecorrerArreglo {
public static void main(String[] args) {
int[] arrayInt = {1, 20, 30, 2, 3, 5}; //Definicin del arreglo
for(int i=0; i < arrayInt.length; i++)
System.out.println (arrayInt[i]);
}
}
Con un while:
public class RecorrerArreglo {
public static void main(String[] args) {
int[] arrayInt = {1, 20, 30, 2, 3, 5};
int i=0;
while(i<arrayInt.length){
System.out.println (arrayInt[i]);
i++;
}
}
}
Con un for versin 1.5 de java:
public class RecorrerArreglo {
public static void main(String[] args) {
int[] arrayInt = {1, 20, 30, 2, 3, 5}; //Definicin del arreglo
//Recorre e imprime todos los elementos de un array
//previniendo ndices fuera de rango
for(int elemento: arrayInt)
System.out.println (elemento);
}
}
Versin 2.2 44 de 285
6.6 Asignacin de arreglos
Java permite la asignacin de un arreglo a otro arreglo. Por ejemplo:
int a[ ] = {1,2,3};
int b[ ] = new int[3];
....
a = b; //Esto debe ser desarrollado en un mtodo y no directamente en la clase.
De esta manera, se est haciendo una copia de la referencia a los mismos datos en memoria. As, al
modificar un valor en el arreglo de origen, esto afectar al valor de arreglo de destino.
Para evitar lo anterior se debe usar el mtodo clone() que realiza una copia del objeto arreglo en
otro objeto arreglo.
public class AsignarArray {
int a[] = {1,2,3};
int b[] = (int[])a.clone();
public static void main(String args[]){
AsignarArray obj = new AsignarArray();
obj.a[1]=111;
for(int i=0; i<3; i++)
System.out.println(obj.a[i]);
System.out.println("----------");
for(int j=0; j<3; j++)
System.out.println(obj.b[j]);
}
}
Notar que los valores del arreglo b no fueron modificados.
6.7 Ejemplos
1. Crear 10 nmero decimales aleatorios entre 1 (inclusive) hasta antes de 100. Math.Random()
genera nmeros double entre 0 y menor que 1.0.
public class Aleatorios {
public static void main(String[] args) {
double[] samples = new double[10];
for(int i = 0; i < samples.length; i++) { samples[i] = 100.0*Math.random() + 1.0; }
for(int i = 0; i < samples.length; i++) { System.out.println(samples[i]); }
}
}
Versin 2.2 45 de 285
2. Crear 10 nmero enteros aleatorios entre 1 y 100 (ambos incluidos).
Considerar que:
(int)100.9999 ==> 100
(int)1.001 ==> 1
public class Aleatorios {
public static void main(String[] args) {
int[] samples = new int[10];
for(int i = 0; i < samples.length; i++) {
samples[i] = (int) (100.0 * Math.random() + 1.0);
}
for(int i = 0; i < samples.length; i++) {
System.out.println(samples[i]);
}
}
}
3. Encontrar el mximo en un grupo de valores en un arreglo unidimensional.
public class Maximo {
public static void main(String[] args) {
int[] a = {2,-1,4,3,1,4};
int max = 0;
for(int e: a)
if(e>max)
max=e;
System.out.println(max);
}
}
4. Calcular el promedio de valores almacenados en un arreglo unidimensional.
package view;
public class Arreglo02 {
public static void main(String[] args) {
double[] val = {1., 20., 30., 2., 3., 5.};
double prom = 0.0;
for(int i=0; i < val.length; i++){
prom = prom + val[i];
}
prom = prom / val.length;
System.out.println(prom);
}
}
Versin 2.2 46 de 285
7 Clase
7.1 Objetivos
Manejar el uso de arreglos de objetos.
7.2 Conocimiento previo
Uso de arreglos unidimensionales y encapsulacin de datos.
7.3 Arreglos de objetos
Se puede crear una matriz de objetos de cualquier clase. Se procede de la misma manera que se crea una
matriz de nmeros o de caracteres. Por ejemplo, para crear crear una matriz de objetos de la clase
CPersona que soporte 100 elementos, se procede:
CPersona[ ] listaPersonas = new CPersona[100]
As se tiene, el objeto listaPersona que referencias a objeto de la clase CPersona. Cada elemento de la
matriz de objeto ser inicializado con el valor null. Para asignar un valor a la matriz se puede usar:
listaPersonas[i]= new CPersona([argumentos])
En este ejemplo tenemos la clase Alumno que recibe datos de alumnos y los encapsula:
public class AlumnoMatrizObjeto {
private String alumno = new String("");
private int edad = 0;
private double notaFinal = 0.0;
public AlumnoMatrizObjeto() { }
public AlumnoMatrizObjeto(String alumno, int edad, double notaFinal ) {
setAlumno(alumno);
setEdad(edad);
setNotaFinal(notaFinal);
}
public String getAlumno() { return alumno; }
Versin 2.2 47 de 285
1
1
1
1
]
1

listaPersonas
CPersona[0]
CPersona[1]
CPersona[99]
.....
public void setAlumno(String alumno) { this.alumno = alumno; }
public int getEdad() { return edad; }
public void setEdad(int edad) { this.edad = edad; }
public double getNotaFinal() { return notaFinal; }
public void setNotaFinal(double notaFinal) { this.notaFinal = notaFinal; }
}
Esta clase contiene los datos:
public class AlumnoMatrizObjetoDatos {
public static String[][] datos = {{"Juan Perez","25","6.2"},
{"Carla Perez","24","3.2"},
{"Graciela Perez","18","4.6"}
};
}
La clase que muestra informacin recupera los datos y los encapsula como objeto de AlumnoMatrizObjeto.
Luego usando esta encapsulacin recupera datos desde los objeto y hace clculos:
public class AlumnoMatrizObjetoView {
static AlumnoMatrizObjetoDatos obj = new AlumnoMatrizObjetoDatos();
static AlumnoMatrizObjeto obj1 = new AlumnoMatrizObjeto();
static AlumnoMatrizObjeto[] datosAlumnos = new AlumnoMatrizObjeto[3];
static double suma = 0;
public static void main(String args[]){
for(int i=0; i<obj.datos.length; i++) {
datosAlumnos[i] = new
AlumnoMatrizObjeto(obj.datos[i][0],
Integer.parseInt(obj.datos[i][1]),
Double.parseDouble(obj.datos[i][2]));
}
for(int i=0; i<obj.datos.length; i++)
suma = suma + datosAlumnos[i].getNotaFinal();
System.out.println("Suma notas:" + suma);
suma=0.0;
for(int i=0; i<obj.datos.length; i++)
suma = suma + datosAlumnos[i].getEdad();
System.out.println("Suma edades:" + suma);
}
}
7.4 Uso de parmetros tipo arreglo
Al devolver informacin de un mtodo mediante return, las variables de tipo de datos primitivos siempre se
devuelven por valor y los objetos siempre se devuelven por referencia. Para que un mtodo reciba un
arreglo a travs de una llamada de mtodo, la lista de parmetros del mtodo debe indicar que se recibir
un arreglo. Por ejemplo para definir un mtodo se puede usar:
void modificar(int x[ ])
Para pasar un arreglo, por ejemplo int c[ ], al mtodo modificar anterior se procede:
modificar( c );
Versin 2.2 48 de 285
Crear un mtodo que sea capaz de recibir un arreglo unidimensional de enteros y devuelva el mayor valor:
package dat;
public class ParametroArreglo01 {
static int[] datos = {4,-2,6,-1,0,0,5};
public static void main(String[] args) {
System.out.println(maxDatos(datos));
}

static int maxDatos(int datos[]){
int max=0;
for(int dato: datos)
if(dato>max)
max = dato;
return max;
}
}
7.5 La clase Arrays
Esta clase proporciona mltiples mtodos para manipular arreglos sobre mltiples tipos de datos T:
primitivos (enteros, reales, caracteres y booleanos) y objetos.
static void sort(T[] datos)
Ordena el array.
static void sort(T[] datos, int desde, int hasta)
Ordena el array entre las posiciones indicadas.
7.6 Ejemplos
1. Crear un mtodo que sea capaz de recibir un arreglo de datos unidimensional de tipo double y que
sea capaz de calcular y devolver el promedio de esos valores.
public class Trabajador {
public double calcularPromedio(double[] valores){
double prom = 0.0;
for(int i=0; i<valores.length; i++)
prom = prom + valores[i];
return prom/valores.length;
}
}
2. Crear un mtodo que reciba un arreglo de tipo char, que sea capaz de calcular y devolver la
cantidad de nmeros. Considera la frase Juan a ganado $890.000 en 1er da de trabajo.
public class Trabajador {

public int cuentaNumeros(char[] palabra){
int cant = 0;
for(int i=0; i<palabra.length; i++)
if(Character.isDigit(palabra[i]))
cant = cant + 1;
return cant;
}
}
public static void main(String[] args) {
Trabajador obj = new Trabajador();
Versin 2.2 49 de 285
char[] valores = {'J','u','a','n',' ','a',' ','g','a','n','a','d','o',' ',
'$','8','9','0','.','0','0','0',' ','e','n',' ','1','e','r',' ',
'd','','a',' ','d','e',' ','t','r','a','b','a','j','o'};
System.out.println("Promedio: " + obj.cuentaNumeros(valores));
}
7.7 Trabajo 3
Desarrollar un programa que reciba un arreglo de n nmeros reales correspondientes a las estaturas de n
personas. Se piden crear mtodos que reciban un arreglo del tipo citado y sean capaces devolver lo
solicitado.
(a) La media de las estaturas.
(b) Las alturas mxima y mnima.
(c) Determine cuntos son ms altos y cuantos ms bajos que la media.
(d) La desviacin estndar:
(e) Calcular la moda (si no la hay devolver -1). La moda es el nmero ms repetido (considerar que ese
valor es nico).
(f) Use los datos: {1.62, 1.44, 1.78, 1.98, 2.10, 1.61, 1.90, 1.78}. Observar que para estos datos en
valor de n = 8.
Considerar dos arreglos unidimensionales x e y de valores decimales y del mismo rango. Calcular los
valores a y b indicados los cuales son utilizados para encontrar la recta de regresin y = a + b*x.
Use los datos: x={1.30, 1.45, 1.50, 1.56, 1.70, 1.73, 1.85, 1.85, 1.85, 1.91}
y={45.4, 56.3, 49.2, 89.3, 56.4, 44.4, 65.3, 61.0, 70.7, 80.5}
Observar que para estos datos el valor de n = 10.
Versin 2.2 50 de 285
8 Clase
8.1 Objetivos
Manejar el concepto de arreglo bidimensional y aplicarlo en el uso de algoritmos.
8.2 Conocimiento previo
Uso de arreglos unidimensionales.
8.3 Arreglos Bidimensionales
Supongamos que usted tiene un inters en el tiempo, y tiene la intencin de registrar la temperatura de cada
da durante un ao en 10 ubicaciones geogrficas separadas a lo largo del ao. Una vez que haya
solucionado la logstica de la recogida de esta informacin, puede declarar este arreglo:
float[][] temperature = new float[10][365];
Suponga que se desea simular estas temperaturas, para lo cual tiene como informacin que estos valores
estn entre -10C y +35C
package dat;
public class Temperatura {
public static void main(String[] args) {
float[][] temperature = new float[365][10]; // Temperature array
for(int i = 0; i<temperature.length; i++) {
for(int j = 0; j < temperature[0].length; j++) {
temperature[i][j] = (float)(45.0*Math.random() - 10.0);
}
}
for(int i = 0; i<temperature.length; i++) {
System.out.println("Dia:"+(i+1)+"--------------");
for(int j = 0; j < temperature[0].length; j++) {
System.out.println(temperature[i][j]);
}
}
}
}
Versin 2.2 51 de 285
En este caso para la contabilizacin de las columnas se procede:
int a[ ][ ] = new int[10][3];
a.length; // resultado 10 cantidad de filas
a[0].length; // resultado 3 cantidad de columnas
8.4 Inicializacin de arreglos bidimensionales
Para el caso de arreglos tipo String
String datos[ ][ ] = {{"A1","A2"},
{"Enlatados","natural"}};
8.5 Ejemplos
1. Mximo Matriz, recorrida por filas
public class MaximoMatrizFilas {
static int x[][] = {{2,-1,4,3,1,4},
{8,2,-3,9,2,7}
};
public static void main(String[] args) {
int max=x[0][0];
for(int i=0; i < x.length; i++)
for(int j=0; j < x[0].length; j++)
if(x[i][j] > max)
max = x[i][j];
System.out.println(max);
}
}
2. Mximo Matriz, recorrida por columnas
public class MaximoMatrizColumnas {
static int x[][] = {{2,-1,4,3,1,4},
{8,2,-3,9,2,7}
};
public static void main(String[] args) {
int max=x[0][0];
for(int i=0; i < x[0].length; i++)
for(int j=0; j < x.length; j++)
if(x[j][i] > max)
max = x[j][i];
System.out.println(max);
}
}
Versin 2.2 52 de 285
x00 x01 x02 x03 x04 x05 x.length = 1
2 -1 4 3 1 4
x[ 0] .length = 5
8 2 -3 9 2 7
x10 x11 x12 x13 x14 x15
x00 x01 x02 x03 x04 x05 x.length = 1
2 -1 4 3 1 4
x[ 0] .length = 5
8 2 -3 9 2 7
x10 x11 x12 x13 x14 x15
Crear un mtodo que sea capaz de recibir un arreglo bidimensional cuadrado de enteros y devuelva el
arreglo transpuesto:
package dat;
public class ParametroArreglo02 {
static int[][] datos = {{-2,4,0},{21,-45,12},{-50,21,-45}};
public static void main(String[] args) {
int[][] traspuesta = transp(datos);
for(int i=0; i<traspuesta.length; i++){
System.out.println();
for(int j=0; j < traspuesta.length; j++)
System.out.print(traspuesta[i][j]+" ");
}
}
static int[][] transp(int[][] datos){
int[][] resul = new int[datos.length][datos.length];
for(int i=0; i<datos.length; i++)
for(int j=0; j < datos.length; j++)
resul[i][j]=datos[j][i];
return resul;
}
}
8.6 Trabajo 4
Considerar que se requiere un programa java que sea capaz de manejar las ventas de los siguientes
productos. Los siguientes datos deben ser definidos en un arreglo bidimensional de tipo String.
Producto Cdigo Cantidad inicial en
bodega (cajas)
Precio por
caja en Ch$
Peras AX10 10.000 10.000
Manzanas AX20 1.000 5.000
Uvas AX30 20.000 40.000
Por cada compra se tiene un descuento por volumen dado por:
Consideraciones:
(a) El sistema pregunta si se desea vender o ver el stock en bodega.
(b) Si seleccionar vender, entonces se pide la cantidad de cajas a comprar para los tres productos. Se
debe mostrar el total sin descuento por cada producto, el total de descuento aplicado a cada
producto y el total a pagar. En el caso que la cantidad a vender, para cualquiera de los tres
productos, supere el contenido en el stock, entonces el proceso de venta no se llevar a cabo para
ninguno de los producto y se mostrar un mensaje indicando el error.
(c) Si selecciona ver stock en bodega, entonces para los tres productos se debe mostrar el stock en
bodega.
Versin 2.2 53 de 285

'

>
< <
<
descuento Venta
descuento Venta
descuento cajas Venta
% 10 , 000 . 5
% 5 , 000 . 5 000 . 1
% 0 , 1000
9 Clase
9.1 Objetivos
Presentar problemas tipo para la evaluacin 2. Valor 12.5% de la nota 1.
9.2 Conocimiento previo
Contenidos de las clases 6, 7 y 8
9.3 Modelo de evaluacin 2
Ejercicio 1
Considerar un arreglo bidimensional de nmeros enteros de orden 4x5.
(a) Crear el arreglo.
(b) Crear un mtodo que calcule la cantidad de elementos repetidos en el arreglo.
(c) Crear un mtodo que almacene en un arreglo unidimensional el promedio de los valores de cada
una de las filas del arreglo bidimensional.
(d) Crear un arreglo que almacene los datos ordenados de menor a mayor usando los datos del arreglo
unidimensional anterior.
Ejercicio 2
(a) Crear la clase Proceso
(b) Dentro de la clase anterior definir el mtodo: public double posPromedio(String a[ ],int inf, int sup),
que recibe un arreglo unidimensional de String y dos valores enteros inf y sup. El mtodo regresa el
promedio de los valores contenidos entre los ndices inf y sup del arreglo a.
(c) Dentro de la clase anterior definir el mtodo: public double posMinimo(String a[ ],int inf, int sup) que
recibe un arreglo unidimensional de String y dos valores enteros inf y sup. El mtodo regresa el
menor valor contenidos entre los ndices inf y sup del arreglo a.
(d) Crear la clase ViewProceso
(e) Enviar los valores a[5]={3.4, -5.6, 2.9, 6.6, -6.1}, inf=1, sup=4 al mtodo descrito en la parte (b) y (c)
y mostrar el resultado
Ejercicio 3
Una empresa vende ciertos productos que deben ser almacenados en una matriz bidimensional.
Cdigo Precio Cantidad en bodega
AX10 1000 10000
AX20 500 30000
AX30 3000 500
Las ventas de estos productos deben se almacenadas en un arreglo bidimensional.
Cdigo Cantidad
AX20 10000
AX10 2000
Versin 2.2 54 de 285
AX20 25000
AX30 300
AX10 3000
AX20 1000
AX30 300
AX10 500
Crear un mtodo que sea capaz de devolver en un arreglo bidimensional el cdigo de los productos que
tiene ventas sobre el stock de de bodega y las cantidad vendidas sobre el stock de bodega.
Ejercicio 4
(a) Elabore un mtodo void sin parmetros que para una matriz bidimensional cuadrada A con elementos
numricos de tipo String sea capaz de calcular y mostrar: Max(A) 2*suma(diagonal(A)).
(b) Crear un arreglo bidimensional 3x2 de valores enteros aleatorios que contenga slo nmeros primos.
(c) Crear un arreglo String unidimensional que contenga los siguiente nombre:
Juan Perez Gamboa
Pilar del Carmen Ubilla Carrillo
Juanito Reyes
Anibal Jaramillo Baeza
Se pide crear un mtodo que calcule el total de letras maysculas de todos los nombres.
Se pide crear un mtodo que muestre el nombre o apellido con mayor cantidad de letras.
(d) Considerar un arreglo bidimensional 5x3 de datos enteros.
Crear un mtodo que calcule el promedio de los valores.
Crear un mtodo que calcule la cantidad de valores en el arreglo menores que cero.
Crear un mtodo que calcule la cantidad de nmeros primos contenidos en el arreglo.
Crear un mtodo que calcule la cantidad de nmeros entre -1 y 1 contenidos en el arreglo.
Crear un arreglo unidimensional que sea capaz de almacenar la suma de cada columna del arreglo.
Crear otro arreglo bidimensional 5x3 que sea capaz de almacenar los valores ordenados.
Ejercicio 5
Crear un arreglo unidimensional que soporte 10 elementos con valores aleatorios entre 0 y 10.
(a) Almacenar los valores en un segundo arreglos pero con los valores ordenados.
(b) Crear un mtodo que reciba un valor de tipo String y devuelva la posicin en que se encuentra el
valor en el arreglo. Considerar que si el arreglo est repetido se deben mostrar todas las posiciones.
Ejercicio 6
Se necesita un programa java que sea capaz de manejar las ventas de los siguientes productos.
Cdigo del Producto Precio
AX10 10000
AX20 20000
AX30 50000
Versin 2.2 55 de 285
Las ventas que se deben considerar son:
Rut Producto Cantidad
14000000 AX20 100
14200000 AX10 40
14100000 AX30 30
14000000 AX20 150
14100000 AX10 200
14000000 AX30 50
14300000 AX30 80
Se pide:
(a) Crear un mtodo sin parmetros que calcule la cantidad de productos vendidos de cada tipo.
(b) Crear un mtodo sin parmetros que calcule la suma total en pesos vendidos para cada uno de los
clientes.
Solucin ejercicio 2
package dat;
public class Proceso {
public double posPromedio(String a[], int inf, int sup){
double promedio=0.0;
for(int i=inf; i<=sup; i++){
promedio +=Double.parseDouble(a[i]);
}
return promedio/(double)(sup-inf);
}
public double posMinimo(String a[], int inf, int sup){
double minimo=0.0;
minimo=Double.parseDouble(a[inf]);
for(int i=inf; i<=sup; i++){
if(minimo > Double.parseDouble(a[i])){
minimo = Double.parseDouble(a[i]);
}
}
return minimo;
}
}
package dat;
public class ViewProceso {
public static void main(String[] args) {
String[] a = {"3.4","5.6","2.9","6.6","-6.1"};
int inf = 1;
int sup = 4;
Proceso obj = new Proceso();
System.out.println(obj.posPromedio(a, inf, sup));
System.out.println(obj.posMinimo(a, inf, sup));
}
}
Versin 2.2 56 de 285
10 Clase
10.1 Objetivos
Manejar en concepto de diagramacin UML.
10.2 Conocimiento previo
Concepto de clase, tributos y mtodos.
10.3 Uso de la herencia en la POO
Nos interesan los desafos que plantean el desarrollo de lo que llamaremos software de dimensin
industrial. Aqu se encuentran aplicaciones que mantienen, por ejemplo, la integridad de cientos de miles
de registros de informacin que mientras se permiten actualizaciones y consultas concurrentes; y sistemas
para la gestin de trfico areo o ferroviario. Los sistemas de software de esta clase tienden a tener un
ciclo de vida largo, y a lo largo del tiempo muchos usuarios llegan a depender de su funcionamiento
correcto.
La caracterstica principal del software de dimensin industrial es que resulta sumamente difcil, si no
imposible, para el desarrollador individual comprender todas las partes de su diseo. Para ser claro, la
complejidad de tales sistemas excede la capacidad intelectual humana.
Ley. La complejidad del software es una propiedad esencial, no accidental.
La complejidad se deriva de:
La complejidad del dominio del problema.
Versin 2.2 57 de 285
La dificultad de gestionar el proceso de desarrollo.
La flexibilidad que se puede alcanzar a travs del software.
Los problemas de caracterizar el comportamiento de sistemas discretos.
Las consecuencias de la complejidad son:
Cuando ms complejo sea el sistema, ms abierto est al derrumbamiento total. Un constructor
pensara raramente en aadir un subsotano a un edificio ya construido de cien plantas, hacer estos
sera muy costoso e indudablemente sera una invitacin al fracaso. Asombrosamente, los usuarios
de sistemas de software casi nunca se lo piensan dos veces a la hora de solicitar tales cambios.
Nuestro fracaso en dominar la complejidad del software lleva a proyectos retrasados, que exceden
el presupuesto, y que son deficientes respecto a los requerimientos fijados.
10.4 UML
Lenguaje Unificado de Modelado (UML, por sus siglas en ingls, Unified Modeling Language) es el lenguaje
de modelado de sistemas de software ms conocido y utilizado en la actualidad; est respaldado por el
OMG (Object Management Group). Es un lenguaje grfico para visualizar, especificar, construir y
documentar un sistema. UML ofrece un estndar para describir un "plano" del sistema (modelo),
incluyendo aspectos conceptuales tales como procesos de negocio y funciones del sistema, y aspectos
concretos como expresiones de lenguajes de programacin, esquemas de bases de datos y componentes
reutilizables.
Es importante resaltar que UML es un "lenguaje de modelado" para especificar o para describir mtodos o
procesos. Se utiliza para definir un sistema, para detallar los artefactos en el sistema y para documentar y
construir. En otras palabras, es el lenguaje en el que est descrito el modelo.
Se puede aplicar en el desarrollo de software entregando gran variedad de formas para dar soporte
a una metodologa de desarrollo de software (tal como el Proceso Unificado Racional o RUP), pero no
especifica en s mismo qu metodologa o proceso usar.
La programacin orientada a objetos viene siendo un complemento perfecto de UML, pero no por
eso se toma UML slo para lenguajes orientados a objetos.
UML cuenta con varios tipos de diagramas, los cuales muestran diferentes aspectos de las
entidades representadas. En UML 2.0 hay 13 tipos diferentes de diagramas.
Versin 2.2 58 de 285
Para el diseo de diagramas puedes emplear diversas aplicaciones que permiten en diversos niveles
diagramas y controlar el proyecto. Para este curso puedes usar la aplicacin dia que puede ser bajada
desde http://live.gnome.org/Dia.
El nombre de la clase se coloca en la parte superior del rectngulo y es una palabra con la primera letra en
mayscula. Si el nombre de la clase consta de ms de una palabra nalas e inicie cada palabra con
mayscula.
El atributo es una propiedad o caracterstica de una clase y describe un rango de valores que la propiedad
podr contener en los objetos de la clase. Si el atributo consiste de una sola palabra se escribe en
minscula. Sin embargo, si el nombre consiste en ms de una palabra, cada palabra ser unida a la anterior
y comenzar con una mayscula. Adems, se podr especificar el tipo de cada atributo. String, float, integer,
boolean.
Las operaciones es algo que la clase puede realizar. Se aplica el mismo estndar de nombre que los
atributos. En los parntesis podr los parmetros con los cuales funciona la operacin junto con su tipo de
dato. Adems, se podr indicar el tipo de datos devuelto.
Los estereotipos son un conjunto de acciones que se realizaran una y otra vez. Se indican entre parntesis
dobles nombreEstereotipo. Un ejemplo de esto son las interfaces de java, esta es una clase que declara
operaciones pero no las implementa. De esta manera, un estereotipo permite crear nuevos elementos a
partir de otros ya existentes.
Versin 2.2 59 de 285
10.5 Agregacin
Se crean objetos de las clases existentes dentro de la nueva clase. Simplemente se est reutilizando (y no
especializando) la funcionalidad del cdigo. Esto es lo que hemos vistos en los captulos anteriores.
Ms especficamente, la agregacin se produce cuando una clase consta de otras. Cuando modele
con agregacin tenga la precaucin que se cumpla la relacin esparte-de.
Notar una caracterstica que se cumple para este diagrama:
Los puntos son parte de los polgonos
Si los polgonos no existen, entonces esto no implica que los puntos dejen de existir. Por ende, los
puntos tiene vida propia independiente de la existencia o no de los polgonos.
El diamante blanco ilustra lo anterior.
Veamos otros ejemplos
Las ruedas forman parte del MedioDeTransporte (por ejemplo un automvil)
Pero, su ciclo de vida de las Ruedas no esta atado a MedioDeTransporte. Es
decir, si el MedioDeTransporte (por ejemplo, el automvil) se destruye,
entonces las ruedas como concepto siguen existiendo independientemente
(podramos decir que las ruedas puede utilizarse en otros artefactos que no
son medios de transporte, por ejemplo, ruedas dentadas)
Versin 2.2 60 de 285
10.6 Composicin
Con la composicin, el objeto parte puede pertenecer a un todo nico; es ms, se espera, por lo general,
que las partes vivan y mueran con el todo. Cualquier borrado del todo se extiende en cascada a las partes.
Al igual que en la agregacin, es una relacin estructural pero se le suma, que tiene un mtodo de
destruccin de los objetos. Y a diferencia de la asociacin, el ciclo de vida del objeto Area est relacionado
con el del objeto Ruta. Es decir que si la ruta de viaje se levanta, las reas que surgan a partir de ella
desaparecen.
Mucho se ha discutido a cerca de las agregaciones y las composiciones, ya que algunos sostienen
que los lenguajes orientados a objetos, tienen garbage collector, por lo que no necesitan mtodos de
destruccin de los objetos (relacionados a los ciclos de vida en la composicin).
La programacin es la misma para las composiciones y las agregaciones, y que la diferencia es
meramente conceptual entre una y otras.
Versin 2.2 61 de 285
10.7 Asociacin
Es generalmente, una relacin estructural entre clases o la conexin conceptual entre dos clases. En el
ejemplo, existe un atributo conductor en la clase MedioDeTransportes, que es del tipo Conductor. La
navegalidad nos muestra donde esta ubicado el atributo. Es decir, cual es la clase que tiene contiene el
atributo si sta no lo mostrase.
10.8 Multiplicidad
Versin 2.2 62 de 285
10.9 Herencia
La reutilizacin del software se consigue creando nuevas clases, pero en vez de crearlas de la nada, se
utilizan clases ya existentes que otras personas ya han construido y depurado (sin modificar el cdigo
existentes en ellas).
As, la reutilizacin del software es crear nuevas clases a partir de clases ya existentes, absorbiendo
sus atributos y comportamientos e incorporando capacidades que las nuevas clases requieren. Esto se
consigue con el concepto de herencia.
Versin 2.2 63 de 285
Clase: Instrumento
Mtodo: Tocar( )
SubClase: Cuerdas
Mtodo: Tocar( )
Contiene generalidades de cmo
tocar los diversos instrumentos.
Incorpora la forma especfica
de tocar instrumentos de cuerda.
Versin 2.2 64 de 285
10.10 Definiciones de herencia
La herencia es un concepto que tiene relacin directa con la reutilizacin de cdigo. El objetivo es usar lo ya
hecho y especializarlo. Veamos varias definiciones de herencia
1. Primero el maestro Rumbaugh.
James Rumbaugh es un cientfico de la computacin y un metodologista de objeto. Es mejor
conocido por su trabajo en la creacin de la Tcnica de Modelado de Objetos y el Lenguaje
Unificado de Modelado (UML). Doctorado en ciencias de la computacin por el M.I.T.
Rumbaugh dirigi el desarrollo de la OMT, en el Centro de Investigacin y Desarrollo de la
General Electric, donde trabaj durante ms de 25 aos.
Se uni a Rational Software en 1994, y trabaj all con Ivar Jacobson y Grady Booch ("los
Tres Amigos") para desarrollar UML. Ms tarde fusionaron sus metodologas de desarrollo de
software, OMT, OOSE y Booch en el Proceso Unificado Racional (RUP). En el 2003 se traslad a
IBM, despus de su adquisicin de Rational Software. Se retir en 2006.
Ha escrito varios libros sobre UML y RUP, junto a Ivar Jacobson y Grady Booch.
Versin 2.2 65 de 285
Ejemplos de utilizacin de herencia
2. Segn Wikipedia
Es una propiedad que permite que los objetos sean creados a partir de otros ya existentes,
obteniendo caractersticas (mtodos y atributos) similares a los ya existentes.
Es la relacin entre una clase general y otra clase ms especifica.
Es un mecanismo que nos permite crear clases derivadas a partir de clase base, nos permite
compartir automticamente mtodos y datos entre clases subclases y objetos.
Por ejemplo: Si declaramos una clase prrafo derivada de una clase texto, todos los mtodos y
variables asociadas con la clase texto, son automticamente heredados por la subclase prrafo.
La herencia es uno de los mecanismos de la programacin orientada a objetos, por medio del
cual una clase se deriva de otra, llamada entonces superclase, de manera que extiende su
funcionalidad.
La idea es la de partir de las situaciones ms generales e ir derivando hacia las ms
particulares, creando categoras, de la misma forma en que piensa el ser humano.
3. Segn Microsoft
La herencia, junto con la encapsulacin y el polimorfismo, es una de las tres caractersticas
principales (o "pilares") de la programacin orientada a objetos. La herencia permite crear nuevas
clases que reutilizan, extienden y modifican el comportamiento que se define en otras clases. La
clase cuyos miembros se heredan se denomina clase base y la clase que hereda esos miembros se
denomina clase derivada.
En la ilustracin siguiente se muestra una clase WorkItem que representa un elemento de
trabajo en algn proceso de negocio. Como todas las clases, deriva de Object y hereda todos sus
mtodos. WorkItem agrega cinco miembros propios. Esto incluye un constructor, porque los
constructores no se heredan. ChangeRequest hereda de WorkItem y representa un tipo
determinado de elemento de trabajo. ChangeRequest agrega dos miembros ms a los miembros
que hereda de WorkItem y Object. Debe agregar su propio constructor y tambin agrega un
miembro que permitir asociar ChangeRequest al elemento WorkItem original al que se aplica el
cambio.
Versin 2.2 66 de 285
4. Segn Sun Mycrosystem (actualmente Oracle)
La herencia es "un mecanismo por el cual una clase est definida en referencia a otras clases las
cuales agregan todas sus caractersticas
En este ejemplo:
La clase Manager va a sobre escribir el mtodo increaseSalary()
La clase Engineer va a usar los mtodos de la clase Employee
Versin 2.2 67 de 285
10.11 Relacin es-uny tiene-un
10.12 Subclases
Las relaciones de herencia forman estructuras jerrquicas similares a rbol. Una superclase existe en una
relacin jerrquica con sus subclases:
Ejemplo:
Una comunidad universitaria tpica comprende miles de personas que son miembros de la
comunidad.
Estas personas consisten en empleados, estudiantes y ex alumnos.
Los empleados son docentes, personal administrativo o directivos.
Los docentes pueden ser de planta o contratados por horas.
Los de planta pueden ser titulares, asociados, auxiliares o instructores.
Los estudiantes pueden ser de pregrado y postgrado.
Versin 2.2 68 de 285
Ejemplo:
Un auto es un tipo especial de vehculo
Lo datos que definen su estado incluyen a los necesarios para el vehculo genrico y algunos ms.
Tiene un mtodo particular para moverse hacia un destino y un mtodo exclusivo de cambiar una
rueda.
Un helicptero tambin es un vehculo y tiene otro mtodo distinto de moverse hacia un destino.
Un Ferrari TestaRossa es un tipo concreto de auto que tiene una forma particular de sustituir un
fusible.
Versin 2.2 69 de 285
11 Clase
11.1 Objetivos
Manejar y aplicar el concepto de herencia
11.2 Conocimiento previo
Conceptos de UML.
11.3 extends
Si se requiere que la clase ComisionEmpleado herede de la clase Empleado en java, se emplea la
palabra reservada extends. Por ejemplo
11.4 Sobrescribir mtodos
Las subclases heredan el estado y el comportamiento en forma de las variables y los mtodos de su
superclase.
La subclase puede utilizar los tems heredados de su superclase tal y como son, o puede
modificarlos o sobrescribirlos.
Por eso, segn se va bajando por el rbol de la herencia, las clases se convierten en ms y ms
especializadas.
Los mtodos private se puede sobrescribir
Versin 2.2 70 de 285
Los mtodos protected NO se pueden sobrescribir private
Los mtodos public NO se pueden sobrescribir protected o private
11.5 Object
En java todas las clases deben derivar de alguna otra.
La clase ms alta, la clase de la que todas las dems descienden, es la clase Object, definida en
java.lang.
Object es la raz de la herencia de todas las clases.
Versin 2.2 71 de 285
11.6 super
Se utiliza para dar acceso a miembros de una superclase desde una subclase.
Por ejemplo:
Si un mtodo oculta una de las variables miembros de una superclase, entonces se puede
acceder desde una subclase mediante super.
Si un mtodo sobrescribe un mtodo de una superclase, entonces se puede acceder a este
ltimo mediante super desde una subclase.
Se puede incluir una llamada explcita al constructor de la superclase (mediante la referencia super)
como primer enunciado del constructor de la subclase.
Si no se llama implcitamente a un constructor de la superclase, entonces, el constructor de la
subclase llamar implcitamente al constructor por omisin de la superclase (constructor sin
argumentos).
Versin 2.2 72 de 285
1. El objeto c llama al constructor de la clase This_c.
2. El constructor de la clase This_c llama, mediante super(x,y), al constructor de la clase This_b.
3. El constructor de la clase This_b llama, mediante super(x), al constructor de la clase This_a.
4. El valor de x=4 se da en la clase This_a.
5. Se baja a la clase This_b que da el valor y=5.
6. Se baja a la clase This_c que da el valor z=10.
Versin 2.2 73 de 285
11.7 Ejemplo 1
Calcular la media aritmtica y desviacin estndar enviando los datos en un arreglo de largo 6
desde el mtodo constructor. Recordar que los arreglos en java requieren tener un largo fijo antes
de ser usados.
Se debe generar una superclase Media y una subclase Desviacion, en donde se especialice el
mtodo mediaDes() de la clase Media en la subclase Desviacion.
public class Media{
public double[] datos = new double[6];
public Media(double[] datos){
for(int i=0; i<6; i++)
this.datos[i]=datos[i];
}
public double mediaDes(){
double resultado=0.0;
for(int i=0; i<6; i++)
resultado = resultado + this.datos[i];
return (resultado/6.0);
}
}
Versin 2.2 74 de 285
public class Desviacion extends Media{
public double[] datos = new double[6];
public Desviacion(double[] datos){
super(datos);
for(int i=0; i<6; i++)
this.datos[i]=datos[i];
}
public double mediaDes(){
double resultado=0.0;
for(int i=0; i<6; i++)
resultado = Math.pow(this.datos[i]-super.mediaDes(),2.0);
resultado = Math.pow(resultado/(6.0-5.0),0.5);
return (resultado/6.0);
}
}
import java.applet.Applet;
import java.awt.Graphics;
public class Ver extends Applet{
public double datos[] = {1.0,2.0,3.0,4.0,5.0,6.0};
public Media obj1;
public Desviacion obj2;
public void init(){
obj1 = new Media(datos);
obj2 = new Desviacion(datos);
}
public void paint(Graphics g){
g.drawString("Media: "+ String.valueOf(obj1.mediaDes()),20,20);
g.drawString("Desviacion Estandar: "+ String.valueOf(obj2.mediaDes()),20,40);
}
}
Resultado:
Versin 2.2 75 de 285
11.8 Ejemplo 2
Se pide:
Crear el diagrama de clases que de soporte al problema planteado
Basado estrictamente en su diagrama de clases cree en java las clase, atributos y
mtodos
Versin 2.2 76 de 285
package proc;
public class Jugador {
//Conceptos comunes a todos los jugadores
private String nombre="";
private int numero=0;
private int goles=0;
public Jugador() {
}
//Mtodo para recibir los datos indicados
public Jugador(String nombre, int numero, int goles) {
setNombre(nombre);
setNumero(numero);
setGoles(goles);
}
//Mtodo propio de todos los jugadores
public int valoracion(){
int val=0;
val = getGoles() * 30;
return val;
}
public int getGoles() { return goles; }
public void setGoles(int goles) { this.goles = goles; }
public String getNombre() { return nombre; }
public void setNombre(String nombre) { this.nombre = nombre; }
public int getNumero() { return numero; }
public void setNumero(int numero) { this.numero = numero; }
}
package proc;
public class Atacante extends Jugador {
//Conceptos propios de los atacantes
private int pases=0;
private int recuperados=0;
public Atacante() {
}
//Mtodo para recibir los datos indicados
public Atacante(String nombre, int numero, int goles, int pases, int recuperados) {
super(nombre, numero, goles);
setPases(pases);
setRecuperados(recuperados);
}
public int getPases() { return pases; }
public void setPases(int pases) { this.pases = pases; }
public int getRecuperados() { return recuperados; }
public void setRecuperados(int recuperados) { this.recuperados = recuperados; }
//Mtodo propio de todos los atacantes
@Override
public int valoracion(){
int val=0;
val = super.valoracion() + getPases()*2 + getRecuperados()*3;
return val;
}
}
Versin 2.2 77 de 285
package proc;
public class Defensor extends Jugador {
//Conceptos propios de los defensores
private int pases=0;
private int recuperados=0;
public Defensor() {
}
//Mtodo para recibir los datos indicados
public Defensor(String nombre, int numero, int goles, int pases, int recuperados) {
super(nombre, numero, goles);
setPases(pases);
setRecuperados(recuperados);
}
public int getPases() { return pases; }
public void setPases(int pases) { this.pases = pases; }
public int getRecuperados() { return recuperados; }
public void setRecuperados(int recuperados) { this.recuperados = recuperados; }
//Mtodo propio de todos los defensores
@Override
public int valoracion(){
int val=0;
val = super.valoracion() + getPases()*1 + getRecuperados()*4;
return val;
}
}
package proc;
public class Portero extends Jugador {
//Conceptos propios de los porteros
private int paradas=0;
public Portero() {
}
//Mtodo para recibir los datos indicados
public Portero(String nombre, int numero, int goles, int paradas) {
super(nombre, numero, goles);
setParadas(paradas);
}
public int getParadas() { return paradas; }
public void setParadas(int paradas) { this.paradas = paradas; }
//Mtodo propio de todos los porteros
@Override
public int valoracion(){
int val=0;
val = super.valoracion() + getParadas()*5;
return val;
}
}
Versin 2.2 78 de 285
11.9 Mtodos final
Son mtodos que implementan un bloqueo para evitar que cualquiera clase heredada sobrescriba el
mtodo.
As, se asegura que se mantenga el comportamiento durante la herencia, evitando que sea
sobrescrito.
Cualquier mtodo private o static de una clase es implcitamente final.
11.10 Clases final
Son clases que no pueden tener subclases.
Esto previenen posibles ataques que se intenten desarrollar a la clase.
La clase String del paquete java.lang es de este tipo.
Los mtodos de una clase final son automticamente final.
Versin 2.2 79 de 285
public class Sobre {
public int x;
public int y;
public Sobre( ) {
x = 4;
y = 5;
}
final void radio(int z) { z = x + y; }
}
public class IntentaSobrescribir extends Sobre {
public int a;
public int b;
public IntentaSobrescribir(){
super();
a=3;
b=4;
}
void radio (int c) {
c = a * b;
}
}
Intenta sobrescribir
el mtodo final radio
final public class A {
private int x=0;
private int y=0;
public A() { }
public A(int x, int y) {
this.setX(x);
this.setY(y);
}
public int getX() { return x; }
public int getY() { return y; }
public void setX(int x) { this.x = x; }
public void setY(int y) { this.y = y; }
public void radio(int z) { z = x + y; }
}
public class B extends A {
public B() { }
}
11.11 Trabajo 5
Usando herencia escribir un programa que sea capaz de calcular el volumen de un cilindro.
El rea de un crculo es:
Volumen del cilindro es:
Versin 2.2 80 de 285
12 Clase
12.1 Objetivos
Aplicar el concepto de clase abstracta, polimorfismo e interfaces.
12.2 Conocimiento previo
Uso de herencia.
12.3 Clases abstractas
Son clases que no necesitan ser instanciadas (no se generan objetos de ellas). En UML se denota en letras
cursivas o mediante estereotipos.
Un mtodo abstracto es aquel que est slo declarado, pero que sus subclases implementen de
acuerdo al uso que se quiera dar.
Por ejemplo, si en la clase A se define el mtodo abstracto sueldo, entonces las subclases de A
darn su propia implementacin al mtodo sueldo:
Pago por horas.
Pago por monto fijo.
Una clase abstracta no necesita contener un mtodo abstracto.
Una clase abstracta puede contener mtodos abstracto y no abstractos. As, se puede dejar parte
de la implementacin a sus subclases y el resto se puede implementar en la propia clase abstracta.
Si una clase B hereda desde una clase abstracta, entonces debe dar implementacin a todos los
mtodos abstractos, o sino, la clase B debe ser definida como abstracta.
La clase B proporcionar su propia implementacin al mtodo Contablizar().
La clase C proporcionar su propia implementacin al mtodo Contablizar().
Versin 2.2 81 de 285
Tambin se puede dar
Ejemplo:
En una aplicacin de dibujo orientada a objetos, se pueden dibujar crculos, rectngulos, lneas, etc.
Cada uno de esos objetos grficos comparten ciertos estados (posicin, caja de dibujo) y
comportamiento (movimiento, redimensionado).
Podemos aprovecharnos de esas similitudes y declararlos todos a partir de un mismo objeto padre.
Sin embargo, los objetos grficos tambin tienen diferencias substanciales: dibujar un crculo es
bastante diferente a dibujar un rectngulo. Los objetos grficos no pueden compartir estos tipos de
estados o comportamientos.
Otra caracterstica relevante es que una clase que hereda desde ObjtoGrafico est obligada a dar
implementacin al mtodo dibujar(). Por ende, a priori, de esta clase no debera heredar la clase Trabajador.
Versin 2.2 82 de 285
12.4 Ejemplo 1
Este es un tpico ejemplo en donde se tiene los trabajadores con distintos tipos de sueldo:
Sueldo fijo.
Sueldo por horas trabajadas.
Lo interesante de esto, es que si se requiere agregar un nuevo tipo de sueldo se debe heredar desde la
clase Trabajador.
public abstract class Trabaja {
private String nombre="";
private String apellido="";
public Trabaja(String nombre, String apellido) {
this.setNombre(nombre);
this.setApellido(apellido);
}
public String getNombre() { return nombre; }
public String getApellido() { return apellido; }
public void setApellido(String apellido) { this.apellido = apellido; }
public void setNombre(String nombre) { this.nombre = nombre; }
abstract double sueldo();
}
public class Fijo extends Trabaja {
private double sueldo;
public Fijo(String nombre, String apellido, double sueldo) {
super(nombre,apellido);
this.setSueldo(sueldo);
}
public void setSueldo(double s) { sueldo = (s > 0 ? s : 0); }
public double sueldo() { return sueldo; }
}
public class Horas extends Trabaja {
private double nroHoras;
private double valorHora;
public Horas(String nombre, String apellido,double nroHoras, double valorHora) {
super(nombre, apellido);
setNroHoras(nroHoras);
setValorHora(valorHora);
}
public void setNroHoras(double nh) { nroHoras = (nh > 0 ? nh : 0); }
public void setValorHora(double vh) { valorHora = (vh > 0 ? vh : 0); }

public double sueldo() { return nroHoras * valorHora; }
}
12.5 Interfaz
Una interfaz es un conjunto de operaciones (mtodos) que especifica cierto aspecto de
funcionalidad. Es un conjunto de operaciones que una clase (la interfaz) presenta a otras.
Versin 2.2 83 de 285
Trabaja
Fijo Horas
Una interfaz puede tambin contener datos miembro, pero estos son siempre static y final. Observar
que no es necesario declararlos static o final, pues lo son por estar contenidos en una interfaz.
Se modelan grficamente igual que una clase.
Una interfaz en Java es una clase en la que todos sus mtodos son abstractos. En ellas se
especifica qu se debe hacer pero no su implementacin. Sern las clases que implementen estas
interfaces las que implementen el comportamiento de los mtodos.
La palabra en ingls es: interface y la traduccin al espaol es interfaz, o en plural interfaces.
El uso de interfaces proporciona la siguiente ventaja:
Obligar a que ciertas clases utilicen los mismos mtodos (nombres y parmetros).
Versin 2.2 84 de 285
Versin 2.2 85 de 285
Versin 2.2 86 de 285
12.6 Polimorfismo
Versin 2.2 87 de 285
Versin 2.2 88 de 285
Versin 2.2 89 de 285
12.7 Ejemplo 2
Suponga que se requiere crear un programa en java que sea capaz de calcular el valor del arriendo de
diversos productos. De esta manera, dependiendo del tipo de producto que se necesita arrendar, el mtodo
procede a calcular segn se indica:
Libros: Costo de $200 por da.
Pelculas: Todas con un costo fijo de $500. Sin embargo, los Estrenos tiene un costo adicional de
$1.000 por da y el resto un costo adicional de $100 por da.
package owt;
//Clase que define el Arriendo recibiendo como datos los das de arriendo
public class Alquiler {
private int dias=0;
public Alquiler() { }
public Alquiler(int dias) { this.setDias(dias); }
public int getDias() { return dias; }
public final void setDias(int dias) { this.dias = dias; }
}
package owt;
abstract public class Item {
//Mtodo que usaremos para el proceso requerido
abstract protected int aCobrar(Alquiler a);
}
package owt;
//Define el arriendo de Libros implementado el mtodo aCobrar()
public class Libros extends Item {
@Override
protected int aCobrar(Alquiler a) {
int total =0;
total = a.getDias()*200;
return total;
}
}
package owt;
//Define el arriendo de Pelculas implementado el mtodo aCobrar()
public final class Pelicula extends Item {
private int tipo=0;
public Pelicula() { }
public Pelicula(int tipo) { this.setTipo(tipo); }
public int getTipo() { return tipo; }
public void setTipo(int tipo) { this.tipo = tipo; }
@Override
protected int aCobrar(Alquiler a) {
int total=0;
if(this.getTipo()==1){
total = 500 + a.getDias()*1000;
}
if(this.getTipo()==2){
Versin 2.2 90 de 285
total = 500 + a.getDias()*100;
}
return total;
}
}
package owt;
//Ejecuta procesos
public class Ver {
public static void main(String[] args){
//3 das de arriendo del tipo de pelcula 2
Alquiler o1 = new Alquiler(3);
Pelicula p1 = new Pelicula(2);
System.out.println("Arriendo pelicula no estreno: " + p1.aCobrar(o1));
//4 das de arriendo del tipo de pelcula 1
Alquiler o2 = new Alquiler(4);
Pelicula p2 = new Pelicula(1);
System.out.println("Arriendo pelicula estreno: " + p2.aCobrar(o2));
//10 das de arriendo de un libro
Alquiler o3 = new Alquiler(10);
Libros p3 = new Libros();
System.out.println("Arriendo libro: " + p3.aCobrar(o3));
}
}
Versin 2.2 91 de 285
13 Clase
13.1 Objetivos
Desarrollar la evaluacin 3. . Valor 12.5% de la nota 2.
13.2 Conocimiento previo
Contenidos de las clases 11, 12 y 13.
13.3 Modelos de evaluacin 3
Ejercicio 1
En un puerto se alquilan amarres para barcos de distinto tipo. Para cada alquiler se guarda el rut del cliente,
las fechas inicial y final de alquiler y el barco que lo ocupar. Un barco se caracteriza por su matrcula y su
eslora en metros.
Un alquiler se calcula multiplicando el nmero de das de ocupacin (incluyendo los das inicial y
final) por un mdulo funcin de cada barco obtenido multiplicando por 10 los metros de eslora por un valor
fijo de $200. Sin embargo, ahora se pretende diferenciar la informacin de algunos tipos de barcos:
El nmero de mstiles para veleros, con un valor fijo de $20.000 por mstil.
La potencia en caballos de fuerza para embarcaciones deportivas a motor. Por cada 10 caballos de
fuerza o fraccin de este un valor fijo de $2.000
La potencia en caballos de fuerza ms el nmero de camarotes para yates de lujo. Por cada 10
caballos de fuerza truncado al entero correspondiente un valor fijo de $5.000 y un valor fijo de
$1.000 por camarote.
Utilizando la herencia de forma apropiada, disee el diagrama de clases y sus relaciones, con detalle de
atributos y mtodos necesarios.
Solucin
package view;
import java.util.Calendar;
import java.util.Date;
public class Alquiler {
private String rut;
private Date inicio;
private Date fin;
public Alquiler() {
}
public Alquiler(String rut, Date inicio, Date fin) {
this.rut = rut;
this.inicio = inicio;
this.fin = fin;
}
public Date getFin() {
return fin;
}
Versin 2.2 92 de 285
public void setFin(Date fin) {
this.fin = fin;
}
public Date getInicio() {
return inicio;
}
public void setInicio(Date inicio) {
this.inicio = inicio;
}
public String getRut() {
return rut;
}
public void setRut(String rut) {
this.rut = rut;
}
public int diasCobro(){
Calendar f1 = Calendar.getInstance();
f1.setTime(this.getInicio());
Calendar f2 = Calendar.getInstance();
f2.setTime(this.getFin());
int dias = 0;
dias = f2.get(Calendar.DATE) - f1.get(Calendar.DATE) + 1;
return dias;
}
}
package view;
public class Barco {
private String matricula;
private int eslora;
private Alquiler alquiler;
public Barco() {
}
public Barco(String matricula, int eslora, Alquiler alquiler) {
this.matricula = matricula;
this.eslora = eslora;
this.alquiler = alquiler;
}
public int getEslora() {
return eslora;
}
public void setEslora(int eslora) {
this.eslora = eslora;
}
public String getMatricula() {
return matricula;
Versin 2.2 93 de 285
}
public void setMatricula(String matricula) {
this.matricula = matricula;
}
public Alquiler getAlquiler() {
return alquiler;
}
public void setAlquiler(Alquiler alquiler) {
this.alquiler = alquiler;
}
public int cobro(){
int valor=0;
valor = this.alquiler.diasCobro() * 10 * this.eslora * 200;
return valor;
}
}
package view;
public class Velero extends Barco {
private int mastiles;
public Velero(String matricula, int eslora, Alquiler alquiler, int mastiles) {
super(matricula,eslora, alquiler);
this.mastiles = mastiles;
}

public int getMastiles() {
return mastiles;
}
public void setMastiles(int mastiles) {
this.mastiles = mastiles;
}
@Override
public int cobro(){
int valor=0;
valor = super.cobro() + this.getMastiles() * 20000;
return valor;
}
}
package view;
public class Deportivas extends Barco {
private int cc;
public Deportivas(String matricula, int eslora, Alquiler alquiler, int cc) {
super(matricula,eslora, alquiler);
this.cc = cc;
}
Versin 2.2 94 de 285
public int getCc() {
return cc;
}
public void setCc(int cc) {
this.cc = cc;
}
@Override
public int cobro(){
int valor=0;
double caballo = Math.ceil(this.getCc() / 10.);
valor = (int) (super.cobro() + caballo * 2000);
return valor;
}
}
package view;
public class Yates extends Barco{
private int cc;
private int camatores;
public Yates(String matricula, int eslora, Alquiler alquiler, int cc, int camatores) {
super(matricula,eslora, alquiler);
this.cc = cc;
this.camatores = camatores;
}
public int getCamatores() {
return camatores;
}
public void setCamatores(int camatores) {
this.camatores = camatores;
}
public int getCc() {
return cc;
}
public void setCc(int cc) {
this.cc = cc;
}
@Override
public int cobro(){
int valor=0;
double caballo = Math.floor(this.getCc() / 10.);
valor = (int) (super.cobro() + caballo * 5000 + this.getCamatores() * 1000);
return valor;
}
}
Versin 2.2 95 de 285
package view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Ver {
public static void main(String[] args) throws ParseException {
Alquiler o1 = new Alquiler("14000000", fechas("01/01/2011"), fechas("31/01/2011"));
Alquiler o2 = new Alquiler("14000000", fechas("01/01/2011"), fechas("03/01/2011"));
Alquiler o3 = new Alquiler("14000000", fechas("01/01/2011"), fechas("10/01/2011"));

Velero v = new Velero("AV10",12,o1, 10);
Deportivas d = new Deportivas("AD70", 5, o2, 105);
Yates y = new Yates("AY40",200,o3,5125,300);
System.out.println("Velero: " + v.cobro());
System.out.println("Deportivas: " + d.cobro());
System.out.println("Yate: " + y.cobro());
}
static Date fechas(String a) throws ParseException{
String dateFormatString = "dd/MM/yyyy";
SimpleDateFormat format = new SimpleDateFormat(dateFormatString);
Date fe = format.parse(a);
return fe;
}
}
Ejercicio 2
Usando herencia escribir un programa que sea capaz de calcular el volumen de una esfera.
El rea de una esfera es:
Volumen de una esfera es:
Versin 2.2 96 de 285
Ejercicio 3
La empresa abc est dedicada por aos a la produccin y exportacin de frutas. Cada una de sus ventas
las maneja con un porcentaje de descuento estndar por volmenes de ventas; ms especficamente, si las
ventas son mayores a 20 toneladas y menores o igual a 50, entonces el descuento es de un 10% y si las
toneladas superan las 50, entonces el descuento es de un 30%. Adicional mente:
Las naranjas tiene un descuento dependiendo de la temporada (1ra = 2.5%, 2da = 1.5%)
Las paltas tiene un descuento adicional dependiente del destino y la temporada: 5% si las ventas
son desarrolladas a la Repblica Popular China en la 1ra temporada, 3% si las ventas son
desarrolladas a la Repblica Popular China en la 2ra temporada, 1% si las ventas son desarrolladas
a Europa en la 1ra temporada, 1.5% si las ventas son desarrolladas a Europa en la 2ra temporada y
un % en otros casos.
Todas los trmites de exportacin son desarrollados por varios agente que operan en Chile y con
representantes en distintas ciudades del planeta tierra.
Se pide:
(a) Ilustrar un diagrama de clases, respetando las normativas UML, que represente el problema
descrito.
(b) Disee un programa java para la programacin de cada una de las clases diseadas en el diagrama
de clases.
(c) Enviar la siguiente informacin e indicar el porcentaje de descuento que se aplicar por cada una de
las ventas.
Producto Toneladas Valor de 1 tonelada Destino Temporada
Naranjas 40 10000 ---- 2
Naranjas 5 12000 ---- 1
Paltas 100 20000 Republica Popular
China
2
Paltas 500 16000 Europa 1
Ejercicio 4
Considerar que se debe disear un modelo para describir la herencia de vehculos (tanques, motos, autos,
otros). Crear un diagrama de clases que sea capaz de describir lo solicitado. Indique, para un par de clase,
cual es el mtodo que se especializa que provoca la herencia entre esas clases.
Versin 2.2 97 de 285
14 Clase
14.1 Objetivos
Usar y definir excepciones.
14.2 Conocimiento previo
Programacin en java.
14.3 Manejo de excepciones
Existe una regla de oro en el mundo de la programacin: en los programas ocurren errores.
Versin 2.2 98 de 285
Esto es sabido; pero:
Qu sucede realmente despus de que ha ocurrido el error?
Cmo se maneja el error?
Quin lo maneja?
Puede recuperarlo el programa?
El lenguaje Java utiliza excepciones para proporcionar capacidades de manejo de errores.
Una excepcin es un evento que ocurre durante la ejecucin del programa que interrumpe el flujo normal de
las sentencias. Muchas clases de errores pueden utilizar excepciones, desde:
Serios problemas de hardware, como la avera de un disco duro
A los simples errores de programacin, como tratar de acceder a un elemento de un Array fuera de
sus lmites.
14.4 Lanzar una excepcin
Cuando un error ocurre dentro de un mtodo Java, el mtodo crea un objeto exception y lo maneja fuera,
en el sistema de ejecucin. Este objeto contiene informacin sobre la excepcin, incluyendo su tipo y el
estado del programa cuando ocurri el error. El sistema de ejecucin es el responsable de buscar algn
cdigo para manejar el error.
En terminologa java, crear una objeto exception y manejarlo por el sistema de ejecucin se llama
lanzar una excepcin.
14.5 Captura una excepcin
Despus de que un mtodo lance una excepcin, el sistema de ejecucin entra en accin para buscar el
manejador de la excepcin.
Un manejador de excepcin es considerado adecuado si el tipo de la excepcin lanzada es el
mismo que el de la excepcin manejada por el manejador. As la excepcin sube sobre la pila de llamadas
hasta que encuentra el manejador apropiado y una de las llamadas a mtodos maneja la excepcin, se dice
que el manejador de excepcin elegido captura la excepcin.
Si el sistema de ejecucin busca exhaustivamente por todos los mtodos de la pila de llamadas sin
encontrar el manejador de excepcin adecuado, el sistema de ejecucin finaliza (y consecuentemente el
programa Java tambin).
Versin 2.2 99 de 285
El cdigo dentro del try { } es el que se va a controlar:
g.drawString( Saludos[i],25,25 );
Al producirse un error en este cdigo, el manejador de excepciones buscar en el primer bloque
catch, una excepcin del tipo ArrayIndexOutOfBoundsException, que verifica que el arreglo
saludos[i] no este fuera de rango en los valores de su ndice i.
Si esto falla, entonces el manejador de excepciones buscar en el segundo bloque catch, una
excepcin del tipo Exception que es gatillado independiente del error que ocurra.
Por ltimo, independiente que hallan o no errores, el cdigo contenido en el bloque finally se
ejecutar.
14.6 Exception - Throwable
Versin 2.2 100 de 285
Las excepciones en tiempo de ejecucin son heredadas desde la clase RuntimeException, las cuales son
capturadas en tiempo de ejecucin y no de compilacin. Algunas excepciones en tiempo de ejecucin son:
ArrayIndexOutOfBoundsException: Si un programa intenta acceder a un ndice de arreglo fuera
del intervalos.
NullPointerException: Un programa crea una referencia a un objeto, pero todava no ha sido
creado.
ClassCastException: Mutacin no valida. Por ejemplo, se intenta transformar un dato de un tipo1 a
otros tipo2 sin existir consistencia en estos tipos. Por ejemplo,
Object x = new Integer(0);
System.out.println((String)x);
ArithmeticException: Se lanza cuando una excepcin aritmtica a ocurrido. Por ejemplo, cero
elevado a infinito.
IOException: Cubre las excepciones ocurridas al ejecutar una operacin de entrada salida. Por
ejemplo, apertura o cierre de archivos.
ClassNotFoundException: Se referenci una clase que el sistema es incapaz de encontrar.
DataFormatException: Error en el formato de los datos.
SQLException: Problemas con la definicin del String que define una consulta SQL.
Constructores de Exception:
Exception()
Exception(String message): Construye una nueva excepcin con el detalle especificado en el
mensaje .
Exception(String message, Throwable cause): Construye una nueva excepcin con el mensaje
de detalle especificado y la causa
Exception(Throwable cause)
Mtodos de Exception:
No tiene mtodos asociados
Versin 2.2 101 de 285
Constructores de Throwable
Throwable()
Throwable(String message): Construye un nuevo Throwable con el mensaje de detalle
especificado
Throwable(String message, Throwable cause): Construye un nuevo Throwable con el mensaje
de detalle especificado y causa
Throwable(Throwable cause)
Mtodos de Throwable
String getMessage(): Devuelve la cadena del mensaje del constructor Throwable(String message)
void printStackTrace(): Imprime esta Throwable y su backtrace en la secuencia de error estndar
Otros.
14.7 Error
ThreadDeath: Se produce cuando, por ejemplo, un hilo ejecutndose es deliberadamente detenido
y el hilo no captura esta excepcin
LinkageError: Se produce cuando, por ejemplo, existe incompatibilidad entre clases o el intento de
crear un objeto en una clase inexistente
VirtualMachineError: hay 4 subclases de esta clase que capturan errores catastrficos que pueden
ocurrir en la JVM. Por ejemplo, quedar sin recursos para funcionar
14.8 try catch -finally
El Bloque try: El primer paso es poner la sentencia Java dentro de la cual se puede producir la
excepcin dentro de un bloque try.
Los bloques catch: Despus se debe asociar un manejador de excepciones con un bloque try
proporcionndole uno o ms bloques catch directamente despus del bloque try.
El bloque finally se ejecutar independiente si el bloque try lanz o no una excepcin en cualquiera
de los bloques catch. Tambin se ejecutar si se sale de try mediante return, break o continue.
Sin embargo, si se lanza una excepcin para la que no se encuentra un catch asociado, entonces
cuando el control pase al bloque finally ste tambin podra lanzar una excepcin, en cuyo caso se
perder la primera excepcin.
Versin 2.2 102 de 285
Error
ThreadDeath LinkageError VirtualMachineError
Versin 2.2 103 de 285
int valor;
try {
for( x=0, valor = 100; x < 100; x ++ )
valor /= x;
}
catch( ArithmeticException e ) {
System.out.println( "Matemticas locas!" );
}
catch( Exception e ) {
System.out.println( "Se ha producido un error" );
}
14.9 throw
La sentencia throw se utiliza para lanzar explcitamente una excepcin de tipo Throwable, bien mediante
un parmetro en una clusula catch o utilizando el operador new. La forma general de la sentencia throw es:
throw ObjetoThrowable;
Se pueden definir excepciones propias, no hay por qu limitarse a las predefinidas y a sus
subclases; bastar con extender la clase Exception y proporcionar la funcionalidad extra que requiera el
tratamiento de esa excepcin.
Cuando se crea una nueva excepcin, derivando de una clase Exception ya existente, se puede
cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a travs de un mtodo.
Normalmente, el texto del mensaje proporcionar informacin para resolver el problema o sugerir una
accin alternativa. Por ejemplo:
package dat;
public class SinGasolina extends Exception{
//Llama al constructor exception(String mesage) de la clase Exception
SinGasolina( String s ) {
super( s );
}
}
package dat;
public class UsoSinGasolina {
public static void main(String[] args){
uso();
}
public static void uso(){
int j = 0;
try {
if( j < 1 ) throw new SinGasolina("Usando deposito de reserva");
} catch( SinGasolina e ) {
System.out.println( e.getMessage() ); //Muestra el mensaje del constructor de Exception
}
}
}
Resultado:
Se puede usar ms informacin usando el mtodo printStackTrace()
package dat;
public class SinGasolina extends Exception{
//Llama al constructor exception(String mesage) de la clase Exception
SinGasolina( String s ) {
super( s );
}
}
Versin 2.2 104 de 285
package dat;
public class UsoSinGasolina {
public static void main(String[] args){
uso();
}
public static void uso(){
int j = 0;
try {
if( j < 1 ) throw new SinGasolina("Usando deposito de reserva");
} catch( SinGasolina e ) {
System.out.println( e.getMessage() ); //Muestra el mensaje del constructor de Exception
e.printStackTrace();
}
}
}
14.10 throws
Lista las excepciones que un mtodo puede lanzar. Las excepciones que un mtodo lanza explcitamente o
que son lanzadas por mtodos invocados por este, deben ser listadas en throws. Para que un mtodo en
Java, pueda lanzar excepciones, hay que indicarlo expresamente.
void metodoAsesino() throws NullPointerException, CaidaException
14.11 Ejemplos
Versin 2.2 105 de 285
Versin 2.2 106 de 285
Compila
OK
NO
Ejecuta
NO
Ejecuta
Versin 2.2 107 de 285
Versin 2.2 108 de 285
Indicar que se va a imprimir:
Versin 2.2 109 de 285
Va a imprimir:
Versin 2.2 110 de 285
A. 1
B. 1
3
A. 1
4
D. 1
3
4
A. 1
2
3
4
F. No hay error
Versin 2.2 111 de 285
Para el caso anterior el Netbeans muestra:
Versin 2.2 112 de 285
Versin 2.2 113 de 285
Para el caso anterior el Netbeans muestra
Versin 2.2 114 de 285
Versin 2.2 115 de 285
14.12 Ejercicios
1. Crear una aplicacin ja va que sea capaz de ejecutar los siguientes procesos:
CLASE Venta
(a) Crear un mtodo constructor que sea capaz de recibir el cdigo de un producto
(String) y la cantidad vendida (int).
(b) Crear un mtodo sin parmetros que permita validar que el rango de la cantidad
vendida est entre 100 y 1000 unidades. Para informar valores fuera del rango se
debe crear una excepction.
(c) Crear un mtodo sin parmetros que sea capaz de calcular el total a pagar.
CLASE Producto
(a) Crear un mtodo que reciba como parmetro una variable String que representa el
cdigo de un producto. Se debe validar que est compuesto de slo nmeros de largo
6 exactamente. Para informar cdigos incorrectos se debe crear una excepction.
(b) La informacin de los productos vlidos est almacenada en un arreglo
bidimensional de tipo String con los siguientes datos:
Cdigo Precio
125468 100.000
325697 200.000
326598 500.000
326548 1.000.000
CLASE Ver
(a) Desde el mtodo main se debe enviar datos a la clase Venta con un cdigo y la
cantidad vendida.
(b) Se pide verificar, con valores incorrectos, que las exception se gatillan.
(c) Se pide verificar, con valores correctos, que se obtiene el total a pagar.
2. Crear una aplicacin java que sea capaz de almacenar en un archivo plano cada una de las
excepciones que ocurren en cualquier proceso.
(a) Para ello se debe crear un mtodo que reciba un parmetro una variable de tipo String y
que almacene el valor del parmetro en el archivo plano.
(b) Adems, se debe crear un mtodo que reciba como parmetro una variable de tipo String
y que busque el valor en cada una de las lneas del archivo plano e informe la cantidad
de veces que el valor se encuentra en el archivo.
3. Crear una aplicacin java que sea capaz de implementar excepciones de las por defecto
heredan de la clase Exception para las siguientes situaciones.
(a) Se leer desde el teclado un valor de tipo String que debe contener concretamente un
valor de tipo int
4. Indicar un ejemplo de cdigo en dnde se gatillen las excepciones:
(a) FontFormatException
(b) IllegalAccessException
(c) IOException
(d) NotBoundException
(e)
Versin 2.2 116 de 285
Versin 2.2 117 de 285
15 Clase
15.1 Objetivos
Uso de colecciones y en particular las clase ArrayList.
15.2 Conocimiento previo
Conceptos de orientacin a objetos y encapsulacin de datos.
15.3 Colecciones
Java tiene desde la versin 1.2 todo un juego de clases e interfaces para guardar colecciones de objetos.
Por ejemplo, si necesitamos almacenar objeto de la clase Estudiante con los atributos nombre, edad e
incorpora (que es la fecha de incorporacin), se podra tener:
Juan Prez Prez 34 01/03/10
Carla Saldivia Herrera 23 15/03/10
Carola Fandez Fica 19 10/03/10
Anita Suazo Gonzlez 20 18/03/10
Para almacenar estos datos lo podemos hacer en un arreglo. Sin embargo, el inconveniente es que el largo
del arreglo debe ser previamente definido y debemos programar la aplicacin del tamao de este.
De esta forma, las colecciones no requieren de un tamao inicial y una vez que el tamao asignado
por java el sobrepasado (o hay indicios de que el espacio almacenado no ser suficiente) entonces java
desarrolla el proceso de ampliacin del tamao.
import java.util.ArrayList;
public class Estudiante {
private String nombre="";
private int edad=0;
private String incorpora="";
//Permite manejar datos objetos
private ArrayList dat = new ArrayList();
public Estudiante() { }
public Estudiante(String nombre, int edad, String incorpora) {
this.setNombre(nombre);
this.setEdad(edad);
this.setIncorpora(incorpora);
}
public int getEdad() { return edad; }
public void setEdad(int edad) { this.edad = edad; }
public String getincorpora() { return incorpora; }
public void setIncorpora(String incorpora) { this.incorpora = incorpora; }
public String getNombre() { return nombre; }
public void setNombre(String nombre) { this.nombre = nombre; }
//Permite devolver los datos almacenados
public ArrayList getDat() {
return dat;
}

Versin 2.2 118 de 285
//Permite almacenar objetos con datos de la clase Estudiante
public void setDat(Estudiante dat) {
this.dat.add(dat);
}
}
Observaciones:
Las colecciones permiten almacenar slo un tipo de datos que debe ser un objeto. Por ende, si se
requiere almacenar ms de un tipo de datos, estos deben encapsularse para luego ser
almacenados como objetos de la clase que maneja la encapsulacin.
Los datos son mantenidos con el nombre del objeto de la coleccin. Por lo tanto, si me solicitan los
datos lo que hacemos es devolver el nombre del objeto de la coleccin. Para este ejemplo, lo que
se debe devolver es dat.
15.4 Iterator
Interfaz que se usa, por lo general, para mostrar elementos uno a uno.
Versin 2.2 119 de 285
15.5 Collection
Interfaz que define los mtodos bsicos para el manejo de estructuras de datos. Es la interfaz raz dentro
del manejo de colecciones.
15.6 List
La interfaz List considera mtodos adicionales a la interfaz Collection, aadiendo el manejo de ndices.
Adems, se trabaja con la lista ordenada (permitiendo valores duplicados) o con parte de la lista.
Versin 2.2 120 de 285
15.7 ArrayList
Clase que implementa los mtodos de la interfaz List. No tiene ningn mtodo sincronizado (excepto set y
get). Por lo tanto, acepta el acceso concurrente a los mtodos. De esta manera, desde diversos hilos se
puede acceder a los mtodos.
El ArrayList asume la estructura de lista simple enlazada. De esta manera es eficiente en la
bsqueda de informacin pero deficiente en la insercin y borrado.
import java.util.*;
public class Ejemplo1{
public static void main(String [ ]args) {
ArrayList items1 = new ArrayList();
items1.add("Juan Perez");
items1.add("Carla Ortuza");
items1.add("Elias Menares");
Iterator iterateItems1 = items1.iterator();
while (iterateItems1.hasNext()) {
System.out.println(iterateItems1.next());
}
}
}
Versin 2.2 121 de 285
Vamos a usar la clase Estudiante.
package view;
import bean.Estudiante;
import java.util.Iterator;
public class IngresaMuestra {
public static void main(String[] args) {
//Objeto que maneja los elementos de la clase
Estudiante o = new Estudiante();
//Almacena datos en el ArryList
o.setDat(new Estudiante("Juan Prez Prez",34,"01/03/10"));
o.setDat(new Estudiante("Carla Saldivia Herrera",23,"15/03/10"));
o.setDat(new Estudiante("Carola Fandez Fica",19,"10/03/10"));
o.setDat(new Estudiante("Anita Suazo Gonzlez",20,"18/03/10"));
//Muestra la cantidad de objetos almacenados en el ArrayList
System.out.println("Cantidad de objetos en ArrayList: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().listIterator();iterador.hasNext();){
Estudiante e = (Estudiante)iterador.next();
System.out.println("Nombre: " + e.getNombre()); //Muestra nombre
System.out.println("Edad: " + e.getEdad()); //Muestra Edad
System.out.println("Incorporacin: " + e.getincorpora()); //Muestra incorporacin
System.out.println();
}
}
}
15.8 Set
No incorpora ningn mtodo nuevo. Por sobre lo que es una collection, un set agrega una sola restriccin:
Al ingresar datos con la misma variable asume un slo valor en la lista. Si se intenta agregar un valor ya
existente en la lista pero con variables distintas, entonces este proceso se desarrollar.
La ventaja de utilizar Sets es que preguntar si un elemento ya est contenido mediante contains()
suele ser muy eficiente. Entonces es conveniente utilizarlos cada vez que necesitemos una coleccin en la
que no importe el orden, pero que necesitemos preguntar si un elemento est o no.
Versin 2.2 122 de 285
15.9 HashSet
Implementa los mtodos de la interfaz Set. Usa una tabla de hash. Los elementos no se encuentran
ordenados y pueden variar su posicin de acuerdo al proceso de balanceo de la estructura que desarrolle la
tabla de hash. ptima para cantidades pequeas de datos.
La clase HashSet aprovecha la segunda de las funciones. A cada objeto que se aade a la
coleccin se le pide que calcule su hash. Este valor ser un nmero entre -2147483647 y 2147483648.
Basado en ese valor se lo guarda en una tabla. Ms tarde, cuando se pregunta con contains() si un objeto x
ya est, habr que saber si est en esa tabla. En qu posicin de la tabla est? HashSet puede saberlo, ya
que para un objeto determinado, el hash siempre va a tener el mismo valor. Entonces la funcin contains de
HashSet saca el hash del objeto que le pasan y va con eso a la tabla. En la posicin de la tabla hay una lista
de objetos que tienen ese valor de hash, y si uno de esos es el buscado contains devuelve true.
package bean;
import java.util.HashSet;
public final class Producto {
private String nombre;
private int cantidad;
private HashSet dat = new HashSet();
public Producto() {
}
public Producto(String nombre, int cantidad) {
this.setNombre(nombre);
this.setCantidad(cantidad);
}
public int getCantidad() { return cantidad; }
public void setCantidad(int cantidad) { this.cantidad = cantidad; }
public String getNombre() { return nombre; }
public void setNombre(String nombre) { this.nombre = nombre; }
public HashSet getDat() { return dat; }
public void setDat(Producto dat) { this.dat.add(dat); }
}
Versin 2.2 123 de 285
package view;
import bean.Producto;
import java.util.Iterator;
public class MuestraHash {
public static void main(String[] args) {
//Objeto que maneja los elementos de la clase
Producto o = new Producto();
//Almacena datos en el HashSet
o.setDat(new Producto("Pan",34));
o.setDat(new Producto("Leche",19));
o.setDat(new Producto("Azucar",20));
o.setDat(new Producto("Leche",19)); //Si lo ingresa
Producto o1 = new Producto("Leche",19);
o.setDat(o1); /Si lo ingresa
o.setDat(o1); //Esto no lo ingresa
//Muestra la cantidad de objetos almacenados en el HashSet
System.out.println("Cantidad de objetos en HashSet: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().iterator();iterador.hasNext();){
Producto e = (Producto)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidad
System.out.println();
}
}
}
Considerar la siguiente modificacin el cdigo anterior.
package view;
import bean.Producto;
import java.util.Iterator;
public class MuestraHash {
public static void main(String[] args) {
//Objeto que maneja los elementos de la clase
Producto o = new Producto();
//Almacena datos en el HashSet
o.setDat(new Producto("Pan",34));
o.setDat(new Producto("Leche",19));
o.setDat(new Producto("Azucar",20));
o.setDat(new Producto("Leche",19)); ///Si lo ingresa
Producto o1 = new Producto("Leche",19);
o.setDat(o1); //Si lo ingresa
o.setDat(o1); //Esto no lo ingresa
Producto o2 = new Producto("Leche",19);
o.setDat(o2); //Si lo ingresa
//Muestra la cantidad de objetos almacenados en el HashSet
System.out.println("Cantidad de objetos en HashSet: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().iterator();iterador.hasNext();){
Producto e = (Producto)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidad
System.out.println();
}
}
}
Versin 2.2 124 de 285
Observar que el orden no necesariamente es el mismo para los mismos datos.
15.10 TreeSet
Implementa los mtodos de la interfaz Set. Los elementos se encuentran ordenados ascendentemente.
Inserta los elementos efectuando comparaciones con el mtodo comparateTo() de la interfaz Comparator, lo
cual puede diferir de equals.
TreeSet usa una tcnica completamente diferente a la explicada para HashSet. Construye un rbol
con los objetos que se van agregando al conjunto. Un rbol es una forma en computacin de tener un
conjunto de cosas todo el tiempo en orden, y permitir que se agreguen ms cosas y que el orden se
mantenga. Al tener todo en orden TreeSet puede fcilmente saber si un objeto est.
Una ventaja de TreeSet es que el orden en el que aparecen los elementos al recorrerlos es el orden
natural de ellos. Una desventaja es que mantener todo ordenado tiene un costo, y esta clase es un poco
menos eficiente que HashSet.
En el siguiente ejemplo, se crea la clase Productos con los atributos nombre y cantidad la cual debe
implementar la interface Comparable que te exige dar implementacin al mtodo comparateTo que tiene el
cdigo para distinguir entre un objeto y otro de la clase Productos. En este ejemplo la diferencia se le ha
indicado que sea desarrollada por el nombre.
Versin 2.2 125 de 285
package bean;
import java.util.TreeSet;
public final class Productos implements Comparable{
private String nombre;
private int cantidad;
private TreeSet dat = new TreeSet();
public Productos() {
}
public Productos(String nombre, int cantidad) {
this.setNombre(nombre);
this.setCantidad(cantidad);
}
public int getCantidad() {
return cantidad;
}
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public TreeSet getDat() {
return dat;
}
public void setDat(Productos dat) {
this.dat.add(dat);
}
@Override
public boolean equals(Object objeto) {
// Indica en base a que atributos se iguala el objeto
if (objeto == null) {
return false;
}
Productos productos = (Productos)objeto;
if (this.getNombre().equals(productos.getNombre())) {
return true;
}
return false;
}
@Override
public int hashCode() {
// retorna un identificador nico del objeto.
return this.getNombre().hashCode();
}
Versin 2.2 126 de 285
public int compareTo(Object objeto) {
// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales
Productos productos = (Productos) objeto;
String nombreObjeto = productos.getNombre().toLowerCase();
String nombreThis = this.getNombre().toLowerCase();
return (nombreThis.compareTo(nombreObjeto));
}
}
package view;
import bean.Productos;
import java.util.Iterator;
public class MuestraTree {
public static void main(String[] args) {
//Objeto que maneja los elementos de la clase
Productos o = new Productos();
//Almacena datos en el TreeSet
o.setDat(new Productos("Pan",34));
o.setDat(new Productos("Leche",19));
o.setDat(new Productos("Azucar",20));
o.setDat(new Productos("Leche",19)); //No lo ingresa
Productos o1 = new Productos("Leche",19);
o.setDat(o1); //No lo ingresa
o.setDat(o1); //No lo ingresa
Productos o2 = new Productos("Arveja",19);
o.setDat(o2); //Si lo ingresa
//Muestra la cantidad de objetos almacenados en el TreeSet
System.out.println("Cantidad de objetos en TreeSet: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().iterator();iterador.hasNext();){
Productos e = (Productos)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidad
System.out.println();
}
}
}
Versin 2.2 127 de 285
16 Clase
16.1 Objetivos
Uso de colecciones y en particular las clase ArrayList y Vector.
16.2 Conocimiento previo
Conceptos de orientacin a objetos y encapsulacin de datos.
16.3 Map
Declara mtodos que permiten manejar elementos como para clave valor sin permitir claves duplicadas.
Versin 2.2 128 de 285
MTODO
void clear()
Elimina todos los elementos
boolean containsKey(Object key)
Retorna true si se tiene un elemento para la clave
indicada.
boolean containsValue(Object value)
Retorna true si se tiene uno o ms elementos
para el elemento indicado
Set<Map<clave,valor>> EntrySet()
Retorna una vista de la lista.
Object get(Object key)
Retorna el elemento para la clave indicada o null
si el valor no est en la lista
int hashCode()
Retorna el valor de hash
boolean isEmpty()
Retorna true si la lista no contiene el par clave
valor
Set setKey()
Retorna el conjunto de claves de la lista. Con este
mtodo no se obtiene la lista por elemento sino
que completa
Object put(Object key, Object value)
Ingresa un elemento clave valor a la lista
void putAll(Map<calve,valor>)
Copia la lista completa de elementos
Object remove(Object key)
Elimina el elemento indicado por la clave
int size()
Indica el nmero de elementos de la lista
Collection values()
Retorna los valores de la lista (no las claves). Con
este mtodo no se obtiene la lista por elemento
sino que completa

16.4 HashMap
Implementa los mtodos declarados en la interfaz Map, que permiten manejar elementos como para clave
valor sin permitir claves duplicadas. Permite valores NULL como claves y valor. No garantiza el orden de los
elementos y este orden se puede ver afecto por el proceso de balanceo de carga ejecutado por el hash.
Veamos ahora un ejemplo con encapsulacin de informacin.
package bean;
import java.util.HashMap;
public final class Articulos {
private String nombre;
private int cantidad;
private HashMap dat = new HashMap();
public Articulos() {
}
public Articulos(String nombre, int cantidad) {
this.setNombre(nombre);
this.setCantidad(cantidad);
}
public int getCantidad() {
return cantidad;
}
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public HashMap getDat() {
return dat;
}
public void setDat(int corr, Articulos dat) {
this.dat.put(corr, dat);
}
}
Versin 2.2 129 de 285
package view;
import bean.Articulos;
import java.util.Iterator;
import java.util.Map;
public class MuestraHashMap {
public static void main(String[] args) {
Articulos o = new Articulos();
o.setDat(1, new Articulos("Pan",34));
o.setDat(2, new Articulos("Leche",19));
o.setDat(3, new Articulos("Azucar",20));
o.setDat(4, new Articulos("Leche",19));
//Muestra la cantidad de objetos almacenados en el HashMap
System.out.println("Cantidad de objetos en HashMap: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().entrySet().iterator();iterador.hasNext();){
Map.Entry e = (Map.Entry)iterador.next();
System.out.println("Clave: " + e.getKey()); //Muestra clave
Articulos ee = (Articulos)e.getValue();
System.out.println("Producto: " + ee.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + ee.getCantidad()); //Muestra cantidad
System.out.println();
}

}
}
Versin 2.2 130 de 285
Observar que si se almacena un valor con la misma clave, entonces se almacenar el ltimo valor
perdiendo el valor original.
package view;
import bean.Articulos;
import java.util.Iterator;
import java.util.Map;
public class MuestraHashMap {
public static void main(String[] args) {
Articulos o = new Articulos();
o.setDat(1, new Articulos("Pan",34));
o.setDat(2, new Articulos("Leche",19));
o.setDat(3, new Articulos("Azucar",20));
o.setDat(4, new Articulos("Leche",19));
o.setDat(3, new Articulos("Mantequilla",29));
//Muestra la cantidad de objetos almacenados en el TreeSet
System.out.println("Cantidad de objetos en TreeSet: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().entrySet().iterator();iterador.hasNext();){

Map.Entry e = (Map.Entry)iterador.next();
System.out.println("Clave: " + e.getKey()); //Muestra clave
Articulos ee = (Articulos)e.getValue();
System.out.println("Producto: " + ee.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + ee.getCantidad()); //Muestra cantidad
System.out.println();
}

}
}
Versin 2.2 131 de 285
16.5 TreeMap
Implementa los mtodos declarados en la interfaz Map, que permiten manejar elementos como para clave
valor sin permitir claves duplicadas. Permite valores NULL como claves y valor. Ordena los elementos
ascendentemente en relacin a la clave.
package bean;
import java.util.TreeMap;
public final class Articulo {
private String nombre;
private int cantidad;
private TreeMap dat = new TreeMap();
public Articulo() {
}
public Articulo(String nombre, int cantidad) {
this.setNombre(nombre);
this.setCantidad(cantidad);
}
public int getCantidad() {
return cantidad;
}
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public TreeMap getDat() {
return dat;
}
public void setDat(String clave, Articulo dat) {
this.dat.put(clave, dat);
}
}
Versin 2.2 132 de 285
import java.util.Map;
public class MuestraTreeMap {
public static void main(String[] args) {
Articulo o = new Articulo();
o.setDat("AX20", new Articulo("Pan",34));
o.setDat("AB30", new Articulo("Leche",19));
o.setDat("AR60", new Articulo("Azucar",20));
o.setDat("AU10", new Articulo("Leche",19));
o.setDat("AD70", new Articulo("Mantequilla",29));
//Muestra la cantidad de objetos almacenados en el TreeMap
System.out.println("Cantidad de objetos en TreeMap: " + o.getDat().size());
System.out.println();
for (Iterator iterador= o.getDat().entrySet().iterator();iterador.hasNext();){
Map.Entry e = (Map.Entry)iterador.next();
System.out.println("Clave: " + e.getKey()); //Muestra clave
Articulo ee = (Articulo)e.getValue();
System.out.println("Producto: " + ee.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + ee.getCantidad()); //Muestra cantidad
System.out.println();
}
}
}
Versin 2.2 133 de 285
16.6 Vector
La clase Vector de la versin 1.1 de Java es equivalente a esta clase ArrayList para la versin 1.2 de java.
La diferencia es que la clase Vector es Thread-Safe, lo que implica que todos sus mtodos estn
sincronizados. Esto redunda en un mayor costo de proceso pues debe monitorearse permanentemente los
bloqueos.
import java.util.*;

public class Ejemplo30{
public static void main(String args[])
{
Vector v = new Vector();
v.addElement("one");
v.addElement("two");
v.insertElementAt("zero",0);
v.insertElementAt("apps",3);
v.insertElementAt("three",4);
System.out.println("Tamano:" +v.size());
for(int i=0; i<v.size(); i++)
System.out.print(v.elementAt(i)+" ");
System.out.println();
Versin 2.2 134 de 285
METODO
Vector()
Constructor
Vector(int inicialCapacity)
Crea un vector con la capacidad indicada
Vector(int initialCapacity, int capacityIncrement)
Crea un vector con la capacidad e incremento indicado
int capacity()
Especifica el nmero de elementos que puede tener el vector
int size()
Devuelve la cantidad de elemento presente
void addElement(Object obj)
Aade un objeto al final
boolean removeElement(Object obj)
Elimina el primer objeto que encuentra como su argumento y
desplaza los restantes. Si no lo encuentra devuelve false
void removeAllElements()
Elimina todos los elementos
Object clone()
Devuelve una copia del vector
void setSize(int newSize)
Establece un nuevo tamao
boolean isEmpty()
Devuelve true si no tiene elementos
Object firstElement()
Devuelve el primer elemento
Object lastElement()
Devuelve el ltimo elemento
void insertElementAt(Object obj, int index)
Inserta un elemento por delante de una determinada posicin

System.out.println();
v.removeElement("apps");
System.out.println("Nuevo Tamano:" +v.size());
for(int i=0; i<v.size(); i++)
System.out.print(v.elementAt(i)+" ");
System.out.println();
}
}
16.7 Trabajo semana 10
Desarrollar un programa java que sea capaz de generar nmeros aleatorios enteros entre 1 y 100 y
almacenarlos en 4 ArrayList segn se indica.
Primero Valores entre 1-25
Segundo Valores entre 26-50
Tercero Valores entre 51-75
Cuarto Valores entre 76-100
Crear los 4 ArrayList con capacidad inicial de 10 valores.
Crear un mtodo que reciba un valor entero y almacene en el ArrayList que corresponda. Observar
que si la capacidad de un ArrayList se ve sobrepasada, entonces se deber incrementar en 20
valores ms.
Crear un mtodo que muestre cual de los ArrayList contiene la mayor cantidad de datos.
Crear un mtodo que sea capaz de recibir 3 parmetros:
El nombre de un ArrayList
Un valor entero de bsqueda
Un valor entero de reemplazo.
Se pide que el mtodo, si existe el ArrayList, cambie el valor de bsqueda por el de reemplazo (si
este existe).
Crear un mtodo que reciba un ArrayList y lo almacene en un TreeSet y muestre su informacin. El
mtodo debe concatenar la informacin que llega en el TreeSet.
Versin 2.2 135 de 285
17 Clase
17.1 Objetivos
Desarrollar la evaluacin 4. Valor 12.5% de la nota 2.
17.2 Conocimiento previo
Contenidos de las clases 16, 17 y 18
17.3 Modelos de evaluacin 4
Ejercicio 1
Para cada uno de los cdigos siguientes indicar la excepcin que generan.
(a) NumberFormatException
(b) RuntimeException
(c) ArrayIndexOutOfBoundsException
(d) NullPointerException
(e) ClassCastException
Caso 1:
package view;
public class Excepcion01 {
public static void main(String[] args) {
String a = "q2";
int b = Integer.parseInt(a);
System.out.println(b);
}
}
Caso 2.
package view;
public class A {
private int val;
public A(int val) {
this.val = val;
}
public int getVal() {
return val;
}
}
package view;
public class Excepcion02 {
static A o = new A("4");
public static void main(String[] args) {
System.out.println(o.getVal());
Versin 2.2 136 de 285
}
}
Caso 3.
package view;
public class Excepcion03 {
public static void main(String[] args) {
Double a = new Double("12.12");
double b = 12.12;
String c ="";
c = a + b;
System.out.println(c);
}
}
Caso 4:
package view;
public class Excepcion04 {
public static void main(String[] args) {
Double a = new Double("12.12");
double b = 12.12;
double c=0.0;
c = Double.parseDouble(Double.toString(a) + b);
System.out.println(c);
}
}
Caso 5:
package view;
public class Excepcion05 {
public static void main(String[] args) {
float[] a = {(float) 12.12,(float) 22.22};
float sum = 0;
for(int i=0; i<=a.length;i++)
sum = sum + a[i];
}
}
Caso 6.
package view;
public class Excepcion07 {
public static void main(String[] args) {
A o = null;
int a = 10;
if(a > 10)
o=new A(12);
else
System.out.println(o.getVal());
}
Versin 2.2 137 de 285
}
Caso 7:
package view;
public class Excepcion06 {
public static void main(String[] args) {
Object x = "0s";
System.out.println((Integer)x);
}
}
Ejercicio 2
Crear una arreglo de 10 valores aleatorios decimales entre 0 y menores que uno. Asignar el arreglo a una
coleccin que los almacene ordenados ascendentemente.
Crear un mtodo para mostrar la informacin almacenada en la coleccin seleccionada.
Crear un mtodo que sea capaz de mostrar el mayor valor usando la coleccin seleccionada.
Crear un mtodo que sea capaz de mostrar el menor valor usando la coleccin seleccionada.
Crear un mtodo que recupere todos los valores entre 0.1 y 0.4 ambos valores incluidos y los
almacene en un ArrayList.
Solucin:
package view;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;
public class Colecciones01 {
static TreeSet b = new TreeSet();
public static void main(String[] args) {
Random r=new Random();
double[] a = new double[10];
for(int i=0; i<a.length; i++){
a[i] = r.nextDouble();
}
for(int i=0; i<a.length; i++){
b.add(a[i]);
}
Colecciones01 c = new Colecciones01();
c.muestra();
c.mayor();
c.menor();
for(Iterator i = c.valores().iterator(); i.hasNext();){
System.out.println(i.next());
}
}
void muestra(){
for(Iterator i = b.iterator(); i.hasNext();){
System.out.println(i.next());
}
Versin 2.2 138 de 285
}
double mayor(){
double valor=0.0;
System.out.println("Mayor: " + b.last());
return valor;
}
double menor(){
double valor=0.0;
System.out.println("Menor: " + b.first());
return valor;
}
ArrayList valores(){
ArrayList dat = new ArrayList();
for(Iterator i = b.iterator(); i.hasNext();){
double val = Double.parseDouble(String.valueOf(i.next()));
if(val>=0.1 && val<=0.4){
dat.add(val);
}
}
return dat;
}
}
Ejercicio 3
Crear un programa que sea capaz de manejar la informacin de trabajadores de una empresa la cual debe
almacenar ordenada por rut el cual para cada trabajador en nico. La informacin del trabajador es el rut y
el nombre con informacin inicial:
Rut Nombre
14000000 Juan Perez Ubilla
14500000 Carla Barrera Perez
14200000 Julio Hernan Cardenas Baeza
14300000 Clara Vicencia Robles Robles
14100000 Pedro Lucas Juarez Hernandez
Selecciones la coleccin ms apropiada para almacenar la informacin.
Crear un mtodo que reciba el rut y el nombre y lo almacena en la coleccin.
Crear un mtodo que reciba el rut y el nombre, busque el rut en la coleccin y reemplace en nombre
por el valor indicado. Si el rut no existe, entonces se debe emitir un mensaje de error.
Crear un mtodo que reciba un String y que sea capaz de mostrar los rut en donde se encuentran el
String. Por ejemplo, si el String es Perez, entonces mostrar 14000000 y 14500000.
package view;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
public class Colecciones02 {
static TreeMap<String,String> dat =new TreeMap<String, String>();
public static void main(String[] args) {
dat.put("14000000", "Juan Perez Ubilla");
dat.put("14500000", "Carla Barrera Perez");
dat.put("14200000", "Julio Hernan Cardenas Baeza");
Versin 2.2 139 de 285
dat.put("14300000", "Clara Vicencia Robles Robles");
dat.put("14100000", "Pedro Lucas Juarez Hernandez");
Colecciones02 o = new Colecciones02();
o.buscar("Perez");
}
void almacena(String rut, String nombre){
dat.put(rut, nombre);
}
boolean reemplaza(String rut, String nombre){
if(dat.containsKey(rut)){
dat.remove(rut);
dat.put(rut, nombre);
return true;
} else {
return false;
}
}
void buscar(String data){
for(Iterator i = dat.entrySet().iterator(); i.hasNext();){
Map.Entry e = (Map.Entry)i.next();
String rut = (String)e.getKey();
String nombre = (String)e.getValue();
if(nombre.indexOf(data) != -1){
System.out.println(rut);
}
}
}
}
Versin 2.2 140 de 285
18 Clase
18.1 Objetivos
Uso de las colecciones genricas.
18.2 Conocimiento previo
Manejo de colecciones no genricas.
18.3 Colecciones Genricas
Consideremos la clase ArrayList vista en las clases anteriores:
public class ArrayList // Antes JDK 5.0
{
public Object get(int i) { . . . }
public void add(Object o) { . . . }
. . .
private Object[] elementData;
}
Lo anterior tiene dos problemas:
1. Se necesita indicar el tipo cada vez que se recupera un valor.
ArrayList files = new ArrayList();
. . .
String filename = (String) names.get(0);
2. Esto puede provocar un error de ejecucin que no se puede capturar el tiempo de compilacin.
La versin 5.0 del JDK ofrece una mejor implementacin de las colecciones como ArrayList. Por ejemplo, si
se necesita almacenar slo informacin de tipo String se tendr:
ArrayList<String> files = new ArrayList<String>();
Ahora no se necesita indicar los tipos. Simplemente se recupera con:
String filename = files.get(0);
Ahora el compilador dar un error en tiempo de compilacin para la instruccin.
files.add(new File(". . ."));
Versin 2.2 141 de 285
18.4 Ejemplo de uso
Consideremos el siguiente cdigo:
Compilacin no presenta problemas:
Consideremos ahora el siguiente cdigo:
Nuevamente la compilacin no presenta problemas:
Versin 2.2 142 de 285
Consideremos ahora el siguiente cdigo. Netbeans nos a marcado de inmediato el error en tiempo de
compilacin.
18.5 Iterator<>
La interfaz Iterator toma el lugar de la Enumeration en el marco de las colecciones en Java.
Permiten eliminar elementos de los datos recogidos en la iteracin con una semntica bien definida.
Mtodo se han mejorado
18.6 Vector<>
La caractersticas particular es que los objetos estn sincronizados. Para crear un objeto podemos emplear:
El vector almacena objetos tipo String.
El vector almacena inicialmente slo 100 objetos tipo String. Si se llena se duplica automticamente
la capacidad.
Para indicarle que el aumento sea de 10 objetos podemos definir
Versin 2.2 143 de 285
Veamos como almacenar un arreglo en una coleccin genrica y luego desde la coleccin mostrar sus
datos.
import java.util.Vector;
public class TrySimpleVector {
public static void main(String[] args) {
Vector<String> names = new Vector<String>();
String[] firstnames = { Jack, Jill, John,
Joan, Jeremiah, Josephine};
// Agrega la lista al Vector (slo pueden ser datos String)
for(String first : firstnames) {
names.add(first);
}
//Como cada dato del vector es String, entonces cada dato de names
//se transfiere a name para ser mostrado
for(String n : names) {
System.out.println(n);
}
}
}
En el ejemplo anterior tambin se pudo haber usado para recorrer el Vector:
18.7 ArrayList<>
Permite que todos los elementos, incluidos los nulos.
Esta clase es aproximadamente equivalente a la de vectores, excepto que es la falta de
sincronizacin: Si varios hilos de acceder a un ArrayList ejemplo simultnea, y al menos uno de los
hilos modifica estructuralmente la lista, debe ser sincronizado externamente.
Una aplicacin puede aumentar la capacidad de un ArrayList directamente usando el mtodo
ensureCapacity.
18.7.1 add
Permite asociar valores a un objeto de un ArrayList.
Versin 2.2 144 de 285
package view;
import java.util.ArrayList;
public class Generico01 {
public static void main(String[] args) {
ArrayList<Integer> a = new ArrayList<Integer>();
a.add(0,new Integer(10));
a.add(1,new Integer(111));
a.add(2,new Integer(12));
a.add(new Integer(133));
a.add(new Integer(14));
System.out.println("Cantidad de elementos: "+a.size());
for(int aa : a){
System.out.println("Valor: "+aa);
}
}
}
Para manejar datos encapsulados tenemos:
package bean;
import java.util.ArrayList;
public final class Trabajador {
private String nombre="";
private int edad=0;
private ArrayList<Trabajador> a = new ArrayList<Trabajador>();
public Trabajador() {
}
public Trabajador(String nombre, int edad) {
this.setNombre(nombre);
this.setEdad(edad);
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public ArrayList<Trabajador> getDatos() {
return a;
}
public void setDatos(Trabajador a) {
this.a.add(a);
}
}
Versin 2.2 145 de 285
package view;
import bean.Trabajador;
import java.util.Iterator;
public class Generico02 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
System.out.println("Cantidad de registros: "+t.getDatos().size());
for (Iterator<Trabajador> iterador= t.getDatos().iterator();iterador.hasNext();){
Trabajador e = (Trabajador)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getEdad()); //Muestra edad
System.out.println();
}
}
}
18.7.2 clear
Elimina los datos referenciados por un objeto de un ArrayList. Su uso es relevante cuando, por ejemplo, se
deben enviar datos para la construccin de un listado con informacin; en este caso, se deben limpiar los
datos referenciados por el objeto ArrayList cada vez que se requiere ver nueva informacin.
18.7.3 contains remove
La combinacin es usada para verificar si un valor existe y luego eliminarlo. Para este caso se debe dar
implementacin al mtodo toComparate() en la clase que encapsula la informacin.
package bean;
import java.util.ArrayList;
public final class Trabajador implements Comparable{
private String nombre="";
private int edad=0;
private ArrayList<Trabajador> a = new ArrayList<Trabajador>();
public Trabajador() {
}
public Trabajador(String nombre, int edad) {
this.setNombre(nombre);
this.setEdad(edad);
}
public int getEdad() { return edad; }
public void setEdad(int edad) { this.edad = edad; }
public String getNombre() { return nombre; }
public void setNombre(String nombre) { this.nombre = nombre; }
public ArrayList<Trabajador> getDatos() { return a; }
public void setDatos(Trabajador a) { this.a.add(a); }
Versin 2.2 146 de 285
@Override
public boolean equals(Object objeto) {
// Indica en base a que atributos se iguala el objeto
if (objeto == null) {
return false;
}
Trabajador productos = (Trabajador)objeto;
if (this.getNombre().equals(productos.getNombre())) {
return true;
}
return false;
}
@Override
public int hashCode() {
// retorna un identificador nico del objeto.
return this.getNombre().hashCode();
}
public int compareTo(Object objeto) {
// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales
Trabajador productos = (Trabajador) objeto;
String nombreObjeto = productos.getNombre().toLowerCase();
String nombreThis = this.getNombre().toLowerCase();
return (nombreThis.compareTo(nombreObjeto));
}
}
Implementamos la verificacin de la existencia del objeto a eliminar en la lista y luego lo eliminamos.
package view;
import bean.Trabajador;
import java.util.Iterator;
public class Generico03 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Pedro",72));
if(t.getDatos().contains(new Trabajador("Pedro",42))){ //Analiza si el objeto existe
t.getDatos().remove(new Trabajador("Pedro",42)); //Elimina el objeto
}
for (Iterator<Trabajador> iterador= t.getDatos().iterator();iterador.hasNext();){
Trabajador e = (Trabajador)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getEdad()); //Muestra edad
System.out.println();
}
}
}
Versin 2.2 147 de 285
Considerar este caso en el cual hay dos valores en la lista de los que se necesitan eliminar. As, slo se
eliminar el primero que encuentre.
package view;
import bean.Trabajador;
import java.util.Iterator;
public class Generico03 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Pedro",72));
t.setDatos(new Trabajador("Pedro",42));
if(t.getDatos().contains(new Trabajador("Pedro",42))){ //Analiza si el objeto existe
t.getDatos().remove(new Trabajador("Pedro",42)); //elimina el objeto
}
for (Iterator<Trabajador> iterador= t.getDatos().iterator();iterador.hasNext();){
Trabajador e = (Trabajador)iterador.next();
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getEdad()); //Muestra edad
System.out.println();
}
}
}
18.7.4 size
Retorna la cantidad de objetos contenidos en una lista.
18.7.5 isEmpty
Analiza si la lista contiene objetos.
18.7.6 indexOf lastIndexOf
El primero busca la posicin de la primera ocurrencia y el segundo busca la ltima posicin de la ocurrencia.
package bean;
import java.util.ArrayList;
public final class Trabajador implements Comparable{
//El mismo cdigo de la clase anterior
.
}
Versin 2.2 148 de 285
package view;
import bean.Trabajador;
public class Generico06 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
System.out.println("Primera aparicin: "+t.getDatos().indexOf(new Trabajador("Maria",22)));
System.out.println("Ultima aparicin: "+t.getDatos().lastIndexOf(new Trabajador("Maria",22)));
}
}
18.7.7 get
Busca valores dentro de una lista segn el ndice que se indique.
package bean;
import java.util.ArrayList;
public final class Trabajador{
//El mismo cdigo de la clase anterior
.
}
package view;
import bean.Trabajador;
public class Generico07 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Pedro",72));
t.setDatos(new Trabajador("Pedro",42));
for(int i=0; i<t.getDatos().size(); i++){
Trabajador e = (Trabajador)t.getDatos().get(i); //Recupera los datos
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getEdad()); //Muestra edad
System.out.println();
}
}
}
Versin 2.2 149 de 285
18.7.8 set
Reemplaza un valor en una posicin.
package bean;
import java.util.ArrayList;
public final class Trabajador{
//El mismo cdigo de la clase anterior
.
}
package view;
import bean.Trabajador;
public class Generico08 {
public static void main(String[] args) {
Trabajador t = new Trabajador();
t.setDatos(new Trabajador("Juan",21));
t.setDatos(new Trabajador("Pedro",42));
t.setDatos(new Trabajador("Maria",22));
t.setDatos(new Trabajador("Josefa",72));
t.setDatos(new Trabajador("Pedro",72));
t.setDatos(new Trabajador("Pedro",42));
t.getDatos().set(2, new Trabajador("Omar",33)); //Modifica los datos del ndice 2
for(int i=0; i<t.getDatos().size(); i++){
Trabajador e = (Trabajador)t.getDatos().get(i);
System.out.println("Producto: " + e.getNombre()); //Muestra nombre
System.out.println("Cantidad: " + e.getEdad()); //Muestra edad
System.out.println();
}
}
}
18.8 Iterable<>
Esta interfaz contiene un slo mtodo y se usa para recorrer datos asiendo uso de Iterator<>.
Versin 2.2 150 de 285
18.9 Collection
Es una interfaz que hereda desde la interfaz Iterable<>.
Versin 2.2 151 de 285
18.10 Set<>
Es una interfaz con las siguientes propiedades:
No mantiene el orden de insercin.
No admite elementos duplicados.
Si se aade un objeto al conjunto y hay otro igual no se produce ningn cambio.
18.11 List<>
Es una interfaz con las siguientes propiedades:
Coleccin que s mantiene el orden de insercin y que puede contener elementos duplicados
Acceso por posicin
No est permitido
Pero si est permitido
Tambin puede ser el objeto de una clase.
Observar que es compatible en usar int con Integer. Sin embargo, no es compatible usar Iterator con Integer
Versin 2.2 152 de 285
18.12 Map<,>
Es una interfaz que no permite claves duplicadas.
18.13 Implementacin
Versin 2.2 153 de 285
19 Clase
19.1 Objetivos
Uso de base de datos con Java.
19.2 Conocimiento previo
Uso de colecciones genricas
19.3 SQL
En un lenguaje de programacin creado para ejecutar consultas a base de datos.
19.3.1 Tabla
Estructura fsica que define la forma mediante la cual se almacenarn los datos. Por ejemplo, si
necesitamos almacenar los datos de los trabajadores de una compaa tenemos:
Rut
Nombre
Edad
Estatura
Fecha de ingreso
Sexo
Los tipos de estos datos guardan relacin con la funcin que estos cumplen. As se tendr:
Rut varchar(20)
Nombre varchar(100)
Edad int
Estatura double
Fecha de ingreso date
Sexo boolean
19.3.2 MySql
Vamos a emplear el MySql 5.x como motor de base de datos. Este se debe bajar desde:
http://www.mysql.com/downloads/mysql/
Versin 2.2 154 de 285
Para instalar el Motor seguir los siguientes pasos una vez que se ha bajado el archivo indicado.
Paso 1: Seleccionar Next.
Versin 2.2 155 de 285
Paso 2: Aceptar y seleccionar Next.
Paso 3: Seleccionar Complete:
Versin 2.2 156 de 285
Paso 4: Seleccionar Install
Paso 5: Seleccionar Next
Versin 2.2 157 de 285
Paso 6: Seleccionar Next
Paso 7: Seleccionar Finish
Versin 2.2 158 de 285
Paso 8: Seleccionar Next.
Paso 9: Seleccionar Standard Configuration y luego Next.
Versin 2.2 159 de 285
Paso 10: Seleccionar el Service name y luego Next
Paso 11: Indicar una clave para el usuario administrador del motor de base de datos. Nosottros usaremos
como password root.
Versin 2.2 160 de 285
Paso 12: Seleccionar execute.
19.3.3 PK
Es el identificador de unicidad de cada registro de la tabla. Por ejemplo, para trabajadores de una empresa
nacional podra ser el rut, el cual identifica de manera nica a cada trabajador.
19.3.4 Crear tabla
Crear la tabla de nombre trabajador, con pk rut y con los siguientes datos:
Rut varchar(20)
Nombre varchar(100)
Edad int
Estatura double
Fecha de ingreso date
Sexo boolean
create table trabajador
(
rut varchar(20) primary key,
nombre varchar(100),
edad int,
estatura double(4,2),
ingreso datetime,
sexo bit
)
Versin 2.2 161 de 285
Para ejecutar este proceso en mysql se debe ingresar a la consola que no solicitar la password que le
indicamos.
Luego se debe crear la base de datos. En este caso el nombre ser dgac.
Versin 2.2 162 de 285
Luego se debe ingresar en el contexto de la base de datos dgac. Para eso usar la instruccin use dgac.
Luego hacer copiar y pegar con el script de creacin de la tabla.
19.3.5 insert
Usar la siguiente instruccin para el ingreso de datos, haciendo copiar pegar:
insert into trabajador (rut,nombre,edad,estatura,ingreso,sexo) values ('14000000','Juan Perez',45,1.72,'2010/01/31',1);
insert into trabajador (rut,nombre,edad,estatura,ingreso,sexo) values ('14100000','Sara Perez',31,1.62,'2010/01/15',0);
insert into trabajador (rut,nombre,edad,estatura,ingreso,sexo) values ('14200000','Hugo Galaz',22,1.66,'2010/02/01',1);
insert into trabajador (rut,nombre,edad,estatura,ingreso,sexo) values ('14300000','Maria Ugarte',32,1.93,'2010/02/01',0);
insert into trabajador (rut,nombre,edad,estatura,ingreso,sexo) values ('14400000','Jose Urrutia',40,1.88,'2010/02/15',1);
Versin 2.2 163 de 285
Esta instruccin tiene por obligacin insert into, luego entre parntesis los campos a los cuales se le
necesita ingresar datos, enseguida la palabra values para finalizar entre parntesis con los datos
asociados en una relacin 1-1 con el nombre de los campos.
19.3.6 update
Esta instruccin da la posibilidad de cambiar datos en uno o ms registros. Por ejemplo, cambiar la edad del
rut=14.200.000 a 50 aos.
update trabajador
set edad=50
where rut='14200000';
19.3.7 delete
Esta instruccin da la posibilidad de eliminar uno o ms registros. Por ejemplo, eliminar el rut=14.200.000.
delete from trabajador
where rut=14200000;
19.3.8 select
Da la posibilidad de visualizar registros.
Caso 1: Ver todos los datos.
select * from trabajador;
Caso 2: Ver todos los registros con edad < 32 aos.
select * from trabajador where edad < 32;
Caso 3: Ver todos los registros con edad entre 30 y 40 aos ambos valores incluidos.
select * from trabajador where edad between 30 and 40;
Versin 2.2 164 de 285
Caso 4: Contar la cantidad de registros.
select count(*) from trabajador;
Caso 5: Ver el nombre y edad los registros con edad entre 30 y 40 aos ambos valores incluidos.
select nombre, edad from trabajador where edad between 30 and 40;
19.4 JDBC
Java Database Connectivity, ms conocida por sus siglas JDBC, es una API que permite la ejecucin de
operaciones sobre bases de datos desde el lenguaje de programacin Java, independientemente del
sistema operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto SQL del
modelo de base de datos que se utilice.
El API JDBC se presenta como una coleccin de interfaces Java y mtodos de gestin de
manejadores de conexin hacia cada modelo especfico de base de datos. Un manejador de conexiones
hacia un modelo de base de datos en particular es un conjunto de clases que implementan las interfaces
Java y que utilizan los mtodos de registro para declarar los tipos de localizadores a base de datos (URL)
que pueden manejar. Para utilizar una base de datos particular, el usuario ejecuta su programa junto con la
biblioteca de conexin apropiada al modelo de su base de datos, y accede a ella estableciendo una
conexin, para ello provee el localizador a la base de datos y los parmetros de conexin especficos. A
partir de all puede realizar con cualquier tipo de tareas con la base de datos a las que tenga permiso:
consulta, actualizacin, creacin, modificacin y borrado de tablas, ejecucin de procedimientos
almacenados en la base de datos, etc.
La especificacin se encuentra en:
http://java.sun.com/javase/6/docs/technotes/guides/jdbc/
Versin 2.2 165 de 285
19.5 Qu hace la API de JDBC?
En trminos simples, una tecnologa basada en JDBC driver (controlador JDBC ") permite hacer tres cosas:
1. Establecer una conexin con una fuente de datos
2. Enviar consultas y actualizar las declaraciones a la fuente de datos
3. Proceso de los resultados
19.6 Conexin de Informacin general
Un objeto Connection representa una conexin con una base de datos. Una sesin de conexin incluye las
instrucciones SQL que se ejecutan y los resultados que se devuelven en la conexin. Una sola aplicacin
puede tener una o ms conexiones con una sola base de datos, o puede tener conexiones con muchas
bases de datos diferentes.
19.7 Establecer una conexin
La forma tradicional de establecer una conexin con una base de datos es llamar a la
DriverManager.getConnection mtodo. Este mtodo toma una cadena que contiene una direccin URL. La
clase DriverManager conocida como la capa de gestin de JDBC, intenta localizar un controlador que puede
conectarse a la base de datos correspondiente a dicha URL. La clase DriverManager mantiene una lista de
clases Driver registrados, y cuando el getConnection mtodo se llama, comprueba con cada conductor en la
lista hasta que encuentre uno que pueda conectarse a la base de datos especificada en la URL. El mtodo
de Driver connect utiliza esta URL para realmente establecer la conexin.
El cdigo siguiente es un ejemplo de la apertura de una conexin a una base de datos ubicada en la
jdbc:odbc:wombat con un ID de usuario de oboy y 12Java como la contrasea:
String url = "jdbc:odbc:wombat";
Connection con = DriverManager.getConnection(url, "oboy", "12Java");
El JDBC 2.0 proporciona la interfaz DataSource como una alternativa a la DriverManager para establecer
una conexin. Cuando una clase DataSource se ha aplicado adecuadamente, el objeto DataSource se
puede utilizar para producir objetos Connection que participan en la agrupacin de conexiones y / o objetos
Connection que pueden participar en transacciones distribuidas. DataSource es la alternativa preferida para
la creacin de una conexin.
Una aplicacin utiliza un objeto Connection producido por DataSource de manera esencialmente es
la misma que utiliza un objeto Connection producido por el DriverManager.
19.8 Liberacin DBMS Recursos
Se recomienda que los programadores de cerrar explcitamente las conexiones y las declaraciones que han
creado cuando ya no son necesarios.
Un programador de escribir cdigo en el lenguaje de programacin Java y que no utilice ninguna de
recursos externos, no necesita preocuparse por la gestin de memoria. El recolector de basura elimina
automticamente los objetos cuando ya no se utiliza y libera la memoria que se utiliza. Cuando la memoria
se est agotando, se reciclan los objetos desechados, haciendo que la memoria que ocupan actualmente
disponible para la reutilizacin rpida.
Sin embargo, si una aplicacin utiliza los recursos externos, como lo hace cuando tiene acceso a un
Motor de Base de Datos con la API de JDBC, el recolector de basura no tiene manera de conocer el estado
de esos recursos. Por lo tanto, se recomienda que los programadores explcitamente cerrar todas las
conexiones (con el mtodo Connection.close y declaraciones con el mtodo Statement.close) tan pronto
como ya no son necesarios.
Versin 2.2 166 de 285
19.9 Crear una conexin
Para esto se va a crear una clase que proporciones el servicio y en la cual se puedan configurar en duro
sus parmetros.
package conec;
public class ConexionBD {
private static String url= "jdbc:mysql://localhost/dgac"; //Se conecta a la base de datos dgac
private static String user= "root"; //El usuario es root
private static String pass= "root"; //La clave del usuario root es root

public static String getDriver() {
String driver= "com.mysql.jdbc.Driver"; //Declara el Driver a usar
return driver;
}
public static String getUrl() { //Retorna la url con la ubicacin de la base de datos
return url;
}
public static String getUser() { //Retorna el usuario de conexin a la base de datos
return user;
}
public static String getPass() { //Retorna el password del usuario de conexin a la base de datos
return pass;
}
}
19.10 Insertar datos
Desde la consola del MySQL crear la base de datos dgac y la tabla alumno siguiente:
create database dgac;
use dgac;
create table alumno(
rut varchar(20),
edad int,
sexo boolean,
primary key(rut)
);
Para mostrar la estructura de la tabla:
Versin 2.2 167 de 285
Ingresar los siguiente datos usando el comando insert:
insert into alumno (rut,edad,sexo) values ('14000000',25,true);
insert into alumno (rut,edad,sexo) values ('12000000',35,true);
insert into alumno (rut,edad,sexo) values ('10000000',45,false);
insert into alumno (rut,edad,sexo) values ('16000000',18,true);
insert into alumno (rut,edad,sexo) values ('15000000',30,false);
insert into alumno (rut,edad,sexo) values ('9000000',50,true);
Para visualizar la informacin se usa el comando select
Crear un proyecto:
Versin 2.2 168 de 285
Crear la clase ConexionDB en la package conec:
El cdigo asociado a la clase es el anterior.
Versin 2.2 169 de 285
Crear la clase IngresaAlumno en el package proc:
package proc;
import conec.ConexionBD;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class IngresaAlumno {
public static void main(String[] args){
//Declara el driver
try {
Class.forName(ConexionBD.getDriver());
} catch (ClassNotFoundException ex) { }
try {
//Genera conexin
Connection con = DriverManager.getConnection(ConexionBD.getUrl(),
ConexionBD.getUser(),
ConexionBD.getPass());
//String que define el proceso
String SQL=" insert into alumno(rut,edad,sexo) values('14100000',26,true);";
//Objeto para generar el proceso
Statement st = con.createStatement();
//Proceso de insercin
st.executeUpdate(SQL);
st.close();
con.close();
} catch (SQLException ex) { }
}
}
Versin 2.2 170 de 285
19.11 Driver de Conexin
Para ejecutar el cdigo correctamente es necesario instalar el Driver de conexin de MySQL que se baja
desde :
http://www.mysql.com/downloads/connector/j/
Copiar el Driver dentro dela carpeta del proyecto:
Luego instalarlo para que sea reconocido por NetBeans:
Versin 2.2 171 de 285
Se tiene:
Despus de ejecutar el proceso se tiene:
Versin 2.2 172 de 285
20 Clase
20.1 Objetivos
Uso de componentes bsicos de Swings, validaciones y mensajes de cuadros de dilogos.
20.2 Conocimiento previo
Uso de mtodos y colecciones.
20.3 JTextField
Permite el ingreso de datos en un formulario. Las propiedades ms usadas son:
getText(): Permite conocer el valor seleccionado.
setText(String a): Permite asignar el valor a.
Asociar el siguiente cdigo al botn, haciendo doble click sobre el.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String valor = this.jTextField1.getText(); //Recupera el valor ingresado
JOptionPane.showMessageDialog(null, valor);
}
Versin 2.2 173 de 285
20.4 toolTipText
Permite emitir un mensaje al posicin el mouse sobre el objeto al que se le ha asociado la propiedad. Para
el ejemplo anterior, aplicaremos el mensaje al JTextField.
20.5 matches
Las expresiones regulares son una secuencia de caracteres y smbolos que definen un conjunto de cadenas
(caracteres literales y smbolos especiales). Son tiles para validar la entrada y asegurar que los datos
estn en un formato especfico. Por ejemplo
Un cdigo postal debe coincidir de 5 dgitos
Un apellido debe comenzar con mayscula
Un nmero telefnico debe tener solo nmeros
El mtodo matches recibe una cadena que especifica la expresin regular, y compara el contenido de un
objeto String. Devuelve un valor Boolean indicando si hubo concordancia o no.
Las expresiones son:
Cualquier dgito: un carcter numrico.
Cualquier carcter de palabra: un carcter alfanumrico o guin bajo.
Cualquier carcter de espacio en blanco: es un espacio, tabulador, retorno de carro o nueva lnea.
Versin 2.2 174 de 285
[abc] a, b, o c
[^abc] Cualquier carcter excepto a, b, o c (negacin)
[a-zA-Z] Desde la a a la z o desde la A hasta la Z, incluidos
[a-d[m-p]] Desde la a hasta la d, o desde la m a la p: [a-dm-p] (unin)
[a-z&&[def]] La d, la e, o la f (interseccin)
[a-z&&[^bc]] Desde la a hasta la z, excepto la b y la c: [ad-z] (resta)
[a-z&&[^m-p]] Desde la a hasta la z, excepto desde la m hasta la p: [a-lq-z](resta)
d Un nmero: [0-9]
D Todo menos un numero: [^0-9]
s Un espacio en blanco: [ x0Bf ]
S Todo menos un espacio en blanco: [^s]
w Una letra: [a-zA-Z_0-9]
W Todo menos letras: [^w]
X? X, una o ninguna vez
X* X, cero o ninguna vez
X+ X, una o ms veces
X{n} X, exactamente n veces
X(n,} X, por lo menos n veces
X{n,m} X, por lo menos n veces pero no mas de m veces
Slo ser valido el ingreso de 5 letras a minsculas seguidas.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("aaaaa") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Versin 2.2 175 de 285
Comprobar que el ingreso sea de slo nmeros.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("\\d*") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Comprobar que el ingreso sea de slo nmeros y exactamente tres unidades.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("\\d{3}") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Versin 2.2 176 de 285
Validar que una entrada slo sean slo letras (no soporte espacios en blanco, ni la letra , ni letras
acentuadas).
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("[a-zA-Z]*") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Versin 2.2 177 de 285
Usando el patrn ( [A-Z][a-zA-Z]*) en este caso le estamos diciendo que la entrada para ser valida debe
tener el primer carcter en mayscula [A-Z] y que los siguientes caracteres pueden ser cualquier carcter
tanto minscula como mayscula [a-zA-Z] con el asterisco final le estamos diciendo que los siguientes
caracteres van a ser iguales a la expresin previamente indicada, sea la expresin que esta entre
corchetes directamente al lado izquierdo del asterisco.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("[A-Z][a-zA-Z]*") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Valida que la fecha ingresada sea 1/2/2011 01/02/2011 1/02/2011 01/2/2011.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("\\d{1,2}/\\d{1,2}/\\d{4}") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Versin 2.2 178 de 285
Validar que el ingreso sean exactamente 2 letras maysculas (menos la ) y exactamente 2 nmeros.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String val = this.jTextField1.getText();
if(val.matches("[A-Z]{2}\\d{2}") && val.length()>0){
JOptionPane.showMessageDialog(null, "Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null, "Ingreso incorrecto");
}
}
Versin 2.2 179 de 285
20.6 JSlider
Permiten seleccionar una opcin dentro de un aspecto continuo de valores. En Netbeans se maneja con el
componente:
Considerar la configuracin
Se genera el siguiente componente:
Versin 2.2 180 de 285
Si se necesita que el componente se deslice slo por los valores, entonces se debe anexar la propiedad
snapToTicks.
Tambin se pueden generar secuencias con otros elementos como letras. Para esto se debe incluir el
siguiente mtodo en el constructor del JFrame, lo cual define las letras y el valor numrico asociados
private void usoLetras(){
Hashtable<Integer, Component> rotulos = new Hashtable<Integer, Component>();
rotulos.put(10, new JLabel("A"));
rotulos.put(20, new JLabel("B"));
rotulos.put(30, new JLabel("C"));
rotulos.put(40, new JLabel("D"));
rotulos.put(50, new JLabel("E"));
rotulos.put(60, new JLabel("F"));
jSlider1.setLabelTable(rotulos);
}
El ltimo valor 20 deja al componete inicindose en B, para este caso.
Versin 2.2 181 de 285
Sus constructores son:
Considerar el siguiente formulario:
Para recuperar los valores:
Versin 2.2 182 de 285
20.7 JList
Un JList le presenta al usuario un grupo de tems para elegir. Las propiedades ms usadas son:
getSelectedValue(): Recupera un valor de tipo Object.
getSelectedValues(): Recupera ms de un valor de tipo Object[].
getSelectedIndex(): Recupera la posicin del valor recuperado.
getSelectedIndices(): Recupera la posicin del valor recuperado mediante un arreglo de tipo int[].
Para manejarlo en Netbeans se usa el componente:
Lanzar uno de estos elementos. Se va a agregar una lista de nmeros al componente.
DefaultListModel modelo = new DefaultListModel();
for(int i = 1; i<=10; i++){
modelo.addElement(i);
}
jList1.setModel(modelo);
Versin 2.2 183 de 285
Para agregar un grupo de letras.
DefaultListModel modelo = new DefaultListModel();
modelo.addElement("A");
modelo.addElement("B");
modelo.addElement("C");
modelo.addElement("D");
modelo.addElement("E");
modelo.addElement("F");
modelo.addElement("G");
modelo.addElement("H");
modelo.addElement("I");
modelo.addElement("J");
jList1.setModel(modelo);
Con lo anterior se puede seleccionar ms de un elemento. Para seleccionar slo uno se debe activar la
opcin a SINGLE:
Se van a recuperar el o los valores. Para esto incluir un JButton y un JTable. El cdigo de ejecucin del
botn es:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
Object[] valores = jList1.getSelectedValues(); //Recupera los valores seleccionados en JList
Object[][] celda = new String[valores.length][1];
String[] nombreColumna = {"valores"};
int i=0;
for(Object valor: valores){
celda[i][0] = valor;
jTable1.setModel(new DefaultTableModel(celda,nombreColumna));
i += 1;
}
}
Versin 2.2 184 de 285
Con la siguiente propiedad se puede controlar como nuestros elementos aparecen en la lista.
Con la siguiente opcin se obtiene:
Ejemplo: Se va a considerar una aplicacin en donde se requiere transferir valores desde un JList a otros
en donde en el segundo JList los datos deben salir ordenados.
Versin 2.2 185 de 285
El cdigo para incluir los valores en el mtodo constructor es:
public DobleJList() {
initComponents();
DefaultListModel modelo = new DefaultListModel();
modelo.addElement("Enero");
modelo.addElement("Febrero");
modelo.addElement("Marzo");
modelo.addElement("Abril");
modelo.addElement("Mayo");
modelo.addElement("Junio");
modelo.addElement("Julio");
modelo.addElement("Agosto");
modelo.addElement("Septiembre");
modelo.addElement("Octubre");
modelo.addElement("Noviembre");
modelo.addElement("Diciembre");
jList1.setModel(modelo);
}
Observar que se necesita definir la variable de instancia que maneja los datos enviados desde un JList a
otro. Se usa TreeSet pues almacena los valores ordenados
public class DobleJList extends javax.swing.JFrame {
//Es necesario definirlo aqu, para no perder las los valores contra varias acciones sobre le botn >>
//Tambin almacena los datos ordenados para mostrarlos as
TreeSet<Object> datosTreeSet = new TreeSet<Object>();

El cdigo del botn >> es:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
//Los valores se almacenan en un Vector<> pues es lo que permite setListData
Vector<Object> datosVector = new Vector<Object>();
Object[] valores = jList1.getSelectedValues();
for(Object valor: valores)
datosTreeSet.add(valor);
for(Object valor: datosTreeSet)
datosVector.add(valor);
jList2.setListData(datosVector); }
El cdigo del botn << es:
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
//Los valores se almacenan en un Vector<> pues es lo que permite setListData
Vector<Object> datosVector = new Vector<Object>();
Object[] valores = jList2.getSelectedValues();
for(Object valor: valores)
datosTreeSet.remove(valor);
for(Object valor: datosTreeSet)
datosVector.add(valor);
jList2.setListData(datosVector);
}
Versin 2.2 186 de 285
Ejemplo: Crear un JList que al seleccionar un color de su lista cambie automticamente el color del objeto
de la lista seleccionado. Para desarrollar esto se va a recurrir a la siguiente propiedad del JList
El cdigo que se debe incorporar es:
private void jList1ValueChanged(javax.swing.event.ListSelectionEvent evt) {
Color colores[] = { Color.black, Color.blue, Color.green,
Color.orange, Color.pink, Color.red, Color.white, Color.yellow };
jList1.setSelectionBackground(colores[jList1.getSelectedIndex()]);
}
En el mtodo constructor tenemos:
public class Otros extends javax.swing.JFrame {
public Otros() {
initComponents();
DefaultListModel modelo = new DefaultListModel();
modelo.addElement("Negro");
modelo.addElement("Azul");
modelo.addElement("Verde");
modelo.addElement("Naranja");
modelo.addElement("Rosa");
modelo.addElement("Rojo");
modelo.addElement("Blanco");
modelo.addElement("Amarillo");
jList1.setModel(modelo);
}
Versin 2.2 187 de 285
20.8 Cuadro de dilogo
La clase JOptionPane tiene cuatro mtodos para mostrar cuadro de dilogo:
showMessageDialog: Muestra un mensaje y espera a que le usuario pulse OK.
showConfirmDialog: Muestra un mensaje y obtiene confirmacin (SI/NO).
showOptionDialog: Muestra un mensaje y obtiene una opcin de una serie de opciones.
showInputDialog: Muestra un mensaje y obtiene una lnea de entrada del usuario.
Un cuadro de dilogo tiene los siguientes componentes:
Un icono
Un mensaje
Uno o ms botones de opciones
Opcionalmente en algunos casos un campo de texto en que el usuario introduzca una cadena de
caracteres.
El icono depende del tipo de mensaje:
ERROR_MESSAGE 0
INFORMATION_MESSAGE 1
WARNING_MESSAGE 2
QUESTION_MESSAGE 3
PLAIN_MESSAGE (No tiene icono asociado) 4
Se pueden usar icono propios en los cuatro primeros mensajes.
Considerar el siguiente cdigo:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
JOptionPane.showMessageDialog(null,
"Mensaje que se necesita",
"Titulo del dialogo", JOptionPane.ERROR_MESSAGE);
JOptionPane.showMessageDialog(null,
"Mensaje que se necesita",
"Titulo del dialogo", JOptionPane.INFORMATION_MESSAGE);
Versin 2.2 188 de 285
JOptionPane.showMessageDialog(null,
"Mensaje que se necesita",
"Titulo del dialogo", JOptionPane.WARNING_MESSAGE);
JOptionPane.showMessageDialog(null,
"Mensaje que se necesita",
"Titulo del dialogo", JOptionPane.QUESTION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Mensaje que se necesita",
"Titulo del dialogo", JOptionPane.PLAIN_MESSAGE);
}
ERROR_MESSAGE
INFORMATION_MESSAGE
WARNING_MESSAGE
QUESTION_MESSAGE
PLAIN_MESSAGE
Versin 2.2 189 de 285
Se puede especificar cuatro tipos de mensajes
String: Dibuja la cadena de caracteres
Icon: Muestra el cono
Component: Muestra el componente
Object[ ]: Muestra todos los objetos del array, apilados uno encima del otro. Tambin
se puede usar "\n"
Cualquier otro objeto: Se aplica a toString y muestra la cadena resultante.
Usamos un arreglos para emitir el siguiente mensaje:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
Object[] mensaje = {"Producto eliminados:","Azucar","Fideos","Aceite"};
JOptionPane.showMessageDialog(null,
mensaje,
"Titulo del dialogo", JOptionPane.INFORMATION_MESSAGE);
}
Los botones de la parte inferior dependen del tipo de cuadro de dilogo y del tipo de opcin.
showMessageDialog OK
showInputDialog OK/Cancel
showConfirmDialog DEFAULT_OPTION
YES_NO_OPTION 0
YES_NO_CANCEL_OPTION 1
OK_CANCEL_OPTION 2
showOptionDialog Se puede mostrar una serie de opciones mediante un array de objetos.
Versin 2.2 190 de 285
Vamos a ver un ejemplo que solicita informacin y luego la analiza.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String primerNumero;
String segundoNumero;
String resultado;
int numero1;
int numero2;
// recibir el primer numero del usuario como una cadena
primerNumero = JOptionPane.showInputDialog("Escriba el primer entero:");
// recibir el segundo numero del usuario como una cadena
segundoNumero = JOptionPane.showInputDialog("Escriba el segundo entero :");
// convertir los numeros de tipo String a tipo int
numero1 = Integer.parseInt(primerNumero);
numero2 = Integer.parseInt(segundoNumero);
resultado = "";
if (numero1 == numero2) {
resultado = "Nmeros iguales";
}
if (numero1 < numero2) {
resultado = "Primer nmero menor que el segundo";
}
if (numero1 > numero2) {
resultado = "Primer nmero mayor que el segundo";
}
// Mostrar los resultados
JOptionPane.showMessageDialog(null,
resultado,
"Resultados de la comparacin",
JOptionPane.INFORMATION_MESSAGE);
}
Versin 2.2 191 de 285
showConfirmDialog devuelven enteros indicando qu botn ha pulsado el usuario.
OK_OPTION 0
CANCEL_OPTION 1
YES_OPTION 2
NO_OPTION 3
CLOSED_OPTION 4
Por ejemplo, para generar la siguiente secuencia que nos permite dependiendo de la respuesta.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
int n=JOptionPane.showConfirmDialog(null,
"Esta seguro que desea eliminar el registro ...",
"Confirma",
0);
if(n==0){
JOptionPane.showMessageDialog(null, "Hizo clic en SI");
}
if(n==1){
JOptionPane.showMessageDialog(null, "Hizo clic en NO");
}
}
Versin 2.2 192 de 285
21 Clase
21.1 Objetivos
Desarrollar el trabajo 1. Valor 12.5% de la nota 3.
21.2 Conocimiento previo
Contenidos del semestre.
21.3 Modelos de evaluacin 5
Observaciones:
Fecha de revisin: Jueves 09 junio de 2011
Nota 4.0 = 80% del puntaje
Base de datos: unab
Tabla cliente:
codigo varchar(10) PK
nombre varchar(100)
estatura double
nivelEducacional int
Disear un formulario que sea capaz de solicitar informacin de un cliente:
Codigo: TextField.
Nombre: TextField.
Estatura: JList, valores con dos decimal entre 1.5 y 2.0.
Nivel educacional: Un JSlider con valores bsica, media, universitaria, postgrado.
Botones:
Almacenar los datos (28 puntos)
Limpiar los TextField (2 puntos)
Se debe validar que el nombre contenga al menos 20 caracteres. En caso de error se debe mostrar una
ventana con el mensaje y los datos no se deben almacenar. (10 puntos)
Cada vez que se almacena correctamente un cliente se debe mostrar un mensaje en la parte inferior que
indique la cantidad total de cliente almacenados. (10 puntos)
Al llegar al quinto cliente ingresado, el color del mensaje debe pasar a verde con negrita y letra cursiva
tahoma. (10 puntos)
Si el cdigo del cliente existe en la base de datos, entonces el registro no se deben almacenar y se muestra
una ventana de mensaje indicando el error. (20 puntos)
Se debe validar que el cdigo del cliente est compuesto de una letra mayscula, dos nmeros y tres letras
minsculas. Si no cumple esta condicin el registro no se debe almacenar y se mostrar una ventana con el
error. (20 puntos)
Versin 2.2 193 de 285
22 Clase
22.1 Objetivos
Uso de componentes Swings.
22.2 Conocimiento previo
Uso de mtodos y colecciones.
22.3 JFormattedTextField
No es ms que una extensin de JTextField que viene a cubrir algunas de las deficiencias que todos
encontrbamos en l. Es un componente que cumple una doble funcin.
Por una parte, permite que el usuario entre el texto que se corresponde con un dato solicitado por la
aplicacin.
Por otra, permite a la aplicacin mostrar datos al usuario.
La principal limitacin del JTextField es que permite entrar cualquier texto y que no hay manera fcil de
mostrar un texto con un formato concreto. No hay posibilidad de establecer un control sobre lo que el
usuario entra ni manera sencilla de mostrar convenientemente datos de tipos tan habituales como fechas o
nmeros. El componente de Netbeans es:
Suponga que se necesita ingresar 7 nmeros obligando a ingresar primero tres nmeros, luego un guin y
por ltimo 4 nmeros. El formato debe ser: ###-####. En Netbeans se debe configurar en la propiedad
Versin 2.2 194 de 285
El resultado es que slo se pueden ingresar a los ms tres nmeros al inicio, luego el guin y por ltimo los
ms 4 nmeros. Observar que slo se pueden ingresar nmeros.
Observar que este formato impide el ingreso de otro carcter que no sea un nmero. Los caracteres usados
son:
Ejemplos:
Ingresar exactamente 2 letras y 2 nmeros.
Observar que el componente impide el ingreso de ms valores y distintos de los definidos.
Versin 2.2 195 de 285
Permitir slo 5 letras maysculas transformando las letras minsculas a maysculas.
Transformar nmeros a cantidades separadas por miles usando un punto.
Al cambiar el foco se tiene:
Versin 2.2 196 de 285
22.4 PasswordField - Separator
El primer componete permite el ingreso de informacin, el segundo permite el ingreso de texto que se usa
para validar el password de un usuario al ingresar al sistema, el tercero permite usar una lnea de
separacin.
Limpiar las dos cajas de texto para quedar cmo:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String usuario;
char[] pass;

usuario = this.jTextField1.getText();
pass = this.jPasswordField1.getPassword();
//User correcto: JPerez
//Password correcta: Juan#1234
if(usuario.equals("JPerez") && analizaPass(pass)){
JOptionPane.showMessageDialog(null,"Ingreso correcto");
}
else{
JOptionPane.showMessageDialog(null,"Error");
}
}
//Analizar la password Juan#1234
boolean analizaPass(char[] pass){
boolean resp=true;
char[] pass1 = {'J','u','a','n','#','1','2','3','4'};
for(int i=0; i<pass.length; i++)
if(pass[i] != pass1[i])
resp=false;
return resp;
}
Versin 2.2 197 de 285
22.5 JRadioButton
Sirve para manjar una eleccin desde varias opciones. Para manejar desde Netbeans usamos el
componente.
Adems, se debe acompaar del componente JbuttonGroup que permite agrupar un conjunto de
componentes JradioButton.
Como ejemplo vamos a seleccionar un JPanel y lo lanzamos sobre un JFrame.
Usando la propiedad Border cambiamos la forma grfica del JPanel.
Versin 2.2 198 de 285
Luego lanzamos 3 JradioButton dentro del JPanel.
Dejar como se muestra.
Lanzar un JGroupButton sobre el JFrame. Notar que este componente no se aprecia grficamente, para
poder verlo se debe usar el Inspector.
Versin 2.2 199 de 285
Podemos ver ahora el componente en el Inspector.
Vamos ahora a programar el JButton.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
String mensaje="";

if(this.jRadioButton1.isSelected())
mensaje = "Color Verde";
if(this.jRadioButton2.isSelected())
mensaje = "Color Rojo";
if(this.jRadioButton3.isSelected())
mensaje = "Color Blanco";

JOptionPane.showMessageDialog(null, mensaje);
}
Versin 2.2 200 de 285
22.6 CheckBox
Este componente sirve para seleccionar una opcin. Las propiedades ms usadas son:
isSelected(): Permite saber si el CheckBox est seleccionado.
Ejemplo de uso: Seleccione un JPanel.
Usando la propiedad Border del JPanel genere lo siguiente:
Versin 2.2 201 de 285
Anexar el JButton para conseguir:
Seleccionar los JCheckBox siguientes:
El cdigo asociado el botn es:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
boolean pref1 = true;
boolean pref2 = true;
boolean pref3 = true;
boolean pref4 = true;
pref1 = this.jCheckBox1.isSelected();
pref2 = this.jCheckBox2.isSelected();
pref3 = this.jCheckBox3.isSelected();
pref4 = this.jCheckBox4.isSelected();
Object[] mensaje = {"Seleccin:",this.jCheckBox1.getText()+" :"+pref1
,this.jCheckBox2.getText()+" :"+pref2
,this.jCheckBox3.getText()+" :"+pref3
,this.jCheckBox4.getText()+" :"+pref4};
JOptionPane.showMessageDialog(null,mensaje);
}
Versin 2.2 202 de 285
Un ejemplo de ejecucin:
22.7 Spinner
Este componente sirve para seleccionar una opcin desde una lista. Mtodos: Los mtodos asociados ms
usados son:
getValue(): Permite recuperar el valor seleccionado.
Seleccionar 3 JLabel, 3 JSpinner y un JButton.
Versin 2.2 203 de 285
Seleccionar el primer JSpinner, marcar su propiedad Model y proporcionar el siguiente formato.
Seleccionar el segundo JSpinner, marcar su propiedad Model y proporcionar el siguiente formato.
Versin 2.2 204 de 285
Seleccionar el tercer JSpinner, marcar su propiedad Model y proporcionar el siguiente formato.
El formato definitivo es:
Versin 2.2 205 de 285
Para dar una forma ms atractiva a los componentes marcar cada uno de los JSpinner y su propiedad
Border.
El cdigo asociado al JButton es:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
Object val1= new Object();
Object val2 = new Object();
Object val3 = new Object();
val1 = this.jSpinner1.getValue();
val2 = this.jSpinner2.getValue();
Versin 2.2 206 de 285
val3 = this.jSpinner3.getValue();

Object[] mensaje = {"Seleccin:",this.jLabel1.getText()+" :"+val1
,this.jLabel2.getText()+" :"+val2
,this.jLabel3.getText()+" :"+val3};
JOptionPane.showMessageDialog(null,mensaje);
}
Versin 2.2 207 de 285
22.8 JTabbedPane
Con la clase JTabbedPane, podemos tener varios componentes (normalmente objetos JPanel)
compartiendo el mismo espacio. El usuario puede elegir qu componente ver seleccionando la pestaa del
componente deseado. Para manejar desde Netbeans usamos el componente.
Para trabajar estos componentes vamos a hacer clic segn se indica en el siguiente diagrama:
Resultado:
Versin 2.2 208 de 285
Para conseguir las pestaas se debe agregar JPanel al JTabbedPane
Resultado:
Versin 2.2 209 de 285
Agregar otro JPanel
Resultado
Versin 2.2 210 de 285
Se han agregado al final 4 pestaas
Para cambiar el nombre a las pestaas y poner un mensaje cada vez que se posa el mouse sobre una de
ellas
Observar que el Jpanel1 sebe estar seleccionado para que lo anterior se pueda apreciar:
Versin 2.2 211 de 285
De la misma forma las pestaas siguientes marcarlas como Ingreso, Eliminacin y Actualizacin con un
mensaje apropiado al posarse sobre ellas.
Tambin se les puede agregar un icono a las pestaas en la opcin:
Versin 2.2 212 de 285
Vamos a agregar elementos ahora en las pestaas para generar el mantenedor. Incluir un JTable.
Nuevamente se recomienda manejar los elementos en el Inspector del Netbeans.
Versin 2.2 213 de 285
En el ingreso se van a considerar los siguientes componentes:
En MySQL 4.1.x se ha creado la base de datos duoc y la tabla:
create table alumno
(
id_alumno int auto_increment,
rut varchar(50),
edad int,
sexo boolean,
primary key(id_alumno)
);
Ingresar un datos
insert into alumno (rut,edad,sexo) values ('14000000',25,true);
Tener presente como almacena los datos MySQL
La clase para conexin es:
package conec;
public class ConexionBD {
private static String url= "jdbc:mysql://localhost/duoc";
private static String user= "root";
private static String pass= "root";

public static String getDriver() {
String driver= "com.mysql.jdbc.Driver";
return driver;
}
public static String getUrl() { return url; }
public static String getUser() { return user; }
public static String getPass() { return pass; }
}
Versin 2.2 214 de 285
La clase Alumno para empaquetar los datos
package bean;
public class Alumno {
private String rut= new String("");
private int edad = 0;
private boolean sexo = false;
public Alumno(){ }
public Alumno(String rut, int edad, boolean sexo){
this.setRut(rut);
this.setEdad(edad);
this.setSexo(sexo);
}
public String getRut() { return rut; }
public void setRut(String rut) { this.rut = rut; }
public int getEdad() { return edad; }
public void setEdad(int edad) { this.edad = edad; }
public boolean isSexo() { return sexo; }
public void setSexo(boolean sexo) { this.sexo = sexo; }
}
Cdigo asociado al botn de ingreso:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
try {
Class.forName(ConexionBD.getDriver());
} catch (ClassNotFoundException ex) {
Logger.getLogger(Pruebas.class.getName()).log(Level.SEVERE, null, ex);
}
try {
Connection con = DriverManager.getConnection(ConexionBD.getUrl(),
ConexionBD.getUser(),
ConexionBD.getPass());
Statement st = con.createStatement();
String rut = this.jTextField1.getText();
int edad = Integer.parseInt(String.valueOf(this.jComboBox1.getSelectedItem()));
boolean sexo = this.jRadioButton1.isSelected();
String SQL=" insert into alumno (rut,edad,sexo) values (' "+
rut + "'," +
edad + "," +
sexo + ");";
int n = st.executeUpdate(SQL);
if(n==1){
this.jLabel3.setVisible(true);
this.jLabel3.setText("Registro insertado");
}
if(n==0){
this.jLabel3.setVisible(true);
this.jLabel3.setText("Registro NO insertado"); }
} catch (SQLException ex) {
Logger.getLogger(Pruebas.class.getName()).log(Level.SEVERE, null, ex);
}
}
Versin 2.2 215 de 285
Ya se ha ingresado datos
Vamos a implementar el Jtable; en este caso es, jTable2.
public void actualizaTabla(){
Vector<Alumno> dat = new Vector<Alumno>();
try {
Class.forName(ConexionBD.getDriver());
} catch (ClassNotFoundException ex) {
Logger.getLogger(Pruebas.class.getName()).log(Level.SEVERE, null, ex);
}
try {
Connection con = DriverManager.getConnection(ConexionBD.getUrl(),
ConexionBD.getUser(),
ConexionBD.getPass());
Statement st = con.createStatement();
String SQL=" select select rut, edad, sexo from alumno ";
ResultSet rs = st.executeQuery(SQL);
while(rs.next()){
String rutRecupera = rs.getString(1);
int edadRecupera = rs.getInt(2);
boolean sexoRecupera = rs.getBoolean(3);
dat.add(new Alumno(rutRecupera, edadRecupera, sexoRecupera));
}
int j = dat.size();
Object[][] celdas = new String[dat.size()][3];
String[] nombreColumnas = {"RUT","Edad","Sexo"};
int i=0;
for(Alumno al: dat){
celdas[i][0] = (Object)al.getRut();
celdas[i][1] = (Object)String.valueOf(al.getEdad());
celdas[i][2] = (Object)String.valueOf(al.isSexo());
this.jTable2.setModel(new DefaultTableModel(celdas,nombreColumnas));
i += 1;
}
} catch (SQLException ex) {
Logger.getLogger(Pruebas.class.getName()).log(Level.SEVERE, null, ex);
}
}
Este mtodo debe ser llamado desde el mtodo constructor de JFrame que contiene al JTabbedPane
public Pruebas() {
initComponents();
this.jLabel3.setVisible(false);
actualizaTabla();
}
Versin 2.2 216 de 285
El resultado es:
Observar que si se ingresa un nuevo valor en la pestaa de Ingreso la pestaa Ver no se actualiza. Para
lograr la actualizacin se debe activar el siguiente mtodo:
private void jTabbedPane1StateChanged(javax.swing.event.ChangeEvent evt) {
actualizaTabla();
}
Se ingresar un nuevo dato
Versin 2.2 217 de 285
Nos cambiamos de pestaa y est el registro ingresado:
Versin 2.2 218 de 285
23 Clase
23.1 Objetivos
Mostrar datos usando JTable.
23.2 Conocimiento previo
Conexin a base de datos.
23.3 JTable
http://www.java2s.com/Tutorial/Java/0240__Swing/publicJTableVectorrowDataVectorcolumnNames.htm
http://www.magusoft.net/neotrials/pages/start.html
Como programadores, sabemos muy bien que la presentacin de datos tabulados es una de las tareas ms
comunes que se presentan al momento de crear interfaces grficas; desde la simple tabla que permite
nicamente mostrar el resultado de una consulta, hasta las que permiten editar directamente el contenido de
cada celda, ordenar las columnas, personalizar su apariencia, otras.
Todas las tareas antes descritas, y muchas otras, son posibles de realizar utilizando la clase JTable;
por supuesto, mientras ms complejo sea el requerimiento a cubrir, se requerir en igual medida utilizar ms
mtodos o recursos de la clase.
Los constructores son:
Versin 2.2 219 de 285
Vamos a considerar en Netbeans la siguiente situacin:
Para eliminar las columnas y filas usamos la propiedad model
Versin 2.2 220 de 285
Eliminando todas las filas se tiene:
El mtodo para agregar en el constructor del formulario ser:
private void initValores(){
String[] columnNames = {
"Nombre", "Apellido", "Pasatiempo", "Aos de Practica","Soltero(a)"
};
Object[][] data = {
{"Mary", "Campione", "Esquiar", new Integer(5), new Boolean(false)},
{"Lhucas", "Huml", "Patinar", new Integer(3), new Boolean(true)},
{"Kathya", "Walrath", "Escalar", new Integer(2), new Boolean(false)},
{"Marcus", "Andrews", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Lalth", "Nadar", new Integer(4), new Boolean(false)}
};
jTable1.setModel(new javax.swing.table.DefaultTableModel(
data, columnNames));
jScrollPane1.setViewportView(jTable1);
}
Versin 2.2 221 de 285
En el caso de usar Vector no se puede asignar al Jtable un tipo de dato como
Persona(String,String,String,Integer,Boolean) para el caso anterior. Un solucin ser:
private void initValores(){
Vector<String> columnNames = new Vector<String>();
columnNames.add("Nombre");
columnNames.add("Apellido");
columnNames.add("Pasatiempo");
columnNames.add("Aos de Practica");
columnNames.add("Soltero(a)");
Vector<String> data1 = new Vector<String>();
data1.addElement("Mary");
data1.addElement("Campione");
data1.addElement("Esquiar");
data1.addElement("5");
data1.addElement("false");
Vector<String> data2 = new Vector<String>();
data2.addElement(new String("Lhucas"));
data2.addElement(new String("Huml"));
data2.addElement(new String("Patinar"));
data2.addElement(new String("3"));
data2.addElement(new String("true"));

Vector<Vector> data = new Vector<Vector>();
data.add(data1);
data.add(data2);
jTable1.setModel(new javax.swing.table.DefaultTableModel(
data, columnNames));
jScrollPane1.setViewportView(jTable1);
}
Vamos a generar en una tabla informacin dada la eleccin que se desarrolla en un ComboBox. Se
pretende esto:
Versin 2.2 222 de 285
Y al seleccionar en el ComboBox otro departamento, entonces cambian los datos correspondientes:
Los datos de la base de datos son:
create database usotablas;
use usotablas;
create table departamento
(
id_dpto int auto_increment,
nombre_dpto varchar(100),
primary key(id_dpto)
);
insert into departamento (nombre_dpto) values('Informatica');
insert into departamento (nombre_dpto) values('RR.HH.');
insert into departamento (nombre_dpto) values('Comercial');
insert into departamento (nombre_dpto) values('Operaciones');
insert into departamento (nombre_dpto) values('Producccion');
insert into departamento (nombre_dpto) values('Marketing');
create table paises
(
id_pais int auto_increment,
nombre_pais varchar(100),
primary key(id_pais)
);
insert into paises (nombre_pais) values ('Chile');
insert into paises (nombre_pais) values ('Peru');
insert into paises (nombre_pais) values ('Argentina');
insert into paises (nombre_pais) values ('Bolivia');
insert into paises (nombre_pais) values ('Paraguay');
insert into paises (nombre_pais) values ('Uruguay');
insert into paises (nombre_pais) values ('Colombia');
create table trabajador
(
id_trab int auto_increment,
id_dpto int,
nombre_trab varchar(100),
edad int,
sexo boolean,
estatura double(4,2),
ingreso date,
id_pais int,
primary key(id_trab),
foreign key (id_dpto) references departamento(id_dpto),
foreign key (id_pais) references paises(id_pais)
);
Versin 2.2 223 de 285
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'Juan
Perez',24,false,1.67,'2000-12-01',4);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (3,'Juanita
Perez',33,true,1.77,'2000-11-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'Esteban
Perez',45,false,1.87,'2000-12-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'Sandra
Perez',62,true,1.90,'2000-12-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'Pedro
Perez',47,false,1.80,'2000-09-01',2);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (1,'Jonas
Perez',55,false,1.77,'2000-12-01',3);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (5,'Sofia
Perez',27,true,1.92,'2000-08-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (6,'Oscar
Perez',19,false,1.72,'2000-11-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (6,'Leandro
Perez',36,false,1.80,'2000-11-01',1);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (4,'Carlita
Perez',30,true,1.67,'2000-09-01',5);
insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (3,'Anibal
Perez',74,false,1.60,'2000-11-01',1);
El mtodo que llena el ComboBox con los datos de departamento, implementado en el mtodo constructor
es:
private void initDepartamento(){
Vector<String> dat = new Vector<String>();
Vector<Trabajador> datTrab = new Vector<Trabajador>();
try {
Class.forName(ConexionDB.getDriver());
} catch (ClassNotFoundException ex) {
Logger.getLogger(Muestra.class.getName()).log(Level.SEVERE, null, ex);
}
try {
Connection con = DriverManager.getConnection(ConexionDB.getUrl(),
ConexionDB.getUser(),
ConexionDB.getPass());
Statement st = con.createStatement();
String sql = " Select nombre_dpto from departamento " +
" order by 1 ";
ResultSet rs = st.executeQuery(sql);
int i = 1;
String primerValor = new String("");
while(rs.next()){
if(i==1){
primerValor = rs.getString(1);
}
String nombreRecupera = rs.getString(1);
dat.add(nombreRecupera);
i += 1;
}
for(Object da: dat)
this.jComboBox1.addItem(da);
sql = " Select id_dpto from departamento where nombre_dpto='"+primerValor+"'";
Versin 2.2 224 de 285
rs = st.executeQuery(sql);
int idDpto=0;
while(rs.next()){
idDpto = rs.getInt(1);
}

sql = " Select " +
" (select a.nombre_dpto from departamento as a where b.id_dpto=a.id_dpto) as dpto, " +
" nombre_trab, " +
" edad, " +
" sexo, " +
" estatura, " +
" ingreso, " +
" (select c.nombre_pais from paises as c where b.id_pais=c.id_pais) as pais " +
" from trabajador as b where b.id_dpto="+idDpto+" order by 1, 2 ";
Vector columNames = new Vector();
columNames.addElement("Departamento");
columNames.addElement("Nombre Trabajador");
columNames.addElement("Edad");
columNames.addElement("Sexo");
columNames.addElement("Estatura");
columNames.addElement("Ingreso");
columNames.addElement("Pais");
rs = st.executeQuery(sql);

Vector<Vector> data = new Vector<Vector>();
while(rs.next()){
Vector row1 = new Vector();
row1.addElement(rs.getObject(1));
row1.addElement(rs.getObject(2));
row1.addElement(rs.getObject(3));
row1.addElement(rs.getObject(4));
row1.addElement(rs.getObject(5));
row1.addElement(rs.getObject(6));
row1.addElement(rs.getObject(7));
data.add(row1);
}
jTable1.setModel(new javax.swing.table.DefaultTableModel(data, columNames));
jScrollPane1.setViewportView(jTable1);
} catch (SQLException ex) {
Logger.getLogger(Muestra.class.getName()).log(Level.SEVERE, null, ex);
} finally{
}
}
Versin 2.2 225 de 285
El cdigo asociado a los cambios de los valores seleccionados en el ComboBox son:
private void jComboBox1ItemStateChanged(java.awt.event.ItemEvent evt) {
String dpto = String.valueOf(this.jComboBox1.getSelectedItem());
try {
Class.forName(ConexionDB.getDriver());
} catch (ClassNotFoundException ex) {
Logger.getLogger(Muestra.class.getName()).log(Level.SEVERE, null, ex);
}
try {
Connection con = DriverManager.getConnection(ConexionDB.getUrl(),
ConexionDB.getUser(),
ConexionDB.getPass());
Statement st = con.createStatement();
String sql = " Select id_dpto from departamento where nombre_dpto='"+dpto+"'";
ResultSet rs = st.executeQuery(sql);
int idDpto=0;
while(rs.next()){
idDpto = rs.getInt(1);
}
sql = " Select " +
" (select a.nombre_dpto from departamento as a where b.id_dpto=a.id_dpto) as dpto, " +
" nombre_trab, " +
" edad, " +
" sexo, " +
" estatura, " +
" ingreso, " +
" (select c.nombre_pais from paises as c where b.id_pais=c.id_pais) as pais " +
" from trabajador as b where b.id_dpto="+idDpto+" order by 1, 2 ";
Vector columNames = new Vector();
columNames.addElement("Departamento");
columNames.addElement("Nombre Trabajador");
columNames.addElement("Edad");
columNames.addElement("Sexo");
columNames.addElement("Estatura");
columNames.addElement("Ingreso");
columNames.addElement("Pais");
Versin 2.2 226 de 285
rs = st.executeQuery(sql);

Vector<Vector> data = new Vector<Vector>();
while(rs.next()){
Vector row1 = new Vector();
row1.addElement(rs.getObject(1));
row1.addElement(rs.getObject(2));
row1.addElement(rs.getObject(3));
row1.addElement(rs.getObject(4));
row1.addElement(rs.getObject(5));
row1.addElement(rs.getObject(6));
row1.addElement(rs.getObject(7));
data.add(row1);
}
jTable1.setModel(new javax.swing.table.DefaultTableModel(data, columNames));
jScrollPane1.setViewportView(jTable1);
} catch (SQLException ex) {
Logger.getLogger(Muestra.class.getName()).log(Level.SEVERE, null, ex);
} finally{
}
}
Versin 2.2 227 de 285
24 Clase
24.1 Objetivos
Desarrollar el trabajo 2. Valor 12.5% de la nota 3.
Desarrollar el trabajo 3. Valor 15% de la nota 4.
24.2 Conocimiento previo
Contenidos del semestre.
24.3 Evaluacin 6
Observaciones:
Fecha de revisin: Jueves 23 junio de 2011
Nota 4.0 = 80% del puntaje
Base de datos: unab
Tabla cliente:
codigo varchar(10) PK
nombre varchar(100)
edad int
sexo boolean
preferencia1 boolean
preferencia2 boolean
preferencia3 boolean
preferencia4 boolean
estatura double
nivelEducacional int
Disear un formulario que sea capaz de solicitar informacin de un cliente:
Codigo: TextField.
Nombre: TextField.
Edad: ComboBox
Sexo: RadioButton
Preferencia1: CheckBox
Preferencia2: CheckBox
Preferencia3: CheckBox
Preferencia4: CheckBox
Estatura: JList, valores con dos decimal entre 1.5 y 2.0.
Nivel educacional: Un JSlider con valores bsica, media, universitaria, postgrado.
Proceso 1
En una pestaa crear una opcin que permita ingresar datos. No se debe validar nada.
(20 puntos)
Proceso 2
En una pestaa se debe mostrar en un ComboBox los cdigos de los clientes almacenados y al ingresar por
primera vez al lado del ComboBox se debe mostrar el nombre del cliente. Adems, si en esta pestaa se
selecciona otro cdigo del ComboBox, entonces se debe actualizar el nombre del cliente.
(10 puntos)
En esta pestaa se debe implementar un botn para eliminar el cliente almacenado.
(10 puntos)
Versin 2.2 228 de 285
Proceso 3
En una pestaa se debe mostrar en un ComboBox los cdigos de los clientes almacenados y al ingresar por
primera vez al lado del ComboBox se debe mostrar todos los datos del cliente usando los mismo objetos
grficos de la pestaa de ingreso de clientes. Adems, si en esta pestaa se selecciona otro cdigo del
ComboBox, entonces se debe actualizar los datos del cliente.
(30 puntos)
En esta pestaa se debe implementar un botn para actualizar los datos del cliente almacenado.
(10 puntos)
Proceso 4
Se deben mostrar los datos del clientes usando un JTable.
(10 puntos)
Proceso 5
Cada vez que se produce un ingreso de cliente y se produce un cambio de pestaa, entonces los datos
deben reflejar esos cambios.
(10 puntos)
24.4 Evaluacin 7
Observaciones
1. El desarrollo debe ser en netbeans 6.9 y mysql 5.x.
2. La fecha de revisin es el martes 28 de junio de 2011 en clases.
3. Nota 4 = 80% del puntaje.
create database unab;
use unab;
create table departamento
(
codigo varchar(2) primary key,
nombre varchar(100)
);
insert into departamento values('GE','Gerencia General');
insert into departamento values('OP','Operaciones');
insert into departamento values('FI','Finanzas');
insert into departamento values('CO','Comercial');
insert into departamento values('MA','Marketing');
insert into departamento values('IF','Informatica');
insert into departamento values('AD','Auditoria');
insert into departamento values('PL','Planificacion');
insert into departamento values('FS','Fiscalia');
create table documento
(
tipo varchar(2)
nombre varchar(100)
);
insert into documento values('OF','Oficio');
insert into documento values('RE','Resolucion');
insert into documento values('MA','Mail');
insert into documento values('FA','Fax');
insert into documento values('ME','Memo');
insert into documento values('NO','Nota breve');
Versin 2.2 229 de 285
create table documentos_tratados
(
numero int,
cod_dep varchar(2),
cod_tipo varchar(2),
constraint primary key(numero, cod_dep, cod_tipo),
constraint foreign key (cod_dep) references departamento(codigo),
constraint foreign key (cod_tipo) references documento(tipo)
);
Problema
Se le ha solicitado desarrollar un programa java que sea capaz de manejar documentos que son enviados a
diversos departamento. Para esto se debe disear un formulario que:
Solicite al usuario, mediante un JSlider, el tipo de documento almacenados es la base de datos.
(10 puntos)
Mediante un JList mostrar los destinos de los documentos almacenados en la base de datos.
(10 puntos)
El botn >> enva los destinos seleccionados desde JList de la izquierda a la derecha.
(10 puntos)
El botn << enva los destinos seleccionados desde JList de la derecha a la izquierda.
(10 puntos)
El botn Almacenar Informacin almacena los datos en la tabla documentos_tratados.
(30 puntos)
El botn Ver Informacin muestra los datos en la tabla documentos_tratados. Para estos se debe
pedir el nmero del documento y mediante un botn se muestran los datos en un JTable.
(30 puntos)
Versin 2.2 230 de 285
25 Clase
25.1 Objetivos
Uso de colecciones y en particular las clase ArrayList y Vector.
25.2 Conocimiento previo
Conceptos de orientacin a objetos y encapsulacin de datos.
25.3 JMenu
Seleccionar:
Va a generar:
Versin 2.2 231 de 285
Para incorporar un submen procedemos como se muestra
Para cambiar los nombres de lo que se ve, hacer doble clic sobre File
Tambin se puede usar el men contextual:
Versin 2.2 232 de 285
Se tiene:
De la misma forma se cambia el nombre a FIle
Para generar un submen sobre un men se tiene:
Ahora incluir los tem necesarios:
Versin 2.2 233 de 285
Finalmente se tiene:
Crear un formulario llamado VerCliente
Para la opcin ver se va a considerar:
El cdigo para ejecutar el formulario desde el men es:
Versin 2.2 234 de 285
Vamos a agregar un nueva opcin de men:
Vamos a agregar dos radiobuttom
Vamos a agregar un separador
Vamos a agregar tres checkbox
Versin 2.2 235 de 285
Se debe agrupar los radio buttom
Marcar ambos radiobuttom y agregar al agrupamiento
Se tiene:
Versin 2.2 236 de 285
25.4 JTree
Seleccionar:
Se tiene:
Versin 2.2 237 de 285
Al ejecutarlo se tiene:
Los componentes del rbol se manejan el la propiedad "model"
Versin 2.2 238 de 285
Generar la siguiente estructura. Considera que un espacio genera un opcin dentro de otra.
Se obtiene:
Versin 2.2 239 de 285
Como ejemplo de aplicacin vamos generar el siguiente formulario
Se tiene:
Versin 2.2 240 de 285
Lanzar un JTree en el lateral izquierdo:
Generar la siguiente estructura:
Versin 2.2 241 de 285
Para manejar la posicin inicial de la lnea de divisin
Para manejar el ancho de la lnea de divisin
La orientacin se maneja en:
Versin 2.2 242 de 285
Vamos a desarrollar un mantenedor con el uso de JTree. Para los formularios se deben usar JPanel. Vamos
a Crear los siguientes paneles:
Versin 2.2 243 de 285
El formulario es:
Tiene las opciones:
Versin 2.2 244 de 285
El cdigo asociado al primer Jpanel es una variable tipo Vector static para que los datos ingresados desde
este formulario sean accesibles desde otros formularios
El cdigo asociado al botn de ingreso de datos es:
Versin 2.2 245 de 285
Al formulario para ver datos se le agreg un botn para visualizar datos. El cdigo asociado a este botn es:
Ahora, desde el contenedor del JSplitPane se tiene el cdigo asociado al evento ValueChanged:
Versin 2.2 246 de 285
La clase cliente es:
package bean;
public class Cliente {
private String rut="";
private int edad=0;
public Cliente(){ }
public Cliente(String rut, int edad){
this.setRut(rut);
this.setEdad(edad);
}
public String getRut() {
return rut;
}
public void setRut(String rut) {
this.rut = rut;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
}
En la ejecucin se tiene:
Versin 2.2 247 de 285
Versin 2.2 248 de 285
25.5 JScrollPane
Cuando un componente ocupa mucho espacio en pantalla o contiene mucha informacin, un JScrollPane
permite asociarle una pequea vista o ventana deslizable o corrediza que permite solo que se vea una parte
de dicho componente.
Lanzar un componente JScrollPane:
Luego dentro de el, lanzar un JPanel.
Genera algo similar a lo siguiente:
Versin 2.2 249 de 285
Al agregar algunos componentes se puede tener lo siguiente:
Versin 2.2 250 de 285
26 Adicionales
26.1 Objetivos
Usar mtodos para el manejo de fechas y horas.
26.2 Conocimiento previo
Creacin de mtodos.
26.3 Date
Representa un momento especfico en el tiempo, con precisin de milisegundos. La mayora de sus
mtodos estn desaprobados. El siguiente cdigo entrega la fecha y hora actual.
package view;
import java.util.Date;
public class Metodos3 {
public static void main(String[] args) {
Date dt = new Date();
System.out.println(dt);
}
}
26.4 Calendar
Calendar es una clase abstracta para la conversin entre un objeto Date y un conjunto de campos enteros
como YEAR , MONTH , DAY , HOUR , y as sucesivamente. Calendar interpretar una Date de acuerdo a las
reglas de un sistema de calendario especfico.
Para crear una instancia se debe usar el siguiente cdigo, esto se debe al hecho de que la clase
Calendar es abstracta (ver clases ms adelante).
Calendar dat = Calendar.getInstance();
El siguiente cdigo se recupera la hora actual y cada uno de sus valores especficos. Observar que enero=0
y que el da de la semana (que es lunes) es 2.
package view;
import java.util.Calendar;
public class Metodos4 {
public static void main(String[] args) {
Calendar dat = Calendar.getInstance();

System.out.println("Ao: " + dat.get(Calendar.YEAR));
System.out.println("Mes: " + dat.get(Calendar.MONTH));
System.out.println("Dia: " + dat.get(Calendar.DATE));
System.out.println();
System.out.println("Segundos: " + dat.get(Calendar.SECOND));
System.out.println("Minutos: " + dat.get(Calendar.MINUTE));
System.out.println("Horas: " + dat.get(Calendar.HOUR));
System.out.println();
System.out.println("Dia de la semana: " + dat.get(Calendar.DAY_OF_WEEK));
}
}
Versin 2.2 251 de 285
En el siguiente ejemplo sea definido una fecha con hora en duro. Observar que para saber la hora se debe
usar AM_PM que es 0 si el horario es AM y 1 si el horario es PM
package view;
import java.util.Calendar;
public class Metodos5 {
public static void main(String[] args) {
Calendar dat = Calendar.getInstance();
dat.set(2011, 02, 12, 15 , 30, 55);
System.out.println("Ao: " + dat.get(Calendar.YEAR));
System.out.println("Mes: " + dat.get(Calendar.MONTH));
System.out.println("Dia: " + dat.get(Calendar.DATE));
System.out.println();
System.out.println("Segundos: " + dat.get(Calendar.SECOND));
System.out.println("Minutos: " + dat.get(Calendar.MINUTE));
System.out.println("AM=0, PM=1: " + dat.get(Calendar.AM_PM));
System.out.println("Hora: " + dat.get(Calendar.HOUR));
}
}
Para asociar un valor de tipo Date a uno de tipo Calendar:
package view;
import java.util.Calendar;
import java.util.Date;
public class Metodos6 {
public static void main(String[] args) {
Date dt = new Date();
Calendar dat = Calendar.getInstance();
dat.setTime(dt);
System.out.println("Ao: " + dat.get(Calendar.YEAR));
System.out.println("Mes: " + dat.get(Calendar.MONTH));
System.out.println("Dia: " + dat.get(Calendar.DATE));
System.out.println();
System.out.println("Segundos: " + dat.get(Calendar.SECOND));
System.out.println("Minutos: " + dat.get(Calendar.MINUTE));
System.out.println("AM=0, PM=1: " + dat.get(Calendar.AM_PM));
System.out.println("Hora: " + dat.get(Calendar.HOUR));
}
}
La clase siguiente muestra como se pueden sumar y restar valores.
package view;
import java.util.Calendar;
import java.util.Date;
public class Metodos7 {
public static void main(String[] args) {
Date dt = new Date();
Calendar dat = Calendar.getInstance();
dat.setTime(dt);
System.out.println("Actual: " + dat.getTime());
dat.add(Calendar.YEAR, 2);
System.out.println("Dos aos ms: " + dat.getTime());
dat.add(Calendar.YEAR, -4);
Versin 2.2 252 de 285
System.out.println("Cuatro aos menos: " + dat.getTime());
dat.add(Calendar.MONTH, 2);
System.out.println("Dos meses ms: " + dat.getTime());
dat.add(Calendar.DATE, 2);
System.out.println("Dos horas ms: " + dat.getTime());
dat.add(Calendar.DATE, -2);
System.out.println("Dos horas menos: " + dat.getTime());
dat.add(Calendar.HOUR, 2);
System.out.println("Dos horas ms: " + dat.getTime());
}
}
La clase siguiente muestra como java maneja la resta de fecha. Considerar que el mtodo expuesto slo
diferencia los valores indicados sin considerar los aos.
package view;
import java.util.Calendar;
public class Metodos8 {
public static void main(String[] args) {
Calendar dat1 = Calendar.getInstance();
dat1.set(2005, 10, 20, 15 , 30, 55);
Calendar dat2 = Calendar.getInstance();
dat2.set(2011, 02, 22, 15 , 30, 55);
int aa = dat2.get(Calendar.YEAR) - dat1.get(Calendar.YEAR);
System.out.println("Resta aos: " + aa);
int mm = dat2.get(Calendar.MONTH) - dat1.get(Calendar.MONTH);
System.out.println("Resta meses: " + mm);
int dd = dat2.get(Calendar.DATE) - dat1.get(Calendar.DATE);
System.out.println("Resta meses: " + dd);
}
}
La clase siguiente muestra cmo deducir cuando una fecha es mayor, menor o igual que otra.
package view;
import java.util.Calendar;
public class Metodos9 {
public static void main(String[] args) {
Calendar dat1 = Calendar.getInstance();
dat1.set(2005, 10, 20, 15 , 30, 55);
long dat11 = dat1.getTimeInMillis();
Calendar dat2 = Calendar.getInstance();
dat2.set(2011, 02, 22, 15 , 30, 55);
long dat12 = dat2.getTimeInMillis();
Calendar dat3 = Calendar.getInstance();
dat3.set(2011, 02, 22, 15 , 30, 55);
long dat13 = dat3.getTimeInMillis();
long dif1 = dat11 - dat12;
if(dif1>0){ System.out.println("dat1 > dat2"); }
if(dif1==0){ System.out.println("dat1 = dat2"); }
if(dif1<0){ System.out.println("dat1 <= dat2"); }
Versin 2.2 253 de 285
long dif2 = dat12 - dat13;
if(dif2>0){ System.out.println("dat2 > dat3"); }
if(dif2==0){ System.out.println("dat2 = dat3"); }
if(dif2<0){ System.out.println("dat2 <= dat3"); }
}
}
26.5 SimpleDateFormat
Permite mostrar las fechas en el formato que queramos o a reconstruirlas a partir de una cadena de texto.
Los siguientes ejemplos muestran cmo los patrones de fecha y hora se interpretan en la configuracin
regional de EE.UU.. La fecha determinada y el tiempo son 07/04/2001 12:08:56 hora local en la zona del
Pacfico de EE.UU.
26.6 GregorianCalendar
Maneja fecha y horas internacionales, que admite operaciones de calendario aplicables a la mayor parte del
mundo. Admite las eras AC y DC.
Versin 2.2 254 de 285
Ejercicio 1
En una empresa dedicada a la produccin de software se necesita controlar las horas de llegadas de los
trabajadores de lunes a viernes. El total de trabajadores son 8.
(a) Crear una matriz con datos que sea capaz de almacenar las horas de llegadas una semana de los 8
trabajadores. Para esto usted debe suponer los valores de tipo double en donde, por ejemplo, las
08:30 son las 8.50, las 08:15 son las 8.25.
(b) Calcular y mostrar el promedio de hora de llegada de la semana de datos de los 8 trabajadores.
(c) Calcular y mostrar el promedio de hora de llegada de cada uno de los 8 trabajadores en la semana
de datos.
Versin 2.2 255 de 285
27 Adicionales 1
27.1 Objetivos
Formatear datos considerando la regin.
27.2 Conocimiento previo
Uso de mtodos en Java.
27.3 Format
Es una clase abstracta para dar formato a fechas, mensajes y nmeros. Puede analizar si la informacin es
sensible a la localidad.
Las subclases DateFormat, MessageFormat, y NumberFormat formatean, respectivamente fechas,
mensajes y nmeros.
27.4 Locate
Un objeto de la clase Locale representa una regin geogrfica especfica, poltica o cultural. Una operacin
que requiere una configuracin regional para llevar a cabo su tarea se llama sensible a la localidad y utiliza
la configuracin regional de adaptar la informacin para el usuario. Por ejemplo, mostrando un nmero es
una operacin sensible a la localidad - el nmero debe tener un formato acorde a las costumbres y
convenios de pas de origen del usuario, regin o cultura.
Los cdigos de idioma se definen en la norma ISO 639, un estndar internacional que asigna los cdigos de
dos y de tres letras para la mayora de lenguas del mundo. La configuracin regional de java utiliza los
cdigos de dos letras para identificar el idioma de destino. Ver: http://www.loc.gov/standards/iso639-
2/php/code_list.php
Versin 2.2 256 de 285
El argumento pas son Cdigo ISO. Estos cdigos son las maysculas, los cdigos de dos letras definido
por la norma ISO-3166. Ver: http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html
Los constructores son:
Locale(String language)
Locale(String language, String country)
Locale(String language, String country, String variant)
Por ejemplo:
// Crear un entorno local genrico de habla Inglesa (Canad, EEUU, ...)
Locale locale1 = new Locale("en");
// Crear un entorno de habla Inglesa para la regin de Canad
Locale locale2 = new Locale("en", "CA");
// Crear un entorno especfico de habla Ingls, para la configuracin regional de EE.UU. para SiliconValley
Locale locale3 = new Locale("en", "US", "SiliconValley");
Utilizando el cdigo ISO 639 de dos letras, la representa en ingls. Los cdigos ISO 3166 CA y US
representan a Canad y los Estados Unidos, respectivamente: La ltima lnea de cdigo anterior muestra
cmo crear una configuracin local con una variante opcional: SiliconValley. Esto es ms especfica que la
primera instancia. No slo es la configuracin regional de un EE.UU. que hablan Ingls, pero tambin se
asocia con una variante adicional, SiliconValley. Debido a que uno de sus propsitos es proporcionar a los
desarrolladores la capacidad de definir escenarios personalizados, la variante puede ser cualquier cosa que
usted necesita.
La clase Locale tiene muchos campos estticos que representan instancias de objetos Locale. Por
ejemplo, Locale.FRANCE es un objeto esttico prefabricados de configuracin regional que representa de
habla francesa Francia. Usted puede utilizar Locale.FRANCE en cualquier lugar puede utilizar new Locale
("fr", "FR").
La gua de admitidos en la plataforma J2SE 5.0 proporciona una lista completa de todos los idiomas
reconocidos.
Por ejemplo, para obtener la compatibilidad de la clase NumberFormat:
Locale[] localeList = NumberFormat.getAvailableLocales();
Versin 2.2 257 de 285
Para conocer la configuracin se tiene:
package view;
import java.util.Locale;
public class Formato12 {
public static void main(String[] args) {
System.out.println(Locale.getDefault());
}
}
Observar que depende de la configuracin del equipo.
Versin 2.2 258 de 285
27.5 MessageFormat
Proporciona un medio para producir mensajes concatenados en forma independiente del idioma. Utilice esta
opcin para construir mensajes que aparecen para los usuarios finales. MessageFormat toma un conjunto
de objetos, les da formato, a continuacin, inserta las cadenas de formato en el patrn en los lugares
adecuados.
En este caso, MessageFormat reemplaza {0} por el valor de la variable que le pasamos. Podemos poner
ms variables poniendo {1}, {2} y as sucesivamente.
package view;
import java.text.MessageFormat;
public class Formato1 {
public static void main(String[] args) {
int numeroErrores = 20;
//Sin MessageFormat
String mensaje1 = "se han encontrado " + numeroErrores + " errores";
//Con MessageFormat
String mensaje2 = MessageFormat.format("se han encontrado {0} errores", numeroErrores);
System.out.println(mensaje1);
System.out.println(mensaje2);
}
}
Tambin se pueden almacenar los valores a mostrar en un arreglo. Observar que para que muestre la
comilla doble () le anteponemos \.
package view;
import java.text.MessageFormat;
public class Formato2 {
public static void main(String[] args) {
int fileCount = 1273;
String diskName = "MyDisk";
Object[] testArgs = {new Long(fileCount), diskName};
MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0} file(s).");
System.out.println(form.format(testArgs));
}
}
27.6 ChoiceFormat
Un ChoiceFormat le permite adjuntar un formato a un rango de nmeros. Se utiliza generalmente en un
MessageFormat para el manejo de los plurales. Al crear un ChoiceFormat, debe especificar una serie de
formatos y una variedad de lmites. La longitud de estas matrices deben ser los mismos. Por ejemplo:
limits = {1,2,3,4,5,6,7}
formats = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
limits = {0, 1, ChoiceFormat.nextDouble(1)}
formats = {"no files", "one file", "many files"}
En este ejemplo los valores entre 1 y 7 mostrarn lo das e la semana. Observar lo que sucede para valores
ms pequeos o ms grandes.
Versin 2.2 259 de 285
package view;
import java.text.ChoiceFormat;
public class Formato7 {
public static void main(String[] args) {
double[] limits = {1, 2, 3, 4, 5, 6, 7};
String[] monthNames = {"Domingo", "Lunes",
"Martes", "Miercoles",
"Jueves", "Viernes", "Sabado"};
ChoiceFormat form = new ChoiceFormat(limits, monthNames);
for (int i = 0; i <= 11; ++i) {
System.out.println(i + " -> " + form.format(i));
}
}
}
Si necesitamos especificar con mayor detalle la separacin entre cifras singulares o plurales podemos usar
el siguiente cdigo. Observar que {0,number} indica un nmero en la posicin {0}.
package view;
import java.text.ChoiceFormat;
import java.text.MessageFormat;
public class Formato3 {
public static void main(String[] args) {
MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
double[] filelimits = {0, 1, ChoiceFormat.nextDouble(1)};
String[] filepart = {"no files", "one file", "{0,number} files"};
ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
//Indica el ndice de inicio del formato=0 y el formato a aplicar=fileForm
form.setFormatByArgumentIndex(0, fileform);
int fileCount = 0;
String diskName = "MyDisk";
Object[] testArgs = {new Long(fileCount), diskName};
System.out.println(form.format(testArgs));

fileCount = 1;
Object[] testArgs1 = {new Long(fileCount), diskName};
System.out.println(form.format(testArgs1));

fileCount = 2;
Object[] testArgs2 = {new Long(fileCount), diskName};
System.out.println(form.format(testArgs2));

fileCount = -3;
Object[] testArgs3 = {new Long(fileCount), diskName};
System.out.println(form.format(testArgs3));
}
}
Este ejemplo muestra el uso de diversos formatos.
package view;
import java.text.MessageFormat;
public class Formato4 {
public static void main(String[] args) {
Object[] params = new Object[]{new Integer(123), new Integer(1234),
new Integer(12345), new Integer(123456)};
Versin 2.2 260 de 285
String msg = MessageFormat.format("There are {3} a''s and {1} b''s", params);
System.out.println(msg);
msg = MessageFormat.format("There are {3,number} a''s and {1,number} b''s", params);
System.out.println(msg);
//Nmeros enteros
msg = MessageFormat.format("There are {0,number,#} a''s and {1,number,#} b''s", params);
System.out.println(msg);

//Nmeros decimales
params = new Object[]{new Double(123.45), new Double(1234.56)};
msg = MessageFormat.format("There are {0,number,#.#} a''s and {1,number,#.#} b''s", params);
System.out.println(msg);

//Moneda
msg = MessageFormat.format("There are {0,number,currency} a''s and {1,number,currency} b''s", params);
System.out.println(msg);

//Porcentaje
msg = MessageFormat.format("There are {0,number,percent} a''s and {1,number,percent} b''s", params);
System.out.println(msg);
}
}
Versin 2.2 261 de 285
Ahora considerar la siguiente configuracin regional.
Ahora para la siguiente configuracin regional.
Observar en este ejemplo el uso de los formatos de nmeros enteros, fechas y horas.
package view;
import java.text.MessageFormat;
import java.util.Date;
public class Formato8 {
public static void main(String[] args) {
Object[] arguments = { new Integer(7), new Date(System.currentTimeMillis()),
"se escribe este apunte con la siguiente cantidad de calificaciones:" };
String result = MessageFormat.format("A las {1,time} del {1,date}, {2} {0,number,integer}.", arguments);
System.out.println(result);
}
}
Versin 2.2 262 de 285
27.7 NumberFormat
NumberFormat es la clase base abstracta para todos los formatos de nmero. Esta clase proporciona la
interfaz para el formato y el anlisis de los nmeros.
NumberFormat le ayuda a analizar los nmeros y el formato para cualquier configuracin regional.
Su cdigo puede ser totalmente independiente de las convenciones de localizacin de puntos decimales,
separadores de miles, o incluso los dgitos decimales en particular usado, o si el formato de nmero es an
decimal.
27.8 DecimalFormat
DecimalFormat es una subclase concreta de NumberFormat que da formato a los nmeros decimales. Tiene
una variedad de caractersticas diseadas para permitir a los nmeros de analizar y dar formato en
cualquier lugar, incluido el apoyo a Occidente, el rabe, y los dgitos ndicos. Tambin es compatible con
diferentes tipos de nmeros, incluyendo nmeros enteros (123), nmeros de punto fijo (123.4), la notacin
cientfica (1.23E4), porcentajes (12%), y las cantidades de moneda ($123). Todos ellos pueden ser
localizados en una regin determinada.
DecimalFormat utiliza ROUND_HALF_EVEN para el formato de los redondeo. De esta manera, antes de
mostrar los nmeros debemos usar una funcin que nos permita redondear estos en el formato adecuado
de decimales usado en nuestra regin (por ejemplo, HALF_UP).
package view;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;
public class Formato5 {
public static void main(String[] args) {
//Regin: se usa la , para separador de miles y el . para decimales
Locale.setDefault(Locale.CANADA);
//El smbolo 0 muestra un cero cuando no exista un dgito
//Notar que el nmero se ha redondeado
NumberFormat formatter = new DecimalFormat("000000");
String s = formatter.format(-1234.567); // -001235
System.out.println("000000 : " + s);

//El simbolo # muestra un digito nada sino existe un digito
formatter = new DecimalFormat("##");
s = formatter.format(-1234.567); // -1235
System.out.println("## : " + s);
Versin 2.2 263 de 285

formatter = new DecimalFormat("##00");
s = formatter.format(0); // 00
System.out.println("##00 : " + s);
//El simbolo . muestra el punto decimal
formatter = new DecimalFormat(".00");
s = formatter.format(-.567); // -.57
System.out.println(".00 : " + s);

formatter = new DecimalFormat("0.00");
s = formatter.format(-.567); // -0.57
System.out.println("0.00 : " + s);

formatter = new DecimalFormat("#.#");
s = formatter.format(-1234.567); // -1234.6
System.out.println("#.# : " + s);

formatter = new DecimalFormat("#.######");
s = formatter.format(-1234.567); // -1234.567
System.out.println("#.###### : " + s);

formatter = new DecimalFormat(".######");
s = formatter.format(-1234.567); // -1234.567
System.out.println(".###### : " + s);

formatter = new DecimalFormat("#.000000");
s = formatter.format(-1234.567); // -1234.567000
System.out.println("#.000000 : " + s);
//El simbolo , se usa para agrupar numeros
formatter = new DecimalFormat("#,###,###");
s = formatter.format(-1234.567); // -1,235
System.out.println("#,###,### : " + s);

s = formatter.format(-1231231234567.890); // -1,231,231,234,568
System.out.println("#,###,### : " + s);
}
}
Versin 2.2 264 de 285
Para:
Locale.setDefault(Locale.ITALIAN);
package view;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class Formato6 {
public static void main(String[] args) {
Locale[] locales = NumberFormat.getAvailableLocales();
double myNumber = -1234.56;
NumberFormat form;
for (int j = 0; j < 4; ++j) {
System.out.println("FORMAT");
for (int i = 0; i < locales.length; ++i) {
if (locales[i].getCountry().length() == 0) {
continue; // Skip language-only locales
}
Versin 2.2 265 de 285
System.out.print(locales[i].getDisplayName());
switch (j) {
case 0:
form = NumberFormat.getInstance(locales[i]);
break;
case 1:
form = NumberFormat.getIntegerInstance(locales[i]);
break;
case 2:
form = NumberFormat.getCurrencyInstance(locales[i]);
break;
default:
form = NumberFormat.getPercentInstance(locales[i]);
break;
}
if (form instanceof DecimalFormat) {
System.out.print(": " + ((DecimalFormat) form).toPattern());
}
System.out.print(" -> " + form.format(myNumber));
try {
System.out.println(" -> " + form.parse(form.format(myNumber)));
} catch (ParseException e) { }
}
}
}
}
Algunos resultados son:
run:
FORMAT
japons (Japn): #,##0.### -> -1,234.56 -> -1234.56
espaol (Per): #,##0.### -> -1.234,56 -> -1234.56
japons (Japn,JP): #,##0.### -> -1,234.56 -> -1234.56
espaol (Panam): #,##0.### -> -1,234.56 -> -1234.56
serbio (Bosnia y Hercegovina): #,##0.### -> -1.234,56 -> -1234.56
espaol (Guatemala): #,##0.### -> -1,234.56 -> -1234.56
rabe (Emiratos rabes Unidos): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
noruego (Noruega): #,##0.### -> -1 234,56 -> -1234.56
albans (Albania): #,##0.### -> -1.234,56 -> -1234.56
rabe (Iraq): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
rabe (Yemen): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
portugus (Portugal): #,##0.### -> -1.234,56 -> -1234.56
griego (Chipre): #,##0.### -> -1.234,56 -> -1234.56
rabe (Qatar): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
macedonio (Macedonia): #,##0.###;(#,##0.###) -> (1.234,56) -> -1234.56
alemn (Suiza): #,##0.### -> -1'234.56 -> -1234.56
ingls (Estados Unidos): #,##0.### -> -1,234.56 -> -1234.56
fins (Finlandia): #,##0.### -> -1 234,56 -> -1234.56
ingls (Malta): #,##0.### -> -1,234.56 -> -1234.56
Versin 2.2 266 de 285
eslovenio (Eslovenia): #,##0.### -> -1.234,56 -> -1234.56
eslovaco (Eslovaquia): #,##0.### -> -1 234,56 -> -1234.56
turco (Turqua): #,##0.### -> -1.234,56 -> -1234.56
rabe (Arabia Saudita): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
ingls (Reino Unido): #,##0.### -> -1,234.56 -> -1234.56
serbio (Serbia y Montenegro): #,##0.### -> -1.234,56 -> -1234.56
ingls (Nueva Zelanda): #,##0.### -> -1,234.56 -> -1234.56
noruego (Noruega,Nynorsk): #,##0.### -> -1 234,56 -> -1234.56
lituano (Lituania): #,##0.## -> -1 234,56 -> -1234.56
espaol (Nicaragua): #,##0.### -> -1,234.56 -> -1234.56
irlands (Irlanda): #,##0.### -> -1,234.56 -> -1234.56
francs (Blgica): #,##0.### -> -1.234,56 -> -1234.56
espaol (Espaa): #,##0.### -> -1.234,56 -> -1234.56
rabe (Lbano): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
francs (Canad): #,##0.### -> -1 234,56 -> -1234.56
estonio (Estonia): #,##0.### -> -1 234,56 -> -1234.56
rabe (Kuwait): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
serbio (Serbia): #,##0.### -> -1.234,56 -> -1234.56
espaol (Estados Unidos): #,##0.### -> -1,234.56 -> -1234.56
espaol (Mxico): #,##0.### -> -1,234.56 -> -1234.56
rabe (Sudn): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
indonesio (Indonesia): #,##0.### -> -1.234,56 -> -1234.56
espaol (Uruguay): #,##0.### -> -1.234,56 -> -1234.56
letn (Letonia): #,##0.### -> -1 234,56 -> -1234.56
portugus (Brasil): #,##0.### -> -1.234,56 -> -1234.56
rabe (Siria): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
espaol (Repblica Dominicana): #,##0.### -> -1,234.56 -> -1234.56
francs (Suiza): #,##0.### -> -1'234.56 -> -1234.56
hind (India): #,##0.### -> -,. -> -1234.56
espaol (Venezuela): #,##0.### -> -1.234,56 -> -1234.56
rabe (Bahrin): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
ingls (Filipinas): #,##0.### -> -1,234.56 -> -1234.56
rabe (Tnez): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
alemn (Austria): #,##0.### -> -1.234,56 -> -1234.56
neerlands (Holanda): #,##0.### -> -1.234,56 -> -1234.56
espaol (Ecuador): #,##0.### -> -1.234,56 -> -1234.56
chino (Taiwn): #,##0.### -> -1,234.56 -> -1234.56
rabe (Jordania): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
islands (Islandia): #,##0.### -> -1.234,56 -> -1234.56
espaol (Colombia): #,##0.### -> -1.234,56 -> -1234.56
Versin 2.2 267 de 285
espaol (Costa Rica): #,##0.### -> -1,234.56 -> -1234.56
espaol (Chile): #,##0.### -> -1.234,56 -> -1234.56
.......
27.9 DateFormat
DateFormat es una clase abstracta para el de formato de fecha de manera independiente del lenguaje.
Utilice getDateInstance para obtener el formato de la fecha normal para ese pas.
Utilice getTimeInstance para obtener el formato de hora de ese pas.
Utilice getDateTimeInstance para obtener un formato de fecha y hora.
Los estilos de formato incluyen: FULL, LONG, MEDIUM y SHORT
SHORT: 12.13.52 or 3:30pm
MEDIUM: Jan 12, 1952
LONG: January 12, 1952 or 3:30:32pm
FULL: Tuesday, April 12, 1952 AD or 3:30:42pm PST.
Veamos un ejemplo de uso.
package view;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
public class Formato9 {
public static void main(String[] args) {
Date date = new Date();
String s = DateFormat.getDateInstance(DateFormat.SHORT).format(date);
System.out.println("SHORT: " + s); // 24/02/11

s = DateFormat.getDateInstance(DateFormat.MEDIUM).format(date);
System.out.println("MEDIUM: " + s); // 24/02/2011

s = DateFormat.getDateInstance(DateFormat.LONG).format(date);
System.out.println("LONG: " + s); // 24 de febrero de 2011
s = DateFormat.getDateInstance(DateFormat.FULL).format(date);
System.out.println("FULL: " + s); //jueves 24 de febrero de 2011
// Valores por defecto: MEDIUM
s = DateFormat.getDateInstance().format(date);
System.out.println("Valores por defecto: " + s);
// Valores por defecto: MEDIUM
s = DateFormat.getDateInstance(DateFormat.DEFAULT).format(date);
System.out.println("Valores por defecto: " + s);
// Parse
try {
date = DateFormat.getDateInstance(DateFormat.DEFAULT).parse("25-02-2011");
System.out.println("parse: " + date);
} catch (ParseException e) { System.out.println("Error"); }
}
}
Versin 2.2 268 de 285
Observar que el siguiente cambio produce un error.
try {
date = DateFormat.getDateInstance(DateFormat.DEFAULT).parse("25/02/2011");
System.out.println("parse: " + date);
} catch (ParseException e) { System.out.println("Error"); }
27.10 SimpleDateFormat
SimpleDateFormat es una clase concreta para dar formato y analizar las fechas de una manera sensible a la
localidad o regin.
Un patrn de caracteres especiales se utiliza para especificar el formato de la fecha. Este ejemplo
muestra algunos. Este formato utiliza la configuracin regional (que, en el caso del autor, es
Locale.ENGLISH). Si el ejemplo se ejecuta en una localidad diferente, el texto (por ejemplo, nombres de los
meses) no ser la misma.
Para mostrar la fecha actual en formato mes/dia/ao.
package view;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Formato13 {
public static void main(String[] args) {
SimpleDateFormat formateador = new SimpleDateFormat("MM/dd/yyyy");
System.out.println(formateador.format(new Date()));
}
}
Observacin:
MM=mes
mm=minutos.
Versin 2.2 269 de 285
Para convertir un valor de tipo String en Date. Luego se muestra el valor usando el Date.
package view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Formato14 {
public static void main(String[] args) throws ParseException {
String dato = "31/12/2009";
SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
Date dt = formateador.parse(dato);
System.out.println(formateador.format(dt));
}
}
Para mostrar el da en palabras de una fechas determinada:
package view;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
public class Formato15 {
public static void main(String[] args) throws IOException, ParseException {
Calendar cal = Calendar.getInstance();
SimpleDateFormat formateador = new SimpleDateFormat("'Hoy es' EEEEEEEEE dd 'de' MMMMM 'de'
yyyy");
SimpleDateFormat formatea = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat forma = new SimpleDateFormat("'Ingresaste' EEEEEEEEE dd 'de' MMMMM 'de' yyyy");
cal.setTimeZone(TimeZone.getDefault());
System.out.println(formateador.format(new Date()));
BufferedReader fe_cha = new BufferedReader(new InputStreamReader(System.in));
BufferedReader fecha = new BufferedReader (fe_cha);
System.out.println("Ingrese una fecha ej.'18/01/1952' ");
String validaFecha = fecha.readLine();
String fechaAs = (validaFecha.toString().trim());
try
{
//False: Indica que el formato es estricto.
//Ttrue: Indica que se puede usar una aproximacin.
formatea.setLenient(false);
Date fechaForm = formatea.parse(fechaAs);
System.out.println(forma.format(fechaForm));
}
catch (ParseException e)
{
System.out.println("Error, la cadena de texto no se puede convertir en fecha.");
}
}
}
Versin 2.2 270 de 285
Formato en otros idiomas.
package view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
public class Formato16 {
public static void main(String[] args) throws ParseException {
//Fecha -> String
Calendar now = new GregorianCalendar();
SimpleDateFormat name, standar;
String nameFormat, standarFormat;
//Obtener la fecha actual en un calendario
Date nowDate = now.getTime();
//Definimos dos formatos para mostrar fechas
name = new SimpleDateFormat("EEEE, dd MMMM yyyy");
standar = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
//Aplicamos el formato a la fecha actual.
nameFormat = name.format( nowDate );
standarFormat = standar.format( nowDate );
System.out.println(nameFormat);
System.out.println(standarFormat);
//Aplicamos un formato en otro idioma.
name = new SimpleDateFormat("EEEE, dd MMMM yyyy", Locale.TRADITIONAL_CHINESE);
nameFormat = name.format(nowDate);
System.out.println(nameFormat);

name = new SimpleDateFormat("EEEE, dd MMMM yyyy", Locale.UK);
nameFormat = name.format(nowDate);
System.out.println(nameFormat);
}
}
Versin 2.2 271 de 285
28 Adicionales 2
28.1 Objetivos
Caractersticas adicionales de Java.
28.2 Conocimiento previo
Uso de mtodos en Java.
28.3 Argumentos variables
Java permite pasar un nmero variable de argumentos a un mtodo. Esto se consigue mediante la
expresin "..." a partir del momento en que queramos tener un nmero variable de argumentos.
En este ejemplo la funcin miFunc(String s1, int... datos) es capaz de recibir obligatoriamente un dato de
tipo String y el resto es una lista opcin de enteros.
public class ArgumentosVariables {
public static void main(String[] args) {
miFunc("Hola");
miFunc("Mundo",6);
miFunc("Chile",6,2,8);
}
public static void miFunc(String s1, int... datos){
System.out.println(s1);
for(int dato: datos)
System.out.println(dato);
}
}
Observar que en este caso la variable datos hace las veces de un arreglo sin dimensin mxima definida.
public class UsoMain {
public static void main(String... args) {
imprimir("Uno", "Dos", "Tres");
}
public static void imprimir(String... cadenas) {
for (String cadena : cadenas)
System.out.println(cadena);
}
}
28.4 Mtodo main
public static void main(String[] args)
El mtodo main recibe un arreglo de String como nico argumento. Este es un vector de cadenas de
caracteres representa que los parmetros opcionales que le podemos pasar por la lnea de comando.
Versin 2.2 272 de 285
El siguiente programa lee desde la lnea de comando dos argumento y luego muestra la informacin:
package dat;
public class UsoMain {
public static void main(String[] args) {
System.out.println("Hola: " + args[0]);
System.out.println("Hola: " + args[1]);
}
}
Tambin se puede procesar como:
public class Ejemplo{
public static void main(String[ ] args) {
System.out.println("Los argumentos son:");
for(int i=0;i < args.length; i++)
System.out.println(args[i]);
}
}
Tambin se puede procesar como:
public class Ejemplo{
public static void main(String[ ] args) {
System.out.println("Los argumentos son:");
for(String arg: args)
System.out.println(arg);
}
}
Versin 2.2 273 de 285
29 Adicionales 3
29.1 Objetivos
Analizar e implementar algoritmos de ordenacin y bsqueda.
29.2 Conocimiento previo
Programacin en java.
29.3 Ordenacin
La ordenacin o clasificacin de datos (sort, en ingls) es una operacin consistente en disponer un
conjunto estructura de datos en algn determinado orden con respecto a uno de los campos de
elementos del conjunto. Por ejemplo, cada elemento del conjunto de datos de una gua telefnica tiene un
campo nombre, un campo direccin y un campo nmero de telfono; la gua telefnica est dispuesta en
orden alfabtico de nombres; los elementos numricos se pueden ordenar en orden creciente o decreciente
de acuerdo al valor numrico del elemento. En terminologa de ordenacin, el elemento por el cual est
ordenado un conjunto de datos (o se est buscando) se denomina clave.
La lista se dice que est en orden ascendente si: i < j implica que k[i] <= k[j]
4 5 14 21 32 45 orden ascendente
75 70 35 16 14 12 orden descendente
Zacarias Rodriguez Martinez Lopez Garcia orden descendente
Los mtodos (algoritmos) de ordenacin son numerosos, por ello se debe prestar especial atencin en su
eleccin. Cmo se sabe cul es el mejor algoritmo? La eficiencia es el factor que mide la calidad y
rendimiento de un algoritmo. En el caso de la operacin de ordenacin, dos criterios se suelen seguir a la
hora de decidir qu algoritmo de entre los que resuelven la ordenacin es el ms eficiente: 1) tiempo
menor de ejecucin en computadora; 2) menor nmero de instrucciones.
29.4 Algoritmo de la burbuja
En el caso de un array (lista) con n elementos, la ordenacin por burbuja requiere hasta n 1 pasadas. Por
cada pasada se comparan elementos adyacentes y se intercambian sus valores cuando el primer elemento
es mayor que el segundo elemento. Al final de cada pasada, el elemento mayor ha burbujeado hasta la
cima de la sublista actual. Las etapas del algoritmo son:
El ejemplo siguiente ilustra el
funcionamiento del algoritmo de la
burbuja con un array de 5 elementos
A = (50, 20, 40, 80, 30), donde se
introduce una variable interruptor
para detectar si se ha producido
intercambio en la pasada.

Versin 2.2 274 de 285


Versin 2.2 275 de 285
La codificacin en C es:

29.5 algoritmo de ordenacin
El algoritmo de ordenacin tal vez ms sencillo sea el denominado de intercambio que ordena los elementos
de una lista en orden ascendente. Este algoritmo se basa en la lectura sucesiva de la lista a ordenar,
comparando el elemento inferior de la lista con los restantes y efectuando intercambio de posiciones cuando
el orden resultante de la comparacin no sea el correcto.
El algoritmo se ilustra con la lista original 8, 4, 6, 2 que ha de convertirse en la lista ordenada 2, 4, 6, 8. El
algoritmo realiza n 1 pasadas (3 en el ejemplo), siendo n el nmero de elementos, y ejecuta las siguientes
operaciones.

Versin 2.2 276 de 285


El mtodo ordIntercambio utiliza dos bucles anidados. Suponiendo que la lista es de tamao n, el rango del
bucle externo ir desde el ndice 0 hasta n 2. Por cada ndice i, se comparan los elementos posteriores de
ndices j = i + 1, i + 2, ..., n 1. El intercambio (swap) de los elementos a[i],a[j] se realiza en un bloque que
utiliza el algoritmo siguiente:
aux = a[i];
a[i] = a[j];
a[j]= aux ;
El algoritmo en C es:

Versin 2.2 277 de 285
29.6 Bsqueda en listas
Con mucha frecuencia los programadores trabajan con grandes cantidades de datos almacenados en arrays
y registros, y por ello ser necesario determinar si un array contiene un valor que coincida con un cierto
valor clave. El proceso de encontrar un elemento especfico de un array se denomina bsqueda. En esta
seccin se examinarn dos tcnicas de bsqueda: bsqueda lineal o secuencial, la tcnica ms sencilla, y
bsqueda binaria o dicotmica, la tcnica ms eficiente.
29.7 Bsqueda secuencial
La bsqueda secuencial busca un elemento de una lista utilizando un valor destino llamado clave. En una
bsqueda secuencial (a veces llamada bsqueda lineal), los elementos de una lista o vector se exploran (se
examinan) en secuencia, uno despus de otro. La bsqueda secuencial es necesaria, por ejemplo, si se
desea encontrar la persona cuyo nmero de telfono es 958-220000 en un directorio o listado telefnico de
su ciudad. Los directorios de telfonos estn organizados alfabticamente por el nombre del abonado en
lugar de por nmeros de telfono, de modo que deben explorarse todos los nmeros, uno despus de otro,
esperando encontrar el nmero 958-220000. El algoritmo de bsqueda secuencial compara cada elemento
del array con la clave de bsqueda. Dado que el array no est en un orden prefijado, es probable que el
elemento a buscar pueda ser el primer elemento, el ltimo elemento o cualquier otro. De promedio, al
menos el programa tendr que comparar la clave de bsqueda con la mitad de los elementos del array. El
mtodo de bsqueda lineal funcionar bien con arrays pequeos o no ordenados.
29.8 Bsqueda binaria
Se sita la lectura en el centro de la lista y se comprueba si la clave coincide con el valor del elemento
central. Si no se encuentra el valor de la clave, se sigue la bsqueda uno en la mitad inferior o superior del
elemento central de la lista. En general, si los datos de la lista estn ordenados se puede utilizar esa
informacin para acortar el tiempo de bsqueda.

Versin 2.2 278 de 285
Codificacin en C:

29.9 Ejercicios
Codificar cada uno de los algoritmos en Java y desarrollar pruebas para datos de tipo numricos y de
caracteres, midiendo los tiempos de ejecucin.
Versin 2.2 279 de 285
30 Adicionales 4
30.1 Objetivos
Uso de casos de uso para la definicin de requerimientos.
30.2 Conocimiento previo
Programacin de sistemas.
30.3 Caso de uso
Un caso de uso es una descripcin de los pasos o las actividades que debern realizarse para llevar a
cabo algn proceso. Los personajes o entidades que participarn en un caso de uso se denominan actores.
En el contexto de ingeniera del software, un caso de uso es una secuencia de interacciones que se
desarrollarn entre un sistema y sus actores en respuesta a un evento que inicia un actor principal sobre
el propio sistema.
Los diagramas de casos de uso sirven para especificar la comunicacin y el comportamiento de
un sistema mediante su interaccin con los usuarios y/u otros sistemas. O lo que es igual, un diagrama que
muestra la relacin entre los actores y los casos de uso en un sistema. Una relacin es una conexin entre
los elementos del modelo, por ejemplo la especializacin y la generalizacin son relaciones. Los diagramas
de casos de uso se utilizan para ilustrar los requerimientos del sistema al mostrar cmo reacciona a eventos
que se producen en su mbito o en l mismo.
Los ms comunes para la captura de requisitos funcionales, especialmente con el desarrollo del
paradigma de la programacin orientada a objetos, donde se originaron, si bien puede utilizarse con
resultados igualmente satisfactorios con otros paradigmas de programacin.
30.4 Normas de aplicacin
Los casos de uso evitan tpicamente la jerga tcnica, prefiriendo la lengua del usuario final o del experto
del campo del saber al que se va a aplicar. Los casos del uso son a menudo elaborados en colaboracin por
los analistas de requerimientos y los clientes.
Cada caso de uso se centra en describir cmo alcanzar una nica meta o tarea de negocio. Desde
una perspectiva tradicional de la ingeniera de software, un caso de uso describe una caracterstica del
sistema. Para la mayora de proyectos de software, esto significa que quizs a veces es necesario
especificar diez o centenares de casos de uso para definir completamente el nuevo sistema. El grado de la
formalidad de un proyecto particular del software y de la etapa del proyecto influenciar el nivel del detalle
requerido en cada caso de uso.
Los casos de uso pretenden ser herramientas simples para describir el comportamiento del software
o de los sistemas. Un caso de uso contiene una descripcin textual de todas las maneras que los actores
previstos podran trabajar con el software o el sistema. Los casos de uso no describen ninguna
funcionalidad interna (oculta al exterior) del sistema, ni explican cmo se implementar. Simplemente
muestran los pasos que el actor sigue para realizar una operacin.
Un caso de uso debe:
Describir una tarea del negocio que sirva a una meta de negocio.
Tener un nivel apropiado del detalle.
Ser bastante sencillo como que un desarrollador lo elabore en un nico lanzamiento.
Situaciones que pueden darse:
Un actor se comunica con un caso de uso (si se trata de un actor primario la comunicacin la
iniciar el actor, en cambio si es secundario, el sistema ser el que inicie la comunicacin).
Un caso de uso extiende otro caso de uso.
Un caso de uso utiliza otro caso de uso.
Versin 2.2 280 de 285
30.5 Plantilla no adecuada
30.6 Plantilla adecuada 1
Versin 2.2 281 de 285
30.7 Plantilla adecuada 2
Versin 2.2 282 de 285
RF- 01 Alta de socio
Objetivos asociados OBJ02 Gestionar las socios
Requisitos asociados RI02 Informacin sobre socios
Descripcin El sistema deber comportarse tal como se describe en
el siguiente caso de uso cuando alguien solicite su
ingreso como
socio
Precondicin El solicitante no es un socio del vdeoclub y tiene su
documentacin disponible
Secuencia
Normal
Paso Accin
1 El empleado del vdeoclub solicita al sistema
comenzar el proceso de alta de un nuevo socio
2 El sistema solicita los siguientes datos del
nuevo socio: n del DNI, nombre, apellidos,
fecha de nacimiento, sexo, direccin y
telfonos de contacto
3 El empleado del vdeoclub solicita los datos
requeridos y la documentacin al nuevo socio
4 El empleado del vdeoclub comprueba que los
datos
del nuevo socio coinciden con los de la
documentacin aportada
5 El empleado del vdeoclub proporciona los
datos requeridos y solicita al sistema que los
almacene
6 El sistema almacena los datos proporcionados,
imprime el carnet de socio e informa al
empleado del vdeo club de que el proceso ha
terminado con xito
7 El empleado del vdeoclub entrega el carnet al
nuevo
socio
Postcondicin El solicitante es socio del vdeoclub y el saldo de su
cuenta es
0
Excepciones Paso Accin
4 Si la documentacin aportada no es correcta, el
empleado del vdeoclub cancela la operacin,
a continuacin este caso de uso termina
31 Adicionales 4
31.1 Objetivos
Trabajo.
31.2 Conocimiento previo
Programacin en java y manejo de swings.
31.3 Base de datos
Crear a base de datos tienda y las siguientes tablas.
Tabla: Cliente
Campo Tipo PK FK
rut varchar(10) YES
razon_social varchar(100)
direccion varchar(100)
rut razon_social direccion
44000000 AXP Estructuras Metlicas Ltda. Las acacias 1234, Santiago
12500000 Maria Luisa Perez Aranguiz Las parcelas 8080, Linares
Tabla: Producto
Campo Tipo PK FK
codigo_producto varchar(4) YES
nombre varchar(100)
codigo_producto nombre
AX10 Samsung Netbook N100 Intel Atom 435 1Gb 250Gb 10.1" 3C SO MeeGo
AX20 Packard Bell Netbook EasyNote Butterfly DOT A-001 AMD Athlon II Neo K125 2GB
320GB 11.6" 6C W7St
AZ10 Sony NTBK VAIO VPC-YB25 AMD Dual Core E350 2Gb 500Gb 11.6" BT HD6310 6C
W7St Negro
Tabla: Sucursal
Campo Tipo PK FK
codigo_sucursal varchar(2) YES
nombre varchar(100)
A1 Mall Vespucio, Santiago
A2 Punta Arenas
Versin 2.2 283 de 285
A3 Concepcin
A4 Santiago Centro
Tabla: Sucursal_Producto
Campo Tipo PK FK
codigo_sucursal varchar(2) YES YES: Sucursal(codigo_sucursal)
codigo_producto varchar(4) YES YES: Producto(codigo_producto)
cantidad_en_bodega int
precio int
codigo_sucursal codigo_producto cantidad_en_bodega precio
A1 AX10 2 119990
A2 AX10 10 140000
A3 AX10 20 119990
A4 AX10 45 119990
A2 AX20 12 209990
A4 AX20 3 189990
A1 AZ10 279990
A2 AZ10 269990
A3 AZ10 289990
Tabla: Moneda
Campo Tipo PK FK
tipo_moneda varchar(2) YES
nombre varchar(100)
valor_pesos double
tipo_moneda nombre valor_pesos
DO Dlar 456,23
EU Euro 653,94
YE Yen 700
Tabla: Venta
Campo Tipo PK FK
id int YES (Autocorrelativo)
rut varchar(10) YES: Cliente(rut)
codigo varchar(4) YES: Producto(codigo)
cantidad int
fecha date
hora date
tipo_moneda varchar(2) YES: Moneda(tipo_moneda)
Versin 2.2 284 de 285
El diagrama relacional es:
Se necesita un sistema que sea capaz de manejar el stock de productos y las ventas de estos en una tienda
comerciales con sucursales a lo largo del pas. Las caractersticas especficas son:
1. Los clientes son aquellos que pueden desarrollar compras.
2. Los productos son ingresados al sistema asignndolos a diferentes sucursales que la tienda tiene a
lo largo del pas.
3. Cada sucursal tiene un precio distinto para el mismo producto.
4. Las ventas pueden ser desarrolladas en los tipos de monedas almacenados en la tabla Moneda.
5. Cada venta debe almacenar el da y hora en que se desarrollar el proceso tomando esos datos
desde la fecha del servidor de base de datos.
Versin 2.2 285 de 285

También podría gustarte