You are on page 1of 285

METODOLOGÍA

DE
PROGRAMACIÓN
Versión 2.2 1 de 285
Índice de contenido
1 Clase.................................................................................................................................................8
1.1 Objetivos..................................................................................................................................8
1.2 Conocimiento previo................................................................................................................8
1.3 Conceptos de encapsulación....................................................................................................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 Métodos específicos...............................................................................................................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 evaluación 1.......................................................................................................38
6 Clase...............................................................................................................................................42
6.1 Objetivos................................................................................................................................42
Versión 2.2 2 de 285
6.2 Conocimiento previo..............................................................................................................42
6.3 Arreglos unidimensionales.....................................................................................................42
6.4 Declaración de arreglos.........................................................................................................43
6.5 Recorrer un arreglo................................................................................................................44
6.6 Asignación 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 parámetros 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 Inicialización 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 evaluación 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 Agregación ..........................................................................................................................60
10.6 Composición........................................................................................................................61
10.7 Asociación............................................................................................................................62
10.8 Multiplicidad........................................................................................................................62
10.9 Herencia...............................................................................................................................63
10.10 Definiciones de herencia....................................................................................................65
10.11 Relación “es-un”·y “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 métodos...........................................................................................................70
11.5 Object...................................................................................................................................71
11.6 super.....................................................................................................................................72
11.7 Ejemplo 1.............................................................................................................................74
11.8 Ejemplo 2.............................................................................................................................76
11.9 Métodos final.......................................................................................................................79
11.10 Clases final.........................................................................................................................79
11.11 Trabajo 5............................................................................................................................80
12 Clase.............................................................................................................................................81
Versión 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 evaluación 3.....................................................................................................92
14 Clase.............................................................................................................................................98
14.1 Objetivos..............................................................................................................................98
14.2 Conocimiento previo............................................................................................................98
14.3 Manejo de excepciones........................................................................................................98
14.4 Lanzar una excepción..........................................................................................................99
14.5 Captura una excepción.........................................................................................................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 evaluación 4...................................................................................................136
18 Clase...........................................................................................................................................141
18.1 Objetivos............................................................................................................................141
18.2 Conocimiento previo..........................................................................................................141
18.3 Colecciones Genéricas.......................................................................................................141
Versión 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 Implementación...............................................................................................................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 Conexión de Información general......................................................................................166
19.7 Establecer una conexión....................................................................................................166
19.8 Liberación DBMS Recursos..............................................................................................166
19.9 Crear una conexión............................................................................................................167
19.10 Insertar datos....................................................................................................................167
19.11 Driver de Conexión..........................................................................................................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 diálogo..............................................................................................................188
21 Clase...........................................................................................................................................193
21.1 Objetivos............................................................................................................................193
21.2 Conocimiento previo..........................................................................................................193
21.3 Modelos de evaluación 5...................................................................................................193
Versión 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 Evaluación 6......................................................................................................................228
24.4 Evaluación 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 Método main......................................................................................................................272
29 Adicionales 3..............................................................................................................................274
29.1 Objetivos............................................................................................................................274
29.2 Conocimiento previo..........................................................................................................274
29.3 Ordenación.........................................................................................................................274
Versión 2.2 6 de 285
29.4 Algoritmo de la burbuja.....................................................................................................274
29.5 algoritmo de ordenación....................................................................................................276
29.6 Búsqueda en listas..............................................................................................................278
29.7 Búsqueda secuencial..........................................................................................................278
29.8 Búsqueda 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 aplicación.........................................................................................................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
Versión 2.2 7 de 285
1 Clase
1.1 Objetivos
• Encapsular datos.
• Restringir el acceso a datos.
1.2 Conocimiento previo
Creación de métodos.
1.3 Conceptos de encapsulación
En programación modular, y más específicamente en programación orientada a objetos, se denomina
encapsulamiento al ocultamiento del estado, es decir, de los datos miembros, de un objeto de manera que
sólo se puede cambiar mediante las operaciones definidas para ese objeto.
De esta forma, el usuario de la clase puede obviar la implementación de los métodos y propiedades
para concentrarse sólo en cómo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado de
maneras imprevistas e incontroladas.
Otra definición un tanto más simple: La encapsulación consiste en ocultar la complejidad de una
clase e impedir accesos no autorizados
Java, como lenguaje orientado a objetos puro que es, implementa la encapsulación (o encapsulamiento)
perfectamente. Este concepto consiste en la ocultación del estado, o lo que es lo mismo, de los datos
miembro de un objeto, de forma que sólo es posible modificar los mismos mediante las operaciones
(métodos, en Java) definidos para dicho objeto. Más específicamente:
Para implementar la encapsulación 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 método constructor de la clase sin parámetros.
• Para cada variable declarar métodos:
◦ Accesadores (conocidos como métodos get): Se utilizan de forma estándar para la recuperación
de datos de un objeto.
◦ Mutadores (conocidos como métodos set): Se utilizan de forma estándar para la asignación de
datos a un objeto, bajo ciertas restricciones.
Versión 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(){ } //Método constructor sin parámetros
//Métodos 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 diagramación de clases usaremos dia v0.97.1 que puedes bajar desde http://dia-installer.de/
-: Privado
+: Publico
Con estos métodos se pueden incorporar restricciones a los valores ingresados. Por ejemplo, en el caso de
la edad se pueden permitir sólo valores > 0 ó cero. Así el método sería ahora:
void setEdad(int edad){
if(edad <= 0)
this.edad = 0;
else
this.edad= edad;
}
También se puede, por ejemplo, en el caso de la nota permitir sólo 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
}
Versión 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 código del producto como parámetro de objeto de la clase que encapsula la información de
productos.
• La cantidad a vender como parámetro del método que calculará el total de la venta.
Considerar los siguiente productos:
Código Nombre Precio unitario
AX10 Faldas 40000
AX20 Pantalón 30000
AX30 Blusa 50000
Se pide no efectuar ningún tipo de validación y enviar los siguientes valores a proceso:
Código Unidades vendidas
AX10 40
AX30 100
Se pide también, mostrar:
• Código del producto
• Nombre del producto
• Precio del producto
• Total a pagar
Esta clase provee la encapsulación de productos. Para el desarrollo de una venta se deberá crear un objeto
de la clase usando su método constructor que debe recibir el código, nombre y precio del producto; usando
su método 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;
}
Versión 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 programación 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);
Versión 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 solución más óptima sería crear un método de impresión 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 tendría:
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;
}
Versión 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 sería 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);
}
}
Versión 2.2 13 de 285
2 Clase
2.1 Objetivos
Conversión de tipos de datos.
2.2 Conocimiento previo
Manejar los datos de tipo primitivos y el uso de métodos
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
métodos por valor, mientras que los objetos se pasan por referencia. De esta manera, no hay forma de
modificar en un método un argumento de tipo primitivo y que esa modificación 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 más que dotar a los datos primitivos con un envoltorio que permita tratarlos como objetos.
Versión 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 minúscula que con mayúscula.
Versión 2.2 15 de 285
Observar que es válido también la combinaciones de letras minúsculas y mayúsculas:
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 recomendación es usar la siguiente inicialización 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();
}
Versión 2.2 16 de 285
Observar que no se pueden usar combinaciones de minúsculas y mayúsculas en los casos indicados con
error. La recomendación es usar Boolean.TRUE.
2.5 Number
Uno de los mayores uso de conversión es usando datos de la clase String. Por ejemplo, en las aplicaciones
de tipo web la mayoría de los datos son recuperados como tipo String independientes que los datos sean
numéricos.
En diagrama de clases de los datos tipo Objetos (o Wrapper). Podemos apreciar que existe una
clase común Number y que después cada uno de los tipos de datos tiene su propia implementación en su
clase.
Versión 2.2 17 de 285
Number
BigDecimal BigInteger Byte Double Float Integer Long Short
Object
2.6 Double
Maneja objetos numéricos tipo Double. Esta clase provee varios métodos 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 métodos de mayor utilidad pues recibe un String y lo transforma en
double. En la jerga de la programación 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 más importante de todos
Versión 2.2 18 de 285
val1 = Double.parseDouble(val4);
System.out.println("val1: " + val1);
//Transforma de String a Double. El segundo más 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 métodos de Integer son análogos a los de la clase Double. Para el método 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 números 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; }
}
Versión 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 método:
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 método:
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 método:
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;
Versión 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.
Código del Producto Precio
AX10 10000
AX20 20000
AX30 50000
Se pide:
(a) Encapsular la información que interviene en el ejercicio.
(b) Crear un método que devuelva un String, sin parámetros y que dado un producto y una cierta
cantidad vendida del producto, calcule y muestre el total a pagar.
(c) Crear un método que reciba el total a pagar (tipo String) y calcule el descuento a aplicar (tipo int con
aproximación de cantidades decimales al primer entero superior al número calculado) según 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
Versión 2.2 21 de 285
3 Clase
3.1 Objetivos
Usar métodos prediseñados.
3.2 Conocimiento previo
Creación de métodos.
3.3 Métodos específicos
Existen una serie de de métodos en java que nos permiten desarrollar procesos. Sin embargo, esta cantidad
de métodos no es tan cuantiosos como otros lenguajes de programación.
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 número.
public class FuncionesEspecificas {
public static void main(String[] args) {
char valor1 = '4';
char valor2 = 'e';
if(Character.isDigit(valor1)){
System.out.println("valor1 es dígito");
} else
{
System.out.println("valor1 no es dígito");
}
if(Character.isDigit(valor2)){
System.out.println("valor2 es dígito");
} else
{
System.out.println("valor2 no es dígito");
}
}
}
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'));
}
}
Versión 2.2 22 de 285
3.5.2 isUpperCase
Determina si el carácter especificado en una letra mayúscula. 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 códigos ascii.
Versión 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 explícitamente no se puede usar.
3.7.1 charAt
Retorna el carácter para una posición específica 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 función se puede generar un validador de números de sólo números 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;
}
}
Versión 2.2 24 de 285
return true;
}
}
Observar que el métodos se debe mejorar que validar números 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 “str”al final de otra cadena. El código 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 aparición del carácter
especificado.
int indexOf(int ch, int fromIndex): Devuelve el índice dentro de esta cadena de la primera aparición del
carácter especificado, a partir de la búsqueda en el índice especificado.
int indexOf(String str): Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena
especificada.
int indexOf(String str, int fromIndex): Devuelve el índice dentro de esta cadena de la primera aparición 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 posición 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 código muestra ejemplos de uso del método. Tener presente que el proceso no es el habitual de
la mayoría de los lenguajes de programación
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
Versión 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 minúsculas utilizando las reglas de
la localización por defecto.
String toLowerCase(Locale locale): Convierte todos los caracteres letras de String a minúsculas utilizando
las reglas dado por Locale.
String toUpperCase(): Convierte todos los caracteres letras de String a mayúsculas utilizando las reglas de
la localización por defecto.
String toUpperCase(Locale locale): Convierte todos los caracteres letras de String a mayúsculas
utilizando las reglas dado por Locale.
Locate: Un objeto Locale representa una determinada región geográfica, política 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 números seudoaleatorios que tiene como
fin principal la simulación.
3.8.1 nextInt
Devuelve un pseudoaleatorios, uniformemente distribuidos entero entre 0 (inclusive) y el valor especificado
(exclusivo). Por ejemplo, generar 10 números 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));
}
}
}
Versión 2.2 26 de 285
Posibles resultados, los cuales dependen de la veces que se ejecute el proceso.
Generar 10 números 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 números 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());
}
}
}
Versión 2.2 27 de 285
4 Clase
4.1 Objetivos
Usar objetos de clases para procesos.
4.2 Conocimiento previo
Creación de métodos.
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 métodos
La referencia es la posición 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;
Versión 2.2 28 de 285
Referencia
Variable grados
Objeto de
CGrados
Objeto referenciado
obj1 obj2 obj3 Referencias
Posiciones
de memoria
Ubicación de objetos
Conclusión:
• Conclusión: Ambas referencias obj1 y obj2 apuntan al mismo objeto.
• Así, accederán a las mismas variables de ejemplar las que son utilizadas en el proceso que
desarrollan los métodos.
• De esta manera, se obtiene los mismos resultados usando obj1 u obj2
Cuando java compila un literal, por ejemplo “abc”, añade un objeto String al área de almacenamiento de
“abc”. De esta manera, si posteriormente aparece el mismo literal en cualquier otra parte del código de la
clase, entonces java no agrega un nuevo objeto, sino que utiliza el que hay. Esto se genera únicamente
con la asignación:
String obj1 = “abc”;
String obj2 = “abc”;
Sin embargo, en relación a lo anterior si la asignación 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
Versión 2.2 29 de 285
obj1 obj2 Referencias
Posiciones
de memoria
Ubicación 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
También 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 }

Versión 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 posición 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");
}
}
Versión 2.2 31 de 285
4.5 StringBuffer - StringBuilder
• Lo más 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 cambiarán en la ejecución del programa (a
diferencia de los objetos String normales, que son inmutables).
• Una clase parecida, StringBuilder, llegó con Java 5. Es idéntica a la anterior salvo que no es
síncrona, lo que significa que puede haber problemas si es una variable a la que accedan diferentes
threads. Sin embargo, para la mayoría de las aplicaciones (donde se ejecuta un solo hilo) supone
una mejora de rendimiento sobre StringBuffer.
Considerar el siguiente código. Este código 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 código usa StringBuffer. En esta ocasión sólo se crea un objeto, al que se le van añadiendo las
cadenas con el método append.
StringBuffer cadena = new StringBuffer(“Cuenta: “);
for (int i=0; i<100; i++) {
cadena.append(“ “ + i + “ “);
}
Lógicamente esto también 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 iteración del bucle, mejorando aún más 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 + " ");
}
Versión 2.2 32 de 285
Buena práctica;
• Si el texto no va a cambiar, utilizar String.
• Si va a cambiar, y la aplicación va a tener un solo hilo de ejecución, utilizar StringBuilder.
• Si el texto cambia durante la ejecución, y la aplicación que accede a él es multi-thread, utilizaremos
StringBuffer.
Versión 2.2 33 de 285
4.6 BigDecimal - RoundingMode
Considerar el siguiente código 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 cálculos directamente (con su coprocesador matemático) pero como las
computadoras "piensan" en binario, cometen errores de precisión 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);
}
}
Versión 2.2 34 de 285
Si hacen sistemas financieros, los pequeños errores de calculo acumulados con varios centavos pueden
resultar en reportes cuyos cálculos diferirán de las operaciones que normalmente realizamos los humanos.
Para resolver este problema, en Java se incluye la clase BigDecimal, que si bien realiza los cálculos 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:
Además consideraremos la clase java.math.RoundingMode que permite el manejo de aproximaciones de
cifras decimales. Los valores posibles son:
• HALF_DOWN
• HALF_EVEN
Versión 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);
}
}
Versión 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 excepción 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 método 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 minúsculas.
(d) El total de letras mayúsculas.
Crear dos variables de tipo StringBuffer con los elementos:
• {ABCDEFGHIJKLMNÑOPQRSTUVWXYZ}
• {0123456789}
Cree un método que, usando esta estructura, sea capaz de validar que el código de un producto esté
compuesto sólo de dos letras mayúsculas al inicio y luego dos números.
Versión 2.2 37 de 285
5 Clase
5.1 Objetivos
Presentar problemas tipo para la evaluación 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 evaluación 1
Problema 1
El cobro de intereses por la venta de un producto está asociado a la relación en días 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 método sin parámetros que sea capaz de calcular y mostrar el interés a pagar en pesos,
donde el interés depende de la cantidad de días de retraso en el pago:
1-30 días 2,00%
31-90 días 4,50%
>90 días 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 método que devuelva un String y que cuente la cantidad de caracteres que contiene la
variable dat.
(b) Crear un método que devuelva un boolean, que recibe como parámetro 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 método devuelve true.
(c) Considerar que variable dat contiene información de fecha en formato dd/mm/aaaa. Crear un
método que transforme adecuadamente el contenido de la variable dat a un tipo de variable que
maneje fechas; el método debe mostrar el día, el mes y el año.
Problema 3
La variable rut se ha definido de tipo StringBuffer. Desarrollar métodos particulares para cada uno de los
siguiente proceso; cada método recibe como parámetro 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 carácter sea un número o una letra k minúscula o mayúscula.
(c) Validar que el carácter guión al centro (-) esté antes del último carácter.
(d) Validar que los caracteres ante del guión al centro (-) sean sólo números.
Versión 2.2 38 de 285
Problema 4
Desarrolle un método que cómo parámetro recibe un código el cual se debe validar. Las condiciones son:
(a) El código debe contener exactamente 4 caracteres.
(b) Los dos primeros dígitos son letras mayúsculas.
(c) Los dos últimos caracteres son números.
(d) En caso de no ser válido el código se debe indicar en el mensaje de error todos las anomalías
producidas.
Problema 5
Cree un método 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. Además
usando esta variable calcular:
• La cantidad de letras mayúsculas.
• La cantidad de letras minúsculas.
• 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 método que cuente con un parámetro StringBuffer y que sea capaz de almacenar en otra
variable StringBuffer el valor numérico que produce la concatenación de las cifras numéricas enviadas en el
parámetro del método. Por ejemplo, si el parámetro es “Ub40Yu7L” entonces se debe almacenar “407”.
Desarrollar el mismo proceso pero almacenando el número en orden inverso. Para el ejemplo sería
“704”.
Solución, 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() {
Versión 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();
Versión 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;
}
}
Versión 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 número 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 actúan como prefijo al identificador del arreglo.
Por ejemplo, una lista con valores válidos 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 características de los arreglos:
• Se crean con el operador new seguido del tipo y número de elementos.
int a[ ] = new int[10]; int a[]=new int[]{1,2,3};
• Se puede acceder al número de elementos de un array con la variable miembro implícita length. Por
ejemplo:
a.length; // resultado 10
• Se accede a los elementos de un arreglo con los corchetes [ ] y un índice que varía de 0 a length-1.
• Los elementos de un array se inicializan al valor por defecto del tipo correspondiente:
◦ Cero para valores numéricos
◦ La cadena vacía para String
◦ False para boolean
◦ null para referencias
• Como todos los objetos, los arreglos se pasan como argumentos a los métodos por referencia.
Versión 2.2 42 de 285
6.4 Declaración 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;
También es válido 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"};
También es válido
String datos[2] = new String[ ];
datos[0]="A1";
datos[1]="A2";
También es válido
String datos[2] = new String[ ];
datos[0]=new String("A1");
datos[1]=new String("A2");
Versión 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}; //Definición 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 versión 1.5 de java:
public class RecorrerArreglo {
public static void main(String[] args) {
int[] arrayInt = {1, 20, 30, 2, 3, 5}; //Definición del arreglo
//Recorre e imprime todos los elementos de un array
//previniendo índices fuera de rango
for(int elemento: arrayInt)
System.out.println (elemento);
}
}
Versión 2.2 44 de 285
6.6 Asignación de arreglos
Java permite la asignación 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 método 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 método 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 número decimales aleatorios entre 1 (inclusive) hasta antes de 100. Math.Random()
genera números 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]); }
}
}
Versión 2.2 45 de 285
2. Crear 10 número 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 máximo 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);
}
}
Versión 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 encapsulación 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 números 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; }
Versión 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 información recupera los datos y los encapsula como objeto de AlumnoMatrizObjeto.
Luego usando esta encapsulación recupera datos desde los objeto y hace cálculos:
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 parámetros tipo arreglo
Al devolver información de un método 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 método reciba un
arreglo a través de una llamada de método, la lista de parámetros del método debe indicar que se recibirá
un arreglo. Por ejemplo para definir un método se puede usar:
void modificar(int x[ ])
Para pasar un arreglo, por ejemplo int c[ ], al método “modificar” anterior se procede:
modificar( c );
Versión 2.2 48 de 285
Crear un método 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 múltiples métodos para manipular arreglos sobre múltiples 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 método 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 método que reciba un arreglo de tipo char, que sea capaz de calcular y devolver la
cantidad de números. Considera la frase “Juan a ganado $890.000 en 1er día 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();
Versión 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 números reales correspondientes a las estaturas de n
personas. Se piden crear métodos que reciban un arreglo del tipo citado y sean capaces devolver lo
solicitado.
(a) La media de las estaturas.
(b) Las alturas máxima y mínima.
(c) Determine cuántos son más altos y cuantos más bajos que la media.
(d) La desviación estándar:
(e) Calcular la moda (si no la hay devolver -1). La moda es el número más 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 regresión 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.
Versión 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 interés en el tiempo, y tiene la intención de registrar la temperatura de cada
día durante un año en 10 ubicaciones geográficas separadas a lo largo del año. Una vez que haya
solucionado la logística de la recogida de esta información, puede declarar este arreglo:
float[][] temperature = new float[10][365];
Suponga que se desea simular estas temperaturas, para lo cual tiene como información que estos valores
están entre -10ºC y +35ºC
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]);
}
}
}
}
Versión 2.2 51 de 285
En este caso para la contabilización 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 Inicialización de arreglos bidimensionales
Para el caso de arreglos tipo String
String datos[ ][ ] = {{"A1","A2"},
{"Enlatados","natural"}};
8.5 Ejemplos
1. Máximo 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. Máximo 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);
}
}
Versión 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 método 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 Código 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.
Versión 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 evaluación 2. Valor 12.5% de la nota 1.
9.2 Conocimiento previo
Contenidos de las clases 6, 7 y 8
9.3 Modelo de evaluación 2
Ejercicio 1
Considerar un arreglo bidimensional de números enteros de orden 4x5.
(a) Crear el arreglo.
(b) Crear un método que calcule la cantidad de elementos repetidos en el arreglo.
(c) Crear un método 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 método: public double posPromedio(String a[ ],int inf, int sup),
que recibe un arreglo unidimensional de String y dos valores enteros inf y sup. El método regresa el
promedio de los valores contenidos entre los índices inf y sup del arreglo a.
(c) Dentro de la clase anterior definir el método: public double posMinimo(String a[ ],int inf, int sup) que
recibe un arreglo unidimensional de String y dos valores enteros inf y sup. El método 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 método 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.
Código 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.
Código Cantidad
AX20 10000
AX10 2000
Versión 2.2 54 de 285
AX20 25000
AX30 300
AX10 3000
AX20 1000
AX30 300
AX10 500
Crear un método que sea capaz de devolver en un arreglo bidimensional el código 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 método void sin parámetros que para una matriz bidimensional cuadrada “A” con elementos
numéricos 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 sólo números 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 método que calcule el total de letras mayúsculas de todos los nombres.
Se pide crear un método que muestre el nombre o apellido con mayor cantidad de letras.
(d) Considerar un arreglo bidimensional 5x3 de datos enteros.
• Crear un método que calcule el promedio de los valores.
• Crear un método que calcule la cantidad de valores en el arreglo menores que cero.
• Crear un método que calcule la cantidad de números primos contenidos en el arreglo.
• Crear un método que calcule la cantidad de números 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 método que reciba un valor de tipo String y devuelva la posición 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.
Código del Producto Precio
AX10 10000
AX20 20000
AX30 50000
Versión 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 método sin parámetros que calcule la cantidad de productos vendidos de cada tipo.
(b) Crear un método sin parámetros que calcule la suma total en pesos vendidos para cada uno de los
clientes.
Solución 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));
}
}
Versión 2.2 56 de 285
10 Clase
10.1 Objetivos
Manejar en concepto de diagramación UML.
10.2 Conocimiento previo
Concepto de clase, tributos y métodos.
10.3 Uso de la herencia en la POO
Nos interesan los desafíos que plantean el desarrollo de lo que llamaremos software de dimensión
industrial. Aquí se encuentran aplicaciones que mantienen, por ejemplo, la integridad de cientos de miles
de registros de información que mientras se permiten actualizaciones y consultas concurrentes; y sistemas
para la gestión de tráfico aéreo 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 característica principal del software de dimensión industrial es que resulta sumamente difícil, si no
imposible, para el desarrollador individual comprender todas las partes de su diseño. 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.
Versión 2.2 57 de 285
• La dificultad de gestionar el proceso de desarrollo.
• La flexibilidad que se puede alcanzar a través del software.
• Los problemas de caracterizar el comportamiento de sistemas discretos.
Las consecuencias de la complejidad son:
• Cuando más complejo sea el sistema, más abierto está al derrumbamiento total. Un constructor
pensaría raramente en añadir un subsotano a un edificio ya construido de cien plantas, hacer estos
sería muy costoso e indudablemente sería una invitación 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 inglés, Unified Modeling Language) es el lenguaje
de modelado de sistemas de software más conocido y utilizado en la actualidad; está respaldado por el
OMG (Object Management Group). Es un lenguaje gráfico para visualizar, especificar, construir y
documentar un sistema. UML ofrece un estándar 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 programación, esquemas de bases de datos y componentes
reutilizables.
Es importante resaltar que UML es un "lenguaje de modelado" para especificar o para describir métodos 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 metodología de desarrollo de software (tal como el Proceso Unificado Racional o RUP), pero no
especifica en sí mismo qué metodología o proceso usar.
La programación orientada a objetos viene siendo un complemento perfecto de UML, pero no por
eso se toma UML sólo 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.
Versión 2.2 58 de 285
Para el diseño de diagramas puedes emplear diversas aplicaciones que permiten en diversos niveles
diagramas y controlar el proyecto. Para este curso puedes usar la aplicación “dia” que puede ser bajada
desde http://live.gnome.org/Dia.
El nombre de la clase se coloca en la parte superior del rectángulo y es una palabra con la primera letra en
mayúscula. Si el nombre de la clase consta de más de una palabra únalas e inicie cada palabra con
mayúscula.
El atributo es una propiedad o característica 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
minúscula. Sin embargo, si el nombre consiste en más de una palabra, cada palabra será unida a la anterior
y comenzará con una mayúscula. Además, 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 estándar de nombre que los
atributos. En los paréntesis podrá los parámetros con los cuales funciona la operación junto con su tipo de
dato. Además, 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 paréntesis
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.
Versión 2.2 59 de 285
10.5 Agregación
Se crean objetos de las clases existentes dentro de la nueva clase. Simplemente se está reutilizando (y no
especializando) la funcionalidad del código. Esto es lo que hemos vistos en los capítulos anteriores.
Más específicamente, la agregación se produce cuando una clase consta de otras. Cuando modele
con agregación tenga la precaución que se cumpla la relación “es–parte-de”.
Notar una característica que se cumple para este diagrama:
• Los puntos son parte de los polígonos
• Si los polígonos 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 polígonos.
• El diamante blanco ilustra lo anterior.
Veamos otros ejemplos
• Las ruedas forman parte del MedioDeTransporte (por ejemplo un automóvil)
• Pero, su ciclo de vida de las Ruedas no esta atado a MedioDeTransporte. Es
decir, si el MedioDeTransporte (por ejemplo, el automóvil) se “destruye”,
entonces las ruedas como concepto siguen existiendo independientemente
(podríamos decir que las ruedas puede utilizarse en otros artefactos que no
son medios de transporte, por ejemplo, ruedas dentadas)
Versión 2.2 60 de 285
10.6 Composición
Con la composición, el objeto parte puede pertenecer a un todo único; es más, 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 agregación, es una relación estructural pero se le suma, que tiene un método de
destrucción de los objetos. Y a diferencia de la asociación, 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 surgían 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 métodos de
destrucción de los objetos (relacionados a los ciclos de vida en la composición).
La programación es la misma para las composiciones y las agregaciones, y que la diferencia es
meramente conceptual entre una y otras.
Versión 2.2 61 de 285
10.7 Asociación
Es generalmente, una relación estructural entre clases o la conexión 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
Versión 2.2 62 de 285
10.9 Herencia
La reutilización 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 código
existentes en ellas).
Así, la reutilización 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.
Versión 2.2 63 de 285
Clase: Instrumento
Método: Tocar( )
SubClase: Cuerdas
Método: Tocar( )
Contiene generalidades de cómo
tocar los diversos instrumentos.
Incorpora la forma específica
de tocar instrumentos de cuerda.
Versión 2.2 64 de 285
10.10 Definiciones de herencia
La herencia es un concepto que tiene relación directa con la reutilización de código. El objetivo es usar lo ya
hecho y especializarlo. Veamos varias definiciones de herencia
1. Primero el maestro Rumbaugh.
James Rumbaugh es un científico de la computación y un metodologista de objeto. Es mejor
conocido por su trabajo en la creación de la Técnica de Modelado de Objetos y el Lenguaje
Unificado de Modelado (UML). Doctorado en ciencias de la computación por el M.I.T.
Rumbaugh dirigió el desarrollo de la OMT, en el Centro de Investigación y Desarrollo de la
General Electric, donde trabajó durante más de 25 años.
Se unió a Rational Software en 1994, y trabajó allí con Ivar Jacobson y Grady Booch ("los
Tres Amigos") para desarrollar UML. Más tarde fusionaron sus metodologías de desarrollo de
software, OMT, OOSE y Booch en el Proceso Unificado Racional (RUP). En el 2003 se trasladó a
IBM, después de su adquisición de Rational Software. Se retiró en 2006.
Ha escrito varios libros sobre UML y RUP, junto a Ivar Jacobson y Grady Booch.
Versión 2.2 65 de 285
Ejemplos de utilización de herencia
2. Según Wikipedia
Es una propiedad que permite que los objetos sean creados a partir de otros ya existentes,
obteniendo características (métodos y atributos) similares a los ya existentes.
• Es la relación entre una clase general y otra clase más especifica.
• Es un mecanismo que nos permite crear clases derivadas a partir de clase base, nos permite
compartir automáticamente métodos y datos entre clases subclases y objetos.
• Por ejemplo: Si declaramos una clase párrafo derivada de una clase texto, todos los métodos y
variables asociadas con la clase texto, son automáticamente heredados por la subclase párrafo.
• La herencia es uno de los mecanismos de la programación 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 más generales e ir derivando hacia las más
particulares, creando categorías, de la misma forma en que piensa el ser humano.
3. Según Microsoft
La herencia, junto con la encapsulación y el polimorfismo, es una de las tres características
principales (o "pilares") de la programación 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 ilustración siguiente se muestra una clase WorkItem que representa un elemento de
trabajo en algún proceso de negocio. Como todas las clases, deriva de Object y hereda todos sus
métodos. 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 más a los miembros
que hereda de WorkItem y Object. Debe agregar su propio constructor y también agrega un
miembro que permitirá asociar ChangeRequest al elemento WorkItem original al que se aplica el
cambio.
Versión 2.2 66 de 285
4. Según 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 características”
En este ejemplo:
• La clase “Manager” va a sobre escribir el método increaseSalary()
• La clase Engineer va a usar los métodos de la clase Employee
Versión 2.2 67 de 285
10.11 Relación “es-un”·y “tiene-un”
10.12 Subclases
Las relaciones de herencia forman estructuras jerárquicas similares a árbol. Una superclase existe en una
relación jerárquica con sus subclases:
Ejemplo:
• Una comunidad universitaria típica 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.
Versión 2.2 68 de 285
Ejemplo:
• Un auto es un tipo especial de vehículo
• Lo datos que definen su estado incluyen a los necesarios para el vehículo genérico y algunos más.
• Tiene un método particular para moverse hacia un destino y un método exclusivo de cambiar una
rueda.
• Un helicóptero también es un vehículo y tiene otro método distinto de moverse hacia un destino.
• Un Ferrari TestaRossa es un tipo concreto de auto que tiene una forma particular de sustituir un
fusible.
Versión 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 métodos
• Las subclases heredan el estado y el comportamiento en forma de las variables y los métodos de su
superclase.
• La subclase puede utilizar los ítems heredados de su superclase tal y como son, o puede
modificarlos o sobrescribirlos.
• Por eso, según se va bajando por el árbol de la herencia, las clases se convierten en más y más
especializadas.
Los métodos private se puede sobrescribir
Versión 2.2 70 de 285
Los métodos protected NO se pueden sobrescribir private
Los métodos public NO se pueden sobrescribir protected o private
11.5 Object
• En java todas las clases deben derivar de alguna otra.
• La clase más alta, la clase de la que todas las demás descienden, es la clase Object, definida en
java.lang.
• Object es la raíz de la herencia de todas las clases.
Versión 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 método oculta una de las variables miembros de una superclase, entonces se puede
acceder desde una subclase mediante super.
• Si un método sobrescribe un método de una superclase, entonces se puede acceder a este
último mediante super desde una subclase.
• Se puede incluir una llamada explícita al constructor de la superclase (mediante la referencia super)
como primer enunciado del constructor de la subclase.
• Si no se llama implícitamente a un constructor de la superclase, entonces, el constructor de la
subclase llamará implícitamente al constructor por omisión de la superclase (constructor sin
argumentos).
Versión 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.
Versión 2.2 73 de 285
11.7 Ejemplo 1
• Calcular la media aritmética y desviación estándar enviando los datos en un arreglo de largo 6
desde el método 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
método 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);
}
}
Versión 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:
Versión 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
métodos
Versión 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() {
}
//Método para recibir los datos indicados
public Jugador(String nombre, int numero, int goles) {
setNombre(nombre);
setNumero(numero);
setGoles(goles);
}
//Método 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() {
}
//Método 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; }
//Método propio de todos los atacantes
@Override
public int valoracion(){
int val=0;
val = super.valoracion() + getPases()*2 + getRecuperados()*3;
return val;
}
}
Versión 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() {
}
//Método 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; }
//Método 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() {
}
//Método 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; }
//Método propio de todos los porteros
@Override
public int valoracion(){
int val=0;
val = super.valoracion() + getParadas()*5;
return val;
}
}
Versión 2.2 78 de 285
11.9 Métodos final
• Son métodos que implementan un bloqueo para evitar que cualquiera clase heredada sobrescriba el
método.
• Así, se asegura que se mantenga el comportamiento durante la herencia, evitando que sea
sobrescrito.
• Cualquier método private o static de una clase es implícitamente 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 métodos de una clase final son automáticamente final.
Versión 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 método 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 círculo es:
Volumen del cilindro es:
Versión 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 método abstracto es aquel que está sólo declarado, pero que sus subclases implementen de
acuerdo al uso que se quiera dar.
◦ Por ejemplo, si en la clase A se define el método abstracto sueldo, entonces las subclases de A
darán su propia implementación al método sueldo:
▪ Pago por horas.
▪ Pago por monto fijo.
• Una clase abstracta no necesita contener un método abstracto.
• Una clase abstracta puede contener métodos abstracto y no abstractos. Así, se puede dejar parte
de la implementación 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 implementación a todos los
métodos abstractos, o sino, la clase B debe ser definida como abstracta.
• La clase B proporcionará su propia implementación al método Contablizar().
• La clase C proporcionará su propia implementación al método Contablizar().
Versión 2.2 81 de 285
También se puede dar
Ejemplo:
• En una aplicación de dibujo orientada a objetos, se pueden dibujar círculos, rectángulos, líneas, etc.
• Cada uno de esos objetos gráficos comparten ciertos estados (posición, 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 gráficos también tienen diferencias substanciales: dibujar un círculo es
bastante diferente a dibujar un rectángulo. Los objetos gráficos no pueden compartir estos tipos de
estados o comportamientos.
Otra característica relevante es que una clase que hereda desde ObjtoGrafico está obligada a dar
implementación al método dibujar(). Por ende, a priori, de esta clase no debería heredar la clase Trabajador.
Versión 2.2 82 de 285
12.4 Ejemplo 1
Este es un típico 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 (métodos) que especifica cierto aspecto de
funcionalidad. Es un conjunto de operaciones que una clase (la interfaz) presenta a otras.
Versión 2.2 83 de 285
Trabaja
Fijo Horas
• Una interfaz puede también 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 gráficamente igual que una clase.
• Una interfaz en Java es una clase en la que todos sus métodos son abstractos. En ellas se
especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas
interfaces las que implementen el comportamiento de los métodos.
• La palabra en inglés es: interface y la traducción al español es interfaz, o en plural interfaces.
• El uso de interfaces proporciona la siguiente ventaja:
◦ Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros).
Versión 2.2 84 de 285
Versión 2.2 85 de 285
Versión 2.2 86 de 285
12.6 Polimorfismo
Versión 2.2 87 de 285
Versión 2.2 88 de 285
Versión 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 método
procede a calcular según se indica:
• Libros: Costo de $200 por día.
• Películas: Todas con un costo fijo de $500. Sin embargo, los Estrenos tiene un costo adicional de
$1.000 por día y el resto un costo adicional de $100 por día.
package owt;
//Clase que define el Arriendo recibiendo como datos los días 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 {
//Método que usaremos para el proceso requerido
abstract protected int aCobrar(Alquiler a);
}
package owt;
//Define el arriendo de Libros implementado el método 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 Películas implementado el método 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){
Versión 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 días de arriendo del tipo de película 2
Alquiler o1 = new Alquiler(3);
Pelicula p1 = new Pelicula(2);
System.out.println("Arriendo pelicula no estreno: " + p1.aCobrar(o1));
//4 días de arriendo del tipo de película 1
Alquiler o2 = new Alquiler(4);
Pelicula p2 = new Pelicula(1);
System.out.println("Arriendo pelicula estreno: " + p2.aCobrar(o2));
//10 días de arriendo de un libro
Alquiler o3 = new Alquiler(10);
Libros p3 = new Libros();
System.out.println("Arriendo libro: " + p3.aCobrar(o3));
}
}
Versión 2.2 91 de 285
13 Clase
13.1 Objetivos
Desarrollar la evaluación 3. . Valor 12.5% de la nota 2.
13.2 Conocimiento previo
Contenidos de las clases 11, 12 y 13.
13.3 Modelos de evaluación 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 matrícula y su
eslora en metros.
Un alquiler se calcula multiplicando el número de días de ocupación (incluyendo los días inicial y
final) por un módulo función de cada barco obtenido “multiplicando por 10 los metros de eslora por un valor
fijo de $200”. Sin embargo, ahora se pretende diferenciar la información de algunos tipos de barcos:
• El número de mástiles para veleros, con un valor fijo de $20.000 por mástil.
• La potencia en caballos de fuerza para embarcaciones deportivas a motor. Por cada 10 caballos de
fuerza o fracción de este un valor fijo de $2.000
• La potencia en caballos de fuerza más el número 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, diseñe el diagrama de clases y sus relaciones, con detalle de
atributos y métodos necesarios.
Solución
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;
}
Versión 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;
Versión 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;
}
Versión 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;
}
}
Versión 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:
Versión 2.2 96 de 285
Ejercicio 3
La empresa “abc” está dedicada por años a la producción y exportación de frutas. Cada una de sus ventas
las maneja con un porcentaje de descuento estándar por volúmenes de ventas; más específicamente, 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 República Popular China en la 1ra temporada, 3% si las ventas son
desarrolladas a la República 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 trámites de exportación 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) Diseñe un programa java para la programación de cada una de las clases diseñadas en el diagrama
de clases.
(c) Enviar la siguiente información 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 diseñar un modelo para describir la herencia de vehículos (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 método que se especializa que provoca la herencia entre esas clases.
Versión 2.2 97 de 285
14 Clase
14.1 Objetivos
Usar y definir excepciones.
14.2 Conocimiento previo
Programación en java.
14.3 Manejo de excepciones
Existe una regla de oro en el mundo de la programación: en los programas ocurren errores.
Versión 2.2 98 de 285
Esto es sabido; pero:
• ¿Qué sucede realmente después de que ha ocurrido el error?
• ¿Cómo se maneja el error?
• ¿Quién lo maneja?
• ¿Puede recuperarlo el programa?
El lenguaje Java utiliza excepciones para proporcionar capacidades de manejo de errores.
Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de
las sentencias. Muchas clases de errores pueden utilizar excepciones, desde:
• Serios problemas de hardware, como la avería de un disco duro
• A los simples errores de programación, como tratar de acceder a un elemento de un Array fuera de
sus límites.
14.4 Lanzar una excepción
Cuando un error ocurre dentro de un método Java, el método crea un objeto “exception” y lo maneja fuera,
en el sistema de ejecución. Este objeto contiene información sobre la excepción, incluyendo su tipo y el
estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún
código para manejar el error.
En terminología java, crear una objeto exception y manejarlo por el sistema de ejecución se llama
lanzar una excepción.
14.5 Captura una excepción
Después de que un método lance una excepción, el sistema de ejecución entra en acción para buscar el
manejador de la excepción.
Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es el
mismo que el de la excepción manejada por el manejador. Así la excepción sube sobre la pila de llamadas
hasta que encuentra el manejador apropiado y una de las llamadas a métodos maneja la excepción, se dice
que el manejador de excepción elegido captura la excepción.
Si el sistema de ejecución busca exhaustivamente por todos los métodos de la pila de llamadas sin
encontrar el manejador de excepción adecuado, el sistema de ejecución finaliza (y consecuentemente el
programa Java también).
Versión 2.2 99 de 285
El código dentro del try { } es el que se va a controlar:
g.drawString( Saludos[i],25,25 );
• Al producirse un error en este código, el manejador de excepciones buscará en el primer bloque
catch, una excepción 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
excepción del tipo “Exception” que es gatillado independiente del error que ocurra.
• Por último, independiente que hallan o no errores, el código contenido en el bloque finally se
ejecutará.
14.6 Exception - Throwable
Versión 2.2 100 de 285
Las excepciones en tiempo de ejecución son heredadas desde la clase RuntimeException, las cuales son
capturadas en tiempo de ejecución y no de compilación. Algunas excepciones en tiempo de ejecución 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 todavía no ha sido
creado.
• ClassCastException: Mutación 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 excepción aritmética a ocurrido. Por ejemplo, cero
elevado a infinito.
• IOException: Cubre las excepciones ocurridas al ejecutar una operación 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 definición del String que define una consulta SQL.
Constructores de Exception:
• Exception()
• Exception(String message): Construye una nueva excepción con el detalle especificado en el
mensaje .
• Exception(String message, Throwable cause): Construye una nueva excepción con el mensaje
de detalle especificado y la causa
• Exception(Throwable cause)
Métodos de Exception:
• No tiene métodos asociados
Versión 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)
Métodos 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 estándar
• Otros.
14.7 Error
• ThreadDeath: Se produce cuando, por ejemplo, un hilo ejecutándose es deliberadamente detenido
y el hilo no captura esta excepción
• 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 catastróficos 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
excepción dentro de un bloque try.
• Los bloques catch: Después se debe asociar un manejador de excepciones con un bloque try
proporcionándole uno o más bloques catch directamente después del bloque try.
• El bloque finally se ejecutará independiente si el bloque try lanzó o no una excepción en cualquiera
de los bloques catch. También se ejecutará si se sale de try mediante return, break o continue.
• Sin embargo, si se lanza una excepción para la que no se encuentra un catch asociado, entonces
cuando el control pase al bloque finally éste también podría lanzar una excepción, en cuyo caso se
perderá la primera excepción.
Versión 2.2 102 de 285
Error
ThreadDeath LinkageError VirtualMachineError
Versión 2.2 103 de 285
int valor;
try {
for( x=0, valor = 100; x < 100; x ++ )
valor /= x;
}
catch( ArithmeticException e ) {
System.out.println( "Matemáticas locas!" );
}
catch( Exception e ) {
System.out.println( "Se ha producido un error" );
}
14.9 throw
La sentencia throw se utiliza para lanzar explícitamente una excepción de tipo Throwable, bien mediante
un parámetro en una cláusula 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 excepción.
Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se puede
cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a través de un método.
Normalmente, el texto del mensaje proporcionará información para resolver el problema o sugerirá una
acción 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 más información usando el método printStackTrace()
package dat;
public class SinGasolina extends Exception{
//Llama al constructor exception(String mesage) de la clase Exception
SinGasolina( String s ) {
super( s );
}
}
Versión 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 método puede lanzar. Las excepciones que un método lanza explícitamente o
que son lanzadas por métodos invocados por este, deben ser listadas en throws. Para que un método en
Java, pueda lanzar excepciones, hay que indicarlo expresamente.
void metodoAsesino() throws NullPointerException, CaidaException
14.11 Ejemplos
Versión 2.2 105 de 285
Versión 2.2 106 de 285
Compila
OK
NO
Ejecuta
NO
Ejecuta
Versión 2.2 107 de 285
Versión 2.2 108 de 285
Indicar que se va a imprimir:
Versión 2.2 109 de 285
Va a imprimir:
Versión 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
Versión 2.2 111 de 285
Para el caso anterior el Netbeans muestra:
Versión 2.2 112 de 285
Versión 2.2 113 de 285
Para el caso anterior el Netbeans muestra
Versión 2.2 114 de 285
Versión 2.2 115 de 285
14.12 Ejercicios
1. Crear una aplicación ja va que sea capaz de ejecutar los siguientes procesos:
CLASE Venta
(a) Crear un método constructor que sea capaz de recibir el código de un producto
(String) y la cantidad vendida (int).
(b) Crear un método sin parámetros 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 método sin parámetros que sea capaz de calcular el total a pagar.
CLASE Producto
(a) Crear un método que reciba como parámetro una variable String que representa el
código de un producto. Se debe validar que esté compuesto de sólo números de largo
6 exactamente. Para informar códigos incorrectos se debe crear una excepction.
(b) La información de los productos válidos está almacenada en un arreglo
bidimensional de tipo String con los siguientes datos:
Código Precio
125468 100.000
325697 200.000
326598 500.000
326548 1.000.000
CLASE Ver
(a) Desde el método main se debe enviar datos a la clase Venta con un código 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 aplicación 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 método que reciba un parámetro una variable de tipo String y
que almacene el valor del parámetro en el archivo plano.
(b) Además, se debe crear un método que reciba como parámetro una variable de tipo String
y que busque el valor en cada una de las líneas del archivo plano e informe la cantidad
de veces que el valor se encuentra en el archivo.
3. Crear una aplicación 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 código en dónde se gatillen las excepciones:
(a) FontFormatException
(b) IllegalAccessException
(c) IOException
(d) NotBoundException
(e)
Versión 2.2 116 de 285
Versión 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 orientación a objetos y encapsulación de datos.
15.3 Colecciones
Java tiene desde la versión 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 incorporación), se podría tener:
Juan Pérez Pérez 34 01/03/10
Carla Saldivia Herrera 23 15/03/10
Carola Faúndez Fica 19 10/03/10
Anita Suazo González 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 aplicación del tamaño de este.
De esta forma, las colecciones no requieren de un tamaño inicial y una vez que el tamaño asignado
por java el sobrepasado (o hay indicios de que el espacio almacenado no será suficiente) entonces java
desarrolla el proceso de ampliación del tamaño.
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;
}

Versión 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 sólo un tipo de datos que debe ser un objeto. Por ende, si se
requiere almacenar más de un tipo de datos, estos deben encapsularse para luego ser
almacenados como objetos de la clase que maneja la encapsulación.
• Los datos son mantenidos con el nombre del objeto de la colección. Por lo tanto, si me solicitan los
datos lo que hacemos es devolver el nombre del objeto de la colección. 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.
Versión 2.2 119 de 285
15.5 Collection
Interfaz que define los métodos básicos para el manejo de estructuras de datos. Es la interfaz raíz dentro
del manejo de colecciones.
15.6 List
La interfaz List considera métodos adicionales a la interfaz Collection, añadiendo el manejo de índices.
Además, se trabaja con la lista ordenada (permitiendo valores duplicados) o con parte de la lista.
Versión 2.2 120 de 285
15.7 ArrayList
Clase que implementa los métodos de la interfaz List. No tiene ningún método sincronizado (excepto set y
get). Por lo tanto, acepta el acceso concurrente a los métodos. De esta manera, desde diversos hilos se
puede acceder a los métodos.
El ArrayList asume la estructura de lista simple enlazada. De esta manera es eficiente en la
búsqueda de información pero deficiente en la inserción 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());
}
}
}
Versión 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 Pérez Pérez",34,"01/03/10"));
o.setDat(new Estudiante("Carla Saldivia Herrera",23,"15/03/10"));
o.setDat(new Estudiante("Carola Faúndez Fica",19,"10/03/10"));
o.setDat(new Estudiante("Anita Suazo González",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("Incorporación: " + e.getincorpora()); //Muestra incorporación
System.out.println();
}
}
}
15.8 Set
No incorpora ningún método nuevo. Por sobre lo que es una collection, un set agrega una sola restricción:
Al ingresar datos con la misma variable asume un sólo 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 colección en la
que no importe el orden, pero que necesitemos preguntar si un elemento está o no.
Versión 2.2 122 de 285
15.9 HashSet
Implementa los métodos de la interfaz Set. Usa una tabla de hash. Los elementos no se encuentran
ordenados y pueden variar su posición de acuerdo al proceso de balanceo de la estructura que desarrolle la
tabla de hash. Óptima para cantidades pequeñas de datos.
La clase HashSet aprovecha la segunda de las funciones. A cada objeto que se añade a la
colección se le pide que calcule su “hash”. Este valor será un número entre -2147483647 y 2147483648.
Basado en ese valor se lo guarda en una tabla. Más tarde, cuando se pregunta con contains() si un objeto x
ya está, habrá que saber si está en esa tabla. ¿En qué posición de la tabla está? HashSet puede saberlo, ya
que para un objeto determinado, el hash siempre va a tener el mismo valor. Entonces la función contains de
HashSet saca el hash del objeto que le pasan y va con eso a la tabla. En la posición 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); }
}
Versión 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 modificación el código 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();
}
}
}
Versión 2.2 124 de 285
Observar que el orden no necesariamente es el mismo para los mismos datos.
15.10 TreeSet
Implementa los métodos de la interfaz Set. Los elementos se encuentran ordenados ascendentemente.
Inserta los elementos efectuando comparaciones con el método comparateTo() de la interfaz Comparator, lo
cual puede diferir de equals.
TreeSet usa una técnica 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 computación de tener un
conjunto de cosas todo el tiempo en orden, y permitir que se agreguen más cosas y que el orden se
mantenga. Al tener todo en orden TreeSet puede fácilmente 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 implementación al método comparateTo que tiene el
código 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.
Versión 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();
}
Versión 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();
}
}
}
Versión 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 orientación a objetos y encapsulación de datos.
16.3 Map
Declara métodos que permiten manejar elementos como para clave valor sin permitir claves duplicadas.
Versión 2.2 128 de 285
MÉTODO
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 más 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
método 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 número de elementos de la lista
Collection values()
Retorna los valores de la lista (no las claves). Con
este método no se obtiene la lista por elemento
sino que completa

16.4 HashMap
Implementa los métodos 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 encapsulación de información.
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);
}
}
Versión 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();
}

}
}
Versión 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();
}

}
}
Versión 2.2 131 de 285
16.5 TreeMap
Implementa los métodos 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 relación 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);
}
}
Versión 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();
}
}
}
Versión 2.2 133 de 285
16.6 Vector
La clase Vector de la versión 1.1 de Java es equivalente a esta clase ArrayList para la versión 1.2 de java.
La diferencia es que la clase Vector es Thread-Safe, lo que implica que todos sus métodos están
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();
Versión 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 número de elementos que puede tener el vector
int size()
Devuelve la cantidad de elemento presente
void addElement(Object obj)
Añade 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 tamaño
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 posición

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 números aleatorios enteros entre 1 y 100 y
almacenarlos en 4 ArrayList según 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 método 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 más.
• Crear un método que muestre cual de los ArrayList contiene la mayor cantidad de datos.
• Crear un método que sea capaz de recibir 3 parámetros:
◦ El nombre de un ArrayList
◦ Un valor entero de búsqueda
◦ Un valor entero de reemplazo.
Se pide que el método, si existe el ArrayList, cambie el valor de búsqueda por el de reemplazo (si
este existe).
• Crear un método que reciba un ArrayList y lo almacene en un TreeSet y muestre su información. El
método debe concatenar la información que llega en el TreeSet.
Versión 2.2 135 de 285
17 Clase
17.1 Objetivos
Desarrollar la evaluación 4. Valor 12.5% de la nota 2.
17.2 Conocimiento previo
Contenidos de las clases 16, 17 y 18
17.3 Modelos de evaluación 4
Ejercicio 1
Para cada uno de los códigos siguientes indicar la excepción 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());
Versión 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());
}
Versión 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
colección que los almacene ordenados ascendentemente.
• Crear un método para mostrar la información almacenada en la colección seleccionada.
• Crear un método que sea capaz de mostrar el mayor valor usando la colección seleccionada.
• Crear un método que sea capaz de mostrar el menor valor usando la colección seleccionada.
• Crear un método que recupere todos los valores entre 0.1 y 0.4 ambos valores incluidos y los
almacene en un ArrayList.
Solución:
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());
}
Versión 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 información de trabajadores de una empresa la cual debe
almacenar ordenada por rut el cual para cada trabajador en único. La información del trabajador es el rut y
el nombre con información 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 colección más apropiada para almacenar la información.
• Crear un método que reciba el rut y el nombre y lo almacena en la colección.
• Crear un método que reciba el rut y el nombre, busque el rut en la colección y reemplace en nombre
por el valor indicado. Si el rut no existe, entonces se debe emitir un mensaje de error.
• Crear un método 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");
Versión 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);
}
}
}
}
Versión 2.2 140 de 285
18 Clase
18.1 Objetivos
Uso de las colecciones genéricas.
18.2 Conocimiento previo
Manejo de colecciones no genéricas.
18.3 Colecciones Genéricas
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 ejecución que no se puede capturar el tiempo de compilación.
La versión 5.0 del JDK ofrece una mejor implementación de las colecciones como ArrayList. Por ejemplo, si
se necesita almacenar sólo información 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 compilación para la instrucción.
files.add(new File(". . ."));
Versión 2.2 141 de 285
18.4 Ejemplo de uso
Consideremos el siguiente código:
Compilación no presenta problemas:
Consideremos ahora el siguiente código:
Nuevamente la compilación no presenta problemas:
Versión 2.2 142 de 285
Consideremos ahora el siguiente código. Netbeans nos a marcado de inmediato el error en tiempo de
compilación.
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 iteración con una semántica bien definida.
• Método se han mejorado
18.6 Vector<>
La características particular es que los objetos están sincronizados. Para crear un objeto podemos emplear:
• El vector almacena objetos tipo String.
• El vector almacena inicialmente sólo 100 objetos tipo String. Si se llena se duplica automáticamente
la capacidad.
• Para indicarle que el aumento sea de 10 objetos podemos definir
Versión 2.2 143 de 285
Veamos como almacenar un arreglo en una colección genérica y luego desde la colección 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 (sólo 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 también 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
sincronización: Si varios hilos de acceder a un ArrayList ejemplo simultánea, y al menos uno de los
hilos modifica estructuralmente la lista, debe ser sincronizado externamente.
• Una aplicación puede aumentar la capacidad de un ArrayList directamente usando el método
ensureCapacity.
18.7.1 add
Permite asociar valores a un objeto de un ArrayList.
Versión 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);
}
}
Versión 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 construcción de un listado con información; en este caso, se deben limpiar los
datos referenciados por el objeto ArrayList cada vez que se requiere ver nueva información.
18.7.3 contains remove
La combinación es usada para verificar si un valor existe y luego eliminarlo. Para este caso se debe dar
implementación al método toComparate() en la clase que encapsula la información.
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); }
Versión 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 verificación 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();
}
}
}
Versión 2.2 147 de 285
Considerar este caso en el cual hay dos valores en la lista de los que se necesitan eliminar. Así, sólo 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 posición de la primera ocurrencia y el segundo busca la última posición de la ocurrencia.
package bean;
import java.util.ArrayList;
public final class Trabajador implements Comparable{
//El mismo código de la clase anterior
….
}
Versión 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 aparición: "+t.getDatos().indexOf(new Trabajador("Maria",22)));
System.out.println("Ultima aparición: "+t.getDatos().lastIndexOf(new Trabajador("Maria",22)));
}
}
18.7.7 get
Busca valores dentro de una lista según el índice que se indique.
package bean;
import java.util.ArrayList;
public final class Trabajador{
//El mismo código 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();
}
}
}
Versión 2.2 149 de 285
18.7.8 set
Reemplaza un valor en una posición.
package bean;
import java.util.ArrayList;
public final class Trabajador{
//El mismo código 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 sólo método y se usa para recorrer datos asiendo uso de Iterator<>.
Versión 2.2 150 de 285
18.9 Collection
Es una interfaz que hereda desde la interfaz Iterable<>.
Versión 2.2 151 de 285
18.10 Set<>
Es una interfaz con las siguientes propiedades:
• No mantiene el orden de inserción.
• No admite elementos duplicados.
• Si se añade un objeto al conjunto y hay otro igual no se produce ningún cambio.
18.11 List<>
Es una interfaz con las siguientes propiedades:
• Colección que sí mantiene el orden de inserción y que puede contener elementos duplicados
• Acceso por posición
• No está permitido
• Pero si está permitido
• También 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
Versión 2.2 152 de 285
18.12 Map<,>
Es una interfaz que no permite claves duplicadas.
18.13 Implementación
Versión 2.2 153 de 285
19 Clase
19.1 Objetivos
Uso de base de datos con Java.
19.2 Conocimiento previo
Uso de colecciones genéricas
19.3 SQL
En un lenguaje de programación creado para ejecutar consultas a base de datos.
19.3.1 Tabla
Estructura física que define la forma mediante la cual se almacenarán los datos. Por ejemplo, si
necesitamos almacenar los datos de los trabajadores de una compañía tenemos:
• Rut
• Nombre
• Edad
• Estatura
• Fecha de ingreso
• Sexo
Los tipos de estos datos guardan relación con la función 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/
Versión 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.
Versión 2.2 155 de 285
Paso 2: Aceptar y seleccionar Next.
Paso 3: Seleccionar Complete:
Versión 2.2 156 de 285
Paso 4: Seleccionar Install
Paso 5: Seleccionar Next
Versión 2.2 157 de 285
Paso 6: Seleccionar Next
Paso 7: Seleccionar Finish
Versión 2.2 158 de 285
Paso 8: Seleccionar Next.
Paso 9: Seleccionar Standard Configuration y luego Next.
Versión 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”.
Versión 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 podría 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
)
Versión 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.
Versión 2.2 162 de 285
Luego se debe ingresar en el contexto de la base de datos dgac. Para eso usar la instrucción use dgac.
Luego hacer copiar y pegar con el script de creación de la tabla.
19.3.5 insert
Usar la siguiente instrucción 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);
Versión 2.2 163 de 285
Esta instrucción tiene por obligación “insert into”, luego entre paréntesis los campos a los cuales se le
necesita ingresar datos, enseguida la palabra “values” para finalizar entre paréntesis con los datos
asociados en una relación 1-1 con el nombre de los campos.
19.3.6 update
Esta instrucción da la posibilidad de cambiar datos en uno o más registros. Por ejemplo, cambiar la edad del
rut=14.200.000 a 50 años.
update trabajador
set edad=50
where rut='14200000';
19.3.7 delete
Esta instrucción da la posibilidad de eliminar uno o más 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 años.
select * from trabajador where edad < 32;
Caso 3: Ver todos los registros con edad entre 30 y 40 años ambos valores incluidos.
select * from trabajador where edad between 30 and 40;
Versión 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 años ambos valores incluidos.
select nombre, edad from trabajador where edad between 30 and 40;
19.4 JDBC
Java Database Connectivity, más conocida por sus siglas JDBC, es una API que permite la ejecución de
operaciones sobre bases de datos desde el lenguaje de programación 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 colección de interfaces Java y métodos de gestión de
manejadores de conexión hacia cada modelo específico 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 métodos 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 conexión apropiada al modelo de su base de datos, y accede a ella estableciendo una
conexión, para ello provee el localizador a la base de datos y los parámetros de conexión específicos. A
partir de allí puede realizar con cualquier tipo de tareas con la base de datos a las que tenga permiso:
consulta, actualización, creación, modificación y borrado de tablas, ejecución de procedimientos
almacenados en la base de datos, etc.
La especificación se encuentra en:
http://java.sun.com/javase/6/docs/technotes/guides/jdbc/
Versión 2.2 165 de 285
19.5 ¿Qué hace la API de JDBC?
En términos simples, una tecnología basada en JDBC driver (controlador JDBC ") permite hacer tres cosas:
1. Establecer una conexión con una fuente de datos
2. Enviar consultas y actualizar las declaraciones a la fuente de datos
3. Proceso de los resultados
19.6 Conexión de Información general
Un objeto Connection representa una conexión con una base de datos. Una sesión de conexión incluye las
instrucciones SQL que se ejecutan y los resultados que se devuelven en la conexión. Una sola aplicación
puede tener una o más conexiones con una sola base de datos, o puede tener conexiones con muchas
bases de datos diferentes.
19.7 Establecer una conexión
La forma tradicional de establecer una conexión con una base de datos es llamar a la
DriverManager.getConnection método. Este método toma una cadena que contiene una dirección URL. La
clase DriverManager conocida como la capa de gestión 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 método 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 método
de Driver connect utiliza esta URL para realmente establecer la conexión.
El código siguiente es un ejemplo de la apertura de una conexión a una base de datos ubicada en la
“jdbc:odbc:wombat” con un ID de usuario de “oboy” y “12Java” como la contraseña:
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 conexión. Cuando una clase DataSource se ha aplicado adecuadamente, el objeto DataSource se
puede utilizar para producir objetos Connection que participan en la agrupación de conexiones y / o objetos
Connection que pueden participar en transacciones distribuidas. DataSource es la alternativa preferida para
la creación de una conexión.
Una aplicación utiliza un objeto Connection producido por DataSource de manera esencialmente es
la misma que utiliza un objeto Connection producido por el DriverManager.
19.8 Liberación DBMS Recursos
Se recomienda que los programadores de cerrar explícitamente las conexiones y las declaraciones que han
creado cuando ya no son necesarios.
Un programador de escribir código en el lenguaje de programación Java y que no utilice ninguna de
recursos externos, no necesita preocuparse por la gestión de memoria. El recolector de basura elimina
automáticamente 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 reutilización rápida.
Sin embargo, si una aplicación 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 explícitamente cerrar todas las
conexiones (con el método Connection.close y declaraciones con el método Statement.close) tan pronto
como ya no son necesarios.
Versión 2.2 166 de 285
19.9 Crear una conexión
Para esto se va a crear una clase que proporciones el servicio y en la cual se puedan configurar “en duro”
sus parámetros.
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 ubicación de la base de datos
return url;
}
public static String getUser() { //Retorna el usuario de conexión a la base de datos
return user;
}
public static String getPass() { //Retorna el password del usuario de conexión 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:
Versión 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 información se usa el comando “select”
Crear un proyecto:
Versión 2.2 168 de 285
Crear la clase ConexionDB en la package conec:
El código asociado a la clase es el anterior.
Versión 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 conexión
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 inserción
st.executeUpdate(SQL);
st.close();
con.close();
} catch (SQLException ex) { }
}
}
Versión 2.2 170 de 285
19.11 Driver de Conexión
Para ejecutar el código correctamente es necesario instalar el Driver de conexión 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:
Versión 2.2 171 de 285
Se tiene:
Después de ejecutar el proceso se tiene:
Versión 2.2 172 de 285
20 Clase
20.1 Objetivos
Uso de componentes básicos de Swings, validaciones y mensajes de cuadros de diálogos.
20.2 Conocimiento previo
Uso de métodos y colecciones.
20.3 JTextField
Permite el ingreso de datos en un formulario. Las propiedades más usadas son:
• getText(): Permite conocer el valor seleccionado.
• setText(String a): Permite asignar el valor “a”.
Asociar el siguiente código al botón, 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);
}
Versión 2.2 173 de 285
20.4 toolTipText
Permite emitir un mensaje al posición 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 símbolos que definen un conjunto de cadenas
(caracteres literales y símbolos especiales). Son útiles para validar la entrada y asegurar que los datos
estén en un formato específico. Por ejemplo
• Un código postal debe coincidir de 5 dígitos
• Un apellido debe comenzar con mayúscula
• Un número telefónico debe tener solo números
El método matches recibe una cadena que especifica la expresión regular, y compara el contenido de un
objeto String. Devuelve un valor Boolean indicando si hubo concordancia o no.
Las expresiones son:
• Cualquier dígito: un carácter numérico.
• Cualquier carácter de palabra: un carácter alfanumérico o guión bajo.
• Cualquier carácter de espacio en blanco: es un espacio, tabulador, retorno de carro o nueva línea.
Versión 2.2 174 de 285
[abc] a, b, o c
[^abc] Cualquier carácter excepto a, b, o c (negación)
[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] (unión)
[a-z&&[def]] La d, la e, o la f (intersección)
[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 número: [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 más 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
Sólo será valido el ingreso de 5 letras a minúsculas 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");
}
}
Versión 2.2 175 de 285
Comprobar que el ingreso sea de sólo números.
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 sólo números 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");
}
}
Versión 2.2 176 de 285
Validar que una entrada sólo sean sólo 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");
}
}
Versión 2.2 177 de 285
Usando el patrón ( “[A-Z][a-zA-Z]*”) en este caso le estamos diciendo que la entrada para ser valida debe
tener el primer carácter en mayúscula [A-Z] y que los siguientes caracteres pueden ser cualquier carácter
tanto minúscula como mayúscula [a-zA-Z] con el asterisco final le estamos diciendo que los siguientes
caracteres van a ser iguales a la expresión previamente indicada, ósea la expresión 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");
}
}
Versión 2.2 178 de 285
Validar que el ingreso sean exactamente 2 letras mayúsculas (menos la Ñ) y exactamente 2 números.
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");
}
}
Versión 2.2 179 de 285
20.6 JSlider
Permiten seleccionar una opción dentro de un aspecto continuo de valores. En Netbeans se maneja con el
componente:
Considerar la configuración
Se genera el siguiente componente:
Versión 2.2 180 de 285
Si se necesita que el componente se deslice sólo por los valores, entonces se debe anexar la propiedad
snapToTicks.
También se pueden generar secuencias con otros elementos como letras. Para esto se debe incluir el
siguiente método en el constructor del JFrame, lo cual define las letras y el valor numérico 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 iniciándose en B, para este caso.
Versión 2.2 181 de 285
Sus constructores son:
Considerar el siguiente formulario:
Para recuperar los valores:
Versión 2.2 182 de 285
20.7 JList
Un JList le presenta al usuario un grupo de ítems para elegir. Las propiedades más usadas son:
• getSelectedValue(): Recupera un valor de tipo Object.
• getSelectedValues(): Recupera más de un valor de tipo Object[].
• getSelectedIndex(): Recupera la posición del valor recuperado.
• getSelectedIndices(): Recupera la posición 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 números al componente.
DefaultListModel modelo = new DefaultListModel();
for(int i = 1; i<=10; i++){
modelo.addElement(i);
}
jList1.setModel(modelo);
Versión 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 más de un elemento. Para seleccionar sólo uno se debe activar la
opción a “SINGLE”:
Se van a recuperar el o los valores. Para esto incluir un JButton y un JTable. El código de ejecución del
botón 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;
}
}
Versión 2.2 184 de 285
Con la siguiente propiedad se puede controlar como nuestros elementos aparecen en la lista.
Con la siguiente opción se obtiene:
Ejemplo: Se va a considerar una aplicación en donde se requiere transferir valores desde un JList a otros
en donde en el segundo JList los datos deben salir ordenados.
Versión 2.2 185 de 285
El código para incluir los valores en el método 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 botón >>
//También almacena los datos ordenados para mostrarlos así
TreeSet<Object> datosTreeSet = new TreeSet<Object>();

El código del botón >> 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 código del botón << 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);
}
Versión 2.2 186 de 285
Ejemplo: Crear un JList que al seleccionar un color de su lista cambie automáticamente el color del objeto
de la lista seleccionado. Para desarrollar esto se va a recurrir a la siguiente propiedad del JList
El código 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 método 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);
}
Versión 2.2 187 de 285
20.8 Cuadro de diálogo
La clase JOptionPane tiene cuatro métodos para mostrar cuadro de diálogo:
• showMessageDialog: Muestra un mensaje y espera a que le usuario pulse OK.
• showConfirmDialog: Muestra un mensaje y obtiene confirmación (SI/NO).
• showOptionDialog: Muestra un mensaje y obtiene una opción de una serie de opciones.
• showInputDialog: Muestra un mensaje y obtiene una línea de entrada del usuario.
Un cuadro de diálogo tiene los siguientes componentes:
• Un icono
• Un mensaje
• Uno o más 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 código:
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);
Versión 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
Versión 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. También
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 diálogo y del tipo de opción.
• 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.
Versión 2.2 190 de 285
Vamos a ver un ejemplo que solicita información 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 = "Números iguales";
}
if (numero1 < numero2) {
resultado = "Primer número menor que el segundo";
}
if (numero1 > numero2) {
resultado = "Primer número mayor que el segundo";
}
// Mostrar los resultados
JOptionPane.showMessageDialog(null,
resultado,
"Resultados de la comparación",
JOptionPane.INFORMATION_MESSAGE);
}
Versión 2.2 191 de 285
showConfirmDialog devuelven enteros indicando qué botón 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");
}
}
Versión 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 evaluación 5
Observaciones:
• Fecha de revisión: 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
Diseñar un formulario que sea capaz de solicitar información 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 básica, 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 código 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 código del cliente esté compuesto de una letra mayúscula, dos números y tres letras
minúsculas. Si no cumple esta condición el registro no se debe almacenar y se mostrará una ventana con el
error. (20 puntos)
Versión 2.2 193 de 285
22 Clase
22.1 Objetivos
Uso de componentes Swings.
22.2 Conocimiento previo
Uso de métodos y colecciones.
22.3 JFormattedTextField
No es más que una extensión de JTextField que viene a cubrir algunas de las deficiencias que todos
encontrábamos en él. Es un componente que cumple una doble función.
• Por una parte, permite que el usuario entre el texto que se corresponde con un dato solicitado por la
aplicación.
• Por otra, permite a la aplicación mostrar datos al usuario.
La principal limitación del JTextField es que permite entrar cualquier texto y que no hay manera fácil 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
números. El componente de Netbeans es:
Suponga que se necesita ingresar 7 números obligando a ingresar primero tres números, luego un guión y
por último 4 números. El formato debe ser: “###-####”. En Netbeans se debe configurar en la propiedad
Versión 2.2 194 de 285
El resultado es que sólo se pueden ingresar a los más tres números al inicio, luego el guión y por último los
más 4 números. Observar que sólo se pueden ingresar números.
Observar que este formato impide el ingreso de otro carácter que no sea un número. Los caracteres usados
son:
Ejemplos:
• Ingresar exactamente 2 letras y 2 números.
Observar que el componente impide el ingreso de más valores y distintos de los definidos.
Versión 2.2 195 de 285
• Permitir sólo 5 letras mayúsculas transformando las letras minúsculas a mayúsculas.
• Transformar números a cantidades separadas por miles usando un punto.
Al cambiar el foco se tiene:
Versión 2.2 196 de 285
22.4 PasswordField - Separator
El primer componete permite el ingreso de información, 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 línea de
separación.
Limpiar las dos cajas de texto para quedar cómo:
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;
}
Versión 2.2 197 de 285
22.5 JRadioButton
Sirve para manjar una elección desde varias opciones. Para manejar desde Netbeans usamos el
componente.
Además, se debe acompañar 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 gráfica del JPanel.
Versión 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 gráficamente, para
poder verlo se debe usar el Inspector.
Versión 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);
}
Versión 2.2 200 de 285
22.6 CheckBox
Este componente sirve para seleccionar una opción. Las propiedades más 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:
Versión 2.2 201 de 285
Anexar el JButton para conseguir:
Seleccionar los JCheckBox siguientes:
El código asociado el botón 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 = {"Selección:",this.jCheckBox1.getText()+" :"+pref1
,this.jCheckBox2.getText()+" :"+pref2
,this.jCheckBox3.getText()+" :"+pref3
,this.jCheckBox4.getText()+" :"+pref4};
JOptionPane.showMessageDialog(null,mensaje);
}
Versión 2.2 202 de 285
Un ejemplo de ejecución:
22.7 Spinner
Este componente sirve para seleccionar una opción desde una lista. Métodos: Los métodos asociados más
usados son:
• getValue(): Permite recuperar el valor seleccionado.
Seleccionar 3 JLabel, 3 JSpinner y un JButton.
Versión 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.
Versión 2.2 204 de 285
Seleccionar el tercer JSpinner, marcar su propiedad Model y proporcionar el siguiente formato.
El formato definitivo es:
Versión 2.2 205 de 285
Para dar una forma más atractiva a los componentes marcar cada uno de los JSpinner y su propiedad
“Border”.
El código 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();
Versión 2.2 206 de 285
val3 = this.jSpinner3.getValue();

Object[] mensaje = {"Selección:",this.jLabel1.getText()+" :"+val1
,this.jLabel2.getText()+" :"+val2
,this.jLabel3.getText()+" :"+val3};
JOptionPane.showMessageDialog(null,mensaje);
}
Versión 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 pestaña del
componente deseado. Para manejar desde Netbeans usamos el componente.
Para trabajar estos componentes vamos a hacer clic según se indica en el siguiente diagrama:
Resultado:
Versión 2.2 208 de 285
Para conseguir las pestañas se debe agregar JPanel al JTabbedPane
Resultado:
Versión 2.2 209 de 285
Agregar otro JPanel
Resultado
Versión 2.2 210 de 285
Se han agregado al final 4 pestañas
Para cambiar el nombre a las pestañas 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:
Versión 2.2 211 de 285
De la misma forma las pestañas siguientes marcarlas como Ingreso, Eliminación y Actualización con un
mensaje apropiado al posarse sobre ellas.
También se les puede agregar un icono a las pestañas en la opción:
Versión 2.2 212 de 285
Vamos a agregar elementos ahora en las pestañas para generar el mantenedor. Incluir un JTable.
Nuevamente se recomienda manejar los elementos en el “Inspector” del Netbeans.
Versión 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 conexión 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; }
}
Versión 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; }
}
Código asociado al botón 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);
}
}
Versión 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 método debe ser llamado desde el método constructor de JFrame que contiene al JTabbedPane
public Pruebas() {
initComponents();
this.jLabel3.setVisible(false);
actualizaTabla();
}
Versión 2.2 216 de 285
El resultado es:
Observar que si se ingresa un nuevo valor en la pestaña de “Ingreso” la pestaña “Ver” no se actualiza. Para
lograr la actualización se debe activar el siguiente método:
private void jTabbedPane1StateChanged(javax.swing.event.ChangeEvent evt) {
actualizaTabla();
}
Se ingresar un nuevo dato
Versión 2.2 217 de 285
Nos cambiamos de pestaña y está el registro ingresado:
Versión 2.2 218 de 285
23 Clase
23.1 Objetivos
Mostrar datos usando JTable.
23.2 Conocimiento previo
Conexión 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 presentación de datos tabulados es una de las tareas más
comunes que se presentan al momento de crear interfaces gráficas; 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 más complejo sea el requerimiento a cubrir, se requerirá en igual medida utilizar más
métodos o recursos de la clase.
Los constructores son:
Versión 2.2 219 de 285
Vamos a considerar en Netbeans la siguiente situación:
Para eliminar las columnas y filas usamos la propiedad “model”
Versión 2.2 220 de 285
Eliminando todas las filas se tiene:
El método para agregar en el constructor del formulario será:
private void initValores(){
String[] columnNames = {
"Nombre", "Apellido", "Pasatiempo", "Años 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);
}
Versión 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 solución será:
private void initValores(){
Vector<String> columnNames = new Vector<String>();
columnNames.add("Nombre");
columnNames.add("Apellido");
columnNames.add("Pasatiempo");
columnNames.add("Años 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 información dada la elección que se desarrolla en un ComboBox. Se
pretende esto:
Versión 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)
);
Versión 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 método que llena el ComboBox con los datos de departamento, implementado en el método 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+"'";
Versión 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{
}
}
Versión 2.2 225 de 285
El código 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");
Versión 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{
}
}
Versión 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 Evaluación 6
Observaciones:
• Fecha de revisión: 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
Diseñar un formulario que sea capaz de solicitar información 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 básica, media, universitaria, postgrado.
Proceso 1
En una pestaña crear una opción que permita ingresar datos. No se debe validar nada.
(20 puntos)
Proceso 2
En una pestaña se debe mostrar en un ComboBox los códigos de los clientes almacenados y al ingresar por
primera vez al lado del ComboBox se debe mostrar el nombre del cliente. Además, si en esta pestaña se
selecciona otro código del ComboBox, entonces se debe actualizar el nombre del cliente.
(10 puntos)
En esta pestaña se debe implementar un botón para eliminar el cliente almacenado.
(10 puntos)
Versión 2.2 228 de 285
Proceso 3
En una pestaña se debe mostrar en un ComboBox los códigos 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
gráficos de la pestaña de ingreso de clientes. Además, si en esta pestaña se selecciona otro código del
ComboBox, entonces se debe actualizar los datos del cliente.
(30 puntos)
En esta pestaña se debe implementar un botón 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 pestaña, entonces los datos
deben reflejar esos cambios.
(10 puntos)
24.4 Evaluación 7
Observaciones
1. El desarrollo debe ser en netbeans 6.9 y mysql 5.x.
2. La fecha de revisión 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');
Versión 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 diseñar 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 botón >> envía los destinos seleccionados desde JList de la izquierda a la derecha.
(10 puntos)
• El botón << envía los destinos seleccionados desde JList de la derecha a la izquierda.
(10 puntos)
• El botón “Almacenar Información” almacena los datos en la tabla “documentos_tratados”.
(30 puntos)
• El botón “Ver Información” muestra los datos en la tabla “documentos_tratados”. Para estos se debe
pedir el número del documento y mediante un botón se muestran los datos en un JTable.
(30 puntos)
Versión 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 orientación a objetos y encapsulación de datos.
25.3 JMenu
Seleccionar:
Va a generar:
Versión 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”
También se puede usar el menú contextual:
Versión 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:
Versión 2.2 233 de 285
Finalmente se tiene:
Crear un formulario llamado VerCliente
Para la opción ver se va a considerar:
El código para ejecutar el formulario desde el menú es:
Versión 2.2 234 de 285
Vamos a agregar un nueva opción de menú:
Vamos a agregar dos radiobuttom
Vamos a agregar un separador
Vamos a agregar tres checkbox
Versión 2.2 235 de 285
Se debe agrupar los radio buttom
Marcar ambos radiobuttom y agregar al agrupamiento
Se tiene:
Versión 2.2 236 de 285
25.4 JTree
Seleccionar:
Se tiene:
Versión 2.2 237 de 285
Al ejecutarlo se tiene:
Los componentes del árbol se manejan el la propiedad "model"
Versión 2.2 238 de 285
Generar la siguiente estructura. Considera que un espacio genera un opción dentro de otra.
Se obtiene:
Versión 2.2 239 de 285
Como ejemplo de aplicación vamos generar el siguiente formulario
Se tiene:
Versión 2.2 240 de 285
Lanzar un JTree en el lateral izquierdo:
Generar la siguiente estructura:
Versión 2.2 241 de 285
Para manejar la posición inicial de la línea de división
Para manejar el ancho de la línea de división
La orientación se maneja en:
Versión 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:
Versión 2.2 243 de 285
El formulario es:
Tiene las opciones:
Versión 2.2 244 de 285
El código asociado al primer Jpanel es una variable tipo Vector static para que los datos ingresados desde
este formulario sean accesibles desde otros formularios
El código asociado al botón de ingreso de datos es:
Versión 2.2 245 de 285
Al formulario para ver datos se le agregó un botón para visualizar datos. El código asociado a este botón es:
Ahora, desde el contenedor del JSplitPane se tiene el código asociado al evento “ValueChanged”:
Versión 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 ejecución se tiene:
Versión 2.2 247 de 285
Versión 2.2 248 de 285
25.5 JScrollPane
Cuando un componente ocupa mucho espacio en pantalla o contiene mucha información, un JScrollPane
permite asociarle una pequeña 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:
Versión 2.2 249 de 285
Al agregar algunos componentes se puede tener lo siguiente:
Versión 2.2 250 de 285
26 Adicionales
26.1 Objetivos
Usar métodos para el manejo de fechas y horas.
26.2 Conocimiento previo
Creación de métodos.
26.3 Date
Representa un momento específico en el tiempo, con precisión de milisegundos. La mayoría de sus
métodos están desaprobados. El siguiente código 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 conversión 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 específico.
Para crear una instancia se debe usar el siguiente código, esto se debe al hecho de que la clase
Calendar es abstracta (ver clases más adelante).
Calendar dat = Calendar.getInstance();
El siguiente código se recupera la hora actual y cada uno de sus valores específicos. Observar que enero=0
y que el día 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("Año: " + 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));
}
}
Versión 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("Año: " + 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("Año: " + 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 años más: " + dat.getTime());
dat.add(Calendar.YEAR, -4);
Versión 2.2 252 de 285
System.out.println("Cuatro años menos: " + dat.getTime());
dat.add(Calendar.MONTH, 2);
System.out.println("Dos meses más: " + dat.getTime());
dat.add(Calendar.DATE, 2);
System.out.println("Dos horas más: " + 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 más: " + dat.getTime());
}
}
La clase siguiente muestra como java maneja la resta de fecha. Considerar que el método expuesto sólo
diferencia los valores indicados sin considerar los años.
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 años: " + 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 cómo 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"); }
Versión 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 cómo los patrones de fecha y hora se interpretan en la configuración
regional de EE.UU.. La fecha determinada y el tiempo son 07/04/2001 12:08:56 hora local en la zona del
Pacífico 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.
Versión 2.2 254 de 285
Ejercicio 1
En una empresa dedicada a la producción 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.
Versión 2.2 255 de 285
27 Adicionales 1
27.1 Objetivos
Formatear datos considerando la región.
27.2 Conocimiento previo
Uso de métodos en Java.
27.3 Format
Es una clase abstracta para dar formato a fechas, mensajes y números. Puede analizar si la información es
sensible a la localidad.
Las subclases DateFormat, MessageFormat, y NumberFormat formatean, respectivamente fechas,
mensajes y números.
27.4 Locate
Un objeto de la clase Locale representa una región geográfica específica, política o cultural. Una operación
que requiere una configuración regional para llevar a cabo su tarea se llama sensible a la localidad y utiliza
la configuración regional de adaptar la información para el usuario. Por ejemplo, mostrando un número es
una operación sensible a la localidad - el número debe tener un formato acorde a las costumbres y
convenios de país de origen del usuario, región o cultura.
Los códigos de idioma se definen en la norma ISO 639, un estándar internacional que asigna los códigos de
dos y de tres letras para la mayoría de lenguas del mundo. La configuración regional de java utiliza los
códigos de dos letras para identificar el idioma de destino. Ver: http://www.loc.gov/standards/iso639-
2/php/code_list.php
Versión 2.2 256 de 285
El argumento país son Código ISO. Estos códigos son las mayúsculas, los códigos 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 genérico de habla Inglesa (Canadá, EEUU, ...)
Locale locale1 = new Locale("en");
// Crear un entorno de habla Inglesa para la región de Canadá
Locale locale2 = new Locale("en", "CA");
// Crear un entorno específico de habla Inglés, para la configuración regional de EE.UU. para SiliconValley
Locale locale3 = new Locale("en", "US", "SiliconValley");
Utilizando el código ISO 639 de dos letras, la representa en inglés. Los códigos ISO 3166 CA y US
representan a Canadá y los Estados Unidos, respectivamente: La última línea de código anterior muestra
cómo crear una configuración local con una variante opcional: SiliconValley. Esto es más específica que la
primera instancia. No sólo es la configuración regional de un EE.UU. que hablan Inglés, pero también se
asocia con una variante adicional, SiliconValley. Debido a que uno de sus propósitos 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 estáticos que representan instancias de objetos Locale. Por
ejemplo, Locale.FRANCE es un objeto estático prefabricados de configuración regional que representa de
habla francesa Francia. Usted puede utilizar Locale.FRANCE en cualquier lugar puede utilizar new Locale
("fr", "FR").
La guía 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();
Versión 2.2 257 de 285
Para conocer la configuración 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 configuración del equipo.
Versión 2.2 258 de 285
27.5 MessageFormat
Proporciona un medio para producir mensajes concatenados en forma independiente del idioma. Utilice esta
opción para construir mensajes que aparecen para los usuarios finales. MessageFormat toma un conjunto
de objetos, les da formato, a continuación, inserta las cadenas de formato en el patrón en los lugares
adecuados.
En este caso, MessageFormat reemplaza {0} por el valor de la variable que le pasamos. Podemos poner
más 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);
}
}
También 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 números. 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 límites. 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 mostrarán lo días e la semana. Observar lo que sucede para valores
más pequeños o más grandes.
Versión 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 separación entre cifras singulares o plurales podemos usar
el siguiente código. Observar que {0,number} indica un número en la posición {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)};
Versión 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);
//Números enteros
msg = MessageFormat.format("There are {0,number,#} a''s and {1,number,#} b''s", params);
System.out.println(msg);

//Números 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);
}
}
Versión 2.2 261 de 285
Ahora considerar la siguiente configuración regional.
Ahora para la siguiente configuración regional.
Observar en este ejemplo el uso de los formatos de números 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);
}
}
Versión 2.2 262 de 285
27.7 NumberFormat
NumberFormat es la clase base abstracta para todos los formatos de número. Esta clase proporciona la
interfaz para el formato y el análisis de los números.
NumberFormat le ayuda a analizar los números y el formato para cualquier configuración regional.
Su código puede ser totalmente independiente de las convenciones de localización de puntos decimales,
separadores de miles, o incluso los dígitos decimales en particular usado, o si el formato de número es aún
decimal.
27.8 DecimalFormat
DecimalFormat es una subclase concreta de NumberFormat que da formato a los números decimales. Tiene
una variedad de características diseñadas para permitir a los números de analizar y dar formato en
cualquier lugar, incluido el apoyo a Occidente, el árabe, y los dígitos índicos. También es compatible con
diferentes tipos de números, incluyendo números enteros (123), números de punto fijo (123.4), la notación
científica (1.23E4), porcentajes (12%), y las cantidades de moneda ($123). Todos ellos pueden ser
localizados en una región determinada.
DecimalFormat utiliza ROUND_HALF_EVEN para el formato de los redondeo. De esta manera, antes de
mostrar los números debemos usar una función que nos permita redondear estos en el formato adecuado
de decimales usado en nuestra región (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) {
//Región: se usa la , para separador de miles y el . para decimales
Locale.setDefault(Locale.CANADA);
//El símbolo 0 muestra un cero cuando no exista un dígito
//Notar que el número 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);
Versión 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);
}
}
Versión 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
}
Versión 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
japonés (Japón): #,##0.### -> -1,234.56 -> -1234.56
español (Perú): #,##0.### -> -1.234,56 -> -1234.56
japonés (Japón,JP): #,##0.### -> -1,234.56 -> -1234.56
español (Panamá): #,##0.### -> -1,234.56 -> -1234.56
serbio (Bosnia y Hercegovina): #,##0.### -> -1.234,56 -> -1234.56
español (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
albanés (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
portugués (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
alemán (Suiza): #,##0.### -> -1'234.56 -> -1234.56
inglés (Estados Unidos): #,##0.### -> -1,234.56 -> -1234.56
finés (Finlandia): #,##0.### -> -1 234,56 -> -1234.56
inglés (Malta): #,##0.### -> -1,234.56 -> -1234.56
Versión 2.2 266 de 285
eslovenio (Eslovenia): #,##0.### -> -1.234,56 -> -1234.56
eslovaco (Eslovaquia): #,##0.### -> -1 234,56 -> -1234.56
turco (Turquía): #,##0.### -> -1.234,56 -> -1234.56
árabe (Arabia Saudita): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
inglés (Reino Unido): #,##0.### -> -1,234.56 -> -1234.56
serbio (Serbia y Montenegro): #,##0.### -> -1.234,56 -> -1234.56
inglés (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
español (Nicaragua): #,##0.### -> -1,234.56 -> -1234.56
irlandés (Irlanda): #,##0.### -> -1,234.56 -> -1234.56
francés (Bélgica): #,##0.### -> -1.234,56 -> -1234.56
español (España): #,##0.### -> -1.234,56 -> -1234.56
árabe (Líbano): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
francés (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
español (Estados Unidos): #,##0.### -> -1,234.56 -> -1234.56
español (México): #,##0.### -> -1,234.56 -> -1234.56
árabe (Sudán): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
indonesio (Indonesia): #,##0.### -> -1.234,56 -> -1234.56
español (Uruguay): #,##0.### -> -1.234,56 -> -1234.56
letón (Letonia): #,##0.### -> -1 234,56 -> -1234.56
portugués (Brasil): #,##0.### -> -1.234,56 -> -1234.56
árabe (Siria): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
español (República Dominicana): #,##0.### -> -1,234.56 -> -1234.56
francés (Suiza): #,##0.### -> -1'234.56 -> -1234.56
hindú (India): #,##0.### -> -१,२३४.५६ -> -1234.56
español (Venezuela): #,##0.### -> -1.234,56 -> -1234.56
árabe (Bahráin): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
inglés (Filipinas): #,##0.### -> -1,234.56 -> -1234.56
árabe (Túnez): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
alemán (Austria): #,##0.### -> -1.234,56 -> -1234.56
neerlandés (Holanda): #,##0.### -> -1.234,56 -> -1234.56
español (Ecuador): #,##0.### -> -1.234,56 -> -1234.56
chino (Taiwán): #,##0.### -> -1,234.56 -> -1234.56
árabe (Jordania): #,##0.###;#,##0.###- -> 1,234.56- -> -1234.56
islandés (Islandia): #,##0.### -> -1.234,56 -> -1234.56
español (Colombia): #,##0.### -> -1.234,56 -> -1234.56
Versión 2.2 267 de 285
español (Costa Rica): #,##0.### -> -1,234.56 -> -1234.56
español (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 país.
• Utilice getTimeInstance para obtener el formato de hora de ese país.
• 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"); }
}
}
Versión 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 región.
Un patrón de caracteres especiales se utiliza para especificar el formato de la fecha. Este ejemplo
muestra algunos. Este formato utiliza la configuración 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/año.
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()));
}
}
Observación:
• MM=mes
• mm=minutos.
Versión 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 día 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 aproximación.
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.");
}
}
}
Versión 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);
}
}
Versión 2.2 271 de 285
28 Adicionales 2
28.1 Objetivos
Características adicionales de Java.
28.2 Conocimiento previo
Uso de métodos en Java.
28.3 Argumentos variables
Java permite pasar un número variable de argumentos a un método. Esto se consigue mediante la
expresión "..." a partir del momento en que queramos tener un número variable de argumentos.
En este ejemplo la función miFunc(String s1, int... datos) es capaz de recibir obligatoriamente un dato de
tipo String y el resto es una lista opción 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 dimensión máxima 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 Método main
public static void main(String[] args)
El método main recibe un arreglo de String como único argumento. Este es un vector de cadenas de
caracteres representa que los parámetros opcionales que le podemos pasar por la línea de comando.
Versión 2.2 272 de 285
El siguiente programa lee desde la línea de comando dos argumento y luego muestra la información:
package dat;
public class UsoMain {
public static void main(String[] args) {
System.out.println("Hola: " + args[0]);
System.out.println("Hola: " + args[1]);
}
}
También 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]);
}
}
También 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);
}
}
Versión 2.2 273 de 285
29 Adicionales 3
29.1 Objetivos
Analizar e implementar algoritmos de ordenación y búsqueda.
29.2 Conocimiento previo
Programación en java.
29.3 Ordenación
La ordenación o clasificación de datos (sort, en inglés) es una operación consistente en disponer un
conjunto —estructura— de datos en algún determinado orden con respecto a uno de los campos de
elementos del conjunto. Por ejemplo, cada elemento del conjunto de datos de una guía telefónica tiene un
campo nombre, un campo dirección y un campo número de teléfono; la guía telefónica está dispuesta en
orden alfabético de nombres; los elementos numéricos se pueden ordenar en orden creciente o decreciente
de acuerdo al valor numérico del elemento. En terminología de ordenación, 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 métodos (algoritmos) de ordenación son numerosos, por ello se debe prestar especial atención en su
elección. ¿Cómo se sabe cuál es el mejor algoritmo? La eficiencia es el factor que mide la calidad y
rendimiento de un algoritmo. En el caso de la operación de ordenación, dos criterios se suelen seguir a la
hora de decidir qué algoritmo —de entre los que resuelven la ordenación— es el más eficiente: 1) tiempo
menor de ejecución en computadora; 2) menor número de instrucciones.
29.4 Algoritmo de la burbuja
En el caso de un array (lista) con n elementos, la ordenación 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.

Versión 2.2 274 de 285


Versión 2.2 275 de 285
La codificación en C es:

29.5 algoritmo de ordenación
El algoritmo de ordenación tal vez más 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 comparación 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 número de elementos, y ejecuta las siguientes
operaciones.

Versión 2.2 276 de 285


El método ordIntercambio utiliza dos bucles anidados. Suponiendo que la lista es de tamaño 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:

Versión 2.2 277 de 285
29.6 Búsqueda 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 específico de un array se denomina búsqueda. En esta
sección se examinarán dos técnicas de búsqueda: búsqueda lineal o secuencial, la técnica más sencilla, y
búsqueda binaria o dicotómica, la técnica más eficiente.
29.7 Búsqueda secuencial
La búsqueda secuencial busca un elemento de una lista utilizando un valor destino llamado clave. En una
búsqueda secuencial (a veces llamada búsqueda lineal), los elementos de una lista o vector se exploran (se
examinan) en secuencia, uno después de otro. La búsqueda secuencial es necesaria, por ejemplo, si se
desea encontrar la persona cuyo número de teléfono es 958-220000 en un directorio o listado telefónico de
su ciudad. Los directorios de teléfonos están organizados alfabéticamente por el nombre del abonado en
lugar de por números de teléfono, de modo que deben explorarse todos los números, uno después de otro,
esperando encontrar el número 958-220000. El algoritmo de búsqueda secuencial compara cada elemento
del array con la clave de búsqueda. 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 búsqueda con la mitad de los elementos del array. El
método de búsqueda lineal funcionará bien con arrays pequeños o no ordenados.
29.8 Búsqueda binaria
Se sitúa 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 búsqueda uno en la mitad inferior o superior del
elemento central de la lista. En general, si los datos de la lista están ordenados se puede utilizar esa
información para acortar el tiempo de búsqueda.

Versión 2.2 278 de 285
Codificación en C:

29.9 Ejercicios
Codificar cada uno de los algoritmos en Java y desarrollar pruebas para datos de tipo numéricos y de
caracteres, midiendo los tiempos de ejecución.
Versión 2.2 279 de 285
30 Adicionales 4
30.1 Objetivos
Uso de casos de uso para la definición de requerimientos.
30.2 Conocimiento previo
Programación de sistemas.
30.3 Caso de uso
Un caso de uso es una descripción de los pasos o las actividades que deberán realizarse para llevar a
cabo algún proceso. Los personajes o entidades que participarán en un caso de uso se denominan actores.
En el contexto de ingeniería del software, un caso de uso es una secuencia de interacciones que se
desarrollarán 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 comunicación y el comportamiento de
un sistema mediante su interacción con los usuarios y/u otros sistemas. O lo que es igual, un diagrama que
muestra la relación entre los actores y los casos de uso en un sistema. Una relación es una conexión entre
los elementos del modelo, por ejemplo la especialización y la generalización son relaciones. Los diagramas
de casos de uso se utilizan para ilustrar los requerimientos del sistema al mostrar cómo reacciona a eventos
que se producen en su ámbito o en él mismo.
Los más comunes para la captura de requisitos funcionales, especialmente con el desarrollo del
paradigma de la programación orientada a objetos, donde se originaron, si bien puede utilizarse con
resultados igualmente satisfactorios con otros paradigmas de programación.
30.4 Normas de aplicación
Los casos de uso evitan típicamente la jerga técnica, 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 colaboración por
los analistas de requerimientos y los clientes.
Cada caso de uso se centra en describir cómo alcanzar una única meta o tarea de negocio. Desde
una perspectiva tradicional de la ingeniería de software, un caso de uso describe una característica del
sistema. Para la mayoría de proyectos de software, esto significa que quizás 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 descripción textual de todas las maneras que los actores
previstos podrían trabajar con el software o el sistema. Los casos de uso no describen ninguna
funcionalidad interna (oculta al exterior) del sistema, ni explican cómo se implementará. Simplemente
muestran los pasos que el actor sigue para realizar una operación.
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 comunicación la
iniciará el actor, en cambio si es secundario, el sistema será el que inicie la comunicación).
• Un caso de uso extiende otro caso de uso.
• Un caso de uso utiliza otro caso de uso.
Versión 2.2 280 de 285
30.5 Plantilla no adecuada
30.6 Plantilla adecuada 1
Versión 2.2 281 de 285
30.7 Plantilla adecuada 2
Versión 2.2 282 de 285
RF- 01 Alta de socio
Objetivos asociados OBJ–02 Gestionar las socios
Requisitos asociados RI–02 Información sobre socios
Descripción El sistema deberá comportarse tal como se describe en
el siguiente caso de uso cuando alguien solicite su
ingreso como
socio
Precondición El solicitante no es un socio del vídeo–club y tiene su
documentación disponible
Secuencia
Normal
Paso Acción
1 El empleado del vídeo–club 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, dirección y
teléfonos de contacto
3 El empleado del vídeo–club solicita los datos
requeridos y la documentación al nuevo socio
4 El empleado del vídeo–club comprueba que los
datos
del nuevo socio coinciden con los de la
documentación aportada
5 El empleado del vídeo–club 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 vídeo club de que el proceso ha
terminado con éxito
7 El empleado del vídeo–club entrega el carnet al
nuevo
socio
Postcondición El solicitante es socio del vídeo–club y el saldo de su
cuenta es
0
Excepciones Paso Acción
4 Si la documentación aportada no es correcta, el
empleado del vídeo–club cancela la operación,
a continuación este caso de uso termina
31 Adicionales 4
31.1 Objetivos
Trabajo.
31.2 Conocimiento previo
Programación 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 Metálicas 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
Versión 2.2 283 de 285
A3 Concepción
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 Dólar 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)
Versión 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 país. Las características específicas son:
1. Los clientes son aquellos que pueden desarrollar compras.
2. Los productos son ingresados al sistema asignándolos a diferentes sucursales que la tienda tiene a
lo largo del país.
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 día y hora en que se desarrollar el proceso tomando esos datos
desde la fecha del servidor de base de datos.
Versión 2.2 285 de 285

Índice de contenido
1 Clase.................................................................................................................................................8 1.1 Objetivos..................................................................................................................................8 1.2 Conocimiento previo................................................................................................................8 1.3 Conceptos de encapsulación....................................................................................................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 Métodos específicos...............................................................................................................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 evaluación 1.......................................................................................................38 6 Clase...............................................................................................................................................42 6.1 Objetivos................................................................................................................................42
Versión 2.2 2 de 285

6.2 Conocimiento previo..............................................................................................................42 6.3 Arreglos unidimensionales.....................................................................................................42 6.4 Declaración de arreglos.........................................................................................................43 6.5 Recorrer un arreglo................................................................................................................44 6.6 Asignación 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 parámetros 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 Inicialización 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 evaluación 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 Agregación ..........................................................................................................................60 10.6 Composición........................................................................................................................61 10.7 Asociación............................................................................................................................62 10.8 Multiplicidad........................................................................................................................62 10.9 Herencia...............................................................................................................................63 10.10 Definiciones de herencia....................................................................................................65 10.11 Relación “es-un”·y “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 métodos...........................................................................................................70 11.5 Object...................................................................................................................................71 11.6 super.....................................................................................................................................72 11.7 Ejemplo 1.............................................................................................................................74 11.8 Ejemplo 2.............................................................................................................................76 11.9 Métodos final.......................................................................................................................79 11.10 Clases final.........................................................................................................................79 11.11 Trabajo 5............................................................................................................................80 12 Clase.............................................................................................................................................81
Versión 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 evaluación 3.....................................................................................................92 14 Clase.............................................................................................................................................98 14.1 Objetivos..............................................................................................................................98 14.2 Conocimiento previo............................................................................................................98 14.3 Manejo de excepciones........................................................................................................98 14.4 Lanzar una excepción..........................................................................................................99 14.5 Captura una excepción.........................................................................................................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 evaluación 4...................................................................................................136 18 Clase...........................................................................................................................................141 18.1 Objetivos............................................................................................................................141 18.2 Conocimiento previo..........................................................................................................141 18.3 Colecciones Genéricas.......................................................................................................141
Versión 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 Implementación...............................................................................................................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 Conexión de Información general......................................................................................166 19.7 Establecer una conexión....................................................................................................166 19.8 Liberación DBMS Recursos..............................................................................................166 19.9 Crear una conexión............................................................................................................167 19.10 Insertar datos....................................................................................................................167 19.11 Driver de Conexión..........................................................................................................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 diálogo..............................................................................................................188 21 Clase...........................................................................................................................................193 21.1 Objetivos............................................................................................................................193 21.2 Conocimiento previo..........................................................................................................193 21.3 Modelos de evaluación 5...................................................................................................193
Versión 2.2 5 de 285

..........249 26 Adicionales......................................................................274 29................................................................................................................................219 23..................................................................................................................................................1 Objetivos..............................................................................1 Objetivos.........2 Conocimiento previo.....................................................................................................................................................................................................................2 Conocimiento previo..................................................................................................................................................................................268 27..................................................3 Ordenación......................................................................................................................................3 Format.........................................................................................................256 27.4 Locate............................................................2 Conocimiento previo..................194 22..........7 Spinner...............251 26........228 24......................................................................................2 6 de 285 .....................................................................................................................................................................................................................................................................1 Objetivos.................259 27............................................3 JFormattedTextField....194 22.198 22..............................................2 Conocimiento previo.......272 28.....................................................................................................194 22.............................................................................................................................................................................................................................................................................................................................228 24.......................................3 Date.................................................................................................................272 28.........................................................................251 26...............................................................................4 PasswordField ......256 27.............................................................2 Conocimiento previo...........................22 Clase................................................................................................................................................................................................1 Objetivos...........9 DateFormat......................................................................5 JScrollPane..............................................................6 ChoiceFormat...................................................3 Evaluación 6.........................................219 24 Clase...................228 24.......................................10 SimpleDateFormat..........231 25..254 26.................................................................................................................................3 Argumentos variables ..................................................................................................Separator.....................................................................4 Método main......................................................251 26......201 22.......................272 28..................................................................237 25......................................6 GregorianCalendar.................................256 27...............................................256 27..........................................231 25....231 25................................................................................219 23...................263 27...............................................................................................................................................................1 Objetivos...............................................................254 27 Adicionales 1.........................................................................203 22.........1 Objetivos...1 Objetivos.................................................................................251 26..................................................................274 29.........................................6 CheckBox.............................................................272 28............197 22.................3 JTable........2 Conocimiento previo........................................................259 27...269 28 Adicionales 2................................................................................256 27................5 MessageFormat................272 29 Adicionales 3.......................................................................219 23...................................8 DecimalFormat.......................................5 JRadioButton..........4 JTree.................263 27...................................................................................................................................................................194 22.....................................228 24........................1 Objetivos................................208 23 Clase.........................231 25......................................................2 Conocimiento previo................3 JMenu........7 NumberFormat....................................................................................251 26.......................4 Evaluación 7..274 Versión 2..................................................................................................................................................................................................................................................................................................5 SimpleDateFormat.................................................................................................................................8 JTabbedPane...............................................................................................................................................................................................................................................................................................229 25 Clase......................................................................................................274 29.............................................................................................4 Calendar........................2 Conocimiento previo...............................................................................................

.........................281 30..................278 29....1 Objetivos...................................................................................2 Conocimiento previo.....................................................................................283 31..............279 30 Adicionales 4.................2 7 de 285 ......................................................................................4 Normas de aplicación.......................3 Base de datos...............280 30...................................29..........................................................................................7 Búsqueda secuencial...................281 30.......................................................................................282 31 Adicionales 4..............................................................................................................283 31..........................3 Caso de uso.....................................................................................5 Plantilla no adecuada..7 Plantilla adecuada 2..............6 Búsqueda en listas..................9 Ejercicios...280 30............................................283 31.....................................................................................................................................................................................................................................278 29............................................................4 Algoritmo de la burbuja........................................................................2 Conocimiento previo..............................274 29.................283 Versión 2.........................................................................................................278 29.......280 30......280 30.....................................................................................................1 Objetivos.........................................................................................5 algoritmo de ordenación.................................................................................................280 30......................................................................................................................................................................8 Búsqueda binaria.........................6 Plantilla adecuada 1.................................................................................................................................276 29.......

de un objeto de manera que sólo se puede cambiar mediante las operaciones definidas para ese objeto. De esta forma. Se debe declarar al menos el método constructor de la clase sin parámetros. Para cada variable declarar métodos: ◦ ◦ Accesadores (conocidos como métodos get): Se utilizan de forma estándar para la recuperación de datos de un objeto. bajo ciertas restricciones. es decir. de los datos miembro de un objeto.3 Conocimiento previo Conceptos de encapsulación Creación de métodos. Inicializar las variables de instancias en sus valores por defecto o los convenientes para el desarrollo. o lo que es lo mismo. como lenguaje orientado a objetos puro que es.2 8 de 285 .1 • • Objetivos Encapsular datos. el usuario de la clase puede obviar la implementación de los métodos y propiedades para concentrarse sólo en cómo usarlos. implementa la encapsulación (o encapsulamiento) perfectamente.2 1. Versión 2. Mutadores (conocidos como métodos set): Se utilizan de forma estándar para la asignación de datos a un objeto. Por otro lado se evita que el usuario pueda cambiar su estado de maneras imprevistas e incontroladas. 1. Este concepto consiste en la ocultación del estado.1 Clase 1. y más específicamente en programación orientada a objetos. Otra definición un tanto más simple: La encapsulación consiste en ocultar la complejidad de una clase e impedir accesos no autorizados Java. se denomina encapsulamiento al ocultamiento del estado. de los datos miembros. En programación modular. Más específicamente: Para implementar la encapsulación en java debemos: • • • • Declara nuestras variable de instancia de la clase como private. en Java) definidos para dicho objeto. Restringir el acceso a datos. de forma que sólo es posible modificar los mismos mediante las operaciones (métodos.

2 9 de 285 . } public void setNota(double nota) { this. Así el método sería ahora: void setEdad(int edad){ if(edad <= 0) this.0 para otros casos.nota = nota.edad = 0.Por ejemplo.0) this. asignado 1. private double nota =0.0 } Versión 2.0.de/ -: Privado +: Publico Con estos métodos se pueden incorporar restricciones a los valores ingresados. else this. } } Para la diagramación de clases usaremos dia v0. si consideramos la clase estudiante con los atributos “edad” y “nota”.nota = nota.nota = 1. Por ejemplo.1 que puedes bajar desde http://dia-installer. } public double getNota() { return nota. void setNota(double nota){ if (nota >=1. public Estudiante(){ } //Variable private e inicializada //Variable private e inicializada //Método constructor sin parámetros //Métodos accesadores y mutadores de las variables edad y nota public int getEdad() { return edad. en el caso de la edad se pueden permitir sólo valores > 0 ó cero.edad= edad. else this.0 && nota <=7.97. } public void setEdad(int edad) { this. se tiene: public class Estudiante { private int edad=0. en el caso de la nota permitir sólo valores entre 1.0.0 y 7. } También se puede.edad = edad. por ejemplo.

private String nombre = "". mostrar: • • • • Código del producto Nombre del producto Precio del producto Total a pagar Unidades vendidas 40 100 Esta clase provee la encapsulación de productos. La cantidad a vender como parámetro del método que calculará el total de la venta. Para esto.1. Para el desarrollo de una venta se deberá crear un objeto de la clase usando su método constructor que debe recibir el código. public final class Producto { private String codigo = "". } Versión 2. } public String getCodigo() { return codigo.setCodigo(codigo).2 10 de 285 . private int precio =0. this. int precio) { this. public Producto() { } public Producto(String codigo.setNombre(nombre). usando su método aPagar() calcula el total a pagar por una venta. } public void setCodigo(String codigo) { this. this. String nombre. nombre y precio del producto. Considerar los siguiente productos: Código AX10 AX20 AX30 Nombre Faldas Pantalón Blusa Precio unitario 40000 30000 50000 Se pide no efectuar ningún tipo de validación y enviar los siguientes valores a proceso: Código AX10 AX30 Se pide también. se deben enviar: • • El código del producto como parámetro de objeto de la clase que encapsula la información de productos. package bean.codigo = codigo.4 Ejemplo Crear un programa Java que sea capaz de manejar las ventas de un producto determinado.setPrecio(precio).

out. Este concepto es fundamental para el uso de la programación orientada a objetos: package view.2 11 de 285 . System. } public int aPagar(int cantidad){ int total = 0. System."Falda".public String getNombre() { return nombre.println("Precio: " + obj1.out. public class Venta { public static void main(String[] args) { Producto obj1 = new Producto("AX10".aPagar(100).40000). Versión 2.getPrecio() * cantidad. int pago1 = obj1.out.getNombre()).getCodigo()). int pago2 = obj2. } public int getPrecio() { return precio.getPrecio()). } public void setPrecio(int precio) { this."Blusa".println("Codigo: " + obj1.out.50000).println("A pagar: " + pago1). } public void setNombre(String nombre) { this.aPagar(40).out. Producto obj2 = new Producto("AX30". import bean. System.println().Producto.nombre = nombre. System.println("Nombre: " + obj1. total = this. } } Esta clase crea dos objetos que manejan independiente cada una de las ventas. System.precio = precio. return total.

nombre = nombre.setCodigo(codigo).println("Codigo: " + obj2.out. String nombre.out.println("Precio: " + this. private int precio =0.out. } } Una solución más óptima sería crear un método de impresión en la clase Producto.System.println("A pagar: " + pago2). public Producto() { } public Producto(String codigo.getCodigo()).println("Codigo: " + this.out. int precio) { this.setNombre(nombre).println("Precio: " + obj2. } En este caso se tendría: package bean. private String nombre = "". System. this. System.2 12 de 285 . public final class Producto { private String codigo = "".out. } public String getCodigo() { return codigo. } public void setNombre(String nombre) { this. public void ver(){ System.getNombre()).out. } Versión 2.getCodigo()).println("Nombre: " + obj2.getPrecio()). System. } public void setCodigo(String codigo) { this. System.setPrecio(precio). System.out.codigo = codigo. this.println("Nombre: " + this. } public String getNombre() { return nombre.getNombre()).getPrecio()).

getPrecio()). System.println("Codigo: " + this. return total. } public void setPrecio(int precio) { this.aPagar(100). } } Versión 2.ver().2 13 de 285 .getPrecio() * cantidad. } } Y la clase que generá el proceso de venta sería ahora: package view. } public void ver(){ System.ver().out.println("Precio: " + this. total = this.out.out.Producto. System. System. import bean.getNombre()).40000).aPagar(40). int pago2 = obj2.precio = precio.out. Producto obj2 = new Producto("AX30".getCodigo()).50000).println("A pagar: " + pago1)."Falda"."Blusa". obj2. obj1.out. public class Venta { public static void main(String[] args) { Producto obj1 = new Producto("AX10".println(). System.public int getPrecio() { return precio.out. } public int aPagar(int cantidad){ int total = 0. System. int pago1 = obj1.println("Nombre: " + this.println("A pagar: " + pago2).

2 Clase
2.1 2.2 2.3 Objetivos Conocimiento previo Wrapper (Envoltura)
Conversión de tipos de datos.

Manejar los datos de tipo primitivos y el uso de métodos

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 métodos por valor, mientras que los objetos se pasan por referencia. De e sta manera, no hay forma de modificar en un método un argumento de tipo primitivo y que esa modificación 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 más que dotar a los datos primitivos con un envoltorio que permita tratarlos como objetos.

Versión 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 minúscula que con mayúscula.

Versión 2.2

15 de 285

Observar que es válido también la combinaciones de letras minúsculas y mayúsculas: 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 recomendación es usar la siguiente inicialización 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(); }

Versión 2.2

16 de 285

Observar que no se pueden usar combinaciones de minúsculas y mayúsculas en los casos indicados con error. La recomendación es usar Boolean.TRUE.

2.5

Number

Uno de los mayores uso de conversión es usando datos de la clase String. Por ejemplo, en las aplicaciones de tipo web la mayoría de los datos son recuperados como tipo String independientes que los datos sean numéricos. En diagrama de clases de los datos tipo Objetos (o Wrapper). Podemos apreciar que existe una clase común Number y que después cada uno de los tipos de datos tiene su propia implementación en su clase.

Object Number
BigDecimal BigInteger Byte Double Float Integer Long Short

Versión 2.2

17 de 285

2.6

Double

Maneja objetos numéricos tipo Double. Esta clase provee varios métodos 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 métodos de mayor utilidad pues recibe un String y lo transforma en double. En la jerga de la programación 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 más importante de todos
Versión 2.2 18 de 285

println("val4: " + val4)." + a2 + " .parseInt(s1) + Integer. public DatWrapper(){ } public DatWrapper(String s1.2 19 de 285 . String s2 = "FF". //Base 16 int a3 = Integer.val1 = Double. } return resul.parseInt(s3.out. if(s1 != null && s2 != null){ resul = Integer.println(a1 + " .valueOf(val4).parseInt(s2." + a3).out. Para el método parseInt existe un caso particular: String s1 = "123".println("val2: " + val2). val2 = Double.out.parseDouble(val4). 2.parseInt(s2). 10). //Transforma de double a String val4 = Double. } public String getS1() { return s1.toString(). System. } public String getS2() { return s2. 16). } public void setS2(String s2) { this. //Transforma de Double a String val4 = val3.55".8 Ejemplo Considere que necesita crear una clase que desarrolle el simple ejercicio de sumar dos números enteros. } public void setS1(String s1) { this.out.7 Integer Los métodos de Integer son análogos a los de la clase Double. } public int sumaDosValores(){ int resul = 0. //Base 10 int a2 = Integer.s1 = s1. String s2){ this. System. //Transforma de String a Double. //Base 2 System.toString(val1). this.s2 = s2. El segundo más importante val4 = "55.println("val4: " + val4). 2).parseInt(s1. System.println("val1: " + val1). pero esto son enviados como combinaciones de: String – String public class DatWrapper { private String s1 = null. private String s2 = null. } } 2. } } Versión 2. int a1 = Integer.setS1(s1). System.setS2(s2).out. String s3 = "10001000".

sumaDosValores()). se debe modificar es método: public float sumaDosValores(){ float resul = 0. pero los valores con enviados como Double. se debe modificar el método: package dat. public class DatWrapperView { static DatWrapper o1 = new DatWrapper(new String("12").parseFloat(s1) + Float. return resul.println("Valores String: " + o1. if(s1 != null && s2 != null) resul = Float. En este caso. } Suponga que ahora el resultado debe ser String. } public void setO1(Double o1) { this.out.parseFloat(s2).parseDouble(s2). } } Resultado: Valores String: -8 Suponga que ahora el resultado debe ser double.o2 = o2.2 20 de 285 . new String("-20")).setO1(o1). return resul. pero siempre los valores con enviados como String.setO2(o2). this. En este caso. } public Double getO2() { return o2. } public void setO2(Double o2) { this. } public Double getO1() { return o1.package dat.parseDouble(s1) + Double. En este caso. if(s1 != null && s2 != null) resul = Double. Versión 2.o1 = o1. } Suponga que ahora el resultado debe ser float. private Double o2 = null. pero siempre los valores con enviados como String. public class DatWrapperDouble { private Double o1 = null. Double o2){ this. public DatWrapperDouble(){ } public DatWrapperDouble(Double o1. public static void main(String[] args) { System. se debe modificar es método: public double sumaDosValores(){ double resul = 0.

9 Trabajo 1 Código del Producto AX10 AX20 Precio 10000 20000 Se necesita un programa java que sea capaz de manejar las ventas de los siguientes productos.0. AX30 50000 Se pide: (a) Encapsular la información que interviene en el ejercicio.out.0). if(o1 != null && o2 != null) valor = d1 + d2. calcule y muestre el total a pagar. double d2 = o2.000 • Un descuento de un 25% si el valor es mayor a 5.2 21 de 285 .000. System.000. return resul. sin parámetros y que dado un producto y una cierta cantidad vendida del producto.println("Valores Double: " + o1.0). resul = String.doubleValue().valueOf(valor). public class DatWrapperDoubleView { static Double o11 = new Double(12.} String sumaDosValores(){ String resul = "". o12). double valor = 0. } } 2.000 y 5. (c) Crear un método que reciba el total a pagar (tipo String) y calcule el descuento a aplicar (tipo int con aproximación de cantidades decimales al primer entero superior al número calculado) según se indica: • Un descuento de un 10% si el valor está entre 2.000 • Un descuento de 0% en otro caso Versión 2.000. } } package dat.sumaDosValores()). public static void main(String[] args) { DatWrapperObject o1 = new DatWrapperObject(o11. double d1 = o1.doubleValue(). (b) Crear un método que devuelva un String. static Double o12 = new Double(-22.

4 3.2 3. 3.isDigit(valor2)){ System. Sin embargo.5 Character IsDigit Esta clase maneja valores de tipo primitivos char como objetos. } else { System. } else { System.println("valor1 es dígito").isDigit(valor1)){ System.println("valor2 no es dígito").1 3.out.3 Objetivos Conocimiento previo Métodos específicos Usar métodos prediseñados.println("valor1 no es dígito").out. char valor2 = 'e'. } } } 3.2 22 de 285 . } } Versión 2.println("valor2 es dígito").out.5. esta cantidad de métodos no es tan cuantiosos como otros lenguajes de programación.isLetter('c')). } if(Character.println(Character.out. Existen una serie de de métodos en java que nos permiten desarrollar procesos.3 Clase 3.out. System. public class FuncionesEspecificas { public static void main(String[] args) { char valor1 = '4'. Creación de métodos.out. Permite analizar si una variable de tipo char es un número.isLetter('5')).1 isLetter Determina si el valor de caracteres especificado es una letra public class Metodos1 { public static void main(String[] args) { System. if(Character.println(Character.

isUpperCase('D')).isUpperCase('5')). } } 3. System.3. System.2 23 de 285 . public class Metodos2 { public static void main(String[] args) { System.5.isUpperCase('c')).out.println(Character. package view.println(Character.println(Character.out.6 ascii La siguiente tabla contiene los códigos ascii.out. De la misma forma se tiene isUpperCase e isWhitespace().2 isUpperCase Determina si el carácter especificado en una letra mayúscula. Versión 2.

charAt(i)> '9' ){ return false.println(isNumeric("-23.charAt(i) < '0' || s.7 String La clase String representa cadenas de caracteres.i++){ if(s.println(isNumeric("23Ab")).out. se implementan como instancias de esta clase.println().out.out.23")).println(isNumeric("-23")). for(int i=0. System. System. package dat.1 charAt Retorna el carácter para una posición específica en una cadena public class FuncionesEspecificas01 { public static void main(String[] args) { String s = "123ABCabc".println(isNumeric("23. System.out. recordar que una variable no inicializada explícitamente no se puede usar.2 24 de 285 .charAt(i)). System.println(isNumeric("Ab23")). System.7. Las variables String se inicializan en null.i++){ System.i<s. } Con esta función se puede generar un validador de números de sólo números enteros. System.23")). es lo mismo declara: String nn.length().out.println(isNumeric("23")). System.out.23")).Sin embargo.out.out.out. } public static boolean isNumeric(String s){ for(int i=0.3. Todos los literales de cadena en los programas Java. String nn = null.println(isNumeric("-23. } } System.out. como "abc". } } Versión 2. 3. public class FuncionesEspecificas02 { public static void main(String[] args) { System. De esta manera.print(s.23")).length().i<s. System.println(isNumeric("23.out.println(isNumeric("Ab")).

substring(0)).out. String espacio = " ".return true. comenzando en el índice especificado. System. int fromIndex): Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena especificada.println(nombre. //Juan Perez //ez //J //Juan Per //u //uan Per //e 25 de 285 Versión 2.4 indexOf int indexOf(int ch): Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado. Para validaciones profesionales en java ver matches. int indexOf(int ch. System. System.substring(1. La cantidad de caracteres rescatados es (endIndex-beginIndex). public class B { public static void main(String[] args) { String nombre = "Juan". } } 3.8)). Decimal y manejar diversos casos.2 . System. int indexOf(String str): Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena especificada.3 equals boolean equals(Object anObject) : Compara esta cadena para el objeto especificado.8)). El código une variables String.out. //Concatena los caracteres String ciudadano = nombre.2)). 3.println(ciudadano).out. int endIndex): Devuelve una nueva cadena que es una subcadena de la cadena desde el índice inicial hasta el final. } } Observar que el métodos se debe mejorar que validar números con .out. a partir de la búsqueda en el índice especificado.println(nombre.2 concat String concat(String str): Concatena la cadena especificada “str”al final de otra cadena.7. String substring(int beginIndex. 3.9)). String apellido = "Perez".println(nombre. System.concat(espacio).7.substring(0.out. int indexOf(String str.println(nombre. int fromIndex): Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado.5 substring String substring(int beginIndex): Devuelve una nueva cadena que es una subcadena de la cadena desde la posición indicada por el índice.println(nombre.println(nombre.out. El código muestra ejemplos de uso del método. Este índice comienza desde cero.substring(0.7.substring(1.7. Tener presente que el proceso no es el habitual de la mayoría de los lenguajes de programación public class C { public static void main(String[] args) { String nombre = "Juan Perez".1)). System. System.concat(apellido).println(nombre.out. System.out.substring(8)).substring(8. 3.

8. import java. i<10. String toUpperCase(): Convierte todos los caracteres letras de String a mayúsculas utilizando las reglas de la localización por defecto.6 toLowerCase . generar 10 números aleatorios enteros entre 0 y 99. for(int i=0.1 nextInt Devuelve un pseudoaleatorios.7 trim String trim (): Devuelve una copia de la cadena. public class Metodos20 { public static void main(String[] args) { Random r=new Random().Random y genera números seudoaleatorios que tiene como fin principal la simulación. 3. String toLowerCase(Locale locale): Convierte todos los caracteres letras de String a minúsculas utilizando las reglas dado por Locale.8 Random La clase Random es parte de package java.nextInt(100)). se crea un objeto Locale para los Estados Unidos y China Locale. Por ejemplo. package view.out.util. i++){ System. String toUpperCase(Locale locale): Convierte todos los caracteres letras de String a mayúsculas utilizando las reglas dado por Locale.System. } } } Versión 2.Random.toLowerCase String toLowerCase(): Convierte todos los caracteres letras de String a minúsculas utilizando las reglas de la localización por defecto. } } //ez 3.US Locate.7. Locate: Un objeto Locale representa una determinada región geográfica. con espacios en blanco iniciales y finales omitido (eliminados). política o cultural. 3.length())).2 26 de 285 .CHINA 3.println(r.7.out.nombre.substring(8. uniformemente distribuidos entero entre 0 (inclusive) y el valor especificado (exclusivo).util.println(nombre. Por ejemplo.

public class Metodos21 { public static void main(String[] args) { Random r=new Random().1). i<10.nextDouble()).Random.Posibles resultados.nextInt(100)).util. import java.println(1+ r. for(int i=0.2 nextDouble Genera números aleatorios entre 0 (incluido) y 1 (no incluido). i++){ System. import java. for(int i=0.out.8. } } } 3. Generar 10 números aleatorios enteros entre 1 y 100.2 27 de 285 . package view.Random. los cuales dependen de la veces que se ejecute el proceso. public class Metodos22 { public static void main(String[] args) { Random r=new Random(). } } } Versión 2. i<10.println(r. en el intervalo [0. o sea. i++){ System.out.util. package view.

2 Conocimiento previo Creación de métodos. pero que entre los diversos objeto comparten los mismos métodos La referencia es la posición de memoria donde se localiza un objeto y no el objeto. obj1 obj2 obj3 Referencias Posiciones de memoria Ubicación de objetos Considere: CGrados obj1. 4. CGrados obj1 = new CGrados(). Versión 2.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. lo que habitualmente se maneja es la referencia de los objetos. CGrados obj2 = new CGrados(). De esta manera. 4.2 28 de 285 . obj2 = obj1. Objeto referenciado Variable grados Referencia Objeto de CGrados Tener presente que cada objeto de un clase crea su propia copia de las variables de ejemplar. CGrados obj1 = new CGrados(). CGrados obj3 = new CGrados().4 Clase 4.1 Objetivos Usar objetos de clases para procesos. obj2.

obj1 obj2 Cada nueva referencia a “abc” usará el mismo objeto abc Con esto tenemos lo siguiente: • • abc El operador == compara las referencias de los objetos. entonces java no agrega un nuevo objeto. Esto es debido al hecho que new crea una nueva área de memoria. Esto se genera únicamente con la asignación: String obj1 = “abc”. se obtiene los mismos resultados usando obj1 u obj2 Cuando java compila un literal. De esta manera. String obj2 = “abc”. en relación a lo anterior si la asignación es como sigue se tendrá áreas de memoria distintas para el literal “abc”.obj1 obj2 Referencias Posiciones de memoria Ubicación de objetos Conclusión: • • • Conclusión: Ambas referencias obj1 y obj2 apuntan al mismo objeto. De esta manera. El operador == no compara los contenidos de los objetos Versión 2. String obj2 = “abc”. Así. por ejemplo “abc”. obj1 obj2 Cada nueva referencia a “abc” usará el mismo objeto abc Sin embargo. accederán a las mismas variables de ejemplar las que son utilizadas en el proceso que desarrollan los métodos.2 29 de 285 . String obj1 = new String(“abc”). añade un objeto String al área de almacenamiento de “abc”. si posteriormente aparece el mismo literal en cualquier otra parte del código de la clase. sino que utiliza el que hay.

if( obj1. El operador equals compara los contenidos de los objetos obj1 abc obj2 obj1 abc abc obj2 equals true   equals true Como ejemplo podemos ver: String obj1 = “abc”.equals(obj2) ){ //resultado true } if( obj1 = = obj2 ){ //resultado true } … String obj3 = new String(“abc”).equals(obj4) ){ // resultado true } if( obj3 = = obj4 ){ //resultado false } … Versión 2.2 30 de 285 . String obj4 = “abc”. String obj2 = “abc”.obj1 abc obj2 obj1 abc abc obj2 == true  x == false También se tiene: • • El operador equals compara las referencias de los objetos. if( obj3.

if(obj1. System.println(obj2). if(obj1==obj2) System.println(obj1).out. System.println("Iguales2Equal").out. entonces se crea un nuevo objeto con el nuevo contenido.4.println("Iguales1Equal").println("Iguales2=="). if(obj1==obj2) System.println("Iguales1=="). //Crea un nuevo objeto en una posición de memoria distinta a la inicial asignada a obj2 System. } } Versión 2. String obj2 = obj1. obj2 = "123".equals(obj2)) System.out.2 31 de 285 .equals(obj2)) System. si se asigna un nuevo valor a una variable.out.out.out.4 Objetos Inmutables Un objeto String es inmutable.println(obj2).println(obj1). System. Por ejemplo.out.out. Observar los resultados del siguiente ejemplo: public class Procesa2 { public static void main(String[] args) { String obj1 = new String("123"). if(obj1.

Sin embargo. i++) { cadena += “ “ + i + “ “. // creamos espacio para 120 caracteres StringBuffer cadena = new StringBuffer(120). al que se le van añadiendo las cadenas con el método append. llegó con Java 5.append(”Cuenta: “). } Lógicamente esto también tiene un coste computacional.2 32 de 285 .5 • • • StringBuffer . mejorando aún más el rendimiento.append(" " + i + " "). al proporcionar suficiente potencial para la mayor parte de los casos. pero éste es inferior al que supone crear un nuevo objeto. i++) { cadena. y en cada uno de ellos va guardando el nuevo contenido. cadena. Este código crea dentro del bucle 99 objetos de tipo String. De todos modos podemos reservar un espacio inicial de forma que no sea necesario hacerlo en cada iteración del bucle. } Versión 2. para la mayoría de las aplicaciones (donde se ejecuta un solo hilo) supone una mejora de rendimiento sobre StringBuffer. Considerar el siguiente código. StringBuffer cadena = new StringBuffer(“Cuenta: “). for (int i=0. En esta ocasión sólo se crea un objeto. StringBuilder. i++) { cadena.append(“ “ + i + “ “). for (int i=0. Una clase parecida. un problema que podemos resolver con StringBuffer String cadena = new String(“Cuenta: “). Esto por supuesto no es eficiente. i<100. } El siguiente código usa StringBuffer. lo que significa que puede haber problemas si es una variable a la que accedan diferentes threads. La clase StringBuffer permite guardar cadenas que cambiarán en la ejecución del programa (a diferencia de los objetos String normales.StringBuilder Lo más utilizado son sin duda objetos de tipo String. Es idéntica a la anterior salvo que no es síncrona. i<100. i<100.4. for (int i=0. que son inmutables).

utilizaremos StringBuffer. Si el texto cambia durante la ejecución. • • • Si el texto no va a cambiar. Si va a cambiar. utilizar String. y la aplicación que accede a él es multi-thread.Buena práctica. Versión 2.2 33 de 285 . y la aplicación va a tener un solo hilo de ejecución. utilizar StringBuilder.

double suma = unCentavo + unCentavo + unCentavo + unCentavo + unCentavo + unCentavo. } } Versión 2. cometen errores de precisión diferentes a los nuestros.math. package view. public class Metodos15 { public static void main(String[] args) { java. public class Metodos14 { public static void main(String[] args) { double unCentavo = 0. System.math.math.2 34 de 285 .add(unCentavo).BigDecimal suma = unCentavo.add(unCentavo).println(suma).6 BigDecimal . System.BigDecimal("0.RoundingMode Considerar el siguiente código y el resultado.add(unCentavo).println(suma).01").BigDecimal unCentavo = new java.add(unCentavo).4. Para solucionar lo anterior podemos proceder como sigue: package view. } } Cuando usamos una variable float o double. java. Como podemos ver el resultado no es el esperado.01.out.add(unCentavo). estamos dejandole al microprocesador de la computadora el trabajo de efectuar los cálculos directamente (con su coprocesador matemático) pero como las computadoras "piensan" en binario.out.

que si bien realiza los cálculos mas lento que "Double/double" los realiza del mismo modo que los humanos (en base 10) y así evitamos el problema. Los valores posibles son: • HALF_DOWN • HALF_EVEN Versión 2.RoundingMode que permite el manejo de aproximaciones de cifras decimales. en Java se incluye la clase BigDecimal. Vamos a emplear esta clase para el desarrollo de aproximaciones: Además consideraremos la clase java. Para resolver este problema. los pequeños errores de calculo acumulados con varios centavos pueden resultar en reportes cuyos cálculos diferirán de las operaciones que normalmente realizamos los humanos.math.Si hacen sistemas financieros.2 35 de 285 .

BigDecimal val4 = new BigDecimal("-0.RoundingMode. BigDecimal val5 = new BigDecimal("-0.println(val4).RoundingMode.HALF_UP). val2 = val2.out.HALF_UP). import java.55400").setScale(2. val6 = val6.out.RoundingMode. System.2 36 de 285 .setScale(2. BigDecimal val2 = new BigDecimal("0.setScale(2. System.55500"). package view. System.55500"). import java.55600").println(val5). System. BigDecimal val6 = new BigDecimal("-0.println(val6).BigDecimal.RoundingMode. BigDecimal val3 = new BigDecimal("0.HALF_UP). val1 = val1.out.RoundingMode.math. public class Metodos17 { public static void main(String[] args) { BigDecimal val1 = new BigDecimal("0.HALF_UP). val3 = val3. val4 = val4.out.HALF_UP).out.out.• HALF_UP Así debemos usar HALF_UP.RoundingMode.println(val2).math.55600").RoundingMode.55400").HALF_UP).setScale(2.println(val3).setScale(2.setScale(2.println(val1). System. } } Versión 2. System. val5 = val5.

Versión 2.math. se requiere dividir 3 / 243 con 6 decimales. Crear dos variables de tipo StringBuffer con los elementos: • • {ABCDEFGHIJKLMNÑOPQRSTUVWXYZ} {0123456789} Cree un método que. System.Para operar con la clase se debe tener presente lo siguiente.divide(new BigDecimal("243"). import java. public class Metodos18 { public static void main(String[] args) { BigDecimal numero = new BigDecimal("3"). (b) El total de espacios entre palabras de la cadena.6.math. import java. RoundingMode. } } 4. System.BigDecimal. import java.2 37 de 285 . usando esta estructura.BigDecimal. (c) El total de letras minúsculas. package view.println(numero).RoundingMode. Por ejemplo.println(numero).math.out.divide(new BigDecimal("243")). (d) El total de letras mayúsculas. public class Metodos19 { public static void main(String[] args) { BigDecimal numero = new BigDecimal("3").HALF_UP).7 Trabajo 2 Desarrolle un proceso mediante un método que sea capaz de recibir una cadena de caracteres y muestre: (a) El total de caracteres. } } Para eliminar la excepción se debe proceder como sigue: package view. sea capaz de validar que el código de un producto esté compuesto sólo de dos letras mayúsculas al inicio y luego dos números.out.

Desarrollar métodos particulares para cada uno de los siguiente proceso. Valor 12. el mes y el año. Problema 3 La variable rut se ha definido de tipo StringBuffer. (d) Validar que los caracteres ante del guión al centro (-) sean sólo números. entonces el valor se transforma en 0. 2.3 Problema 1 Modelos de evaluación 1 El cobro de intereses por la venta de un producto está asociado a la relación en días entre la fecha de vencimiento y la fecha de pago. (c) Validar que el carácter guión al centro (-) esté antes del último carácter. 4 y 3 5.1 Objetivos Presentar problemas tipo para la evaluación 1.5 Clase 5. entonces el método devuelve true. (b) Validar que el último carácter sea un número o una letra k minúscula o mayúscula. cada método recibe como parámetro la variable rut y devuelve un boolean.5% de la nota 1. que recibe como parámetro la variable busca de tipo String y que analiza si está contenida en la variable dat. 5. Por ejemplo. Problema 2 Considerar una variable llamada dat de tipo String: (a) Crear un método que devuelva un String y que cuente la cantidad de caracteres que contiene la variable dat. Considerar los siguientes datos: rut 14000000 14100000 14000000 14200000 A pagar (en pesos) 100000 -200000 1000000 500000 Fecha de vencimiento 15/01/10 15/01/10 20/01/10 20/01/10 Fecha de pago real 17/03/10 16/01/10 01/01/10 31/01/10 Se pide crear un método sin parámetros que sea capaz de calcular y mostrar el interés a pagar en pesos. si dat=”Hola Mundo Java” y busca=”mUndo”.2 38 de 285 . (b) Crear un método que devuelva un boolean. Crear un método que transforme adecuadamente el contenido de la variable dat a un tipo de variable que maneje fechas.50% >90 días 9. (a) Validar que la cantidad de caracteres sea menor o igual a 10.00% Si el valor de A pagar (en pesos) es menor que cero. (c) Considerar que variable dat contiene información de fecha en formato dd/mm/aaaa. el método debe mostrar el día.2 Conocimiento previo Contenidos de las clases 1. donde el interés depende de la cantidad de días de retraso en el pago: 1-30 días 31-90 días 2. Versión 2. pero mayor o igual a 3.00% 4.

import java. import java.Date. Además usando esta variable calcular: • • • • • • La cantidad de letras mayúsculas. private int aPagar.. Desarrollar el mismo proceso pero almacenando el número en orden inverso. Problema 6 Considere una clase java que tiene las siguientes variables: String a = “Hola”.Calendar. //Un espacio String c = “Mundo!. String b = “ “. public class Cobro { private String rut. (b) Los dos primeros dígitos son letras mayúsculas. String d = “Java” Se pide.Problema 4 Desarrolle un método que cómo parámetro recibe un código el cual se debe validar.. Reemplazar la palabra “Java” por “Curso de Java” almacenando los datos en la misma variable.2 39 de 285 . private Date vence. La cantidad de letras minúsculas.”. Problema 7 Desarrolle un método que cuente con un parámetro StringBuffer y que sea capaz de almacenar en otra variable StringBuffer el valor numérico que produce la concatenación de las cifras numéricas enviadas en el parámetro del método. problema 1 package view. Agregar al final de la variable “. Recuperar desde la variable la palabra “Mundo” y almacenarla en otra variable StringBuffer. Solución. simule sus notas de 1 a 7. private Date pago. generar el mensaje “Hola Mundo! Java” y almacenarlo en una variable tipo StringBuffer. (d) En caso de no ser válido el código se debe indicar en el mensaje de error todos las anomalías producidas. Para el ejemplo sería “704”. (c) Los dos últimos caracteres son números. calcule y muestre el promedio de estas. Problema 5 Cree un método que sea capaz de recibir la cantidad de alumnos. si el parámetro es “Ub40Yu7L” entonces se debe almacenar “407”. La cantidad de espacios. Por ejemplo.util.util. public Cobro() { Versión 2. Las condiciones son: (a) El código debe contener exactamente 4 caracteres.

} public void setVence(Date vence) { this. valor = (int) (diasCobro() * interes() * this.setaPagar(aPagar).getInstance().045.setPago(pago). if(diasCobro()>=90) valor=0. } public void setPago(Date pago) { this. return valor. Date pago) { this. } else { this.pago = pago. if(diasCobro()>=31 && diasCobro()<=90) valor=0.vence = vence.aPagar). } public void setaPagar(int aPagar) { if(aPagar <0){ this.aPagar=0.} public Cobro(String rut.setRut(rut). Date vence.aPagar = aPagar. this.02. } public int calculoInteresAPagar(){ int valor=0. int aPagar.rut = rut.9. } public int getaPagar() { return aPagar. } public String getRut() { return rut. } public int diasCobro(){ Calendar f1 = Calendar. } public void setRut(String rut) { this. if(diasCobro()>=1 && diasCobro()<=30) valor=0.setVence(vence). } } public Date getPago() { return pago. } public double interes(){ double valor=0. return valor. Versión 2. this.0. this. } public Date getVence() { return vence.2 40 de 285 .

import java.println(o3. f2.calculoInteresAPagar()). fechas("15/01/10"). System. fechas("20/01/10"). System. import java. fechas("20/01/10"). public class Ver { public static void main(String[] args) throws ParseException { Cobro o1 = new Cobro("14000000".out. 1000000.text. fechas("17/03/10")).out.println(o1. } } Versión 2. SimpleDateFormat format = new SimpleDateFormat(dateFormatString). 100000. return fe.2 41 de 285 .println(o4.calculoInteresAPagar()).get(Calendar.get(Calendar. int dias = 0. } static Date fechas(String a) throws ParseException{ String dateFormatString = "dd/MM/yyyy".out.out. Cobro o2 = new Cobro("14100000".DATE) + 1.Date.calculoInteresAPagar()).setTime(this.f1. -200000. Cobro o3 = new Cobro("14000000".setTime(this.println(o2.f1.getVence()).ParseException. import java.SimpleDateFormat. System. return dias.getPago()). Date fe = format. Calendar f2 = Calendar.util.calculoInteresAPagar()). fechas("16/01/10")). Cobro o4 = new Cobro("14200000". dias = f2. 500000.getInstance(). System. fechas("15/01/10").parse(a). fechas("31/01/10")).DATE) . } } package view. fechas("01/01/10")).text.

int a[]=new int[]{1.12.0.15. todos los componentes del arreglo de tipo double. Por ejemplo. Por ejemplo: a.2 Conocimiento previo Contenidos de las clases 1.length.17.16.13. double[] vValido = {12. una lista con valores válidos para el desarrollo de un examen.1 Objetivos Manejar el concepto de arreglo unidimensional y aplicarlo en el uso de algoritmos.0. Versión 2.5. Los que son referenciados o calificados mediante índices o expresiones ordinales encerradas en corchetes. 2.5. 6. 6.14. Un número fijo de componentes. Los elementos de un array se inicializan al valor por defecto del tipo correspondiente: ◦ ◦ ◦ ◦ • Cero para valores numéricos La cadena vacía para String False para boolean null para referencias • • Como todos los objetos.2.3}.0.5} Algunas de sus características de los arreglos: • • Se crean con el operador new seguido del tipo y número de elementos. que actúan como prefijo al identificador del arreglo.5.14. 2.2 42 de 285 .0.0.17. los arreglos se pasan como argumentos a los métodos por referencia. int a[ ] = new int[10].0. Se puede acceder al número de elementos de un array con la variable miembro implícita length.13.5.5. por ejemplo. // resultado 10 Se accede a los elementos de un arreglo con los corchetes [ ] y un índice que varía de 0 a length-1.6 Clase 6. 3.3 Arreglos unidimensionales Un arreglo es una lista de datos con: 1. Todos del mismo tipo.16. 3 y 4.15.

primes = new int[10]. Versión 2. Una secuencia de datos del tipo String (cadena) se puede declarar como: String datos[ ] = {"A1".10}.9.7.6. primes[1]=2. primes[5]=6.8. primes[2]=3. También es válido String datos[2] = new String[ ].3. datos[0]=new String("A1").5.2 43 de 285 .2.4. datos[0]="A1". primes[7]=8."A2"}. primes[8]=9. primes[9]=10. primes[4]=5. También es válido para el caso anterior: int primes[ ] = {1. primes[6]=7.4 Declaración de arreglos Para inicializar el arreglo podemos emplear: int primes[ ]. También es válido String datos[2] = new String[ ].6. primes[0]=1. primes[3]=4. datos[1]=new String("A2"). datos[1]="A2".

//Definición del arreglo //Recorre e imprime todos los elementos de un array //previniendo índices fuera de rango for(int elemento: arrayInt) System.6.println (elemento). i < arrayInt. for(int i=0. 20. 30.2 44 de 285 . } } } Con un for versión 1. 5}. } } //Definición del arreglo Con un while: public class RecorrerArreglo { public static void main(String[] args) { int[] arrayInt = {1. 2. int i=0.println (arrayInt[i]).out. 5}. 30. 20. 30. 3. while(i<arrayInt. 2.5 de java: public class RecorrerArreglo { public static void main(String[] args) { int[] arrayInt = {1. i++. 20. } } Versión 2. 3.length){ System. 3. i++) System.println (arrayInt[i]). 5}. 2.length.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.out.out.

int b[] = (int[])a.println("----------").b[j]). public class Aleatorios { public static void main(String[] args) { double[] samples = new double[10].out.3}.6.Random() genera números double entre 0 y menor que 1.2. for(int j=0.out. public class AsignarArray { int a[] = {1.length. for(int i=0. } } Notar que los valores del arreglo b no fueron modificados.a[i]).2 45 de 285 .println(samples[i]). i++) { System.0. Así. j<3.println(obj. 6. System. i < samples. i++) System. esto afectará al valor de arreglo de destino.7 Ejemplos 1. } for(int i = 0. a = b. se está haciendo una copia de la referencia a los mismos datos en memoria. //Esto debe ser desarrollado en un método y no directamente en la clase.2. Math.. Para evitar lo anterior se debe usar el método clone() que realiza una copia del objeto arreglo en otro objeto arreglo.0.println(obj.random() + 1. i++) { samples[i] = 100. De esta manera.. j++) System.. public static void main(String args[]){ AsignarArray obj = new AsignarArray().out. Crear 10 número decimales aleatorios entre 1 (inclusive) hasta antes de 100. .a[1]=111. i<3. for(int i = 0. i < samples. obj.3}.6 Asignación de arreglos Java permite la asignación de un arreglo a otro arreglo. Por ejemplo: int a[ ] = {1.0*Math. al modificar un valor en el arreglo de origen.length. int b[ ] = new int[3].out.clone(). } } } Versión 2.

3. Calcular el promedio de valores almacenados en un arreglo unidimensional.println(prom). } } Versión 2. i++) { System.. i < samples.random() + 1. int max = 0. } } 4.out.println(samples[i]).-1.length.length.out. } for(int i = 0.}. i++){ prom = prom + val[i]. double prom = 0.println(max).4}.9999 (int)1..0)..2.0. package view. i < val. Crear 10 número enteros aleatorios entre 1 y 100 (ambos incluidos). 20.out.. public class Arreglo02 { public static void main(String[] args) { double[] val = {1.. Encontrar el máximo en un grupo de valores en un arreglo unidimensional. for(int i=0.2 46 de 285 .length. 30. i++) { samples[i] = (int) (100. 5.length. public class Maximo { public static void main(String[] args) { int[] a = {2.0 * Math. } } } 3. for(int e: a) if(e>max) max=e. Considerar que: (int)100.4.1.001 ==> 100 ==> 1 public class Aleatorios { public static void main(String[] args) { int[] samples = new int[10]. 2. System. } prom = prom / val. i < samples. System. for(int i = 0.3.

3 Arreglos de objetos Se puede crear una matriz de objetos de cualquier clase. Cada elemento de la matriz de objeto será inicializado con el valor null. Se procede de la misma manera que se crea una matriz de números o de caracteres.0.7 Clase 7. CPersona[99] En este ejemplo tenemos la clase Alumno que recibe datos de alumnos y los encapsula: public AlumnoMatrizObjeto(String alumno. public AlumnoMatrizObjeto() { } CPersona[0] CPersona[1] . para crear crear una matriz de objetos de la clase CPersona que soporte 100 elementos.. Por ejemplo. int edad.. double notaFinal ) { setAlumno(alumno). private double notaFinal = 0.1 Objetivos Manejar el uso de arreglos de objetos.. 7.2 Conocimiento previo Uso de arreglos unidimensionales y encapsulación de datos. } public String getAlumno() { return alumno. setEdad(edad). private int edad = 0. el objeto listaPersona que referencias a objeto de la clase CPersona. 7. Para asignar un valor a la matriz se puede usar: listaPersonas[i]= new CPersona([argumentos]) listaPersonas             public class AlumnoMatrizObjeto { private String alumno = new String(""). } Versión 2.2 47 de 285 . se procede: CPersona[ ] listaPersonas = new CPersona[100] Así se tiene. setNotaFinal(notaFinal)..

2"}."25". i<obj.getEdad().parseDouble(obj. Versión 2."6.6"} }.notaFinal = notaFinal.4 Uso de parámetros tipo arreglo Al devolver información de un método mediante return."4. } La clase que muestra información recupera los datos y los encapsula como objeto de AlumnoMatrizObjeto. i++) { datosAlumnos[i] = new AlumnoMatrizObjeto(obj.out. suma=0.datos[i][0]. public static void main(String args[]){ for(int i=0. System.2 48 de 285 .out. } for(int i=0.length.println("Suma notas:" + suma). Double. for(int i=0.datos.parseInt(obj."3. } public void setNotaFinal(double notaFinal) { this. la lista de parámetros del método debe indicar que se recibirá un arreglo.println("Suma edades:" + suma). static AlumnoMatrizObjeto obj1 = new AlumnoMatrizObjeto(). las variables de tipo de datos primitivos siempre se devuelven por valor y los objetos siempre se devuelven por referencia. i<obj. i++) suma = suma + datosAlumnos[i]. i++) suma = suma + datosAlumnos[i].datos. } public void setEdad(int edad) { this.datos[i][2])). } public int getEdad() { return edad. Integer. System. Luego usando esta encapsulación recupera datos desde los objeto y hace cálculos: public class AlumnoMatrizObjetoView { static AlumnoMatrizObjetoDatos obj = new AlumnoMatrizObjetoDatos(). {"Graciela Perez".2"}.getNotaFinal().datos.edad = edad. } } 7.datos[i][1]).length. al método “modificar” anterior se procede: modificar( c ). {"Carla Perez". } public double getNotaFinal() { return notaFinal.0. i<obj. } } Esta clase contiene los datos: public class AlumnoMatrizObjetoDatos { public static String[][] datos = {{"Juan Perez". static AlumnoMatrizObjeto[] datosAlumnos = new AlumnoMatrizObjeto[3]."18"."24".length.public void setAlumno(String alumno) { this. por ejemplo int c[ ].alumno = alumno. Por ejemplo para definir un método se puede usar: void modificar(int x[ ]) Para pasar un arreglo. Para que un método reciba un arreglo a través de una llamada de método. static double suma = 0.

i<palabra. for(int dato: datos) if(dato>max) max = dato.length. • static void sort(T[] datos. int hasta) Ordena el array entre las posiciones indicadas.-2. Crear un método 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.length. 7.println(maxDatos(datos)). } } 2. que sea capaz de calcular y devolver la cantidad de números. return cant. public static void main(String[] args) { System. } } public static void main(String[] args) { Trabajador obj = new Trabajador(). int desde. public class Trabajador { public double calcularPromedio(double[] valores){ double prom = 0.length.5}. public class Trabajador { public int cuentaNumeros(char[] palabra){ int cant = 0.2 49 de 285 . reales.isDigit(palabra[i])) cant = cant + 1.5 La clase Arrays Esta clase proporciona múltiples métodos para manipular arreglos sobre múltiples tipos de datos T: primitivos (enteros. for(int i=0. Crear un método que reciba un arreglo de tipo char. return max. caracteres y booleanos) y objetos. Versión 2.out. for(int i=0.-1.000 en 1er día de trabajo”.0. i++) prom = prom + valores[i].6 Ejemplos 1. return prom/valores. i<valores.6. • static void sort(T[] datos) Ordena el array. i++) if(Character.Crear un método que sea capaz de recibir un arreglo unidimensional de enteros y devuelva el mayor valor: package dat.0.0. Considera la frase “Juan a ganado $890. } static int maxDatos(int datos[]){ int max=0. } } 7. public class ParametroArreglo01 { static int[] datos = {4.

1.'a'.' '.'j'.85. Use los datos: x={1. 1.73. (a) La media de las estaturas. 1. 49.10.'b'. 1.4.'n'. (c) Determine cuántos son más altos y cuantos más bajos que la media.'n'.7.44.'o'}. La moda es el número más repetido (considerar que ese valor es único).char[] valores = {'J'.'a'.91} y={45.'a'.78.56. (f) Use los datos: {1. System.61.'0'. 1.2 50 de 285 .'í'.'e'.'a'.'r'.'.85.' '.' '. (d) La desviación estándar: (e) Calcular la moda (si no la hay devolver -1). Se piden crear métodos que reciban un arreglo del tipo citado y sean capaces devolver lo solicitado.cuentaNumeros(valores)).' '.println("Promedio: " + obj.' '.5} Observar que para estos datos el valor de n = 10.'d'.'0'.85.out. } 7.30. 89.62. 1.'t'.'0'.3. 1. 65. 1.' '.'a'. 56.'e'. 1. 61. '$'.'g'.'u'.70.98.'d'.'9'.'a'.'o'.50.0. 1.3.78}.'8'.' '. 1.' '.7 Trabajo 3 Desarrollar un programa que reciba un arreglo de n números reales correspondientes a las estaturas de n personas. (b) Las alturas máxima y mínima. 1. 56. 2.4. Calcular los valores a y b indicados los cuales son utilizados para encontrar la recta de regresión y = a + b*x.'1'.4. 1.'r'. Versión 2. Observar que para estos datos en valor de n = 8.2. 80.3. Considerar dos arreglos unidimensionales x e y de valores decimales y del mismo rango.'0'.90. 1. 1.'e'.'n'.45. 70.'a'.'. 44. 'd'.

i<temperature.println("Dia:"+(i+1)+"--------------"). for(int j = 0. puede declarar este arreglo: float[][] temperature = new float[10][365].length. i++) { for(int j = 0. Suponga que se desea simular estas temperaturas.length. j < temperature[0].10. } } } } Versión 2. 8.println(temperature[i][j]). 8.8 Clase 8.2 51 de 285 . i++) { System.3 Arreglos Bidimensionales Supongamos que usted tiene un interés en el tiempo. y tiene la intención de registrar la temperatura de cada día durante un año en 10 ubicaciones geográficas separadas a lo largo del año.out. j++) { System. j < temperature[0]. j++) { temperature[i][j] = (float)(45. para lo cual tiene como información que estos valores están entre -10ºC y +35ºC package dat. Una vez que haya solucionado la logística de la recogida de esta información. } } for(int i = 0.out. // Temperature array for(int i = 0. i<temperature. public class Temperatura { public static void main(String[] args) { float[][] temperature = new float[365][10].0*Math.2 Conocimiento previo Uso de arreglos unidimensionales.length.random() .1 Objetivos Manejar el concepto de arreglo bidimensional y aplicarlo en el uso de algoritmos.0).length.

2.4.length = x[ 0] .length. Máximo Matriz.4 Inicialización de arreglos bidimensionales Para el caso de arreglos tipo String String datos[ ][ ] = {{"A1". j++) if(x[i][j] > max) max = x[i][j]. } } 1.length.length.3.5 Ejemplos public class MaximoMatrizFilas { static int x[][] = {{2. System.3.length = 1 5 x10 x11 x12 x13 x14 x15 2.length.println(max). // resultado 10 → cantidad de filas a[0]. {8. i < x[0].2. public static void main(String[] args) { int max=x[0][0].-1."A2"}.7} }.length.2. recorrida por columnas public class MaximoMatrizColumnas { static int x[][] = {{2. {8.7} }. a.4}.length = 1 5 x10 x11 x12 x13 x14 x15 Versión 2.out. // resultado 3 → cantidad de columnas 8.length.9.En este caso para la contabilización de las columnas se procede: int a[ ][ ] = new int[10][3].1.4.9. i++) for(int j=0.println(max).2.-3. public static void main(String[] args) { int max=x[0][0]. j < x.4}.-1. i < x. for(int i=0. {"Enlatados".2 52 de 285 . j++) if(x[j][i] > max) max = x[j][i].out. 8. i++) for(int j=0. Máximo Matriz."natural"}}. for(int i=0. j < x[0].-3. System. recorrida por filas x00 2 8 x01 -1 2 x02 4 -3 x03 3 9 x04 1 2 x05 4 7 x. } } x00 2 8 x01 -1 2 x02 4 -3 x03 3 9 x04 1 2 x05 4 7 x.1.length = x[ 0] .

entonces para los tres productos se debe mostrar el stock en bodega. public static void main(String[] args) { int[][] traspuesta = transp(datos). (c) Si selecciona ver stock en bodega.2 53 de 285 . j++) System. (b) Si seleccionar vender. i++) for(int j=0. return resul.out. para cualquiera de los tres productos.4.-45}}. } } static int[][] transp(int[][] datos){ int[][] resul = new int[datos.Crear un método que sea capaz de recibir un arreglo bidimensional cuadrado de enteros y devuelva el arreglo transpuesto: package dat.out.000 40.{21.000 Por cada compra se tiene un descuento por volumen dado por: . 10% descuento  Consideraciones: (a) El sistema pregunta si se desea vender o ver el stock en bodega.print(traspuesta[i][j]+" ").length]. supere el contenido en el stock. Los siguientes datos deben ser definidos en un arreglo bidimensional de tipo String.-45. j < traspuesta. for(int i=0.println().length.000 .length. j++) resul[i][j]=datos[j][i].0}. } } 8.000 20.000 < = Venta < 5. i<datos. i++){ System.6 Trabajo 4 Considerar que se requiere un programa java que sea capaz de manejar las ventas de los siguientes productos.length][datos.length.21. entonces el proceso de venta no se llevará a cabo para ninguno de los producto y se mostrará un mensaje indicando el error.000 .{-50.000 Precio por caja en Ch$ 10. entonces se pide la cantidad de cajas a comprar para los tres productos.12}. 5% descuento  Venta > = 5. Se debe mostrar el total sin descuento por cada producto.length. el total de descuento aplicado a cada producto y el total a pagar.000 5. j < datos.000 1. i<traspuesta. Producto Peras Manzanas Uvas Código AX10 AX20 AX30 Cantidad inicial en bodega (cajas) 10. public class ParametroArreglo02 { static int[][] datos = {{-2. Versión 2. for(int j=0. En el caso que la cantidad a vender. 0% descuento  Venta < 1000 cajas   1. for(int i=0.

2.5% de la nota 1.int inf. 9. 7 y 8 9.int inf.2 54 de 285 .9 Clase 9. (c) Dentro de la clase anterior definir el método: public double posMinimo(String a[ ]. int sup) que recibe un arreglo unidimensional de String y dos valores enteros inf y sup. que recibe un arreglo unidimensional de String y dos valores enteros inf y sup. int sup). (d) Crear un arreglo que almacene los datos ordenados de menor a mayor usando los datos del arreglo unidimensional anterior. (c) Crear un método que almacene en un arreglo unidimensional el promedio de los valores de cada una de las filas del arreglo bidimensional.4. (a) Crear el arreglo.6. -5. inf=1.9. (d) Crear la clase ViewProceso (e) Enviar los valores a[5]={3.1 Objetivos Presentar problemas tipo para la evaluación 2.3 Ejercicio 1 Modelo de evaluación 2 Considerar un arreglo bidimensional de números enteros de orden 4x5. El método regresa el menor valor contenidos entre los índices inf y sup del arreglo a. Valor 12.1}. El método regresa el promedio de los valores contenidos entre los índices inf y sup del arreglo a. Código AX10 AX20 AX30 Precio 1000 500 3000 Cantidad en bodega 10000 30000 500 Las ventas de estos productos deben se almacenadas en un arreglo bidimensional.2 Conocimiento previo Contenidos de las clases 6. Código AX20 AX10 Cantidad 10000 2000 Versión 2. -6. sup=4 al método 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. (b) Crear un método que calcule la cantidad de elementos repetidos en el arreglo.6. 6. Ejercicio 2 (a) Crear la clase Proceso (b) Dentro de la clase anterior definir el método: public double posPromedio(String a[ ].

Ejercicio 5 Crear un arreglo unidimensional que soporte 10 elementos con valores aleatorios entre 0 y 10. Crear otro arreglo bidimensional 5x3 que sea capaz de almacenar los valores ordenados. (b) Crear un método que reciba un valor de tipo String y devuelva la posición 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. Crear un método que calcule la cantidad de números primos contenidos en el arreglo. Crear un método que calcule el promedio de los valores. Crear un método que calcule la cantidad de valores en el arreglo menores que cero. Código del Producto Precio AX10 AX20 AX30 10000 20000 50000 Versión 2. Crear un método que calcule la cantidad de números entre -1 y 1 contenidos en el arreglo. Se pide crear un método que muestre el nombre o apellido con mayor cantidad de letras.AX20 AX30 AX10 AX20 AX30 AX10 25000 300 3000 1000 300 500 Crear un método que sea capaz de devolver en un arreglo bidimensional el código de los productos que tiene ventas sobre el stock de de bodega y las cantidad vendidas sobre el stock de bodega. Crear un arreglo unidimensional que sea capaz de almacenar la suma de cada columna del arreglo. (d) • • • • • • Considerar un arreglo bidimensional 5x3 de datos enteros. (a) Almacenar los valores en un segundo arreglos pero con los valores ordenados. Ejercicio 4 (a) (b) (c) Elabore un método void sin parámetros que para una matriz bidimensional cuadrada “A” con elementos numéricos de tipo String sea capaz de calcular y mostrar: Max(A) – 2*suma(diagonal(A)).2 55 de 285 . Crear un arreglo bidimensional 3x2 de valores enteros aleatorios que contenga sólo números primos. 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 método que calcule el total de letras mayúsculas de todos los nombres.

6". i++){ promedio +=Double. Proceso obj = new Proceso().2 56 de 285 . sup)). int sup){ double minimo=0.parseDouble(a[inf]). Solución ejercicio 2 package dat.posMinimo(a. i<=sup. i++){ if(minimo > Double.4".parseDouble(a[i]). public class Proceso { public double posPromedio(String a[]. public class ViewProceso { public static void main(String[] args) { String[] a = {"3.6".0. inf.out. for(int i=inf. } return promedio/(double)(sup-inf).out. for(int i=inf. minimo=Double. int inf. } } return minimo. System."5."-6.parseDouble(a[i]). int sup){ double promedio=0. sup)).parseDouble(a[i])){ minimo = Double.0.1"}."2. int sup = 4. } public double posMinimo(String a[]. inf. } } package dat. i<=sup. int inf = 1.println(obj. (b) Crear un método sin parámetros que calcule la suma total en pesos vendidos para cada uno de los clientes. System."6.println(obj. } } Versión 2.9".Las ventas que se deben considerar son: Rut Producto 14000000 14200000 14100000 14000000 14100000 14000000 14300000 AX20 AX10 AX30 AX20 AX10 AX30 AX30 Cantidad 100 40 30 150 200 50 80 Se pide: (a) Crear un método sin parámetros que calcule la cantidad de productos vendidos de cada tipo.posPromedio(a. int inf.

y sistemas para la gestión de tráfico aéreo o ferroviario. La complejidad del software es una propiedad esencial. Versión 2. Ley. no accidental. la integridad de cientos de miles de registros de información que mientras se permiten actualizaciones y consultas concurrentes. 10.10 10.1 Objetivos Clase Manejar en concepto de diagramación UML.2 57 de 285 . Para ser claro.2 Conocimiento previo Concepto de clase. la complejidad de tales sistemas excede la capacidad intelectual humana. La característica principal del software de dimensión industrial es que resulta sumamente difícil. y a lo largo del tiempo muchos usuarios llegan a depender de su funcionamiento correcto. Aquí se encuentran aplicaciones que mantienen. 10.3 Uso de la herencia en la POO Nos interesan los desafíos que plantean el desarrollo de lo que llamaremos software de dimensión industrial. si no imposible. Los sistemas de software de esta clase tienden a tener un ciclo de vida largo. tributos y métodos. La complejidad se deriva de: • La complejidad del dominio del problema. para el desarrollador individual comprender todas las partes de su diseño. por ejemplo.

construir y documentar un sistema. Las consecuencias de la complejidad son: • Cuando más complejo sea el sistema. que exceden el presupuesto. y aspectos concretos como expresiones de lenguajes de programación. es el lenguaje en el que está descrito el modelo. los cuales muestran diferentes aspectos de las entidades representadas. Versión 2. Los problemas de caracterizar el comportamiento de sistemas discretos. • 10. hacer estos sería muy costoso e indudablemente sería una invitación al fracaso.0 hay 13 tipos diferentes de diagramas. los usuarios de sistemas de software casi nunca se lo piensan dos veces a la hora de solicitar tales cambios. Se utiliza para definir un sistema. esquemas de bases de datos y componentes reutilizables. para detallar los artefactos en el sistema y para documentar y construir. incluyendo aspectos conceptuales tales como procesos de negocio y funciones del sistema. Un constructor pensaría raramente en añadir un subsotano a un edificio ya construido de cien plantas.2 58 de 285 . Es un lenguaje gráfico para visualizar. por sus siglas en inglés. está respaldado por el OMG (Object Management Group).• • • La dificultad de gestionar el proceso de desarrollo. Es importante resaltar que UML es un "lenguaje de modelado" para especificar o para describir métodos o procesos. En UML 2.4 UML Lenguaje Unificado de Modelado (UML. UML cuenta con varios tipos de diagramas. En otras palabras. más abierto está al derrumbamiento total. y que son deficientes respecto a los requerimientos fijados. Se puede aplicar en el desarrollo de software entregando gran variedad de formas para dar soporte a una metodología de desarrollo de software (tal como el Proceso Unificado Racional o RUP). La flexibilidad que se puede alcanzar a través del software. Unified Modeling Language) es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad. Asombrosamente. UML ofrece un estándar para describir un "plano" del sistema (modelo). La programación orientada a objetos viene siendo un complemento perfecto de UML. pero no especifica en sí mismo qué metodología o proceso usar. pero no por eso se toma UML sólo para lenguajes orientados a objetos. especificar. Nuestro fracaso en dominar la complejidad del software lleva a proyectos retrasados.

Para el diseño de diagramas puedes emplear diversas aplicaciones que permiten en diversos niveles diagramas y controlar el proyecto. Si el nombre de la clase consta de más de una palabra únalas e inicie cada palabra con mayúscula. Además. Sin embargo. El nombre de la clase se coloca en la parte superior del rectángulo y es una palabra con la primera letra en mayúscula. Los estereotipos son un conjunto de acciones que se realizaran una y otra vez. se podrá indicar el tipo de datos devuelto. float. Para este curso puedes usar la aplicación “dia” que puede ser bajada desde http://live. Las operaciones es algo que la clase puede realizar. si el nombre consiste en más de una palabra. esta es una clase que declara operaciones pero no las implementa. En los paréntesis podrá los parámetros con los cuales funciona la operación junto con su tipo de dato. Además. integer. cada palabra será unida a la anterior y comenzará con una mayúscula. Versión 2. String.gnome.2 59 de 285 . un estereotipo permite crear nuevos elementos a partir de otros ya existentes. Si el atributo consiste de una sola palabra se escribe en minúscula. boolean. se podrá especificar el tipo de cada atributo. Se indican entre paréntesis dobles «nombreEstereotipo». Un ejemplo de esto son las interfaces de java. Se aplica el mismo estándar de nombre que los atributos. De esta manera.org/Dia. El atributo es una propiedad o característica de una clase y describe un rango de valores que la propiedad podrá contener en los objetos de la clase.

por ejemplo. entonces esto no implica que los puntos dejen de existir. El diamante blanco ilustra lo anterior. si el MedioDeTransporte (por ejemplo.5 Agregación Se crean objetos de las clases existentes dentro de la nueva clase.2 60 de 285 . Cuando modele con agregación tenga la precaución que se cumpla la relación “es–parte-de”. entonces las ruedas como concepto siguen existiendo independientemente (podríamos decir que las ruedas puede utilizarse en otros artefactos que no son medios de transporte. los puntos tiene vida propia independiente de la existencia o no de los polígonos. Más específicamente. la agregación se produce cuando una clase consta de otras. el automóvil) se “destruye”.10. ruedas dentadas) Versión 2. su ciclo de vida de las Ruedas no esta atado a MedioDeTransporte. Notar una característica que se cumple para este diagrama: • • • Los puntos son parte de los polígonos Si los polígonos no existen. Es decir. Veamos otros ejemplos • • Las ruedas forman parte del MedioDeTransporte (por ejemplo un automóvil) Pero. Esto es lo que hemos vistos en los capítulos anteriores. Simplemente se está reutilizando (y no especializando) la funcionalidad del código. Por ende.

10.6 Composición Con la composición. Cualquier borrado del todo se extiende en cascada a las partes. se espera. Es decir que si la ruta de viaje se levanta. por lo general. Y a diferencia de la asociación. que las partes vivan y mueran con el todo. Versión 2. por lo que no necesitan métodos de destrucción de los objetos (relacionados a los ciclos de vida en la composición). es más. es una relación estructural pero se le suma.2 61 de 285 . el objeto parte puede pertenecer a un todo único. ya que algunos sostienen que los lenguajes orientados a objetos. las áreas que surgían a partir de ella desaparecen. Al igual que en la agregación. el ciclo de vida del objeto Area está relacionado con el del objeto Ruta. Mucho se ha discutido a cerca de las agregaciones y las composiciones. tienen garbage collector. y que la diferencia es meramente conceptual entre una y otras. La programación es la misma para las composiciones y las agregaciones. que tiene un método de destrucción de los objetos.

que es del tipo Conductor. una relación estructural entre clases o la conexión conceptual entre dos clases. cual es la clase que tiene contiene el atributo si ésta no lo mostrase.7 Asociación Es generalmente.2 62 de 285 . En el ejemplo. 10. existe un atributo “conductor” en la clase MedioDeTransportes.10. Es decir.8 Multiplicidad Versión 2. La navegalidad nos muestra donde esta ubicado el atributo.

Versión 2. la reutilización del software es crear nuevas clases a partir de clases ya existentes. se utilizan clases ya existentes que otras personas ya han construido y depurado (sin modificar el código existentes en ellas). pero en vez de crearlas de la nada. Así. Esto se consigue con el concepto de herencia.10. SubClase: Cuerdas Método: Tocar( ) Incorpora la forma específica de tocar instrumentos de cuerda. absorbiendo sus atributos y comportamientos e incorporando capacidades que las nuevas clases requieren. Clase: Instrumento Método: Tocar( ) Contiene generalidades de cómo tocar los diversos instrumentos.9 Herencia La reutilización del software se consigue creando nuevas clases.2 63 de 285 .

2 64 de 285 .Versión 2.

OMT.10 Definiciones de herencia La herencia es un concepto que tiene relación directa con la reutilización de código. James Rumbaugh es un científico de la computación y un metodologista de objeto. Veamos varias definiciones de herencia 1. Se unió a Rational Software en 1994. después de su adquisición de Rational Software. Ha escrito varios libros sobre UML y RUP. Versión 2.I. Se retiró en 2006. en el Centro de Investigación y Desarrollo de la General Electric. En el 2003 se trasladó a IBM. Más tarde fusionaron sus metodologías de desarrollo de software. donde trabajó durante más de 25 años. Primero el maestro Rumbaugh.10. El objetivo es usar lo ya hecho y especializarlo. Es mejor conocido por su trabajo en la creación de la Técnica de Modelado de Objetos y el Lenguaje Unificado de Modelado (UML). Doctorado en ciencias de la computación por el M. junto a Ivar Jacobson y Grady Booch.2 65 de 285 . Rumbaugh dirigió el desarrollo de la OMT. y trabajó allí con Ivar Jacobson y Grady Booch ("los Tres Amigos") para desarrollar UML.T. OOSE y Booch en el Proceso Unificado Racional (RUP).

Como todas las clases. Según Microsoft La herencia. Por ejemplo: Si declaramos una clase párrafo derivada de una clase texto.Ejemplos de utilización de herencia 2. creando categorías. obteniendo características (métodos y atributos) similares a los ya existentes.2 66 de 285 . En la ilustración siguiente se muestra una clase WorkItem que representa un elemento de trabajo en algún proceso de negocio. porque los constructores no se heredan. junto con la encapsulación y el polimorfismo. ChangeRequest agrega dos miembros más a los miembros que hereda de WorkItem y Object. La clase cuyos miembros se heredan se denomina clase base y la clase que hereda esos miembros se denomina clase derivada. de la misma forma en que piensa el ser humano. La herencia es uno de los mecanismos de la programación orientada a objetos. La idea es la de partir de las situaciones más generales e ir derivando hacia las más particulares. Debe agregar su propio constructor y también agrega un miembro que permitirá asociar ChangeRequest al elemento WorkItem original al que se aplica el cambio. todos los métodos y variables asociadas con la clase texto. Según Wikipedia Es una propiedad que permite que los objetos sean creados a partir de otros ya existentes. Versión 2. deriva de Object y hereda todos sus métodos. extienden y modifican el comportamiento que se define en otras clases. son automáticamente heredados por la subclase párrafo. Esto incluye un constructor. La herencia permite crear nuevas clases que reutilizan. llamada entonces superclase. ChangeRequest hereda de WorkItem y representa un tipo determinado de elemento de trabajo. nos permite compartir automáticamente métodos y datos entre clases subclases y objetos. es una de las tres características principales (o "pilares") de la programación orientada a objetos. • • • • Es la relación entre una clase general y otra clase más especifica. WorkItem agrega cinco miembros propios. de manera que extiende su funcionalidad. • 3. por medio del cual una clase se deriva de otra. Es un mecanismo que nos permite crear clases derivadas a partir de clase base.

2 67 de 285 . Según 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 características” En este ejemplo: • • La clase “Manager” va a sobre escribir el método increaseSalary() La clase Engineer va a usar los métodos de la clase Employee Versión 2.4.

auxiliares o instructores. Estas personas consisten en empleados. asociados. Una superclase existe en una relación jerárquica con sus subclases: Ejemplo: • • • • • • Una comunidad universitaria típica comprende miles de personas que son miembros de la comunidad.11 Relación “es-un”·y “tiene-un” 10. Los estudiantes pueden ser de pregrado y postgrado. estudiantes y ex alumnos. Los de planta pueden ser titulares.12 Subclases Las relaciones de herencia forman estructuras jerárquicas similares a árbol. Los docentes pueden ser de planta o contratados por horas. personal administrativo o directivos. Los empleados son docentes.2 68 de 285 . Versión 2.10.

Un helicóptero también es un vehículo y tiene otro método distinto de moverse hacia un destino.2 69 de 285 .Ejemplo: • • • • • Un auto es un tipo especial de vehículo Lo datos que definen su estado incluyen a los necesarios para el vehículo genérico y algunos más. Versión 2. Un Ferrari TestaRossa es un tipo concreto de auto que tiene una forma particular de sustituir un fusible. Tiene un método particular para moverse hacia un destino y un método exclusivo de cambiar una rueda.

La subclase puede utilizar los ítems heredados de su superclase tal y como son. o puede modificarlos o sobrescribirlos. Por eso.2 70 de 285 . 11. las clases se convierten en más y más especializadas. Por ejemplo 11.4 • • • Sobrescribir métodos Las subclases heredan el estado y el comportamiento en forma de las variables y los métodos de su superclase. se emplea la palabra reservada extends.2 Conocimiento previo Conceptos de UML. según se va bajando por el árbol de la herencia.3 extends Si se requiere que la clase “ComisionEmpleado” herede de la clase “Empleado” en java.1 Objetivos Manejar y aplicar el concepto de herencia Clase 11.11 11. Los métodos private se puede sobrescribir Versión 2.

5 • • • Object En java todas las clases deben derivar de alguna otra. la clase de la que todas las demás descienden.2 71 de 285 . La clase más alta. definida en java.Los métodos protected NO se pueden sobrescribir private Los métodos public NO se pueden sobrescribir protected o private 11.lang. Versión 2. Object es la raíz de la herencia de todas las clases. es la clase Object.

entonces se puede acceder a este último mediante super desde una subclase.6 • • super Se utiliza para dar acceso a miembros de una superclase desde una subclase. Si un método sobrescribe un método de una superclase.2 72 de 285 . entonces.11. Si no se llama implícitamente a un constructor de la superclase. entonces se puede acceder desde una subclase mediante super. el constructor de la subclase llamará implícitamente al constructor por omisión de la superclase (constructor sin argumentos). Versión 2. Por ejemplo: • • Si un método oculta una de las variables miembros de una superclase. • • Se puede incluir una llamada explícita al constructor de la superclase (mediante la referencia super) como primer enunciado del constructor de la subclase.

1. 6. 3. El constructor de la clase This_b llama.2 73 de 285 . 5. 4. El objeto c llama al constructor de la clase This_c.y). al constructor de la clase This_b. al constructor de la clase This_a. Se baja a la clase This_c que da el valor z=10. Se baja a la clase This_b que da el valor y=5. mediante super(x. Versión 2. El constructor de la clase This_c llama. mediante super(x). El valor de x=4 se da en la clase This_a. 2.

• Se debe generar una superclase Media y una subclase Desviacion.datos[i]=datos[i].2 74 de 285 .datos[i]. i++) resultado = resultado + this. for(int i=0.7 • Ejemplo 1 Calcular la media aritmética y desviación estándar enviando los datos en un arreglo de largo 6 desde el método constructor. } } Versión 2. } public double mediaDes(){ double resultado=0. i++) this. public Media(double[] datos){ for(int i=0.11. i<6. public class Media{ public double[] datos = new double[6]. Recordar que los arreglos en java requieren tener un largo fijo antes de ser usados. i<6.0). en donde se especialice el método mediaDes() de la clase Media en la subclase Desviacion. return (resultado/6.0.

resultado = Math. public void init(){ obj1 = new Media(datos).0.Applet.mediaDes()).0. obj2 = new Desviacion(datos). } public double mediaDes(){ double resultado=0. } public void paint(Graphics g){ g.0).5.3. i<6.0}.awt.0). return (resultado/6.Graphics. for(int i=0.6. i++) this.datos[i]=datos[i].pow(this.pow(resultado/(6.20.0.0).20.valueOf(obj2.2.0. i++) resultado = Math.public class Desviacion extends Media{ public double[] datos = new double[6].applet.0.drawString("Media: "+ String. i<6. public Media obj1. public class Ver extends Applet{ public double datos[] = {1. } } Resultado: Versión 2. public Desviacion obj2.2 75 de 285 .0. import java.mediaDes().0.mediaDes()).drawString("Desviacion Estandar: "+ String.4.5).valueOf(obj1. public Desviacion(double[] datos){ super(datos). for(int i=0. } } import java.2.datos[i]-super.40).20).0-5. g.

atributos y métodos Versión 2.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.11.2 76 de 285 .

} public void setNombre(String nombre) { this. } public void setNumero(int numero) { this. val = super. } public int getGoles() { return goles. public Atacante() { } //Método para recibir los datos indicados public Atacante(String nombre. setNumero(numero). setRecuperados(recuperados). int numero. private int goles=0. } } package proc.package proc. } } Versión 2. int recuperados) { super(nombre. int goles) { setNombre(nombre). setGoles(goles). } //Método propio de todos los atacantes @Override public int valoracion(){ int val=0.recuperados = recuperados. public Jugador() { } //Método para recibir los datos indicados public Jugador(String nombre. } public int getRecuperados() { return recuperados. } public int getPases() { return pases. private int numero=0.goles = goles. return val. } public String getNombre() { return nombre. } public void setPases(int pases) { this. setPases(pases).nombre = nombre. val = getGoles() * 30. return val.numero = numero. numero. } public void setGoles(int goles) { this. goles). } public int getNumero() { return numero. int goles. public class Atacante extends Jugador { //Conceptos propios de los atacantes private int pases=0. } //Método propio de todos los jugadores public int valoracion(){ int val=0.pases = pases. private int recuperados=0. public class Jugador { //Conceptos comunes a todos los jugadores private String nombre="". int pases. int numero. } public void setRecuperados(int recuperados) { this.valoracion() + getPases()*2 + getRecuperados()*3.2 77 de 285 .

public Portero() { } //Método para recibir los datos indicados public Portero(String nombre.paradas = paradas.2 78 de 285 . public class Portero extends Jugador { //Conceptos propios de los porteros private int paradas=0. } public int getParadas() { return paradas. goles). } //Método propio de todos los porteros @Override public int valoracion(){ int val=0. int recuperados) { super(nombre. val = super. return val. public Defensor() { } //Método para recibir los datos indicados public Defensor(String nombre.valoracion() + getPases()*1 + getRecuperados()*4. val = super. } public int getPases() { return pases. numero. setPases(pases). } public void setParadas(int paradas) { this. setRecuperados(recuperados). setParadas(paradas).recuperados = recuperados. } } Versión 2. goles).package proc. } public void setPases(int pases) { this. private int recuperados=0. } } package proc. int pases. } //Método propio de todos los defensores @Override public int valoracion(){ int val=0. return val. int goles. } public int getRecuperados() { return recuperados.pases = pases. int numero. public class Defensor extends Jugador { //Conceptos propios de los defensores private int pases=0. } public void setRecuperados(int recuperados) { this.valoracion() + getParadas()*5. numero. int goles. int paradas) { super(nombre. int numero.

public int y.11.9 • • • Métodos final Son métodos que implementan un bloqueo para evitar que cualquiera clase heredada sobrescriba el método. } Intenta sobrescribir el método final “radio” } 11. public Sobre( ) { x = 4. public int b. Cualquier método private o static de una clase es implícitamente final. } final void radio(int z) { z = x + y. evitando que sea sobrescrito. y = 5. Versión 2. Los métodos de una clase final son automáticamente final. public IntentaSobrescribir(){ super().2 79 de 285 . La clase String del paquete java.lang es de este tipo. b=4. } } public class IntentaSobrescribir extends Sobre { public int a. a=3. Así. } void radio (int c) { c = a * b. Esto previenen posibles ataques que se intenten desarrollar a la clase. public class Sobre { public int x. se asegura que se mantenga el comportamiento durante la herencia.10 • • • • Clases final Son clases que no pueden tener subclases.

private int y=0.setY(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. } public void setX(int x) { this. } public void radio(int z) { z = x + y.setX(x). } public int getY() { return y. int y) { this. El área de un círculo es: Volumen del cilindro es: Versión 2. public A() { } public A(int x.2 80 de 285 .final public class A { private int x=0.y = y. } public void setY(int y) { this. } public int getX() { return x.x = x. this.

▪ Pago por monto fijo. Versión 2.2 81 de 285 .3 Clases abstractas Son clases que no necesitan ser instanciadas (no se generan objetos de ellas). • Un método abstracto es aquel que está sólo declarado. ◦ Por ejemplo. o sino. si en la clase A se define el método abstracto sueldo. Si una clase B hereda desde una clase abstracta. La clase C proporcionará su propia implementación al método Contablizar().2 Conocimiento previo Uso de herencia. se puede dejar parte de la implementación a sus subclases y el resto se puede implementar en la propia clase abstracta. pero que sus subclases implementen de acuerdo al uso que se quiera dar. 12. En UML se denota en letras cursivas o mediante estereotipos. 12.12 12. • • • Una clase abstracta no necesita contener un método abstracto. polimorfismo e interfaces. Una clase abstracta puede contener métodos abstracto y no abstractos. entonces las subclases de A darán su propia implementación al método sueldo: ▪ Pago por horas. Así. la clase B debe ser definida como abstracta. • • La clase B proporcionará su propia implementación al método Contablizar().1 Objetivos Clase Aplicar el concepto de clase abstracta. entonces debe dar implementación a todos los métodos abstractos.

etc. Los objetos gráficos no pueden compartir estos tipos de estados o comportamientos.2 82 de 285 . Otra característica relevante es que una clase que hereda desde ObjtoGrafico está obligada a dar implementación al método dibujar(). Versión 2. redimensionado). rectángulos. líneas. a priori. de esta clase no debería heredar la clase Trabajador. Cada uno de esos objetos gráficos comparten ciertos estados (posición. los objetos gráficos también tienen diferencias substanciales: dibujar un círculo es bastante diferente a dibujar un rectángulo.También se puede dar Ejemplo: • • • • En una aplicación de dibujo orientada a objetos. Por ende. Sin embargo. caja de dibujo) y comportamiento (movimiento. se pueden dibujar círculos. Podemos aprovecharnos de esas similitudes y declararlos todos a partir de un mismo objeto padre.

private String apellido="".2 83 de 285 . public Fijo(String nombre. String apellido. this. public Horas(String nombre. Este es un típico ejemplo en donde se tiene los trabajadores con distintos tipos de sueldo: Lo interesante de esto. Versión 2.5 • Interfaz Una interfaz es un conjunto de operaciones (métodos) que especifica cierto aspecto de funcionalidad. public Trabaja(String nombre.4 • • Ejemplo 1 Sueldo fijo. } public double sueldo() { return sueldo. } public void setSueldo(double s) { sueldo = (s > 0 ? s : 0). } Trabaja Fijo Horas public String getNombre() { return nombre.setApellido(apellido). } } 12. } public String getApellido() { return apellido. } abstract double sueldo(). double valorHora) { super(nombre.setSueldo(sueldo).double nroHoras. setNroHoras(nroHoras). Sueldo por horas trabajadas.apellido = apellido. es que si se requiere agregar un nuevo tipo de sueldo se debe heredar desde la clase Trabajador. Es un conjunto de operaciones que una clase (la interfaz) presenta a otras.setNombre(nombre). } public void setValorHora(double vh) { valorHora = (vh > 0 ? vh : 0).12. setValorHora(valorHora). private double valorHora. } } public class Horas extends Trabaja { private double nroHoras. double sueldo) { super(nombre. } public void setNroHoras(double nh) { nroHoras = (nh > 0 ? nh : 0). String apellido.apellido). } public void setNombre(String nombre) { this. apellido). this. String apellido) { this. public abstract class Trabaja { private String nombre="". } public class Fijo extends Trabaja { private double sueldo. } public double sueldo() { return nroHoras * valorHora.nombre = nombre. } public void setApellido(String apellido) { this.

Versión 2. Se modelan gráficamente igual que una clase.• • • Una interfaz puede también contener datos miembro. El uso de interfaces proporciona la siguiente ventaja: • • ◦ Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros). o en plural interfaces. Una interfaz en Java es una clase en la que todos sus métodos son abstractos. Serán las clases que implementen estas interfaces las que implementen el comportamiento de los métodos. pero estos son siempre static y final.2 84 de 285 . En ellas se especifica qué se debe hacer pero no su implementación. La palabra en inglés es: interface y la traducción al español es interfaz. pues lo son por estar contenidos en una interfaz. Observar que no es necesario declararlos static o final.

Versión 2.2 85 de 285 .

Versión 2.2 86 de 285 .

12.6 Polimorfismo Versión 2.2 87 de 285 .

Versión 2.2 88 de 285 .

Versión 2.2 89 de 285 .

//Define el arriendo de Libros implementado el método aCobrar() public class Libros extends Item { @Override protected int aCobrar(Alquiler a) { int total =0. } } package owt. • Películas: Todas con un costo fijo de $500. package owt. } public int getDias() { return dias. los Estrenos tiene un costo adicional de $1. //Clase que define el Arriendo recibiendo como datos los días de arriendo public class Alquiler { private int dias=0. public Pelicula() { } public Pelicula(int tipo) { this.getTipo()==2){ Versión 2. abstract public class Item { //Método que usaremos para el proceso requerido abstract protected int aCobrar(Alquiler a). De esta manera. return total. } } package owt. if(this. dependiendo del tipo de producto que se necesita arrendar. el método procede a calcular según se indica: • Libros: Costo de $200 por día. total = a. } package owt. } public int getTipo() { return tipo.getTipo()==1){ total = 500 + a. } @Override protected int aCobrar(Alquiler a) { int total=0. } if(this. //Define el arriendo de Películas implementado el método aCobrar() public final class Pelicula extends Item { private int tipo=0. public Alquiler() { } public Alquiler(int dias) { this. Sin embargo. } public void setTipo(int tipo) { this.2 90 de 285 . } public final void setDias(int dias) { this.7 Ejemplo 2 Suponga que se requiere crear un programa en java que sea capaz de calcular el valor del arriendo de diversos productos.dias = dias.getDias()*1000.tipo = tipo.12.setTipo(tipo).getDias()*200.000 por día y el resto un costo adicional de $100 por día.setDias(dias).

} } package owt.println("Arriendo libro: " + p3.out. Pelicula p1 = new Pelicula(2). System. //Ejecuta procesos public class Ver { public static void main(String[] args){ //3 días de arriendo del tipo de película 2 Alquiler o1 = new Alquiler(3).out. Pelicula p2 = new Pelicula(1). Libros p3 = new Libros(). System.aCobrar(o2)).2 91 de 285 . //4 días de arriendo del tipo de película 1 Alquiler o2 = new Alquiler(4).getDias()*100.total = 500 + a.out. //10 días de arriendo de un libro Alquiler o3 = new Alquiler(10).println("Arriendo pelicula no estreno: " + p1.aCobrar(o3)). } return total.aCobrar(o1)).println("Arriendo pelicula estreno: " + p2. } } Versión 2. System.

diseñe el diagrama de clases y sus relaciones. this. Clase 13. Solución package view. Valor 12.util. public class Alquiler { private String rut.000 y un valor fijo de $1.5% de la nota 2. Date inicio. import java. .3 Ejercicio 1 Modelos de evaluación 3 En un puerto se alquilan amarres para barcos de distinto tipo.fin = fin.2 Conocimiento previo Contenidos de las clases 11. Sin embargo. public Alquiler() { } public Alquiler(String rut. Por cada 10 caballos de fuerza truncado al entero correspondiente un valor fijo de $5.rut = rut.1 Objetivos Desarrollar la evaluación 3. } public Date getFin() { return fin. Un barco se caracteriza por su matrícula y su eslora en metros. Un alquiler se calcula multiplicando el número de días de ocupación (incluyendo los días inicial y final) por un módulo función de cada barco obtenido “multiplicando por 10 los metros de eslora por un valor fijo de $200”.000 La potencia en caballos de fuerza más el número de camarotes para yates de lujo.000 por mástil. con detalle de atributos y métodos necesarios. 13.13 13. 12 y 13. Date fin) { this.Date.000 por camarote. con un valor fijo de $20. ahora se pretende diferenciar la información de algunos tipos de barcos: • • • El número de mástiles para veleros. Por cada 10 caballos de fuerza o fracción de este un valor fijo de $2. Utilizando la herencia de forma apropiada. las fechas inicial y final de alquiler y el barco que lo ocupará.Calendar.util.inicio = inicio.2 92 de 285 . private Date inicio. La potencia en caballos de fuerza para embarcaciones deportivas a motor. } Versión 2. Para cada alquiler se guarda el rut del cliente. import java. this. private Date fin.

getInstance().setTime(this.getFin()). } public int getEslora() { return eslora.eslora = eslora.eslora = eslora. f1. } public Date getInicio() { return inicio. } } package view. f2. } public void setEslora(int eslora) { this.setTime(this.alquiler = alquiler.getInstance().inicio = inicio.matricula = matricula. } public void setInicio(Date inicio) { this. } public void setRut(String rut) { this.get(Calendar. dias = f2.DATE) + 1.f1.get(Calendar. } public int diasCobro(){ Calendar f1 = Calendar.rut = rut. int dias = 0.getInicio()). int eslora. Alquiler alquiler) { this. this.public void setFin(Date fin) { this. return dias. Calendar f2 = Calendar. public Barco() { } public Barco(String matricula. private int eslora.fin = fin. } public String getMatricula() { return matricula. private Alquiler alquiler. public class Barco { private String matricula. this. Versión 2. } public String getRut() { return rut.2 93 de 285 .DATE) .

eslora.mastiles = mastiles. public Deportivas(String matricula. } public Alquiler getAlquiler() { return alquiler.2 94 de 285 .alquiler. Alquiler alquiler. } } package view.mastiles = mastiles. int cc) { super(matricula.cc = cc.} public void setMatricula(String matricula) { this. return valor. } public int getMastiles() { return mastiles. valor = this. public class Deportivas extends Barco { private int cc. alquiler).getMastiles() * 20000. Alquiler alquiler. alquiler).diasCobro() * 10 * this. this. valor = super.matricula = matricula. int mastiles) { super(matricula. } public void setAlquiler(Alquiler alquiler) { this. } } package view. int eslora. this. public class Velero extends Barco { private int mastiles.eslora * 200.eslora. } public void setMastiles(int mastiles) { this. return valor.alquiler = alquiler. int eslora. } public int cobro(){ int valor=0. } @Override public int cobro(){ int valor=0.cobro() + this. } Versión 2. public Velero(String matricula.

double caballo = Math.eslora.2 95 de 285 . valor = (int) (super.). this. Alquiler alquiler.camatores = camatores.public int getCc() { return cc.camatores = camatores.getCc() / 10.).cc = cc. public Yates(String matricula.cc = cc. } @Override public int cobro(){ int valor=0.cobro() + caballo * 2000). valor = (int) (super. } public int getCc() { return cc.getCamatores() * 1000). } @Override public int cobro(){ int valor=0. private int camatores. return valor.cobro() + caballo * 5000 + this. double caballo = Math. } } package view. int camatores) { super(matricula. } public void setCc(int cc) { this. public class Yates extends Barco{ private int cc.ceil(this.getCc() / 10. int eslora.floor(this. } public void setCamatores(int camatores) { this.cc = cc. this. return valor. } public void setCc(int cc) { this. int cc. } public int getCamatores() { return camatores. } } Versión 2. alquiler).

Alquiler o2 = new Alquiler("14000000".out.2 96 de 285 .cobro()). fechas("01/01/2011").out. } } Ejercicio 2 Usando herencia escribir un programa que sea capaz de calcular el volumen de una esfera.SimpleDateFormat. 105).o3.out.cobro()).println("Yate: " + y.Date.text. import java.ParseException. } static Date fechas(String a) throws ParseException{ String dateFormatString = "dd/MM/yyyy". Date fe = format. System. SimpleDateFormat format = new SimpleDateFormat(dateFormatString). return fe. fechas("10/01/2011")). Velero v = new Velero("AV10". fechas("01/01/2011").println("Velero: " + v.util. El área de una esfera es: Volumen de una esfera es: Versión 2. public class Ver { public static void main(String[] args) throws ParseException { Alquiler o1 = new Alquiler("14000000".println("Deportivas: " + d. 5. import java. System. Yates y = new Yates("AY40".parse(a).300).package view. Deportivas d = new Deportivas("AD70".12.200.o1. o2. fechas("31/01/2011")). Alquiler o3 = new Alquiler("14000000". fechas("03/01/2011")). System.text. 10).5125.cobro()). fechas("01/01/2011"). import java.

2da = 1. 1. entonces el descuento es de un 30%. Cada una de sus ventas las maneja con un porcentaje de descuento estándar por volúmenes de ventas. 3% si las ventas son desarrolladas a la República Popular China en la 2ra temporada.5%. para un par de clase. respetando las normativas UML.2 97 de 285 . Se pide: (a) Ilustrar un diagrama de clases. (c) Enviar la siguiente información e indicar el porcentaje de descuento que se aplicará por cada una de las ventas. 1% si las ventas son desarrolladas a Europa en la 1ra temporada. más específicamente. Versión 2. Producto Naranjas Naranjas Paltas Paltas Toneladas 40 5 100 500 Valor de 1 tonelada 10000 12000 20000 16000 Destino ------Republica China Europa Temporada 2 1 Popular 2 1 Ejercicio 4 Considerar que se debe diseñar un modelo para describir la herencia de vehículos (tanques. cual es el método que se especializa que provoca la herencia entre esas clases.Ejercicio 3 La empresa “abc” está dedicada por años a la producción y exportación de frutas. otros). autos. si las ventas son mayores a 20 toneladas y menores o igual a 50. Todas los trámites de exportación son desarrollados por varios agente que operan en Chile y con representantes en distintas ciudades del planeta tierra. motos. Adicional mente: • Las naranjas tiene un descuento dependiendo de la temporada (1ra = 2. que represente el problema descrito. Crear un diagrama de clases que sea capaz de describir lo solicitado.5% si las ventas son desarrolladas a Europa en la 2ra temporada y un % en otros casos. entonces el descuento es de un 10% y si las toneladas superan las 50.5%) • Las paltas tiene un descuento adicional dependiente del destino y la temporada: 5% si las ventas son desarrolladas a la República Popular China en la 1ra temporada. (b) Diseñe un programa java para la programación de cada una de las clases diseñadas en el diagrama de clases. Indique.

1 Objetivos Usar y definir excepciones. 14. Versión 2. Clase 14.2 98 de 285 .2 Conocimiento previo Programación en java.14 14.3 Manejo de excepciones Existe una regla de oro en el mundo de la programación: en los programas ocurren errores.

crear una objeto exception y manejarlo por el sistema de ejecución se llama lanzar una excepción.2 99 de 285 . el sistema de ejecución entra en acción para buscar el manejador de la excepción. Muchas clases de errores pueden utilizar excepciones. Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es el mismo que el de la excepción manejada por el manejador. En terminología java.Esto es sabido. desde: • • Serios problemas de hardware. Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.4 Lanzar una excepción Cuando un error ocurre dentro de un método Java. incluyendo su tipo y el estado del programa cuando ocurrió el error. en el sistema de ejecución. 14. el sistema de ejecución finaliza (y consecuentemente el programa Java también). se dice que el manejador de excepción elegido captura la excepción. pero: • • • • ¿Qué sucede realmente después de que ha ocurrido el error? ¿Cómo se maneja el error? ¿Quién lo maneja? ¿Puede recuperarlo el programa? El lenguaje Java utiliza excepciones para proporcionar capacidades de manejo de errores.5 Captura una excepción Después de que un método lance una excepción. como tratar de acceder a un elemento de un Array fuera de sus límites. 14. Así la excepción sube sobre la pila de llamadas hasta que encuentra el manejador apropiado y una de las llamadas a métodos maneja la excepción. el método crea un objeto “exception” y lo maneja fuera. como la avería de un disco duro A los simples errores de programación. Este objeto contiene información sobre la excepción. El sistema de ejecución es el responsable de buscar algún código para manejar el error. Si el sistema de ejecución busca exhaustivamente por todos los métodos de la pila de llamadas sin encontrar el manejador de excepción adecuado. Versión 2.

6 Exception . que verifica que el arreglo saludos[i] no este fuera de rango en los valores de su índice i. entonces el manejador de excepciones buscará en el segundo bloque catch.25.25 ). una excepción del tipo “Exception” que es gatillado independiente del error que ocurra.Throwable Versión 2. • • • 14. el código contenido en el bloque finally se ejecutará. Si esto falla. Al producirse un error en este código. Por último.El código dentro del try { } es el que se va a controlar: g. el manejador de excepciones buscará en el primer bloque catch.2 100 de 285 . una excepción del tipo “ArrayIndexOutOfBoundsException”.drawString( Saludos[i]. independiente que hallan o no errores.

Exception(String message. pero todavía no ha sido creado. • • • • • ArithmeticException: Se lanza cuando una excepción aritmética a ocurrido. DataFormatException: Error en el formato de los datos. Por ejemplo. cero elevado a infinito. apertura o cierre de archivos. Por ejemplo. Por ejemplo. Constructores de Exception: • • • • Exception() Exception(String message): Construye una nueva excepción con el detalle especificado en el mensaje .println((String)x). Algunas excepciones en tiempo de ejecución son: • • • ArrayIndexOutOfBoundsException: Si un programa intenta acceder a un índice de arreglo fuera del intervalos. ClassNotFoundException: Se referenció una clase que el sistema es incapaz de encontrar. se intenta transformar un dato de un tipo1 a otros tipo2 sin existir consistencia en estos tipos.out. las cuales son capturadas en tiempo de ejecución y no de compilación.Las excepciones en tiempo de ejecución son heredadas desde la clase RuntimeException. NullPointerException: Un programa crea una referencia a un objeto. IOException: Cubre las excepciones ocurridas al ejecutar una operación de entrada salida. Object x = new Integer(0). Throwable cause): Construye una nueva excepción con el mensaje de detalle especificado y la causa Exception(Throwable cause) Métodos de Exception: • No tiene métodos asociados Versión 2. ClassCastException: Mutación no valida. SQLException: Problemas con la definición del String que define una consulta SQL. Por ejemplo. System.2 101 de 285 .

un hilo ejecutándose es deliberadamente detenido y el hilo no captura esta excepción LinkageError: Se produce cuando. en cuyo caso se perderá la primera excepción. break o continue.8 • • • • try – catch -finally El Bloque try: El primer paso es poner la sentencia Java dentro de la cual se puede producir la excepción dentro de un bloque try. Throwable cause): Construye un nuevo Throwable con el mensaje de detalle especificado y causa Throwable(Throwable cause) Métodos 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 estándar Otros. por ejemplo. El bloque finally se ejecutará independiente si el bloque try lanzó o no una excepción en cualquiera de los bloques catch. Versión 2.2 102 de 285 . 14. por ejemplo. Sin embargo. Los bloques catch: Después se debe asociar un manejador de excepciones con un bloque try proporcionándole uno o más bloques catch directamente después del bloque try. entonces cuando el control pase al bloque finally éste también podría lanzar una excepción.Constructores de Throwable • • • • Throwable() Throwable(String message): Construye un nuevo Throwable con el mensaje de detalle especificado Throwable(String message. 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 catastróficos que pueden ocurrir en la JVM. También se ejecutará si se sale de try mediante return. si se lanza una excepción para la que no se encuentra un catch asociado.7 Error Error ThreadDeath • • • LinkageError VirtualMachineError ThreadDeath: Se produce cuando. Por ejemplo. quedar sin recursos para funcionar 14.

Versión 2.2 103 de 285 .

La forma general de la sentencia throw es: throw ObjetoThrowable. el texto del mensaje proporcionará información para resolver el problema o sugerirá una acción alternativa. no hay por qué limitarse a las predefinidas y a sus subclases. Se pueden definir excepciones propias. public class UsoSinGasolina { public static void main(String[] args){ uso(). public class SinGasolina extends Exception{ //Llama al constructor exception(String mesage) de la clase Exception SinGasolina( String s ) { super( s ). } } package dat. } catch( Exception e ) { System. public class SinGasolina extends Exception{ //Llama al constructor exception(String mesage) de la clase Exception SinGasolina( String s ) { super( s ). bien mediante un parámetro en una cláusula catch o utilizando el operador new. try { if( j < 1 ) throw new SinGasolina("Usando deposito de reserva").println( "Se ha producido un error" ). } catch( SinGasolina e ) { System. Por ejemplo: package dat.println( "Matemáticas locas!" ).getMessage() ). } } Versión 2.int valor. x < 100. derivando de una clase Exception ya existente. x ++ ) valor /= x. La cadena de texto puede ser recuperada a través de un método. bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción. } public static void uso(){ int j = 0. valor = 100. //Muestra el mensaje del constructor de Exception } } } Resultado: Se puede usar más información usando el método printStackTrace() package dat.out.println( e.9 throw La sentencia throw se utiliza para lanzar explícitamente una excepción de tipo Throwable. Normalmente. } 14.out.2 104 de 285 . se puede cambiar el mensaje que lleva asociado. } catch( ArithmeticException e ) { System.out. try { for( x=0. Cuando se crea una nueva excepción.

} public static void uso(){ int j = 0. try { if( j < 1 ) throw new SinGasolina("Usando deposito de reserva").println( e. Las excepciones que un método lanza explícitamente o que son lanzadas por métodos invocados por este. } catch( SinGasolina e ) { System.printStackTrace(). hay que indicarlo expresamente. deben ser listadas en throws.out. } } } 14.11 Ejemplos Versión 2.package dat. CaidaException 14.10 throws Lista las excepciones que un método puede lanzar. //Muestra el mensaje del constructor de Exception e. Para que un método en Java.getMessage() ). pueda lanzar excepciones. public class UsoSinGasolina { public static void main(String[] args){ uso().2 105 de 285 . void metodoAsesino() throws NullPointerException.

NO Ejecuta Compila OK NO Ejecuta Versión 2.2 106 de 285 .

Versión 2.2 107 de 285 .

2 108 de 285 .Versión 2.

2 109 de 285 .Indicar que se va a imprimir: Versión 2.

Va a imprimir: A.2 110 de 285 . No hay error Versión 2. 1 2 3 4 F. 1 4 D. 1 3 A. 1 3 4 A. 1 B.

2 111 de 285 .Versión 2.

Para el caso anterior el Netbeans muestra: Versión 2.2 112 de 285 .

2 113 de 285 .Versión 2.

2 114 de 285 .Para el caso anterior el Netbeans muestra Versión 2.

Versión 2.2

115 de 285

14.12

Ejercicios

1. Crear una aplicación ja va que sea capaz de ejecutar los siguientes procesos: CLASE Venta (a) Crear un método constructor que sea capaz de recibir el código de un producto (String) y la cantidad vendida (int). (b) Crear un método sin parámetros 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 método sin parámetros que sea capaz de calcular el total a pagar. CLASE Producto (a) Crear un método que reciba como parámetro una variable String que representa el código de un producto. Se debe validar que esté compuesto de sólo números de largo 6 exactamente. Para informar códigos incorrectos se debe crear una excepction. (b) La información de los productos válidos está almacenada en un arreglo bidimensional de tipo String con los siguientes datos: Código Precio 125468 100.000 325697 200.000 326598 500.000 326548 1.000.000 CLASE Ver (a) Desde el método main se debe enviar datos a la clase Venta con un código 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 aplicación 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 método que reciba un parámetro una variable de tipo String y que almacene el valor del parámetro en el archivo plano. (b) Además, se debe crear un método que reciba como parámetro una variable de tipo String y que busque el valor en cada una de las líneas del archivo plano e informe la cantidad de veces que el valor se encuentra en el archivo. 3. Crear una aplicación 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 código en dónde se gatillen las excepciones: (a) FontFormatException (b) IllegalAccessException (c) IOException (d) NotBoundException (e)
Versión 2.2 116 de 285

Versión 2.2

117 de 285

15
15.1 Objetivos
Uso de colecciones y en particular las clase ArrayList.

Clase

15.2

Conocimiento previo

Conceptos de orientación a objetos y encapsulación de datos.

15.3

Colecciones

Java tiene desde la versión 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 incorporación), se podría tener: Juan Pérez Pérez Carla Saldivia Herrera Carola Faúndez Fica Anita Suazo González 34 23 19 20 01/03/10 15/03/10 10/03/10 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 aplicación del tamaño de este. De esta forma, las colecciones no requieren de un tamaño inicial y una vez que el tamaño asignado por java el sobrepasado (o hay indicios de que el espacio almacenado no será suficiente) entonces java desarrolla el proceso de ampliación del tamaño. 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; }

Versión 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 sólo un tipo de datos que debe ser un objeto. Por ende, si se requiere almacenar más de un tipo de datos, estos deben encapsularse para luego ser almacenados como objetos de la clase que maneja la encapsulación. Los datos son mantenidos con el nombre del objeto de la colección. Por lo tanto, si me solicitan los datos lo que hacemos es devolver el nombre del objeto de la colección. 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.

Versión 2.2

119 de 285

2 120 de 285 . Además. añadiendo el manejo de índices.5 Collection Interfaz que define los métodos básicos para el manejo de estructuras de datos. se trabaja con la lista ordenada (permitiendo valores duplicados) o con parte de la lista.6 List La interfaz List considera métodos adicionales a la interfaz Collection. 15.15. Es la interfaz raíz dentro del manejo de colecciones. Versión 2.

Por lo tanto. desde diversos hilos se puede acceder a los métodos. De esta manera es eficiente en la búsqueda de información pero deficiente en la inserción y borrado.iterator(). acepta el acceso concurrente a los métodos. items1.out. while (iterateItems1.hasNext()) { System.15. items1.util.next()). Iterator iterateItems1 = items1.2 121 de 285 . De esta manera.add("Juan Perez").add("Carla Ortuza"). import java.7 ArrayList Clase que implementa los métodos de la interfaz List. No tiene ningún método sincronizado (excepto set y get).println(iterateItems1.add("Elias Menares"). items1. El ArrayList asume la estructura de lista simple enlazada. public class Ejemplo1{ public static void main(String [ ]args) { ArrayList items1 = new ArrayList().*. } } } Versión 2.

} } } 15.setDat(new Estudiante("Anita Suazo González".listIterator()."10/03/10")).Estudiante. //Almacena datos en el ArryList o. La ventaja de utilizar Sets es que preguntar si un elemento ya está contenido mediante “contains()” suele ser muy eficiente.setDat(new Estudiante("Carla Saldivia Herrera". //Muestra Edad System.setDat(new Estudiante("Carola Faúndez Fica".println(). package view. import java.println("Incorporación: " + e.23. Entonces es conveniente utilizarlos cada vez que necesitemos una colección en la que no importe el orden.20. Versión 2."01/03/10"))."18/03/10")).hasNext().out.println("Cantidad de objetos en ArrayList: " + o. Si se intenta agregar un valor ya existente en la lista pero con variables distintas. entonces este proceso se desarrollará. un set agrega una sola restricción: Al ingresar datos con la misma variable asume un sólo valor en la lista. o.out.34.2 122 de 285 . import bean.19.println("Nombre: " + e.Iterator.out.out. for (Iterator iterador= o.out.getDat(). //Muestra la cantidad de objetos almacenados en el ArrayList System.println("Edad: " + e.next().getNombre()). Por sobre lo que es una collection. public class IngresaMuestra { public static void main(String[] args) { //Objeto que maneja los elementos de la clase Estudiante o = new Estudiante().util.8 Set No incorpora ningún método nuevo.println().iterador.){ Estudiante e = (Estudiante)iterador. //Muestra nombre System.getincorpora()).getEdad()). pero que necesitemos preguntar si un elemento está o no. System.size()). //Muestra incorporación System.Vamos a usar la clase Estudiante. o.getDat()."15/03/10")). o.setDat(new Estudiante("Juan Pérez Pérez". System.out.

Óptima para cantidades pequeñas de datos. habrá que saber si está en esa tabla. } public String getNombre() { return nombre. } public HashSet getDat() { return dat. private int cantidad. package bean. } public int getCantidad() { return cantidad. A cada objeto que se añade a la colección se le pide que calcule su “hash”.nombre = nombre. public final class Producto { private String nombre. cuando se pregunta con contains() si un objeto x ya está. } public void setDat(Producto dat) { this. La clase HashSet aprovecha la segunda de las funciones. private HashSet dat = new HashSet().15. y si uno de esos es el buscado contains devuelve true. } } Versión 2.setCantidad(cantidad). Entonces la función contains de HashSet saca el hash del objeto que le pasan y va con eso a la tabla. el hash siempre va a tener el mismo valor. int cantidad) { this.add(dat). Los elementos no se encuentran ordenados y pueden variar su posición de acuerdo al proceso de balanceo de la estructura que desarrolle la tabla de hash. } public void setCantidad(int cantidad) { this.util. public Producto() { } public Producto(String nombre. Usa una tabla de hash.2 123 de 285 . Basado en ese valor se lo guarda en una tabla. this.setNombre(nombre). En la posición de la tabla hay una lista de objetos que tienen ese valor de hash.dat. ya que para un objeto determinado.9 HashSet Implementa los métodos de la interfaz Set. Este valor será un número entre -2147483647 y 2147483648.cantidad = cantidad. ¿En qué posición de la tabla está? HashSet puede saberlo.HashSet. import java. } public void setNombre(String nombre) { this. Más tarde.

println("Cantidad: " + e.getDat().out.19). //Almacena datos en el HashSet o.34)).println("Producto: " + e.next(). System. import java.getDat(). } } } Considerar la siguiente modificación el código anterior. public class MuestraHash { public static void main(String[] args) { //Objeto que maneja los elementos de la clase Producto o = new Producto().println().setDat(new Producto("Leche".out.setDat(o1).out.Iterator.Producto. } } } Versión 2.iterador. System. //Muestra cantidad System.setDat(new Producto("Leche". //Si lo ingresa Producto o1 = new Producto("Leche".getNombre()). System.setDat(new Producto("Pan".util.19)).out.getNombre()). ///Si lo ingresa Producto o1 = new Producto("Leche".println().iterator().println("Cantidad de objetos en HashSet: " + o.getDat(). o.package view.setDat(new Producto("Pan". for (Iterator iterador= o.setDat(o2). o.util.){ Producto e = (Producto)iterador.println("Cantidad: " + e. //Muestra nombre System.out. package view.getDat(). //Almacena datos en el HashSet o.Iterator. o. //Muestra cantidad System.size()).out.setDat(new Producto("Leche".Producto.19)). o. o. //Esto no lo ingresa Producto o2 = new Producto("Leche".setDat(o1). /Si lo ingresa o.iterator(). import bean.setDat(new Producto("Leche".out.println().19).out.println(). //Esto no lo ingresa //Muestra la cantidad de objetos almacenados en el HashSet System.getCantidad()).20)). System.println("Cantidad de objetos en HashSet: " + o. import bean.next().){ Producto e = (Producto)iterador. o.setDat(o1).setDat(o1).19)).hasNext().setDat(new Producto("Azucar".getCantidad()).out.setDat(new Producto("Azucar".hasNext(). o. //Si lo ingresa //Muestra la cantidad de objetos almacenados en el HashSet System.out. o. //Si lo ingresa o.size()). for (Iterator iterador= o. public class MuestraHash { public static void main(String[] args) { //Objeto que maneja los elementos de la clase Producto o = new Producto(). import java.19). //Muestra nombre System.println("Producto: " + e.20)).2 124 de 285 . o.19)).34)).iterador.

Al tener todo en orden TreeSet puede fácilmente saber si un objeto está. TreeSet usa una técnica completamente diferente a la explicada para HashSet. En este ejemplo la diferencia se le ha indicado que sea desarrollada por el nombre. 15. y permitir que se agreguen más cosas y que el orden se mantenga. lo cual puede diferir de equals. se crea la clase Productos con los atributos nombre y cantidad la cual debe implementar la interface Comparable que te exige dar implementación al método comparateTo que tiene el código para distinguir entre un objeto y otro de la clase Productos. Inserta los elementos efectuando comparaciones con el método comparateTo() de la interfaz Comparator.10 TreeSet Implementa los métodos de la interfaz Set.Observar que el orden no necesariamente es el mismo para los mismos datos. Un árbol es una forma en computación de tener un conjunto de cosas todo el tiempo en orden. Los elementos se encuentran ordenados ascendentemente. Versión 2. Construye un árbol con los objetos que se van agregando al conjunto.2 125 de 285 . En el siguiente ejemplo. Una desventaja es que mantener todo ordenado tiene un costo. y esta clase es un poco menos eficiente que HashSet. Una ventaja de TreeSet es que el orden en el que aparecen los elementos al recorrerlos es el orden natural de ellos.

} @Override public boolean equals(Object objeto) { // Indica en base a que atributos se iguala el objeto if (objeto == null) { return false. int cantidad) { this.hashCode(). public final class Productos implements Comparable{ private String nombre.TreeSet.setNombre(nombre). } @Override public int hashCode() { // retorna un identificador único del objeto. } public TreeSet getDat() { return dat.cantidad = cantidad.setCantidad(cantidad).getNombre())) { return true. private TreeSet dat = new TreeSet(). } Versión 2. private int cantidad.getNombre().equals(productos. } public int getCantidad() { return cantidad. if (this. import java.nombre = nombre.dat.package bean. } public void setNombre(String nombre) { this. } public void setCantidad(int cantidad) { this. } return false.util.add(dat).getNombre(). } Productos productos = (Productos)objeto. this. } public String getNombre() { return nombre. } public void setDat(Productos dat) { this. return this. public Productos() { } public Productos(String nombre.2 126 de 285 .

println("Producto: " + e.19)). String nombreThis = this. //Almacena datos en el TreeSet o. System. //No lo ingresa Productos o1 = new Productos("Leche".setDat(o1).println().size()). o.println("Cantidad: " + e.){ Productos e = (Productos)iterador. public class MuestraTree { public static void main(String[] args) { //Objeto que maneja los elementos de la clase Productos o = new Productos().out. String nombreObjeto = productos. for (Iterator iterador= o.getNombre().20)).34)). o. o.19).19). //Muestra nombre System. System.util. return (nombreThis.setDat(o2).next(). } } package view. o.setDat(o1).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.getDat().getNombre().println().out.out.Productos. o.Iterator. } } } Versión 2.out.getNombre()).out.setDat(new Productos("Azucar". //Muestra cantidad System. //No lo ingresa Productos o2 = new Productos("Arveja". //No lo ingresa o.toLowerCase().19)).println("Cantidad de objetos en TreeSet: " + o. //Si lo ingresa //Muestra la cantidad de objetos almacenados en el TreeSet System.getCantidad()).setDat(new Productos("Leche". import java.toLowerCase().hasNext().iterador.compareTo(nombreObjeto)).iterator().getDat(). import bean.setDat(new Productos("Leche".setDat(new Productos("Pan".2 127 de 285 .

3 Map Declara métodos que permiten manejar elementos como para clave valor sin permitir claves duplicadas. 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.1 Objetivos Clase Uso de colecciones y en particular las clase ArrayList y Vector.2 Conocimiento previo Conceptos de orientación a objetos y encapsulación de datos.2 128 de 285 . Con este método no se obtiene la lista por elemento sino que completa Object put(Object key. 16. Con este método no se obtiene la lista por elemento sino que completa Versión 2.valor>) Copia la lista completa de elementos Object remove(Object key) Elimina el elemento indicado por la clave int size() Indica el número de elementos de la lista Collection values() Retorna los valores de la lista (no las claves).16 16. MÉTODO void clear() Elimina todos los elementos boolean containsKey(Object key) Retorna true si se tiene un elemento para la clave indicada. 16. boolean containsValue(Object value) Retorna true si se tiene uno o más elementos para el elemento indicado Set<Map<clave. Object value) Ingresa un elemento clave valor a la lista void putAll(Map<calve.valor>> EntrySet() Retorna una vista de la lista.

public final class Articulos { private String nombre.4 HashMap Implementa los métodos declarados en la interfaz Map. } public int getCantidad() { return cantidad. } public HashMap getDat() { return dat. package bean.put(corr. public Articulos() { } public Articulos(String nombre. 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 encapsulación de información.setCantidad(cantidad).dat. } public void setDat(int corr.util. Permite valores NULL como claves y valor. dat). que permiten manejar elementos como para clave valor sin permitir claves duplicadas. private HashMap dat = new HashMap(). } } Versión 2. private int cantidad.setNombre(nombre). Articulos dat) { this.nombre = nombre. this. } public void setCantidad(int cantidad) { this. } public void setNombre(String nombre) { this. import java.16.cantidad = cantidad. } public String getNombre() { return nombre. int cantidad) { this.2 129 de 285 .HashMap.

//Muestra cantidad System. o.out.Entry e = (Map.setDat(4.getValue().println().setDat(2.println("Producto: " + ee. new Articulos("Azucar".Entry)iterador.println(). //Muestra clave Articulos ee = (Articulos)e.iterador.34)).19)).hasNext().20)). new Articulos("Leche".setDat(1.out.println("Cantidad de objetos en HashMap: " + o. for (Iterator iterador= o. //Muestra nombre System.){ Map. o. System. public class MuestraHashMap { public static void main(String[] args) { Articulos o = new Articulos().Iterator.Map.getDat(). import java. new Articulos("Pan".getCantidad()). System. import java.setDat(3. System.out.19)).out.iterator().util.println("Cantidad: " + ee.out.entrySet().getKey()).out. } } } Versión 2. import bean.util.Articulos.println("Clave: " + e.next(). o. //Muestra la cantidad de objetos almacenados en el HashMap System.size()).package view.getDat().getNombre()). o. new Articulos("Leche".2 130 de 285 .

println("Cantidad de objetos en TreeSet: " + o. o.getDat(). for (Iterator iterador= o.setDat(2.println("Cantidad: " + ee.19)).out. package view. //Muestra cantidad System. entonces se almacenará el último valor perdiendo el valor original.getCantidad()).println("Producto: " + ee. //Muestra clave Articulos ee = (Articulos)e.34)). System.Iterator.hasNext().out.getDat().getKey()). System.size()).){ Map.iterator(). o.out.Articulos. import java. //Muestra la cantidad de objetos almacenados en el TreeSet System.Entry e = (Map.entrySet().setDat(1.util.setDat(4.setDat(3.setDat(3. import bean.println().29)). new Articulos("Leche".20)).iterador. public class MuestraHashMap { public static void main(String[] args) { Articulos o = new Articulos().println().next().19)).println("Clave: " + e. new Articulos("Azucar". new Articulos("Leche". System.out.Observar que si se almacena un valor con la misma clave. o.2 131 de 285 . new Articulos("Mantequilla". o. o.getValue().util.getNombre()). import java. } } } Versión 2.Entry)iterador.Map. //Muestra nombre System. new Articulos("Pan".out.out.

} } Versión 2. package bean. que permiten manejar elementos como para clave valor sin permitir claves duplicadas. int cantidad) { this.16.TreeMap. dat). this.setNombre(nombre). private TreeMap dat = new TreeMap(). Permite valores NULL como claves y valor. } public TreeMap getDat() { return dat. } public String getNombre() { return nombre. Articulo dat) { this.setCantidad(cantidad). } public void setNombre(String nombre) { this.nombre = nombre. private int cantidad.5 TreeMap Implementa los métodos declarados en la interfaz Map.cantidad = cantidad.util. } public void setDat(String clave. } public void setCantidad(int cantidad) { this. } public int getCantidad() { return cantidad. public final class Articulo { private String nombre.dat. Ordena los elementos ascendentemente en relación a la clave. public Articulo() { } public Articulo(String nombre.2 132 de 285 . import java.put(clave.

setDat("AD70". } } } Versión 2. public class MuestraTreeMap { public static void main(String[] args) { Articulo o = new Articulo(). //Muestra nombre System.getKey()).setDat("AX20".setDat("AR60". new Articulo("Leche".19)).getDat().iterador.entrySet().util.getCantidad()). //Muestra la cantidad de objetos almacenados en el TreeMap System.out. new Articulo("Leche".println("Clave: " + e. o.out.out.out.){ Map. //Muestra cantidad System. o.next().getDat().29)).println().getNombre()). System.Entry)iterador. new Articulo("Azucar". System.out. o.34)). o. new Articulo("Pan". new Articulo("Mantequilla".import java.19)).iterator().getValue().println("Producto: " + ee.hasNext().Map. for (Iterator iterador= o.println("Cantidad: " + ee.out.2 133 de 285 . o.println("Cantidad de objetos en TreeMap: " + o.setDat("AU10". System. //Muestra clave Articulo ee = (Articulo)e.20)).setDat("AB30".size()).Entry e = (Map.println().

Esto redunda en un mayor costo de proceso pues debe monitorearse permanentemente los bloqueos.println("Tamano:" +v.4).1 de Java es equivalente a esta clase ArrayList para la versión 1. v. lo que implica que todos sus métodos están sincronizados.out.size()).out. Si no lo encuentra devuelve false removeAllElements() Elimina todos los elementos clone() Devuelve una copia del vector setSize(int newSize) Establece un nuevo tamaño isEmpty() Devuelve true si no tiene elementos firstElement() Devuelve el primer elemento int int void boolean void Object void boolean Object Object lastElement() Devuelve el último elemento void insertElementAt(Object obj. int index) Inserta un elemento por delante de una determinada posición import java. v.print(v. Versión 2. METODO Vector() Constructor Vector(int inicialCapacity) Crea un vector con la capacidad indicada Vector(int initialCapacity. System.insertElementAt("apps". i<v. v.2 de java.elementAt(i)+" "). int capacityIncrement) Crea un vector con la capacidad e incremento indicado capacity() Especifica el número de elementos que puede tener el vector size() Devuelve la cantidad de elemento presente addElement(Object obj) Añade un objeto al final removeElement(Object obj) Elimina el primer objeto que encuentra como su argumento y desplaza los restantes.0).size(). public class Ejemplo30{ public static void main(String args[]) { Vector v = new Vector().util.3).6 Vector La clase Vector de la versión 1. La diferencia es que la clase Vector es Thread-Safe.addElement("two").16.out. System. v.addElement("one"). v. for(int i=0.2 134 de 285 .println().*.insertElementAt("zero". i++) System.insertElementAt("three".

out. • • Se pide que el método.removeElement("apps").2 135 de 285 . i++) System.elementAt(i)+" ").size(). for(int i=0. Versión 2. • Crear un método que reciba un ArrayList y lo almacene en un TreeSet y muestre su información.println("Nuevo Tamano:" +v.out.System.print(v. El método debe concatenar la información que llega en el TreeSet.out.println(). } } 16. Crear un método que reciba un valor entero y almacene en el ArrayList que corresponda. entonces se deberá incrementar en 20 valores más.size()).out. Crear un método que muestre cual de los ArrayList contiene la mayor cantidad de datos.println(). cambie el valor de búsqueda por el de reemplazo (si este existe). i<v. Observar que si la capacidad de un ArrayList se ve sobrepasada. Crear un método que sea capaz de recibir 3 parámetros: ◦ ◦ ◦ El nombre de un ArrayList Un valor entero de búsqueda Un valor entero de reemplazo. System.7 Trabajo semana 10 Desarrollar un programa java que sea capaz de generar números aleatorios enteros entre 1 y 100 y almacenarlos en 4 ArrayList según se indica. si existe el ArrayList. System. v. Primero Segundo Tercero Cuarto • • Valores entre 1-25 Valores entre 26-50 Valores entre 51-75 Valores entre 76-100 Crear los 4 ArrayList con capacidad inicial de 10 valores.

17
17.1 Objetivos
Desarrollar la evaluación 4. Valor 12.5% de la nota 2.

Clase

17.2

Conocimiento previo

Contenidos de las clases 16, 17 y 18

17.3
Ejercicio 1

Modelos de evaluación 4

Para cada uno de los códigos siguientes indicar la excepción 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());
Versión 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()); }
Versión 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 colección que los almacene ordenados ascendentemente. • • • • Crear un método para mostrar la información almacenada en la colección seleccionada. Crear un método que sea capaz de mostrar el mayor valor usando la colección seleccionada. Crear un método que sea capaz de mostrar el menor valor usando la colección seleccionada. Crear un método que recupere todos los valores entre 0.1 y 0.4 ambos valores incluidos y los almacene en un ArrayList.

Solución: 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()); }
Versión 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 información de trabajadores de una empresa la cual debe almacenar ordenada por rut el cual para cada trabajador en único. La información del trabajador es el rut y el nombre con información inicial: Rut 14000000 14500000 14200000 14300000 14100000 • • • • Nombre Juan Perez Ubilla Carla Barrera Perez Julio Hernan Cardenas Baeza Clara Vicencia Robles Robles Pedro Lucas Juarez Hernandez

Selecciones la colección más apropiada para almacenar la información. Crear un método que reciba el rut y el nombre y lo almacena en la colección. Crear un método que reciba el rut y el nombre, busque el rut en la colección y reemplace en nombre por el valor indicado. Si el rut no existe, entonces se debe emitir un mensaje de error. Crear un método 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");
Versión 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); } } } }

Versión 2.2

140 de 285

. . . Ahora el compilador dará un error en tiempo de compilación para la instrucción. Simplemente se recupera con: String filename = files.. Clase 18. files.get(0).. } public void add(Object o) { .")).add(new File(". La versión 5. si se necesita almacenar sólo información de tipo String se tendrá: ArrayList<String> files = new ArrayList<String>(). ArrayList files = new ArrayList(). . Ahora no se necesita indicar los tipos. String filename = (String) names. . Se necesita indicar el tipo cada vez que se recupera un valor.. .3 Colecciones Genéricas Consideremos la clase ArrayList vista en las clases anteriores: public class ArrayList // Antes JDK 5.0 del JDK ofrece una mejor implementación de las colecciones como ArrayList. . 2.0 { public Object get(int i) { . } Lo anterior tiene dos problemas: 1.get(0). 18.1 Objetivos Uso de las colecciones genéricas. Por ejemplo. private Object[] elementData.2 Conocimiento previo Manejo de colecciones no genéricas..2 141 de 285 .18 18. } . Esto puede provocar un error de ejecución que no se puede capturar el tiempo de compilación. Versión 2.

4 Ejemplo de uso Consideremos el siguiente código: Compilación no presenta problemas: Consideremos ahora el siguiente código: Nuevamente la compilación no presenta problemas: Versión 2.2 142 de 285 .18.

2 143 de 285 .6 • Vector<> El vector almacena objetos tipo String. Método se han mejorado 18.Consideremos ahora el siguiente código. Netbeans nos a marcado de inmediato el error en tiempo de compilación. 18. • Para indicarle que el aumento sea de 10 objetos podemos definir Versión 2. Para crear un objeto podemos emplear: • El vector almacena inicialmente sólo 100 objetos tipo String. Permiten eliminar elementos de los datos recogidos en la iteración con una semántica bien definida. Si se llena se duplica automáticamente la capacidad.5 • • • Iterator<> La interfaz Iterator toma el lugar de la Enumeration en el marco de las colecciones en Java. La características particular es que los objetos están sincronizados.

“Jeremiah”.println(n). String[] firstnames = { “Jack”. // Agrega la lista al Vector (sólo pueden ser datos String) for(String first : firstnames) { names.add(first).Veamos como almacenar un arreglo en una colección genérica y luego desde la colección mostrar sus datos. Una aplicación puede aumentar la capacidad de un ArrayList directamente usando el método ensureCapacity. import java. “Josephine”}. debe ser sincronizado externamente. excepto que es la falta de sincronización: Si varios hilos de acceder a un ArrayList ejemplo simultánea. y al menos uno de los hilos modifica estructuralmente la lista.1 add Permite asociar valores a un objeto de un ArrayList.7. “John”.2 144 de 285 . public class TrySimpleVector { public static void main(String[] args) { Vector<String> names = new Vector<String>(). “Joan”. entonces cada dato de names //se transfiere a name para ser mostrado for(String n : names) { System.out.7 • • ArrayList<> Permite que todos los elementos. Esta clase es aproximadamente equivalente a la de vectores. } } } En el ejemplo anterior también se pudo haber usado para recorrer el Vector: 18.Vector.util. } //Como cada dato del vector es String. • 18. incluidos los nulos. Versión 2. “Jill”.

add(0.size()).add(2.add(a). } public void setDatos(Trabajador a) { this.nombre = nombre. private int edad=0.edad = edad.new Integer(12)). public final class Trabajador { private String nombre="". for(int aa : a){ System.ArrayList.setEdad(edad).util.package view. import java. a.add(new Integer(14)). public Trabajador() { } public Trabajador(String nombre. } } } Para manejar datos encapsulados tenemos: package bean. private ArrayList<Trabajador> a = new ArrayList<Trabajador>(). a. } public ArrayList<Trabajador> getDatos() { return a.util.a. System.setNombre(nombre). import java.2 145 de 285 . a. } public String getNombre() { return nombre.new Integer(111)). } public void setNombre(String nombre) { this.new Integer(10)).println("Valor: "+aa). public class Generico01 { public static void main(String[] args) { ArrayList<Integer> a = new ArrayList<Integer>().out.add(new Integer(133)).println("Cantidad de elementos: "+a. } } Versión 2.out.add(1. a. } public int getEdad() { return edad. int edad) { this. } public void setEdad(int edad) { this.ArrayList. this. a.

7.out.2 clear Elimina los datos referenciados por un objeto de un ArrayList. int edad) { this.setDatos(new Trabajador("Maria". } public void setNombre(String nombre) { this. System.){ Trabajador e = (Trabajador)iterador.Trabajador.next(). import bean.edad = edad. //Muestra nombre System.Iterator.getEdad()).2 146 de 285 .setDatos(new Trabajador("Juan".add(a).getDatos().nombre = nombre. public Trabajador() { } public Trabajador(String nombre.iterator().setNombre(nombre).util.setDatos(new Trabajador("Josefa".3 contains remove La combinación es usada para verificar si un valor existe y luego eliminarlo.iterador. for (Iterator<Trabajador> iterador= t. } public void setEdad(int edad) { this.getDatos(). public final class Trabajador implements Comparable{ private String nombre="". package bean. //Muestra edad System. se deben limpiar los datos referenciados por el objeto ArrayList cada vez que se requiere ver nueva información. en este caso. System.getNombre()).72)). t.42)).setEdad(edad).hasNext().println("Cantidad: " + e. } public void setDatos(Trabajador a) { this. this.out.package view. Su uso es relevante cuando.7.println("Cantidad de registros: "+t. } Versión 2. se deben enviar datos para la construcción de un listado con información. 18. t.util.println().println("Producto: " + e. import java. Para este caso se debe dar implementación al método toComparate() en la clase que encapsula la información.size()).out. } public ArrayList<Trabajador> getDatos() { return a. } public int getEdad() { return edad. private int edad=0. por ejemplo.out. import java.a. public class Generico02 { public static void main(String[] args) { Trabajador t = new Trabajador().setDatos(new Trabajador("Pedro".22)). t. } } } 18.ArrayList. private ArrayList<Trabajador> a = new ArrayList<Trabajador>().21)). } public String getNombre() { return nombre. t.

hashCode(). if (this. t. } @Override public int hashCode() { // retorna un identificador único del objeto.getDatos().getEdad()). import java.getNombre().out. //Muestra edad System.println("Cantidad: " + e.setDatos(new Trabajador("Pedro".println(). } 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.Iterator.next().setDatos(new Trabajador("Josefa".getNombre().){ Trabajador e = (Trabajador)iterador. package view. //Muestra nombre System. return (nombreThis. } Trabajador productos = (Trabajador)objeto.equals(productos.getNombre()).compareTo(nombreObjeto)). } //Analiza si el objeto existe //Elimina el objeto for (Iterator<Trabajador> iterador= t. import bean.getNombre().out.contains(new Trabajador("Pedro".42))){ t. System. } return false. String nombreThis = this.72)).22)).iterator(). t.Trabajador.out.hasNext(). } } Implementamos la verificación de la existencia del objeto a eliminar en la lista y luego lo eliminamos.getNombre().@Override public boolean equals(Object objeto) { // Indica en base a que atributos se iguala el objeto if (objeto == null) { return false.42)). t.getDatos().getNombre())) { return true. t. t. if(t.setDatos(new Trabajador("Maria". return this. } } } Versión 2.toLowerCase().72)).setDatos(new Trabajador("Juan".toLowerCase().21)).2 147 de 285 . String nombreObjeto = productos. public class Generico03 { public static void main(String[] args) { Trabajador t = new Trabajador().remove(new Trabajador("Pedro".setDatos(new Trabajador("Pedro".util.42)).iterador.getDatos().println("Producto: " + e.

import bean.iterador. 18.72)). sólo se eliminará el primero que encuentre.remove(new Trabajador("Pedro". import java.){ Trabajador e = (Trabajador)iterador.42)).setDatos(new Trabajador("Pedro". import java.getDatos(). package bean.ArrayList.hasNext().println().getDatos(). t.5 isEmpty Analiza si la lista contiene objetos.println("Producto: " + e.setDatos(new Trabajador("Juan".contains(new Trabajador("Pedro".out.Considerar este caso en el cual hay dos valores en la lista de los que se necesitan eliminar.7. 18. System.42)).iterator().21)).setDatos(new Trabajador("Josefa".getDatos().setDatos(new Trabajador("Maria". } } } 18.util. public final class Trabajador implements Comparable{ //El mismo código de la clase anterior ….2 148 de 285 .util. public class Generico03 { public static void main(String[] args) { Trabajador t = new Trabajador().out.4 size Retorna la cantidad de objetos contenidos en una lista. //Muestra edad System. t.7. package view. t.println("Cantidad: " + e. if(t.setDatos(new Trabajador("Pedro". //Muestra nombre System. t.42))){ //Analiza si el objeto existe t.next().setDatos(new Trabajador("Pedro". t. Así.42)).22)).getEdad()). } Versión 2.out.getNombre()).Iterator.7.72)).6 indexOf lastIndexOf El primero busca la posición de la primera ocurrencia y el segundo busca la última posición de la ocurrencia. t. //elimina el objeto } for (Iterator<Trabajador> iterador= t.Trabajador.

72)). } package view.setDatos(new Trabajador("Maria".42)). System. t.ArrayList. t.7.setDatos(new Trabajador("Pedro".Trabajador. i++){ Trabajador e = (Trabajador)t.out.setDatos(new Trabajador("Juan".22)).22)).22)).setDatos(new Trabajador("Maria".out. t. t.setDatos(new Trabajador("Josefa". public class Generico06 { public static void main(String[] args) { Trabajador t = new Trabajador(). t. public class Generico07 { public static void main(String[] args) { Trabajador t = new Trabajador().21)).setDatos(new Trabajador("Juan".22)).size().setDatos(new Trabajador("Pedro".setDatos(new Trabajador("Pedro".72)).21)).setDatos(new Trabajador("Pedro".42)).getNombre()).setDatos(new Trabajador("Pedro". t.42)).setDatos(new Trabajador("Pedro".setDatos(new Trabajador("Josefa".getDatos().println("Cantidad: " + e. } } } Versión 2.get(i).out.package view.22))). t.2 149 de 285 .getDatos().setDatos(new Trabajador("Juan". t. //Muestra nombre System.lastIndexOf(new Trabajador("Maria".out.println().42)).println("Ultima aparición: "+t.72)). import bean.7 get Busca valores dentro de una lista según el índice que se indique. } } 18.Trabajador. t.getDatos().setDatos(new Trabajador("Josefa".indexOf(new Trabajador("Maria".72)).println("Producto: " + e.21)).getDatos().22))). import bean. t. package bean.getEdad()).util. for(int i=0.out. t.42)). t. System.setDatos(new Trabajador("Maria".setDatos(new Trabajador("Maria". import java. //Recupera los datos System. i<t. t. t. t.println("Primera aparición: "+t. //Muestra edad System. t. public final class Trabajador{ //El mismo código de la clase anterior ….

21)).util.22)).getEdad()).println("Cantidad: " + e.33)). Versión 2.println().8 set Reemplaza un valor en una posición. } package view.set(2. t.42)). public final class Trabajador{ //El mismo código de la clase anterior …. t. import bean.get(i). t.72)). public class Generico08 { public static void main(String[] args) { Trabajador t = new Trabajador().42)).setDatos(new Trabajador("Pedro". //Muestra nombre System.8 Iterable<> Esta interfaz contiene un sólo método y se usa para recorrer datos asiendo uso de Iterator<>. import java. t.getNombre()). System.println("Producto: " + e.setDatos(new Trabajador("Pedro". //Modifica los datos del índice 2 for(int i=0.ArrayList.out. t.setDatos(new Trabajador("Pedro". //Muestra edad System. package bean.Trabajador.out.getDatos().2 150 de 285 .72)). } } } 18. t. t.setDatos(new Trabajador("Juan". i++){ Trabajador e = (Trabajador)t.setDatos(new Trabajador("Maria".18. i<t.size().getDatos(). new Trabajador("Omar".getDatos().setDatos(new Trabajador("Josefa".out.7.

18.2 151 de 285 .9 Collection Es una interfaz que hereda desde la interfaz Iterable<>. Versión 2.

Sin embargo.2 152 de 285 .10 • • • Set<> Es una interfaz con las siguientes propiedades: No mantiene el orden de inserción.18. Observar que es compatible en usar int con Integer. Si se añade un objeto al conjunto y hay otro igual no se produce ningún cambio. no es compatible usar Iterator con Integer Versión 2.11 • • • List<> Es una interfaz con las siguientes propiedades: Colección que sí mantiene el orden de inserción y que puede contener elementos duplicados Acceso por posición No está permitido • Pero si está permitido • También puede ser el objeto de una clase. No admite elementos duplicados. 18.

> Es una interfaz que no permite claves duplicadas.12 Map<.13 Implementación Versión 2.2 153 de 285 . 18.18.

1 Tabla Estructura física que define la forma mediante la cual se almacenarán los datos. Clase 19. 19.1 Objetivos Uso de base de datos con Java.2 154 de 285 .19 19.com/downloads/mysql/ Vamos a emplear el MySql 5.mysql.2 MySql http://www.3. si necesitamos almacenar los datos de los trabajadores de una compañía tenemos: • • • • • • Rut Nombre Edad Estatura Fecha de ingreso Sexo Los tipos de estos datos guardan relación con la función que estos cumplen.x como motor de base de datos.3.2 Conocimiento previo Uso de colecciones genéricas 19.3 SQL En un lenguaje de programación creado para ejecutar consultas a base de datos. Este se debe bajar desde: Versión 2. Así se tendrá: • • • • • • Rut Nombre Edad Estatura Fecha de ingreso Sexo varchar(20) varchar(100) int double date boolean 19. Por ejemplo.

Versión 2. Paso 1: Seleccionar Next.2 155 de 285 .Para instalar el Motor seguir los siguientes pasos una vez que se ha bajado el archivo indicado.

Paso 3: Seleccionar Complete: Versión 2.2 156 de 285 .Paso 2: Aceptar y seleccionar Next.

2 157 de 285 .Paso 4: Seleccionar Install Paso 5: Seleccionar Next Versión 2.

Paso 6: Seleccionar Next Paso 7: Seleccionar Finish Versión 2.2 158 de 285 .

2 159 de 285 .Paso 8: Seleccionar Next. Paso 9: Seleccionar Standard Configuration y luego Next. Versión 2.

Versión 2.2 160 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”.

sexo bit ) Versión 2.3 PK Es el identificador de unicidad de cada registro de la tabla.2). nombre varchar(100). con pk rut y con los siguientes datos: Nombre Edad Estatura Fecha de ingreso Sexo create table trabajador ( rut varchar(20) primary key.Paso 12: Seleccionar execute. estatura double(4. el cual identifica de manera única a cada trabajador. para trabajadores de una empresa nacional podría ser el rut. ingreso datetime. 19.3. 19.2 161 de 285 . Por ejemplo.3. edad int.4 • • • • • • Rut Crear tabla varchar(20) varchar(100) int double date boolean Crear la tabla de nombre trabajador.

Luego se debe crear la base de datos.2 162 de 285 .Para ejecutar este proceso en mysql se debe ingresar a la consola que no solicitará la password que le indicamos. Versión 2. En este caso el nombre será dgac.

estatura.sexo) values ('14300000'.sexo) values ('14200000'.32.2 163 de 285 . insert into trabajador (rut.1).ingreso. Luego hacer copiar y pegar con el script de creación de la tabla.sexo) values ('14400000'.edad.ingreso.estatura.ingreso. insert into trabajador (rut.'Jose Urrutia'.nombre.estatura.93.nombre.45.nombre.1.'2010/01/15'.'Sara Perez'.'2010/02/01'.31.nombre.5 insert Usar la siguiente instrucción para el ingreso de datos.66.1).'Maria Ugarte'.ingreso.estatura.'Hugo Galaz'.edad.estatura.edad.sexo) values ('14100000'.nombre.edad. Versión 2.edad.1.22.3. haciendo copiar pegar: insert into trabajador (rut.40.1).'2010/01/31'.0).88.Luego se debe ingresar en el contexto de la base de datos dgac.ingreso. insert into trabajador (rut.'2010/02/01'.'2010/02/15'. 19. Para eso usar la instrucción use dgac. insert into trabajador (rut.0).72.1.1.sexo) values ('14000000'.'Juan Perez'.1.62.

select * from trabajador.6 update Esta instrucción da la posibilidad de cambiar datos en uno o más registros.Esta instrucción tiene por obligación “insert into”. Caso 3: Ver todos los registros con edad entre 30 y 40 años ambos valores incluidos.3. select * from trabajador where edad between 30 and 40. luego entre paréntesis los campos a los cuales se le necesita ingresar datos. eliminar el rut=14.000 a 50 años.2 164 de 285 . 19. Caso 1: Ver todos los datos. Caso 2: Ver todos los registros con edad < 32 años.7 delete Esta instrucción da la posibilidad de eliminar uno o más registros. Versión 2. delete from trabajador where rut=14200000. 19.3.8 select Da la posibilidad de visualizar registros.000. enseguida la palabra “values” para finalizar entre paréntesis con los datos asociados en una relación 1-1 con el nombre de los campos.3. Por ejemplo. 19. Por ejemplo.200.200. update trabajador set edad=50 where rut='14200000'. cambiar la edad del rut=14. select * from trabajador where edad < 32.

independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se accede. Para utilizar una base de datos particular. utilizando el dialecto SQL del modelo de base de datos que se utilice. es una API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java. A partir de allí puede realizar con cualquier tipo de tareas con la base de datos a las que tenga permiso: consulta.Caso 4: Contar la cantidad de registros. Caso 5: Ver el nombre y edad los registros con edad entre 30 y 40 años ambos valores incluidos. actualización. para ello provee el localizador a la base de datos y los parámetros de conexión específicos.2 165 de 285 .sun. 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 métodos de registro para declarar los tipos de localizadores a base de datos (URL) que pueden manejar. etc. el usuario ejecuta su programa junto con la biblioteca de conexión apropiada al modelo de su base de datos. La especificación se encuentra en: http://java. El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo específico de base de datos. modificación y borrado de tablas. select nombre. select count(*) from trabajador.com/javase/6/docs/technotes/guides/jdbc/ Versión 2. creación. 19. ejecución de procedimientos almacenados en la base de datos.4 JDBC Java Database Connectivity. más conocida por sus siglas JDBC. edad from trabajador where edad between 30 and 40. y accede a ella estableciendo una conexión.

Cuando una clase DataSource se ha aplicado adecuadamente. "oboy". y cuando el getConnection método se llama.close) tan pronto como ya no son necesarios. Proceso de los resultados 19. intenta localizar un controlador que puede conectarse a la base de datos correspondiente a dicha URL. Una aplicación utiliza un objeto Connection producido por DataSource de manera esencialmente es la misma que utiliza un objeto Connection producido por el DriverManager.getConnection(url.2 166 de 285 .6 Conexión de Información general Un objeto Connection representa una conexión con una base de datos. se reciclan los objetos desechados. Este método toma una cadena que contiene una dirección URL. La clase DriverManager mantiene una lista de clases Driver registrados.19. si una aplicación utiliza los recursos externos. se recomienda que los programadores explícitamente cerrar todas las conexiones (con el método Connection. Connection con = DriverManager. Sin embargo.close y declaraciones con el método Statement. DataSource es la alternativa preferida para la creación de una conexión. El método de Driver connect utiliza esta URL para realmente establecer la conexión. Versión 2. o puede tener conexiones con muchas bases de datos diferentes. "12Java"). no necesita preocuparse por la gestión de memoria.0 proporciona la interfaz DataSource como una alternativa a la DriverManager para establecer una conexión. Una sola aplicación puede tener una o más conexiones con una sola base de datos. comprueba con cada conductor en la lista hasta que encuentre uno que pueda conectarse a la base de datos especificada en la URL. Enviar consultas y actualizar las declaraciones a la fuente de datos 3. Por lo tanto. El recolector de basura elimina automáticamente los objetos cuando ya no se utiliza y libera la memoria que se utiliza. el recolector de basura no tiene manera de conocer el estado de esos recursos. el objeto DataSource se puede utilizar para producir objetos Connection que participan en la agrupación de conexiones y / o objetos Connection que pueden participar en transacciones distribuidas.5 ¿Qué hace la API de JDBC? En términos simples.8 Liberación DBMS Recursos Se recomienda que los programadores de cerrar explícitamente las conexiones y las declaraciones que han creado cuando ya no son necesarios. haciendo que la memoria que ocupan actualmente disponible para la reutilización rápida.7 Establecer una conexión La forma tradicional de establecer una conexión con una base de datos es llamar a la DriverManager. Un programador de escribir código en el lenguaje de programación Java y que no utilice ninguna de recursos externos. Cuando la memoria se está agotando. La clase DriverManager conocida como la capa de gestión de JDBC. 19. Establecer una conexión con una fuente de datos 2. El JDBC 2. 19. como lo hace cuando tiene acceso a un Motor de Base de Datos con la API de JDBC. El código siguiente es un ejemplo de la apertura de una conexión a una base de datos ubicada en la “jdbc:odbc:wombat” con un ID de usuario de “oboy” y “12Java” como la contraseña: String url = "jdbc:odbc:wombat". una tecnología basada en JDBC driver (controlador JDBC ") permite hacer tres cosas: 1.getConnection método. Una sesión de conexión incluye las instrucciones SQL que se ejecutan y los resultados que se devuelven en la conexión.

19.9

Crear una conexión

Para esto se va a crear una clase que proporciones el servicio y en la cual se puedan configurar “en duro” sus parámetros. 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 ubicación de la base de datos return url; } public static String getUser() { //Retorna el usuario de conexión a la base de datos return user; } public static String getPass() { //Retorna el password del usuario de conexión 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:

Versión 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 información se usa el comando “select”

Crear un proyecto:

Versión 2.2

168 de 285

Crear la clase ConexionDB en la package conec:

El código asociado a la clase es el anterior.

Versión 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 conexión 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 inserción st.executeUpdate(SQL); st.close(); con.close(); } catch (SQLException ex) { } } }

Versión 2.2

170 de 285

19.11

Driver de Conexión
http://www.mysql.com/downloads/connector/j/

Para ejecutar el código correctamente es necesario instalar el Driver de conexión de MySQL que se baja desde :

Copiar el Driver dentro dela carpeta del proyecto:

Luego instalarlo para que sea reconocido por NetBeans:

Versión 2.2

171 de 285

Se tiene: Después de ejecutar el proceso se tiene: Versión 2.2 172 de 285 .

haciendo doble click sobre el.ActionEvent evt) { String valor = this. Uso de componentes básicos de Swings. setText(String a): Permite asignar el valor “a”. Uso de métodos y colecciones. validaciones y mensajes de cuadros de diálogos.showMessageDialog(null.2 173 de 285 .awt. valor). Las propiedades más usadas son: Asociar el siguiente código al botón. } Versión 2.getText().20 20.event. Permite el ingreso de datos en un formulario. private void jButton1ActionPerformed(java.jTextField1.2 20.1 20. //Recupera el valor ingresado JOptionPane.3 • • Clase Objetivos Conocimiento previo JTextField getText(): Permite conocer el valor seleccionado.

5 matches Las expresiones regulares son una secuencia de caracteres y símbolos que definen un conjunto de cadenas (caracteres literales y símbolos especiales).4 toolTipText Permite emitir un mensaje al posición el mouse sobre el objeto al que se le ha asociado la propiedad. y compara el contenido de un objeto String. Para el ejemplo anterior. 20.2 174 de 285 . Las expresiones son: • • • Cualquier dígito: un carácter numérico. Cualquier carácter de espacio en blanco: es un espacio. Devuelve un valor Boolean indicando si hubo concordancia o no. Cualquier carácter de palabra: un carácter alfanumérico o guión bajo. Son útiles para validar la entrada y asegurar que los datos estén en un formato específico. Por ejemplo • • • Un código postal debe coincidir de 5 dígitos Un apellido debe comenzar con mayúscula Un número telefónico debe tener solo números El método matches recibe una cadena que especifica la expresión regular. retorno de carro o nueva línea. tabulador.20. aplicaremos el mensaje al JTextField. Versión 2.

excepto la b y la c: [ad-z] (resta) Desde la a hasta la z. exactamente n veces X.ActionEvent evt) { String val = this.} a.showMessageDialog(null. por lo menos n veces X{n.length()>0){ JOptionPane. } else{ JOptionPane. excepto desde la m hasta la p: [a-lq-z](resta) Un número: [0-9] Todo menos un numero: [^0-9] Un espacio en blanco: [ x0Bf ] Todo menos un espacio en blanco: [^s] Una letra: [a-zA-Z_0-9] Todo menos letras: [^w] X. private void jButton1ActionPerformed(java. la e. o c Cualquier carácter excepto a. o c (negación) Desde la a a la z o desde la A hasta la Z. incluidos Desde la a hasta la d. una o más veces X.event.m} X. una o ninguna vez X.2 175 de 285 .matches("aaaaa") && val.getText().showMessageDialog(null. "Ingreso incorrecto"). b.jTextField1. o la f (intersección) Desde la a hasta la z. o desde la m a la p: [a-dm-p] (unión) La d. "Ingreso correcto"). por lo menos n veces pero no mas de m veces Sólo será valido el ingreso de 5 letras a minúsculas seguidas.awt. cero o ninguna vez X. if(val. } } Versión 2.[abc] [^abc] [a-zA-Z] [a-d[m-p]] [a-z&&[def]] [a-z&&[^bc]] [a-z&&[^m-p]] d D s S w W X? X* X+ X{n} X(n. b.

showMessageDialog(null.jTextField1.2 176 de 285 .event. } else{ JOptionPane. } } Comprobar que el ingreso sea de sólo números y exactamente tres unidades. if(val.length()>0){ JOptionPane.getText().jTextField1.matches("\\d*") && val.awt.event. "Ingreso incorrecto"). "Ingreso correcto").showMessageDialog(null. if(val. } } Versión 2.ActionEvent evt) { String val = this.getText(). private void jButton1ActionPerformed(java.ActionEvent evt) { String val = this.length()>0){ JOptionPane. private void jButton1ActionPerformed(java.matches("\\d{3}") && val. } else{ JOptionPane.showMessageDialog(null.awt. "Ingreso correcto").Comprobar que el ingreso sea de sólo números. "Ingreso incorrecto").showMessageDialog(null.

ni letras acentuadas). } else{ JOptionPane.jTextField1.awt.2 177 de 285 .matches("[a-zA-Z]*") && val. private void jButton1ActionPerformed(java.ActionEvent evt) { String val = this. } } Versión 2.Validar que una entrada sólo sean sólo letras (no soporte espacios en blanco. "Ingreso incorrecto"). "Ingreso correcto"). ni la letra ñ.showMessageDialog(null.event.length()>0){ JOptionPane. if(val.showMessageDialog(null.getText().

ActionEvent evt) { String val = this.awt.length()>0){ JOptionPane. private void jButton1ActionPerformed(java.2}/\\d{1. "Ingreso incorrecto"). ósea la expresión que esta entre corchetes directamente al lado izquierdo del asterisco.2 178 de 285 . private void jButton1ActionPerformed(java. } else{ JOptionPane.matches("[A-Z][a-zA-Z]*") && val.Usando el patrón ( “[A-Z][a-zA-Z]*”) en este caso le estamos diciendo que la entrada para ser valida debe tener el primer carácter en mayúscula [A-Z] y que los siguientes caracteres pueden ser cualquier carácter tanto minúscula como mayúscula [a-zA-Z] con el asterisco final le estamos diciendo que los siguientes caracteres van a ser iguales a la expresión previamente indicada. } } Valida que la fecha ingresada sea 1/2/2011 ó 01/02/2011 ó 1/02/2011 ó 01/2/2011.getText().showMessageDialog(null.showMessageDialog(null. } } Versión 2. if(val. if(val.awt.event.showMessageDialog(null.matches("\\d{1. "Ingreso correcto").2}/\\d{4}") && val.jTextField1.getText(). "Ingreso incorrecto").event.ActionEvent evt) { String val = this.jTextField1. "Ingreso correcto").length()>0){ JOptionPane. } else{ JOptionPane.showMessageDialog(null.

awt.matches("[A-Z]{2}\\d{2}") && val.getText(). private void jButton1ActionPerformed(java.2 179 de 285 . if(val. } } Versión 2.ActionEvent evt) { String val = this.showMessageDialog(null.jTextField1.event.Validar que el ingreso sean exactamente 2 letras mayúsculas (menos la Ñ) y exactamente 2 números.length()>0){ JOptionPane. "Ingreso correcto"). "Ingreso incorrecto").showMessageDialog(null. } else{ JOptionPane.

6 JSlider Permiten seleccionar una opción dentro de un aspecto continuo de valores. En Netbeans se maneja con el componente: Considerar la configuración Se genera el siguiente componente: Versión 2.20.2 180 de 285 .

jSlider1. new JLabel("C")).put(10.put(50. new JLabel("B")).2 181 de 285 . new JLabel("E")). new JLabel("A")). entonces se debe anexar la propiedad snapToTicks.setLabelTable(rotulos). rotulos.put(40. lo cual define las letras y el valor numérico asociados private void usoLetras(){ Hashtable<Integer. Versión 2. rotulos. new JLabel("F")). Component>(). rotulos. new JLabel("D")). } El último valor 20 deja al componete iniciándose en B. rotulos. También se pueden generar secuencias con otros elementos como letras.put(20. rotulos. para este caso. rotulos.put(60. Para esto se debe incluir el siguiente método en el constructor del JFrame.put(30. Component> rotulos = new Hashtable<Integer.Si se necesita que el componente se deslice sólo por los valores.

Sus constructores son: Considerar el siguiente formulario: Para recuperar los valores: Versión 2.2 182 de 285 .

• getSelectedIndices(): Recupera la posición del valor recuperado mediante un arreglo de tipo int[].2 183 de 285 .7 JList Un JList le presenta al usuario un grupo de ítems para elegir. i<=10. Para manejarlo en Netbeans se usa el componente: Lanzar uno de estos elementos. i++){ modelo. Se va a agregar una lista de números al componente. for(int i = 1.20. } jList1. Versión 2. • getSelectedValues(): Recupera más de un valor de tipo Object[]. • getSelectedIndex(): Recupera la posición del valor recuperado.setModel(modelo). Las propiedades más usadas son: • getSelectedValue(): Recupera un valor de tipo Object.addElement(i). DefaultListModel modelo = new DefaultListModel().

addElement("G").awt. jList1. String[] nombreColumna = {"valores"}. } } Versión 2. modelo.setModel(modelo).addElement("D").addElement("C"). Para seleccionar sólo uno se debe activar la opción a “SINGLE”: Se van a recuperar el o los valores. modelo. modelo. DefaultListModel modelo = new DefaultListModel().addElement("J"). El código de ejecución del botón es: private void jButton1ActionPerformed(java. modelo. for(Object valor: valores){ celda[i][0] = valor.getSelectedValues().2 184 de 285 .setModel(new DefaultTableModel(celda.addElement("I").addElement("B"). modelo. modelo.addElement("F").nombreColumna)).length][1].ActionEvent evt) { Object[] valores = jList1.Para agregar un grupo de letras. modelo.addElement("H").addElement("A"). modelo. //Recupera los valores seleccionados en JList Object[][] celda = new String[valores. Con lo anterior se puede seleccionar más de un elemento. Para esto incluir un JButton y un JTable. modelo.event.addElement("E"). jTable1. int i=0. modelo. i += 1.

2 185 de 285 . Versión 2. Con la siguiente opción se obtiene: Ejemplo: Se va a considerar una aplicación en donde se requiere transferir valores desde un JList a otros en donde en el segundo JList los datos deben salir ordenados.Con la siguiente propiedad se puede controlar como nuestros elementos aparecen en la lista.

modelo. Object[] valores = jList2. for(Object valor: datosTreeSet) datosVector.ActionEvent evt) { //Los valores se almacenan en un Vector<> pues es lo que permite setListData Vector<Object> datosVector = new Vector<Object>().addElement("Mayo").JFrame { //Es necesario definirlo aquí.ActionEvent evt) { //Los valores se almacenan en un Vector<> pues es lo que permite setListData Vector<Object> datosVector = new Vector<Object>(). for(Object valor: valores) datosTreeSet. modelo. modelo. jList2.addElement("Marzo").El código para incluir los valores en el método constructor es: public DobleJList() { initComponents(). El código del botón >> es: private void jButton1ActionPerformed(java.awt.addElement("Noviembre").addElement("Septiembre").awt. jList1.add(valor).add(valor). modelo. modelo.addElement("Junio").event.addElement("Enero").addElement("Agosto"). modelo. } El código del botón << es: private void jButton2ActionPerformed(java.event. modelo.swing.addElement("Julio"). for(Object valor: datosTreeSet) datosVector. modelo. modelo.getSelectedValues(). } Observar que se necesita definir la variable de instancia que maneja los datos enviados desde un JList a otro. para no perder las los valores contra varias acciones sobre le botón >> //También almacena los datos ordenados para mostrarlos así TreeSet<Object> datosTreeSet = new TreeSet<Object>(). modelo. DefaultListModel modelo = new DefaultListModel().setListData(datosVector).2 186 de 285 . } Versión 2.addElement("Diciembre").setModel(modelo).add(valor).getSelectedValues().setListData(datosVector). Object[] valores = jList1. modelo. for(Object valor: valores) datosTreeSet. Se usa TreeSet pues almacena los valores ordenados public class DobleJList extends javax.remove(valor). modelo.addElement("Abril"). jList2.addElement("Octubre").addElement("Febrero").

addElement("Naranja").event.JFrame { public Otros() { initComponents().red. modelo. modelo. modelo. } Versión 2. Color.white.ListSelectionEvent evt) { Color colores[] = { Color. } En el método constructor tenemos: public class Otros extends javax. Color.addElement("Azul"). modelo.getSelectedIndex()]).blue. modelo. Color. modelo.orange.addElement("Rojo").addElement("Verde").addElement("Blanco").2 187 de 285 . Color. Para desarrollar esto se va a recurrir a la siguiente propiedad del JList El código que se debe incorporar es: private void jList1ValueChanged(javax.setSelectionBackground(colores[jList1. jList1.pink.black. DefaultListModel modelo = new DefaultListModel().yellow }. Color.addElement("Amarillo"). jList1.swing. Color. Color.Ejemplo: Crear un JList que al seleccionar un color de su lista cambie automáticamente el color del objeto de la lista seleccionado.addElement("Rosa"). modelo.swing.green.setModel(modelo).addElement("Negro"). modelo.

JOptionPane.ERROR_MESSAGE). "Titulo del dialogo". "Mensaje que se necesita".ActionEvent evt) { JOptionPane. 0 1 2 3 4 Considerar el siguiente código: private void jButton1ActionPerformed(java. JOptionPane.showMessageDialog(null.awt.INFORMATION_MESSAGE). "Mensaje que se necesita". El icono depende del tipo de mensaje: • ERROR_MESSAGE • INFORMATION_MESSAGE • WARNING_MESSAGE • QUESTION_MESSAGE • PLAIN_MESSAGE (No tiene icono asociado) Se pueden usar icono propios en los cuatro primeros mensajes. Un cuadro de diálogo tiene los siguientes componentes: • Un icono • Un mensaje • Uno o más botones de opciones • Opcionalmente en algunos casos un campo de texto en que el usuario introduzca una cadena de caracteres. • showOptionDialog: Muestra un mensaje y obtiene una opción de una serie de opciones. JOptionPane.2 188 de 285 . Versión 2. "Titulo del dialogo". • showInputDialog: Muestra un mensaje y obtiene una línea de entrada del usuario.event. • showConfirmDialog: Muestra un mensaje y obtiene confirmación (SI/NO).showMessageDialog(null.20.8 Cuadro de diálogo La clase JOptionPane tiene cuatro métodos para mostrar cuadro de diálogo: • showMessageDialog: Muestra un mensaje y espera a que le usuario pulse OK.

PLAIN_MESSAGE).WARNING_MESSAGE). JOptionPane.QUESTION_MESSAGE).showMessageDialog(null. "Titulo del dialogo".2 189 de 285 . } ERROR_MESSAGE INFORMATION_MESSAGE WARNING_MESSAGE QUESTION_MESSAGE PLAIN_MESSAGE Versión 2. "Mensaje que se necesita". JOptionPane. JOptionPane.JOptionPane. JOptionPane. "Mensaje que se necesita".showMessageDialog(null. "Titulo del dialogo".showMessageDialog(null. "Titulo del dialogo". JOptionPane. "Mensaje que se necesita".

Usamos un arreglos para emitir el siguiente mensaje: private void jButton1ActionPerformed(java. • 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. JOptionPane. Versión 2. mensaje. JOptionPane.ActionEvent evt) { Object[] mensaje = {"Producto eliminados:"."Azucar". También se puede usar "\n" • Cualquier otro objeto: Se aplica a toString y muestra la cadena resultante.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.INFORMATION_MESSAGE).showMessageDialog(null.awt.2 190 de 285 . apilados uno encima del otro. } Los botones de la parte inferior dependen del tipo de cuadro de diálogo y del tipo de opción.event."Fideos"."Aceite"}. "Titulo del dialogo".

String resultado. "Resultados de la comparación". resultado. numero2 = Integer. } if (numero1 > numero2) { resultado = "Primer número mayor que el segundo".Vamos a ver un ejemplo que solicita información y luego la analiza.awt.ActionEvent evt) { String primerNumero. // recibir el primer numero del usuario como una cadena primerNumero = JOptionPane. resultado = "". } if (numero1 < numero2) { resultado = "Primer número menor que el segundo".parseInt(segundoNumero).showMessageDialog(null.showInputDialog("Escriba el segundo entero :"). private void jButton1ActionPerformed(java.2 191 de 285 . String segundoNumero. // recibir el segundo numero del usuario como una cadena segundoNumero = JOptionPane.event. } // Mostrar los resultados JOptionPane.showInputDialog("Escriba el primer entero:"). } Versión 2. int numero1. int numero2. if (numero1 == numero2) { resultado = "Números iguales".parseInt(primerNumero). // convertir los numeros de tipo String a tipo int numero1 = Integer. JOptionPane.INFORMATION_MESSAGE).

para generar la siguiente secuencia que nos permite dependiendo de la respuesta.ActionEvent evt) { int n=JOptionPane.showMessageDialog(null.event.awt.showConfirmDialog(null.".showConfirmDialog devuelven enteros indicando qué botón ha pulsado el usuario. if(n==0){ JOptionPane. } if(n==1){ JOptionPane. "Hizo clic en NO").. "Confirma". "Hizo clic en SI").2 192 de 285 .. "Esta seguro que desea eliminar el registro . 0). private void jButton1ActionPerformed(java. • OK_OPTION 0 • CANCEL_OPTION 1 • YES_OPTION 2 • NO_OPTION 3 • CLOSED_OPTION 4 Por ejemplo.showMessageDialog(null. } } Versión 2.

3 Modelos de evaluación 5 Observaciones: • Fecha de revisión: Jueves 09 junio de 2011 • Nota 4.1 Objetivos Desarrollar el trabajo 1. valores con dos decimal entre 1.2 193 de 285 . universitaria.5 y 2. Botones: • Almacenar los datos • Limpiar los TextField (28 puntos) (2 puntos) Se debe validar que el nombre contenga al menos 20 caracteres. (20 puntos) Versión 2. (10 puntos) Al llegar al quinto cliente ingresado. (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. Valor 12.2 Conocimiento previo Contenidos del semestre. Si no cumple esta condición el registro no se debe almacenar y se mostrará una ventana con el error. postgrado.0 = 80% del puntaje • Base de datos: unab • Tabla cliente: ◦ codigo varchar(10) PK ◦ nombre varchar(100) ◦ estatura double ◦ nivelEducacional int Diseñar un formulario que sea capaz de solicitar información de un cliente: • Codigo: TextField. (20 puntos) Se debe validar que el código del cliente esté compuesto de una letra mayúscula. el color del mensaje debe pasar a verde con negrita y letra cursiva tahoma. • Nombre: TextField. Clase 21.0. entonces el registro no se deben almacenar y se muestra una ventana de mensaje indicando el error. • Nivel educacional: Un JSlider con valores básica. dos números y tres letras minúsculas.21 21. • Estatura: JList.5% de la nota 3. media. 21. (10 puntos) Si el código del cliente existe en la base de datos. En caso de error se debe mostrar una ventana con el mensaje y los datos no se deben almacenar.

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 números. • Por una parte.2 194 de 285 .2 22. No es más que una extensión de JTextField que viene a cubrir algunas de las deficiencias que todos encontrábamos en él.1 22.22 22. El componente de Netbeans es: Suponga que se necesita ingresar 7 números obligando a ingresar primero tres números. permite que el usuario entre el texto que se corresponde con un dato solicitado por la aplicación. luego un guión y por último 4 números. Clase Uso de métodos y colecciones. permite a la aplicación mostrar datos al usuario. En Netbeans se debe configurar en la propiedad Versión 2. Es un componente que cumple una doble función.3 Objetivos Conocimiento previo JFormattedTextField Uso de componentes Swings. La principal limitación del JTextField es que permite entrar cualquier texto y que no hay manera fácil de mostrar un texto con un formato concreto. El formato debe ser: “###-####”. • Por otra.

2 195 de 285 . Observar que este formato impide el ingreso de otro carácter que no sea un número. Observar que sólo se pueden ingresar números. Los caracteres usados son: Ejemplos: • Ingresar exactamente 2 letras y 2 números. luego el guión y por último los más 4 números. Observar que el componente impide el ingreso de más valores y distintos de los definidos.El resultado es que sólo se pueden ingresar a los más tres números al inicio. Versión 2.

Al cambiar el foco se tiene: Versión 2.2 196 de 285 .• Permitir sólo 5 letras mayúsculas transformando las letras minúsculas a mayúsculas. • Transformar números a cantidades separadas por miles usando un punto.

Limpiar las dos cajas de texto para quedar cómo: private void jButton1ActionPerformed(java.'3'. } Versión 2. el segundo permite el ingreso de texto que se usa para validar el password de un usuario al ingresar al sistema.showMessageDialog(null. char[] pass."Error").22.'u'.showMessageDialog(null.'n'.ActionEvent evt) { String usuario.event.getText().'4'}."Ingreso correcto").'2'. char[] pass1 = {'J'. usuario = this.'a'. i++) if(pass[i] != pass1[i]) resp=false.awt.jPasswordField1. el tercero permite usar una línea de separación. } } //Analizar la password Juan#1234 boolean analizaPass(char[] pass){ boolean resp=true.length. return resp. i<pass. for(int i=0.jTextField1.'1'.getPassword().Separator El primer componete permite el ingreso de información.equals("JPerez") && analizaPass(pass)){ JOptionPane. } else{ JOptionPane.2 197 de 285 .4 PasswordField . pass = this. //User correcto: JPerez //Password correcta: Juan#1234 if(usuario.'#'.

22. Para manejar desde Netbeans usamos el componente. Como ejemplo vamos a seleccionar un JPanel y lo lanzamos sobre un JFrame. se debe acompañar del componente JbuttonGroup que permite agrupar un conjunto de componentes JradioButton. Usando la propiedad Border cambiamos la forma gráfica del JPanel. Versión 2.5 JRadioButton Sirve para manjar una elección desde varias opciones.2 198 de 285 . Además.

Dejar como se muestra. Lanzar un JGroupButton sobre el JFrame.2 199 de 285 . Versión 2. Notar que este componente no se aprecia gráficamente.Luego lanzamos 3 JradioButton dentro del JPanel. para poder verlo se debe usar el Inspector.

event.2 200 de 285 .isSelected()) mensaje = "Color Blanco". if(this.jRadioButton3. } Versión 2. private void jButton1ActionPerformed(java. if(this.isSelected()) mensaje = "Color Rojo". mensaje).isSelected()) mensaje = "Color Verde".awt.Podemos ver ahora el componente en el Inspector.jRadioButton2. JOptionPane.jRadioButton1. if(this. Vamos ahora a programar el JButton.ActionEvent evt) { String mensaje="".showMessageDialog(null.

Usando la propiedad “Border” del JPanel genere lo siguiente: Versión 2. Las propiedades más usadas son: • isSelected(): Permite saber si el CheckBox está seleccionado. Ejemplo de uso: Seleccione un JPanel.2 201 de 285 .6 CheckBox Este componente sirve para seleccionar una opción.22.

boolean pref2 = true. } Versión 2.jCheckBox2. pref3 = this.showMessageDialog(null.jCheckBox1.isSelected().this. pref1 = this. Object[] mensaje = {"Selección:".getText()+" :"+pref1 .Anexar el JButton para conseguir: Seleccionar los JCheckBox siguientes: El código asociado el botón es: private void jButton1ActionPerformed(java.this.jCheckBox3.isSelected().awt.2 202 de 285 .isSelected().jCheckBox3.isSelected().jCheckBox4.getText()+" :"+pref3 . boolean pref3 = true. pref2 = this.this.jCheckBox1.jCheckBox4.ActionEvent evt) { boolean pref1 = true. JOptionPane.event.getText()+" :"+pref2 . pref4 = this.this.mensaje). boolean pref4 = true.getText()+" :"+pref4}.jCheckBox2.

2 203 de 285 .Un ejemplo de ejecución: 22. Seleccionar 3 JLabel.7 Spinner Este componente sirve para seleccionar una opción desde una lista. 3 JSpinner y un JButton. Versión 2. Métodos: Los métodos asociados más usados son: • getValue(): Permite recuperar el valor seleccionado.

Seleccionar el segundo JSpinner. marcar su propiedad Model y proporcionar el siguiente formato.2 204 de 285 . Versión 2. marcar su propiedad Model y proporcionar el siguiente formato.Seleccionar el primer JSpinner.

2 205 de 285 . marcar su propiedad Model y proporcionar el siguiente formato.Seleccionar el tercer JSpinner. El formato definitivo es: Versión 2.

val1 = this.jSpinner2.jSpinner1. val2 = this.2 206 de 285 .getValue(). Object val2 = new Object().ActionEvent evt) { Object val1= new Object(). Versión 2. Object val3 = new Object().event.awt. El código asociado al JButton es: private void jButton1ActionPerformed(java.getValue().Para dar una forma más atractiva a los componentes marcar cada uno de los JSpinner y su propiedad “Border”.

getText()+" :"+val2 .this.val3 = this.jLabel2. } Versión 2.jSpinner3.getText()+" :"+val3}.showMessageDialog(null.2 207 de 285 .mensaje). JOptionPane.this.getText()+" :"+val1 .jLabel1.this.jLabel3. Object[] mensaje = {"Selección:".getValue().

8 JTabbedPane Con la clase JTabbedPane. podemos tener varios componentes (normalmente objetos JPanel) compartiendo el mismo espacio. Para manejar desde Netbeans usamos el componente.22.2 208 de 285 . El usuario puede elegir qué componente ver seleccionando la pestaña del componente deseado. Para trabajar estos componentes vamos a hacer clic según se indica en el siguiente diagrama: Resultado: Versión 2.

2 209 de 285 .Para conseguir las pestañas se debe agregar JPanel al JTabbedPane Resultado: Versión 2.

2 210 de 285 .Agregar otro JPanel Resultado Versión 2.

Se han agregado al final 4 pestañas Para cambiar el nombre a las pestañas 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: Versión 2.2 211 de 285 .

2 212 de 285 . Eliminación y Actualización con un mensaje apropiado al posarse sobre ellas. También se les puede agregar un icono a las pestañas en la opción: Versión 2.De la misma forma las pestañas siguientes marcarlas como Ingreso.

Vamos a agregar elementos ahora en las pestañas para generar el mantenedor.2 213 de 285 . Versión 2. Incluir un JTable. Nuevamente se recomienda manejar los elementos en el “Inspector” del Netbeans.

edad int. } public static String getPass() { return pass.En el ingreso se van a considerar los siguientes componentes: En MySQL 4. } public static String getUser() { return user.x se ha creado la base de datos duoc y la tabla: create table alumno ( id_alumno int auto_increment. sexo boolean. Tener presente como almacena los datos MySQL La clase para conexión es: package conec. public static String getDriver() { String driver= "com. Ingresar un datos insert into alumno (rut. rut varchar(50). } } Versión 2. private static String user= "root".1.2 214 de 285 . return driver.mysql.25.edad. private static String pass= "root".sexo) values ('14000000'. public class ConexionBD { private static String url= "jdbc:mysql://localhost/duoc".Driver".jdbc. } public static String getUrl() { return url.true). primary key(id_alumno) ).

String SQL=" insert into alumno (rut. ex).sexo = sexo.jComboBox1. } public boolean isSexo() { return sexo. public Alumno(){ } public Alumno(String rut.getText(). boolean sexo){ this. null.getName())." + sexo + "). null. this.getName())." + edad + ".getSelectedItem())). } } catch (SQLException ex) { Logger. Statement st = con.class.SEVERE.2 215 de 285 .class. } } Versión 2. String rut = this.edad = edad. this.edad.log(Level.jTextField1.jLabel3. int edad = Integer.La clase Alumno para empaquetar los datos package bean. } public String getRut() { return rut.setRut(rut).valueOf(this.event.setText("Registro insertado"). this. } public void setRut(String rut) { this.setEdad(edad).ActionEvent evt) { try { Class. } public void setEdad(int edad) { this.getLogger(Pruebas.setSexo(sexo).jLabel3. this. } } Código asociado al botón de ingreso: private void jButton1ActionPerformed(java. } public void setSexo(boolean sexo) { this.createStatement(). } public int getEdad() { return edad. private int edad = 0.".SEVERE.executeUpdate(SQL).jLabel3. int n = st. ex).parseInt(String. } catch (ClassNotFoundException ex) { Logger.forName(ConexionBD.getDriver()).log(Level.setVisible(true).getConnection(ConexionBD. } try { Connection con = DriverManager. ConexionBD.sexo) values (' "+ rut + "'.jLabel3. public class Alumno { private String rut= new String(""). boolean sexo = this.isSelected().setText("Registro NO insertado"). int edad. } if(n==0){ this. if(n==1){ this.getPass()).jRadioButton1.rut = rut.getUrl(). ConexionBD. private boolean sexo = false.setVisible(true).awt.getLogger(Pruebas.getUser().

jLabel3. } catch (ClassNotFoundException ex) { Logger.getLogger(Pruebas.setModel(new DefaultTableModel(celdas.getEdad()). null.getBoolean(3). this.setVisible(false). celdas[i][1] = (Object)String.nombreColumnas)).2 216 de 285 .getUrl().jTable2.getRut(). actualizaTabla(). String SQL=" select select rut. String[] nombreColumnas = {"RUT". Object[][] celdas = new String[dat.add(new Alumno(rutRecupera.Ya se ha ingresado datos Vamos a implementar el Jtable.getDriver()). en este caso es. } try { Connection con = DriverManager.SEVERE. ConexionBD. celdas[i][2] = (Object)String. int i=0.getName()). boolean sexoRecupera = rs. sexo from alumno ".size(). int edadRecupera = rs.valueOf(al.forName(ConexionBD.SEVERE.getInt(2). Statement st = con.getConnection(ConexionBD."Sexo"}.getUser(). dat.getLogger(Pruebas. ConexionBD.class. } Versión 2. jTable2. edad.getName()). ex). } } catch (SQLException ex) { Logger. null.log(Level."Edad". this.getPass()).next()){ String rutRecupera = rs. } } Este método debe ser llamado desde el método constructor de JFrame que contiene al JTabbedPane public Pruebas() { initComponents(). sexoRecupera)). for(Alumno al: dat){ celdas[i][0] = (Object)al.executeQuery(SQL). } int j = dat. try { Class. edadRecupera. while(rs. ex).class. ResultSet rs = st. i += 1. public void actualizaTabla(){ Vector<Alumno> dat = new Vector<Alumno>().size()][3].createStatement().valueOf(al.log(Level.getString(1).isSexo()).

2 217 de 285 . Para lograr la actualización se debe activar el siguiente método: private void jTabbedPane1StateChanged(javax. } Se ingresar un nuevo dato Versión 2.event.ChangeEvent evt) { actualizaTabla().swing.El resultado es: Observar que si se ingresa un nuevo valor en la pestaña de “Ingreso” la pestaña “Ver” no se actualiza.

Nos cambiamos de pestaña y está el registro ingresado: Versión 2.2 218 de 285 .

hasta las que permiten editar directamente el contenido de cada celda. mientras más complejo sea el requerimiento a cubrir. por supuesto.magusoft.3 • • JTable http://www.1 Objetivos Mostrar datos usando JTable. ordenar las columnas. 23. otras.2 Conocimiento previo Conexión a base de datos.net/neotrials/pages/start. Todas las tareas antes descritas.htm http://www.java2s. sabemos muy bien que la presentación de datos tabulados es una de las tareas más comunes que se presentan al momento de crear interfaces gráficas. Los constructores son: Versión 2. y muchas otras. son posibles de realizar utilizando la clase JTable. Clase 23.2 219 de 285 .html Como programadores. se requerirá en igual medida utilizar más métodos o recursos de la clase. personalizar su apariencia. desde la simple tabla que permite únicamente mostrar el resultado de una consulta.com/Tutorial/Java/0240__Swing/publicJTableVectorrowDataVectorcolumnNames.23 23.

2 220 de 285 .Vamos a considerar en Netbeans la siguiente situación: Para eliminar las columnas y filas usamos la propiedad “model” Versión 2.

table. {"Marcus". Object[][] data = { {"Mary". "Nadar". "Campione".DefaultTableModel( data. "Escalar"."Soltero(a)" }. new Integer(3).2 221 de 285 .setViewportView(jTable1). {"Kathya". new Integer(2). new Boolean(false)} }.Eliminando todas las filas se tiene: El método para agregar en el constructor del formulario será: private void initValores(){ String[] columnNames = { "Nombre". "Apellido". new Integer(5). {"Angela". new Boolean(true)}. {"Lhucas".swing. new Boolean(false)}. new Integer(7). "Años de Practica". "Lalth". jTable1. columnNames)). "Pasatiempo". "Correr". "Walrath".setModel(new javax. "Patinar". new Boolean(true)}. new Integer(4). jScrollPane1. "Andrews". "Esquiar". } Versión 2. new Boolean(false)}. "Huml".

addElement("Esquiar"). data1. data1.DefaultTableModel( data.swing. columnNames)).En el caso de usar Vector no se puede asignar al Jtable un tipo Persona(String. } de dato como Vamos a generar en una tabla información dada la elección que se desarrolla en un ComboBox. data.addElement("false").Boolean) para el caso anterior. data.add("Apellido"). data2. columnNames.addElement(new String("Patinar")).String. columnNames.add("Soltero(a)"). columnNames. data1. Vector<String> data1 = new Vector<String>().addElement(new String("Lhucas")). Vector<String> data2 = new Vector<String>().addElement(new String("3")).String. jTable1. data2. Se pretende esto: Versión 2. data1.addElement("Campione").addElement("Mary"). data2. data2. data2.add("Años de Practica").setModel(new javax.add("Nombre"). Vector<Vector> data = new Vector<Vector>().addElement(new String("Huml")).add(data2).addElement("5").table. jScrollPane1.addElement(new String("true")).add(data1).Integer. data1. columnNames. Un solución será: private void initValores(){ Vector<String> columnNames = new Vector<String>().setViewportView(jTable1). columnNames.add("Pasatiempo").2 222 de 285 .

insert into paises (nombre_pais) values ('Bolivia'). insert into departamento (nombre_dpto) values('RR. insert into paises (nombre_pais) values ('Colombia').2).HH. insert into departamento (nombre_dpto) values('Comercial'). sexo boolean. nombre_dpto varchar(100). ingreso date. insert into departamento (nombre_dpto) values('Informatica'). estatura double(4. insert into departamento (nombre_dpto) values('Operaciones'). use usotablas. insert into paises (nombre_pais) values ('Paraguay').Y al seleccionar en el ComboBox otro departamento. nombre_pais varchar(100). edad int. foreign key (id_pais) references paises(id_pais) ). Versión 2. entonces cambian los datos correspondientes: Los datos de la base de datos son: create database usotablas. id_dpto int. primary key(id_pais) ). create table departamento ( id_dpto int auto_increment.'). insert into paises (nombre_pais) values ('Peru'). insert into paises (nombre_pais) values ('Argentina'). insert into paises (nombre_pais) values ('Chile'). create table trabajador ( id_trab int auto_increment. insert into departamento (nombre_dpto) values('Marketing'). foreign key (id_dpto) references departamento(id_dpto). primary key(id_trab). id_pais int. insert into paises (nombre_pais) values ('Uruguay'). primary key(id_dpto) ). create table paises ( id_pais int auto_increment.2 223 de 285 . insert into departamento (nombre_dpto) values('Producccion'). nombre_trab varchar(100).

edad .'2000-12-01'. sexo. id_pais) values (2.1.80.true.createStatement(). El método que llena el ComboBox con los datos de departamento.1.nombre_trab.45. ingreso.nombre_trab.36.2). sexo.false. sexo.'2000-09-01'. estatura.true. ingreso. id_pais) values (6. estatura. insert into trabajador (id_dpto. sexo.jComboBox1. i += 1.'2000-09-01'. try { Class. insert into trabajador (id_dpto.log(Level.next()){ if(i==1){ primerValor = rs.false. edad . estatura.nombre_trab. edad .nombre_trab.'2000-11-01'.false. edad . edad .62. id_pais) values (3.SEVERE.getLogger(Muestra.nombre_trab.insert into trabajador (id_dpto. sexo.1.nombre_trab.false.24.add(nombreRecupera).1.1. Versión 2. estatura.19.getString(1).30.5).'Carlita Perez'.67. ingreso. edad .1). sexo.nombre_trab.false.'2000-12-01'.'Esteban Perez'.55.nombre_trab. estatura.1.'2000-12-01'.'2000-11-01'.getUrl().1.false. id_pais) values (1. insert into trabajador (id_dpto. sexo. ConexionDB.nombre_trab.'2000-11-01'. sql = " Select id_dpto from departamento where nombre_dpto='"+primerValor+"'". } String nombreRecupera = rs.1. implementado en el método constructor es: private void initDepartamento(){ Vector<String> dat = new Vector<String>(). id_pais) values (3.'Oscar Perez'.80. sexo.'Leandro Perez'.getName()). insert into trabajador (id_dpto. insert into trabajador (id_dpto. while(rs.executeQuery(sql).92. insert into trabajador (id_dpto.'Juanita Perez'.33.getConnection(ConexionDB.1). edad . estatura. id_pais) values (5. edad . insert into trabajador (id_dpto. id_pais) values (2.1. id_pais) values (2. edad . estatura.27.60. ex). ingreso. estatura. estatura.'2000-11-01'. sexo. int i = 1. } try { Connection con = DriverManager.1.nombre_trab. id_pais) values (2. sexo.'2000-08-01'.90.'Juan Perez'.false. ingreso.nombre_trab.'Jonas Perez'. estatura.'Sandra Perez'.true.addItem(da). insert into trabajador (id_dpto. dat. ingreso. } for(Object da: dat) this.1).2 224 de 285 .1).77.67. ingreso.getDriver()). insert into trabajador (id_dpto.class.'Anibal Perez'. String primerValor = new String("").87. sexo. String sql = " Select nombre_dpto from departamento " + " order by 1 ".getPass()).true. edad . null.'2000-12-01'. ingreso. } catch (ClassNotFoundException ex) { Logger.74.47.1). ingreso.72.1. edad . ingreso.1).getUser(). ConexionDB. ResultSet rs = st.1).'Pedro Perez'.77. insert into trabajador (id_dpto.forName(ConexionDB. ingreso. id_pais) values (4.'Sofia Perez'.3). Statement st = con. estatura.4).getString(1). id_pais) values (6. Vector<Trabajador> datTrab = new Vector<Trabajador>().

getObject(3)).getObject(7)). row1. Vector columNames = new Vector(). columNames.getObject(2)). while(rs.2 225 de 285 .addElement(rs.getObject(4)).addElement("Pais").add(row1). columNames.executeQuery(sql).addElement(rs.addElement("Edad"). row1.id_dpto) as dpto.id_dpto="+idDpto+" order by 1.nombre_pais from paises as c where b. while(rs.setViewportView(jTable1).addElement(rs. row1.getObject(6)).id_pais=c. rs = st.addElement("Departamento").addElement("Ingreso"). columNames. int idDpto=0. " + " (select c. } catch (SQLException ex) { Logger. columNames)). jScrollPane1.SEVERE. Vector<Vector> data = new Vector<Vector>(). data.addElement("Nombre Trabajador").swing. 2 ". columNames. " + " nombre_trab. row1. columNames. } finally{ } } Versión 2. columNames.addElement("Estatura").rs = st.next()){ idDpto = rs.next()){ Vector row1 = new Vector(). " + " estatura.getObject(1)).executeQuery(sql). " + " sexo.addElement(rs.DefaultTableModel(data. columNames.class. row1. row1. ex).setModel(new javax. null.addElement(rs.getName()).table.nombre_dpto from departamento as a where b.id_pais) as pais " + " from trabajador as b where b.id_dpto=a. } jTable1.log(Level.addElement(rs.addElement("Sexo"). " + " ingreso.getObject(5)). } sql = " Select " + " (select a.getInt(1).getLogger(Muestra.addElement(rs. row1. " + " edad.

columNames. while(rs. " + " sexo.next()){ idDpto = rs. columNames. 2 ". int idDpto=0.nombre_dpto from departamento as a where b.addElement("Sexo").El código asociado a los cambios de los valores seleccionados en el ComboBox son: private void jComboBox1ItemStateChanged(java.addElement("Nombre Trabajador"). Vector columNames = new Vector(). " + " nombre_trab. ResultSet rs = st.SEVERE.id_pais) as pais " + " from trabajador as b where b. columNames.getDriver()). Statement st = con.id_pais=c. try { Class. " + " (select c.id_dpto="+idDpto+" order by 1.addElement("Edad").event.addElement("Pais").nombre_pais from paises as c where b. columNames. String sql = " Select id_dpto from departamento where nombre_dpto='"+dpto+"'".addElement("Estatura"). null.createStatement(). ConexionDB. columNames.addElement("Departamento").2 226 de 285 .class. } catch (ClassNotFoundException ex) { Logger. ConexionDB. columNames.addElement("Ingreso").log(Level.id_dpto) as dpto. columNames.getConnection(ConexionDB.getUser(). " + " estatura.executeQuery(sql). ex).ItemEvent evt) { String dpto = String.getPass()).getSelectedItem()). } try { Connection con = DriverManager.forName(ConexionDB.valueOf(this.getName()).jComboBox1. } sql = " Select " + " (select a.getLogger(Muestra. Versión 2. " + " ingreso.id_dpto=a.getInt(1).awt.getUrl(). " + " edad.

row1.getObject(6)).rs = st. while(rs. null. columNames)). } finally{ } } Versión 2. row1. row1.addElement(rs.addElement(rs.getLogger(Muestra.table.addElement(rs. row1.getObject(5)). } jTable1.addElement(rs.DefaultTableModel(data. row1.getObject(1)). ex). row1. row1.setViewportView(jTable1).executeQuery(sql).getName()).addElement(rs.getObject(4)).getObject(3)). } catch (SQLException ex) { Logger.setModel(new javax.addElement(rs.add(row1).2 227 de 285 .next()){ Vector row1 = new Vector().log(Level.SEVERE.getObject(2)). jScrollPane1.class.getObject(7)). data.addElement(rs. Vector<Vector> data = new Vector<Vector>().swing.

24 24.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 Diseñar un formulario que sea capaz de solicitar información de un cliente: • Codigo: TextField.3 Evaluación 6 Observaciones: • Fecha de revisión: Jueves 23 junio de 2011 • Nota 4. valores con dos decimal entre 1. • Nombre: TextField. No se debe validar nada. Además. (10 puntos) Versión 2. postgrado. Clase 24. • Nivel educacional: Un JSlider con valores básica. Desarrollar el trabajo 3. si en esta pestaña se selecciona otro código del ComboBox.5 y 2. Valor 15% de la nota 4. Valor 12.2 Conocimiento previo Contenidos del semestre.2 228 de 285 . 24. universitaria. media.1 Objetivos Desarrollar el trabajo 2. entonces se debe actualizar el nombre del cliente. Proceso 1 En una pestaña crear una opción que permita ingresar datos. (20 puntos) Proceso 2 En una pestaña se debe mostrar en un ComboBox los códigos de los clientes almacenados y al ingresar por primera vez al lado del ComboBox se debe mostrar el nombre del cliente.0. • Edad: ComboBox • Sexo: RadioButton • Preferencia1: CheckBox • Preferencia2: CheckBox • Preferencia3: CheckBox • Preferencia4: CheckBox • Estatura: JList.5% de la nota 3. (10 puntos) En esta pestaña se debe implementar un botón para eliminar el cliente almacenado.

(30 puntos) En esta pestaña se debe implementar un botón para actualizar los datos del cliente almacenado.'Gerencia General').'Nota breve'). (10 puntos) Proceso 4 Se deben mostrar los datos del clientes usando un JTable. insert into departamento values('AD'. 2. create database unab.'Oficio'). insert into documento values('OF'. create table documento ( tipo varchar(2) nombre varchar(100) ).Proceso 3 En una pestaña se debe mostrar en un ComboBox los códigos 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 gráficos de la pestaña de ingreso de clientes. insert into departamento values('CO'. insert into documento values('NO'.'Informatica'). use unab. insert into departamento values('PL'. La fecha de revisión es el martes 28 de junio de 2011 en clases. insert into documento values('MA'. insert into departamento values('FS'.2 229 de 285 .'Comercial').'Mail').'Operaciones').9 y mysql 5. Además.'Marketing').'Planificacion'). create table departamento ( codigo varchar(2) primary key. insert into documento values('RE'. nombre varchar(100) ). 3. (10 puntos) Proceso 5 Cada vez que se produce un ingreso de cliente y se produce un cambio de pestaña.'Fiscalia'). insert into departamento values('MA'. entonces se debe actualizar los datos del cliente.4 Evaluación 7 Observaciones 1. El desarrollo debe ser en netbeans 6. insert into documento values('ME'.'Resolucion').'Fax').'Finanzas'). entonces los datos deben reflejar esos cambios.'Memo').'Auditoria'). insert into departamento values('IF'. insert into departamento values('OP'. insert into departamento values('FI'. Versión 2. Nota 4 = 80% del puntaje. (10 puntos) 24. insert into departamento values('GE'. si en esta pestaña se selecciona otro código del ComboBox. insert into documento values('FA'.x.

cod_tipo varchar(2). constraint foreign key (cod_dep) references departamento(codigo). Problema Se le ha solicitado desarrollar un programa java que sea capaz de manejar documentos que son enviados a diversos departamento. constraint foreign key (cod_tipo) references documento(tipo) ). Para esto se debe diseñar un formulario que: • Solicite al usuario. (30 puntos) • • • • Versión 2. Para estos se debe pedir el número del documento y mediante un botón se muestran los datos en un JTable. el tipo de documento almacenados es la base de datos. mediante un JSlider.create table documentos_tratados ( numero int. constraint primary key(numero. (10 puntos) El botón “Almacenar Información” almacena los datos en la tabla “documentos_tratados”. cod_dep.2 230 de 285 . (10 puntos) El botón << envía los destinos seleccionados desde JList de la derecha a la izquierda. (10 puntos) • Mediante un JList mostrar los destinos de los documentos almacenados en la base de datos. (10 puntos) El botón >> envía los destinos seleccionados desde JList de la izquierda a la derecha. cod_tipo). cod_dep varchar(2). (30 puntos) El botón “Ver Información” muestra los datos en la tabla “documentos_tratados”.

25.25 25.1 Objetivos Clase Uso de colecciones y en particular las clase ArrayList y Vector.2 Conocimiento previo Conceptos de orientación a objetos y encapsulación de datos.3 Seleccionar: JMenu Va a generar: Versión 2.2 231 de 285 . 25.

Para incorporar un submenú procedemos como se muestra Para cambiar los nombres de lo que se ve. hacer doble clic sobre “File” También se puede usar el menú contextual: Versión 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: Versión 2.2 233 de 285 .

Finalmente se tiene: Crear un formulario llamado VerCliente Para la opción ver se va a considerar: El código para ejecutar el formulario desde el menú es: Versión 2.2 234 de 285 .

2 235 de 285 .Vamos a agregar un nueva opción de menú: Vamos a agregar dos radiobuttom Vamos a agregar un separador Vamos a agregar tres checkbox Versión 2.

Se debe agrupar los radio buttom Marcar ambos radiobuttom y agregar al agrupamiento Se tiene: Versión 2.2 236 de 285 .

25.2 237 de 285 .4 Seleccionar: JTree Se tiene: Versión 2.

Al ejecutarlo se tiene: Los componentes del árbol se manejan el la propiedad "model" Versión 2.2 238 de 285 .

2 239 de 285 . Se obtiene: Versión 2.Generar la siguiente estructura. Considera que un espacio genera un opción dentro de otra.

2 240 de 285 .Como ejemplo de aplicación vamos generar el siguiente formulario Se tiene: Versión 2.

2 241 de 285 .Lanzar un JTree en el lateral izquierdo: Generar la siguiente estructura: Versión 2.

Para manejar la posición inicial de la línea de división Para manejar el ancho de la línea de división La orientación se maneja en: Versión 2.2 242 de 285 .

2 243 de 285 . Vamos a Crear los siguientes paneles: Versión 2.Vamos a desarrollar un mantenedor con el uso de JTree. Para los formularios se deben usar JPanel.

El formulario es: Tiene las opciones: Versión 2.2 244 de 285 .

2 245 de 285 .El código asociado al primer Jpanel es una variable tipo Vector static para que los datos ingresados desde este formulario sean accesibles desde otros formularios El código asociado al botón de ingreso de datos es: Versión 2.

desde el contenedor del JSplitPane se tiene el código asociado al evento “ValueChanged”: Versión 2. El código asociado a este botón es: Ahora.Al formulario para ver datos se le agregó un botón para visualizar datos.2 246 de 285 .

int edad){ this. } public void setEdad(int edad) { this.setRut(rut). } public String getRut() { return rut.edad = edad. } public void setRut(String rut) { this.setEdad(edad). this. } } En la ejecución se tiene: Versión 2.2 247 de 285 . public class Cliente { private String rut="". private int edad=0. } public int getEdad() { return edad.La clase cliente es: package bean. public Cliente(){ } public Cliente(String rut.rut = rut.

Versión 2.2 248 de 285 .

5 JScrollPane Cuando un componente ocupa mucho espacio en pantalla o contiene mucha información.25. un JScrollPane permite asociarle una pequeña vista o ventana deslizable o corrediza que permite solo que se vea una parte de dicho componente. Genera algo similar a lo siguiente: Versión 2.2 249 de 285 . Lanzar un componente JScrollPane: Luego dentro de el. lanzar un JPanel.

2 250 de 285 .Al agregar algunos componentes se puede tener lo siguiente: Versión 2.

MINUTE)).getInstance().get(Calendar.out. System. import java.Calendar. package view. import java.get(Calendar.2 251 de 285 .util.getInstance(). 26.println("Año: " + dat. Adicionales 26. System. package view.SECOND)).get(Calendar.3 Date Representa un momento específico en el tiempo. System.out.DAY_OF_WEEK)).Date.out. System. con precisión de milisegundos. Observar que enero=0 y que el día de la semana (que es lunes) es 2. System.println("Mes: " + dat.println("Dia: " + dat.26 26.YEAR)).println("Minutos: " + dat.out. y así sucesivamente.out. DAY .println(). Calendar dat = Calendar.out.out.get(Calendar.out.println(dt). public class Metodos3 { public static void main(String[] args) { Date dt = new Date(). System.println("Horas: " + dat.util.get(Calendar. El siguiente código entrega la fecha y hora actual.println().get(Calendar.out.DATE)). } } Versión 2. System.MONTH)). } } 26. HOUR . System. System. La mayoría de sus métodos están desaprobados.println("Dia de la semana: " + dat. Para crear una instancia se debe usar el siguiente código.get(Calendar.out. MONTH .4 Calendar Calendar es una clase abstracta para la conversión entre un objeto Date y un conjunto de campos enteros como YEAR .1 Objetivos Usar métodos para el manejo de fechas y horas. System. public class Metodos4 { public static void main(String[] args) { Calendar dat = Calendar. Calendar interpretar una Date de acuerdo a las reglas de un sistema de calendario específico.HOUR)).2 Conocimiento previo Creación de métodos.println("Segundos: " + dat. El siguiente código se recupera la hora actual y cada uno de sus valores específicos. esto se debe al hecho de que la clase Calendar es abstracta (ver clases más adelante).

out.YEAR.get(Calendar. import java.MONTH)). System.Calendar.get(Calendar.out. PM=1: " + dat.println("Minutos: " + dat. System. dat. System.out.Date.out.get(Calendar.Calendar. System. 02.get(Calendar.out.MINUTE)).MINUTE)). dat.YEAR.println("Hora: " + dat. System. PM=1: " + dat.get(Calendar.DATE)). System.out. import java. 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. -4).getInstance().out. 2). System. 55).out.getTime()).println("Año: " + dat. } } Para asociar un valor de tipo Date a uno de tipo Calendar: package view.println("Año: " + dat.out.out. System. public class Metodos6 { public static void main(String[] args) { Date dt = new Date().SECOND)).get(Calendar.get(Calendar.set(2011.println().println("Actual: " + dat. System. 15 .out.YEAR)).getInstance().println().Date.DATE)).println("Hora: " + dat.println("Dos años más: " + dat.Calendar.YEAR)). import java.setTime(dt). Calendar dat = Calendar.getTime()).util. public class Metodos7 { public static void main(String[] args) { Date dt = new Date().En el siguiente ejemplo sea definido una fecha con hora en duro. } } La clase siguiente muestra como se pueden sumar y restar valores.get(Calendar.println("AM=0. Calendar dat = Calendar.out. System.get(Calendar.println("Dia: " + dat. import java. 12.println("AM=0.util.MONTH)).println("Segundos: " + dat.get(Calendar.HOUR)). dat.getInstance().setTime(dt). dat.println("Minutos: " + dat. 30.AM_PM)).add(Calendar.HOUR)).util.AM_PM)). Versión 2.2 252 de 285 . System.SECOND)).out.out. package view.get(Calendar.out. dat.println("Dia: " + dat.println("Mes: " + dat. import java.out. System.get(Calendar.util. System.get(Calendar.println("Mes: " + dat. System.get(Calendar. System. System. System.add(Calendar.out. System.util. public class Metodos5 { public static void main(String[] args) { Calendar dat = Calendar.println("Segundos: " + dat.out.

getTimeInMillis(). } } La clase siguiente muestra como java maneja la resta de fecha.DATE).getInstance(). dat. 15 .HOUR.getInstance(). -2).out.MONTH) . package view.out.dat1.util.out.getTime()). System. 15 .get(Calendar. dat2. 2).YEAR) . 15 .add(Calendar. dat.out.2 253 de 285 . dat1.println("Cuatro años menos: " + dat. } if(dif1<0){ System.out. 55).println("Resta años: " + aa). dat2. 55).println("Dos horas más: " + dat. 2).dat12. public class Metodos9 { public static void main(String[] args) { Calendar dat1 = Calendar.YEAR). long dat13 = dat3. 22.get(Calendar.println("Resta meses: " + mm).out. System.out. Considerar que el método expuesto sólo diferencia los valores indicados sin considerar los años. long dif1 = dat11 . 55).add(Calendar. 20.dat1.println("Dos horas menos: " + dat.out.getInstance(). menor o igual que otra. Calendar dat2 = Calendar.getInstance(). 15 . 2).println("dat1 = dat2"). } } La clase siguiente muestra cómo deducir cuando una fecha es mayor.getInstance().set(2005.util.println("Dos horas más: " + dat.getTimeInMillis(). Calendar dat2 = Calendar.getTime()). System.set(2011.out. } if(dif1==0){ System.dat1.Calendar. Calendar dat3 = Calendar.add(Calendar. int aa = dat2. 02.getTime()).add(Calendar. public class Metodos8 { public static void main(String[] args) { Calendar dat1 = Calendar. 30.set(2011. dat3.MONTH.get(Calendar.System. 10.MONTH). import java. 22. 02. 30. 02. dat.out.set(2011.Calendar. import java.DATE. dat.println("Dos meses más: " + dat. 55). 10.getTime()). System.println("dat1 > dat2"). 22.getTimeInMillis(). 20. 30. long dat12 = dat2. } Versión 2. 30. System.get(Calendar. System. package view.out. int dd = dat2.DATE. int mm = dat2.getTime()). dat1. if(dif1>0){ System.DATE) .get(Calendar. 30.get(Calendar.println("dat1 <= dat2"). 15 .set(2005.println("Resta meses: " + dd). System. long dat11 = dat1. 55).

out.out. que admite operaciones de calendario aplicables a la mayor parte del mundo. } if(dif2==0){ System. Los siguientes ejemplos muestran cómo los patrones de fecha y hora se interpretan en la configuración regional de EE.long dif2 = dat12 .UU. if(dif2>0){ System.5 SimpleDateFormat Permite mostrar las fechas en el formato que queramos o a reconstruirlas a partir de una cadena de texto.6 GregorianCalendar Maneja fecha y horas internacionales.. } if(dif2<0){ System.println("dat2 <= dat3").dat13.println("dat2 = dat3").out. Admite las eras AC y DC.2 254 de 285 . } } } 26. 26. La fecha determinada y el tiempo son 07/04/2001 12:08:56 hora local en la zona del Pacífico de EE. Versión 2.println("dat2 > dat3").UU.

(c) Calcular y mostrar el promedio de hora de llegada de cada uno de los 8 trabajadores en la semana de datos. Para esto usted debe suponer los valores de tipo double en donde.Ejercicio 1 En una empresa dedicada a la producción de software se necesita controlar las horas de llegadas de los trabajadores de lunes a viernes. las 08:15 son las 8. las 08:30 son las 8. por ejemplo.25.2 255 de 285 . El total de trabajadores son 8. Versión 2. (a) Crear una matriz con datos que sea capaz de almacenar las horas de llegadas una semana de los 8 trabajadores.50. (b) Calcular y mostrar el promedio de hora de llegada de la semana de datos de los 8 trabajadores.

Una operación que requiere una configuración regional para llevar a cabo su tarea se llama sensible a la localidad y utiliza la configuración regional de adaptar la información para el usuario. 27.php Versión 2.3 Objetivos Conocimiento previo Format Formatear datos considerando la región. Puede analizar si la información es sensible a la localidad. Es una clase abstracta para dar formato a fechas. Los códigos de idioma se definen en la norma ISO 639. mensajes y números.2 27. Adicionales 1 Uso de métodos en Java. y NumberFormat formatean. Las subclases DateFormat. mostrando un número es una operación sensible a la localidad .el número debe tener un formato acorde a las costumbres y convenios de país de origen del usuario.2 256 de 285 . política o cultural.loc. un estándar internacional que asigna los códigos de dos y de tres letras para la mayoría de lenguas del mundo. Por ejemplo. región o cultura. La configuración regional de java utiliza los códigos de dos letras para identificar el idioma de destino.4 Locate Un objeto de la clase Locale representa una región geográfica específica.gov/standards/iso6392/php/code_list. Ver: http://www. respectivamente fechas. mensajes y números. MessageFormat.27 27.1 27.

Por ejemplo. // Crear un entorno específico de habla Inglés. Los códigos ISO 3166 CA y US representan a Canadá y los Estados Unidos.fu-berlin.FRANCE es un objeto estático prefabricados de configuración regional que representa de habla francesa Francia.UU. Estos códigos son las mayúsculas. respectivamente: La última línea de código anterior muestra cómo crear una configuración local con una variante opcional: SiliconValley. la variante puede ser cualquier cosa que usted necesita.El argumento país son Código ISO. pero también se asocia con una variante adicional. Versión 2. Debido a que uno de sus propósitos es proporcionar a los desarrolladores la capacidad de definir escenarios personalizados.FRANCE en cualquier lugar puede utilizar new Locale ("fr". Por ejemplo. .2 257 de 285 . La guía de admitidos en la plataforma J2SE 5. que hablan Inglés. Ver: http://www. // Crear un entorno de habla Inglesa para la región de Canadá Locale locale2 = new Locale("en". String variant) Por ejemplo: // Crear un entorno local genérico de habla Inglesa (Canadá. Utilizando el código ISO 639 de dos letras.0 proporciona una lista completa de todos los idiomas reconocidos.. "SiliconValley").de/diverse/doc/ISO_3166.UU. SiliconValley. EEUU. "US". para obtener la compatibilidad de la clase NumberFormat: Locale[] localeList = NumberFormat. para SiliconValley Locale locale3 = new Locale("en". String country. Locale. No sólo es la configuración regional de un EE.) Locale locale1 = new Locale("en"). "FR"). Usted puede utilizar Locale. String country) Locale(String language. Esto es más específica que la primera instancia.getAvailableLocales(). para la configuración regional de EE. "CA").. la representa en inglés.chemie. los códigos de dos letras definido por la norma ISO-3166.html Los constructores son: Locale(String language) Locale(String language. La clase Locale tiene muchos campos estáticos que representan instancias de objetos Locale.

Versión 2. public class Formato12 { public static void main(String[] args) { System.println(Locale.getDefault()).2 258 de 285 .Locale. } } Observar que depende de la configuración del equipo. import java.out.Para conocer la configuración se tiene: package view.util.

").println(mensaje1).text. les da formato.4. package view. "many files"} En este ejemplo los valores entre 1 y 7 mostrarán lo días e la semana.format(testArgs)). Utilice esta opción para construir mensajes que aparecen para los usuarios finales.out. System.5. String diskName = "MyDisk". 1. {2} y así sucesivamente. package view.5 MessageFormat Proporciona un medio para producir mensajes concatenados en forma independiente del idioma. ChoiceFormat. System."Thur".println(mensaje2). Observar que para que muestre la comilla doble (“) le anteponemos \. public class Formato2 { public static void main(String[] args) { int fileCount = 1273."Fri".3. } } 27. a continuación."Tue"."Sat"} • limits = {0. //Sin MessageFormat String mensaje1 = "se han encontrado " + numeroErrores + " errores". Podemos poner más variables poniendo {1}.text.6. public class Formato1 { public static void main(String[] args) { int numeroErrores = 20. inserta las cadenas de formato en el patrón en los lugares adecuados.2 259 de 285 .println(form.MessageFormat. Observar lo que sucede para valores más pequeños o más grandes. MessageFormat toma un conjunto de objetos. import java. MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0} file(s).format("se han encontrado {0} errores". //Con MessageFormat String mensaje2 = MessageFormat. Versión 2.out."Mon". "one file". MessageFormat reemplaza {0} por el valor de la variable que le pasamos. Object[] testArgs = {new Long(fileCount). En este caso.MessageFormat. Al crear un ChoiceFormat. La longitud de estas matrices deben ser los mismos. Se utiliza generalmente en un MessageFormat para el manejo de los plurales.nextDouble(1)} formats = {"no files".27."Wed".6 ChoiceFormat Un ChoiceFormat le permite adjuntar un formato a un rango de números. numeroErrores). import java.7} formats = {"Sun".2. } } También se pueden almacenar los valores a mostrar en un arreglo. debe especificar una serie de formatos y una variedad de límites. diskName}. System. Por ejemplo: • limits = {1.out.

package view. ChoiceFormat fileform = new ChoiceFormat(filelimits. new Integer(12345). monthNames).number} files"}. } } Este ejemplo muestra el uso de diversos formatos.text.out. 5. "one file". import java.ChoiceFormat. new Integer(1234). "Sabado"}. fileCount = 1. Object[] testArgs1 = {new Long(fileCount).format(testArgs1)). diskName}. System. System. String diskName = "MyDisk". Object[] testArgs3 = {new Long(fileCount).2 260 de 285 . fileCount = 2. diskName}.format(testArgs)). ChoiceFormat form = new ChoiceFormat(limits.number} indica un número en la posición {0}.text.println(form. filepart). Object[] testArgs = {new Long(fileCount). "Martes".setFormatByArgumentIndex(0.format(testArgs2)).MessageFormat. for (int i = 0.format(i)).println(form. //Indica el índice de inicio del formato=0 y el formato a aplicar=fileForm form.println(form. 6. "Miercoles".MessageFormat.format(testArgs3)). "{0. } } } Si necesitamos especificar con mayor detalle la separación entre cifras singulares o plurales podemos usar el siguiente código. System.text.out. fileform). int fileCount = 0.out.out. diskName}.println(form. 7}. fileCount = -3. 2. i <= 11. import java. 4. ++i) { System. public class Formato4 { public static void main(String[] args) { Object[] params = new Object[]{new Integer(123). "Viernes". ChoiceFormat.out.ChoiceFormat. new Integer(123456)}. 3.text. "Jueves".nextDouble(1)}.println(i + " -> " + form. Versión 2. String[] filepart = {"no files". String[] monthNames = {"Domingo". "Lunes". diskName}. import java."). Object[] testArgs2 = {new Long(fileCount). package view. 1. double[] filelimits = {0. import java. public class Formato3 { public static void main(String[] args) { MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}. public class Formato7 { public static void main(String[] args) { double[] limits = {1. Observar que {0. package view. System.

number.number} b''s". msg = MessageFormat. params).out. //Números enteros msg = MessageFormat.number.#} b''s".println(msg).format("There are {0. params). //Números decimales params = new Object[]{new Double(123.percent} a''s and {1. System.2 261 de 285 .#} b''s". params).String msg = MessageFormat.#} a''s and {1.number.number} a''s and {1. System. params).percent} b''s".currency} a''s and {1.#.println(msg).#} a''s and {1.out.number. System.currency} b''s". System. //Moneda msg = MessageFormat.out.out.number. params).number.format("There are {3.45).#.println(msg). new Double(1234. System.number.println(msg).number.format("There are {0.56)}. params). msg = MessageFormat. //Porcentaje msg = MessageFormat.format("There are {3} a''s and {1} b''s".println(msg). System. } } Versión 2.format("There are {0.out.println(msg).format("There are {0.out.

time} del {1.date}. fechas y horas. import java. } } Versión 2. String result = MessageFormat.Ahora considerar la siguiente configuración regional.currentTimeMillis()).2 262 de 285 . package view.out.util. Ahora para la siguiente configuración regional. "se escribe este apunte con la siguiente cantidad de calificaciones:" }.Date. new Date(System.".format("A las {1. import java.text.number. System.MessageFormat.integer}. {2} {0. public class Formato8 { public static void main(String[] args) { Object[] arguments = { new Integer(7). Observar en este ejemplo el uso de los formatos de números enteros. arguments).println(result).

2 263 de 285 .23E4). import java. import java. //El símbolo 0 muestra un cero cuando no exista un dígito //Notar que el número se ha redondeado NumberFormat formatter = new DecimalFormat("000000"). Su código puede ser totalmente independiente de las convenciones de localización de puntos decimales. o si el formato de número es aún decimal.8 DecimalFormat DecimalFormat es una subclase concreta de NumberFormat que da formato a los números decimales. separadores de miles.27.CANADA). para decimales Locale. //El simbolo # muestra un digito nada sino existe un digito formatter = new DecimalFormat("##"). String s = formatter. el árabe. // -1235 System.util. // -001235 System.println("000000 : " + s). 27. o incluso los dígitos decimales en particular usado.out. Esta clase proporciona la interfaz para el formato y el análisis de los números.out. números de punto fijo (123. NumberFormat le ayuda a analizar los números y el formato para cualquier configuración regional. s = formatter. De esta manera.DecimalFormat.Locale. Tiene una variedad de características diseñadas para permitir a los números de analizar y dar formato en cualquier lugar. package view.setDefault(Locale.println("## : " + s). y las cantidades de moneda ($123). Todos ellos pueden ser localizados en una región determinada. incluido el apoyo a Occidente. También es compatible con diferentes tipos de números. Versión 2. incluyendo números enteros (123).text.7 NumberFormat NumberFormat es la clase base abstracta para todos los formatos de número.format(-1234. porcentajes (12%).567). y los dígitos índicos. public class Formato5 { public static void main(String[] args) { //Región: se usa la .text. para separador de miles y el . HALF_UP).format(-1234. DecimalFormat utiliza ROUND_HALF_EVEN para el formato de los redondeo.NumberFormat. import java. antes de mostrar los números debemos usar una función que nos permita redondear estos en el formato adecuado de decimales usado en nuestra región (por ejemplo.4). la notación científica (1.567).

890). muestra el punto decimal formatter = new DecimalFormat(".format(-1234.234. formatter = new DecimalFormat("#.000000 : " + s).###").###### : " + s).567000 System.out. s = formatter.2 264 de 285 . // -1234.format(-1234. se usa para agrupar numeros formatter = new DecimalFormat("#.formatter = new DecimalFormat("##00").00").format(0).format(-. formatter = new DecimalFormat(".out. s = formatter.567).567).#").235 System.println("#. s = formatter.out.567).6 System.println("#.###.format(-1234. // -1.out.567). //El simbolo .### : " + s).println("#.567). // -1234. } } Versión 2.println(".format(-.format(-1234.57 System.println("#.println("##00 : " + s).57 System. // -1.567 System.println("0. // -0.###.# : " + s). s = formatter. s = formatter. // -1234. // 00 System. s = formatter.### : " + s).###.format(-1234.out.567 System.000000").format(-1231231234567.out.######"). // -.231.out. // -1234. formatter = new DecimalFormat("#.567). s = formatter.out. formatter = new DecimalFormat("#. s = formatter.00 : " + s). //El simbolo . formatter = new DecimalFormat("0.231.00 : " + s).567).###### : " + s).568 System.out. s = formatter.println(".######").println("#.00").

DecimalFormat.text. i < locales. import java.text.ParseException.text. j < 4. for (int i = 0.Locale.2 265 de 285 . ++i) { if (locales[i]. import java. import java.NumberFormat. double myNumber = -1234.length() == 0) { continue.getCountry().length. // Skip language-only locales } Versión 2. public class Formato6 { public static void main(String[] args) { Locale[] locales = NumberFormat. for (int j = 0.ITALIAN). package view.println("FORMAT").56.out. ++j) { System.Para: Locale.util.setDefault(Locale. import java. NumberFormat form.getAvailableLocales().

56 -> -1234.print(": " + ((DecimalFormat) form).2 266 de 285 .### -> -1.##0.getCurrencyInstance(locales[i]).##0.out.56 árabe (Emiratos Árabes Unidos): #.###.56 árabe (Yemen): #.###.56.234. break.56 árabe (Qatar): #.#.#.(#.### -> -1.234.56 -> -1234.print(" -> " + form.#.##0.###.out.56 -> -1234.-> 1.### -> -1 234.-> -1234.##0.### -> -1.-> -1234.##0.-> -1234. case 1: form = NumberFormat.parse(form.56.##0.56 -> -1234.234.##0. break.56 -> -1234.out.234.##0.234.##0.56 inglés (Malta): #. default: form = NumberFormat.out.###.56 -> -1234.56 macedonio (Macedonia): #.### -> -1'234. break.format(myNumber))).56 español (Guatemala): #.### -> -1.##0.##0.##0.234.56 inglés (Estados Unidos): #.### -> -1.### -> -1.56 serbio (Bosnia y Hercegovina): #.56 -> -1234.##0.###.56 Versión 2.###.56.getDisplayName()).234.##0.234.### -> -1.##0.234. } System.-> 1.### -> -1 234. case 2: form = NumberFormat.##0. break.56 albanés (Albania): #.56 -> -1234.56.234.print(locales[i].56 español (Perú): #. } catch (ParseException e) { } } } } } Algunos resultados son: run: FORMAT japonés (Japón): #.##0. try { System.##0.56 finés (Finlandia): #.###.56 alemán (Suiza): #.56 portugués (Portugal): #.56 -> -1234.234.56) -> -1234.### -> -1.println(" -> " + form.#.getInstance(locales[i]).56 -> -1234.##0. } if (form instanceof DecimalFormat) { System.##0.toPattern()).56 árabe (Iraq): #.-> 1.##0.56 español (Panamá): #.-> 1. switch (j) { case 0: form = NumberFormat.234.getPercentInstance(locales[i]).234.234.##0.### -> -1.56 noruego (Noruega): #.234.###) -> (1.56 -> -1234.56 japonés (Japón.56 -> -1234.56 -> -1234.56 griego (Chipre): #.56 -> -1234.format(myNumber)).### -> -1.System.##0.getIntegerInstance(locales[i]).JP): #.-> -1234.##0.###.234.### -> -1.###.

###.234.56 noruego (Noruega.##0.56 estonio (Estonia): #.56 -> -1234.56 -> -1234.234.###.-> -1234.##0.56 francés (Suiza): #.56 árabe (Túnez): #.###.56 francés (Canadá): #.### -> -1.56 -> -1234.234.-> -1234.##0.234.56 español (Uruguay): #.Nynorsk): #.56 inglés (Nueva Zelanda): #.56.#.##0.##0.##0.##0.234.56 -> -1234.56 árabe (Jordania): #.###.### -> -1 234.#.56 árabe (Kuwait): #.### -> -1.234.##0.56 -> -1234.### -> -1.-> 1.### -> -1.56 español (República Dominicana): #.56 eslovaco (Eslovaquia): #.##0.56 Versión 2.-> -1234.#.56 -> -1234.56 -> -1234.234.-> 1.56 español (España): #.56 irlandés (Irlanda): #.56 -> -1234.234.##0.234.### -> -1 234.-> 1.##0.56 -> -1234.### -> -1'234.56 indonesio (Indonesia): #.eslovenio (Eslovenia): #.-> -1234.56 -> -1234.##0.234.##0.##0.##0.56 árabe (Sudán): #.56 chino (Taiwán): #.###.56 -> -1234.५६ -> -1234.##0.##0.#.#.234.##0.56.56 -> -1234.### -> -1 234.### -> -1.56 -> -1234.### -> -1.56 islandés (Islandia): #.#.##0.234.### -> -1.-> 1.-> 1.2 267 de 285 .234.56.### -> -1.56 -> -1234.56 inglés (Reino Unido): #.### -> -1.###.56 hindú (India): #.##0.56.##0.##0.56 francés (Bélgica): #.##0.56 -> -1234.#.##0.### -> -1 234.-> 1.###.##0.##0.56 lituano (Lituania): #.### -> -1.### -> -१.### -> -1.56 árabe (Bahráin): #.56 español (Ecuador): #.56 -> -1234.56.###.##0.### -> -1.56.234.234.56 árabe (Líbano): #.234.56 serbio (Serbia y Montenegro): #.#.### -> -1 234.२३४.234.##0.##0.-> -1234.56 -> -1234.##0.-> -1234.56 neerlandés (Holanda): #.###.234.234.##0.### -> -1.56.56 -> -1234.234.56 -> -1234.##0.##0.56 -> -1234.##0.56 -> -1234.##0.234.##0.56 -> -1234.-> -1234.##0.56 español (México): #.56 letón (Letonia): #.##0.###.56 -> -1234.### -> -1.##0.56 -> -1234.56 alemán (Austria): #.-> -1234.234.-> 1.56 -> -1234.56 árabe (Siria): #.234.### -> -1.56 español (Venezuela): #.234.## -> -1 234.234.56 -> -1234.56 serbio (Serbia): #.### -> -1.234.##0.56 turco (Turquía): #.###.56 -> -1234.###.234.###.##0.56.56 -> -1234.##0.##0.56 español (Colombia): #.56 español (Nicaragua): #.56 árabe (Arabia Saudita): #.###.234.234.###.### -> -1.### -> -1.56 -> -1234.56 inglés (Filipinas): #.56 -> -1234.56 español (Estados Unidos): #.##0.##0.56 portugués (Brasil): #.-> 1.56 -> -1234.234.### -> -1.### -> -1.### -> -1.##0.### -> -1.##0.### -> -1.234.###.##0.### -> -1.234.

##0. Los estilos de formato incluyen: FULL.56 español (Chile): #.234. // 24/02/2011 s = DateFormat.println("Error").out. package view.FULL).56 -> -1234.text. // 24/02/11 s = DateFormat. } } } Versión 2.println("FULL: " + s). import java. MEDIUM y SHORT • SHORT: 12.out. 1952 or 3:30:32pm • FULL: Tuesday. • Utilice getDateTimeInstance para obtener un formato de fecha y hora.println("Valores por defecto: " + s)..format(date).ParseException.getDateInstance().out.format(date). • Utilice getTimeInstance para obtener el formato de hora de ese país. 1952 • LONG: January 12.Date.LONG). System. // Valores por defecto: MEDIUM s = DateFormat.parse("25-02-2011"). //jueves 24 de febrero de 2011 // Valores por defecto: MEDIUM s = DateFormat.getDateInstance(DateFormat.DEFAULT).9 DateFormat DateFormat es una clase abstracta para el de formato de fecha de manera independiente del lenguaje. // Parse try { date = DateFormat...out.println("Valores por defecto: " + s).### -> -1.### -> -1.out. } catch (ParseException e) { System.getDateInstance(DateFormat.getDateInstance(DateFormat.getDateInstance(DateFormat.util.DateFormat.56 -> -1234.format(date).getDateInstance(DateFormat.println("LONG: " + s). System.println("parse: " + date).. public class Formato9 { public static void main(String[] args) { Date date = new Date(). System. LONG.52 or 3:30pm • MEDIUM: Jan 12.56 ….out. 27.español (Costa Rica): #. Veamos un ejemplo de uso. 1952 AD or 3:30:42pm PST. // 24 de febrero de 2011 s = DateFormat.MEDIUM). System. import java.##0.format(date).println("SHORT: " + s).out.text.13.format(date). • Utilice getDateInstance para obtener el formato de la fecha normal para ese país. System.234.. April 12.DEFAULT).println("MEDIUM: " + s). String s = DateFormat.format(date). System.SHORT).getDateInstance(DateFormat. System. import java.out.2 268 de 285 ..

10 SimpleDateFormat SimpleDateFormat es una clase concreta para dar formato y analizar las fechas de una manera sensible a la localidad o región.Observar que el siguiente cambio produce un error.SimpleDateFormat. es Locale.getDateInstance(DateFormat.util. Versión 2. System.out. } 27. System. } } Observación: • • MM=mes mm=minutos. nombres de los meses) no será la misma. package view. el texto (por ejemplo. try { date = DateFormat.parse("25/02/2011").out. Este ejemplo muestra algunos. import java. Si el ejemplo se ejecuta en una localidad diferente. public class Formato13 { public static void main(String[] args) { SimpleDateFormat formateador = new SimpleDateFormat("MM/dd/yyyy").out. Un patrón de caracteres especiales se utiliza para especificar el formato de la fecha.println("parse: " + date). import java. en el caso del autor. Este formato utiliza la configuración regional (que.2 269 de 285 .text.Date. } catch (ParseException e) { System.DEFAULT).println("Error").println(formateador. Para mostrar la fecha actual en formato mes/dia/año.ENGLISH).format(new Date())).

import java. //Ttrue: Indica que se puede usar una aproximación.println(formateador. System. import java. SimpleDateFormat forma = new SimpleDateFormat("'Ingresaste' EEEEEEEEE dd 'de' MMMMM 'de' yyyy"). System. SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy"). import java.println(formateador.trim()).format(fechaForm)).toString(). String validaFecha = fecha.setLenient(false). } catch (ParseException e) { System.out.out.format(dt)).parse(dato). import java.text.TimeZone. public class Formato14 { public static void main(String[] args) throws ParseException { String dato = "31/12/2009".Calendar. import java.util.parse(fechaAs).io. BufferedReader fecha = new BufferedReader (fe_cha). } } Para mostrar el día en palabras de una fechas determinada: package view.io.SimpleDateFormat.setTimeZone(TimeZone. BufferedReader fe_cha = new BufferedReader(new InputStreamReader(System. Date dt = formateador.text. package view.ParseException.InputStreamReader.Date.Date.BufferedReader.out.'18/01/1952' ").println(forma. import java.SimpleDateFormat.getDefault()). cal. formatea. Date fechaForm = formatea.io.2 270 de 285 .in)). import java.readLine().out. import java.format(new Date())).out.ParseException.util. SimpleDateFormat formateador = new SimpleDateFormat("'Hoy es' EEEEEEEEE dd 'de' MMMMM 'de' yyyy"). } } } Versión 2. public class Formato15 { public static void main(String[] args) throws IOException. Luego se muestra el valor usando el Date. ParseException { Calendar cal = Calendar.IOException. import java. import java. System. System. SimpleDateFormat formatea = new SimpleDateFormat("dd/MM/yyyy").getInstance().Para convertir un valor de tipo String en Date.println("Error.util.text."). import java.text. String fechaAs = (validaFecha. la cadena de texto no se puede convertir en fecha.util. try { //False: Indica que el formato es estricto.println("Ingrese una fecha ej.

println(nameFormat).Calendar.ParseException.text. standarFormat. nameFormat = name. standar = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"). dd MMMM yyyy").format(nowDate).Formato en otros idiomas. } } Versión 2.GregorianCalendar. //Aplicamos un formato en otro idioma. System.Locale.println(standarFormat).util. System. standar. System.println(nameFormat).TRADITIONAL_CHINESE).util.out. nameFormat = name. //Obtener la fecha actual en un calendario Date nowDate = now. name = new SimpleDateFormat("EEEE.format( nowDate ). standarFormat = standar.SimpleDateFormat. System. String nameFormat.util. import java.text. import java.out. name = new SimpleDateFormat("EEEE.2 271 de 285 . dd MMMM yyyy".println(nameFormat). import java. //Definimos dos formatos para mostrar fechas name = new SimpleDateFormat("EEEE. import java. dd MMMM yyyy". //Aplicamos el formato a la fecha actual.out. import java. Locale. SimpleDateFormat name. package view.format( nowDate ). Locale.UK).Date.format(nowDate).util. public class Formato16 { public static void main(String[] args) throws ParseException { //Fecha -> String Calendar now = new GregorianCalendar().getTime().out. import java. nameFormat = name.

1 28.8).out..6).. datos){ System.out. Esto se consigue mediante la expresión ". int. } public static void miFunc(String s1. miFunc("Mundo"." a partir del momento en que queramos tener un número variable de argumentos.. Adicionales 2 Uso de métodos en Java.2 28.println(s1).2 272 de 285 . Versión 2.6. public class UsoMain { public static void main(String. cadenas) { for (String cadena : cadenas) System.. } } Observar que en este caso la variable datos hace las veces de un arreglo sin dimensión máxima definida.out.println(dato). } public static void imprimir(String.. "Dos".println(cadena). datos) es capaz de recibir obligatoriamente un dato de tipo String y el resto es una lista opción de enteros.28 28.3 Objetivos Conocimiento previo Argumentos variables Características adicionales de Java. Java permite pasar un número variable de argumentos a un método... args) { imprimir("Uno"... } } 28. "Tres"). miFunc("Chile". int. public class ArgumentosVariables { public static void main(String[] args) { miFunc("Hola")..2.4 Método main public static void main(String[] args) El método main recibe un arreglo de String como único argumento. Este es un vector de cadenas de caracteres representa que los parámetros opcionales que le podemos pasar por la línea de comando. En este ejemplo la función miFunc(String s1. for(int dato: datos) System.

} } También se puede procesar como: public class Ejemplo{ public static void main(String[ ] args) { System.length. for(String arg: args) System.println("Los argumentos son:").2 273 de 285 .out. public class UsoMain { public static void main(String[] args) { System. } } Versión 2. System.println("Hola: " + args[0]).out. i++) System.println(args[i]).println("Hola: " + args[1]). } } También se puede procesar como: public class Ejemplo{ public static void main(String[ ] args) { System. for(int i=0.out.println("Los argumentos son:").println(arg).out.out.out.i < args.El siguiente programa lee desde la línea de comando dos argumento y luego muestra la información: package dat.

los elementos numéricos se pueden ordenar en orden creciente o decreciente de acuerdo al valor numérico del elemento. 20. En el caso de la operación de ordenación. dos criterios se suelen seguir a la hora de decidir qué algoritmo —de entre los que resuelven la ordenación— es el más eficiente: 1) tiempo menor de ejecución en computadora. el elemento por el cual está ordenado un conjunto de datos (o se está buscando) se denomina clave. Por ejemplo. Programación en java.4 Algoritmo de la burbuja En el caso de un array (lista) con n elementos.2 29. 40. en inglés) es una operación consistente en disponer un conjunto —estructura— de datos en algún determinado orden con respecto a uno de los campos de elementos del conjunto.29 29. Las etapas del algoritmo son: El ejemplo siguiente ilustra el funcionamiento del algoritmo de la burbuja con un array de 5 elementos A = (50. la guía telefónica está dispuesta en orden alfabético de nombres. donde se introduce una variable interruptor para detectar si se ha producido intercambio en la pasada. 2) menor número de instrucciones. el elemento mayor ha «burbujeado» hasta la cima de la sublista actual. 29. un campo dirección y un campo número de teléfono. cada elemento del conjunto de datos de una guía telefónica tiene un campo nombre. Versión 2. La ordenación o clasificación de datos (sort.2 274 de 285 . 30).1 29. 80. Por cada pasada se comparan elementos adyacentes y se intercambian sus valores cuando el primer elemento es mayor que el segundo elemento. En terminología de ordenación. por ello se debe prestar especial atención en su elección. 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 métodos (algoritmos) de ordenación son numerosos. Al final de cada pasada.3 Objetivos Conocimiento previo Ordenación Adicionales 3 Analizar e implementar algoritmos de ordenación y búsqueda. ¿Cómo se sabe cuál es el mejor algoritmo? La eficiencia es el factor que mide la calidad y rendimiento de un algoritmo. la ordenación por burbuja requiere hasta n − 1 pasadas.

Versión 2.2 275 de 285 .

2 276 de 285 . comparando el elemento inferior de la lista con los restantes y efectuando intercambio de posiciones cuando el orden resultante de la comparación no sea el correcto. El algoritmo realiza n − 1 pasadas (3 en el ejemplo). 6. 4. 8. siendo n el número de elementos.La codificación en C es: 29. Versión 2. 6. Este algoritmo se basa en la lectura sucesiva de la lista a ordenar.5 algoritmo de ordenación El algoritmo de ordenación tal vez más sencillo sea el denominado de intercambio que ordena los elementos de una lista en orden ascendente. El algoritmo se ilustra con la lista original 8. 4. y ejecuta las siguientes operaciones. 2 que ha de convertirse en la lista ordenada 2.

El intercambio (swap) de los elementos a[i]. i + 2. Suponiendo que la lista es de tamaño n.El método ordIntercambio utiliza dos bucles anidados.a[j] se realiza en un bloque que utiliza el algoritmo siguiente: aux = a[i]. a[j]= aux .2 277 de 285 . a[i] = a[j]. Por cada índice i. El algoritmo en C es: Versión 2. .. se comparan los elementos posteriores de índices j = i + 1. el rango del bucle externo irá desde el índice 0 hasta n − 2... n − 1.

de modo que deben explorarse todos los números. uno después de otro. si los datos de la lista están ordenados se puede utilizar esa información para acortar el tiempo de búsqueda. uno después de otro. esperando encontrar el número 958-220000. 29. si se desea encontrar la persona cuyo número de teléfono es 958-220000 en un directorio o listado telefónico de su ciudad. al menos el programa tendrá que comparar la clave de búsqueda con la mitad de los elementos del array. El proceso de encontrar un elemento específico de un array se denomina búsqueda. la técnica más sencilla. por ejemplo. es probable que el elemento a buscar pueda ser el primer elemento. Si no se encuentra el valor de la clave. y búsqueda binaria o dicotómica. los elementos de una lista o vector se exploran (se examinan) en secuencia.29. El algoritmo de búsqueda secuencial compara cada elemento del array con la clave de búsqueda. La búsqueda secuencial es necesaria. Dado que el array no está en un orden prefijado. Versión 2. la técnica más eficiente.2 278 de 285 . 29. El método de búsqueda lineal funcionará bien con arrays pequeños o no ordenados. se sigue la búsqueda uno en la mitad inferior o superior del elemento central de la lista.7 Búsqueda secuencial La búsqueda secuencial busca un elemento de una lista utilizando un valor destino llamado clave. En esta sección se examinarán dos técnicas de búsqueda: búsqueda lineal o secuencial. De promedio. Los directorios de teléfonos están organizados alfabéticamente por el nombre del abonado en lugar de por números de teléfono. y por ello será necesario determinar si un array contiene un valor que coincida con un cierto valor clave. En general.6 Búsqueda en listas Con mucha frecuencia los programadores trabajan con grandes cantidades de datos almacenados en arrays y registros. En una búsqueda secuencial (a veces llamada búsqueda lineal). el último elemento o cualquier otro.8 Búsqueda binaria Se sitúa la lectura en el centro de la lista y se comprueba si la clave coincide con el valor del elemento central.

Codificación en C: 29. midiendo los tiempos de ejecución.9 Ejercicios Codificar cada uno de los algoritmos en Java y desarrollar pruebas para datos de tipo numéricos y de caracteres. Versión 2.2 279 de 285 .

especialmente con el desarrollo del paradigma de la programación orientada a objetos.3 Objetivos Conocimiento previo Caso de uso Adicionales 4 Uso de casos de uso para la definición de requerimientos. Un caso de uso contiene una descripción textual de todas las maneras que los actores previstos podrían trabajar con el software o el sistema.4 Normas de aplicación Los casos de uso evitan típicamente la jerga técnica. Una relación es una conexión entre los elementos del modelo. Tener un nivel apropiado del detalle. el sistema será el que inicie la comunicación). en cambio si es secundario. En el contexto de ingeniería del software.2 280 de 285 . prefiriendo la lengua del usuario final o del experto del campo del saber al que se va a aplicar. O lo que es igual. un caso de uso es una secuencia de interacciones que se desarrollarán entre un sistema y sus actores en respuesta a un evento que inicia un actor principal sobre el propio sistema. esto significa que quizás a veces es necesario especificar diez o centenares de casos de uso para definir completamente el nuevo sistema. Cada caso de uso se centra en describir cómo alcanzar una única meta o tarea de negocio. Un caso de uso utiliza otro caso de uso. Un caso de uso es una descripción de los pasos o las actividades que deberán realizarse para llevar a cabo algún proceso. 30. Los diagramas de casos de uso sirven para especificar la comunicación y el comportamiento de un sistema mediante su interacción con los usuarios y/u otros sistemas. Los casos del uso son a menudo elaborados en colaboración por los analistas de requerimientos y los clientes.1 30. Los personajes o entidades que participarán en un caso de uso se denominan actores. Simplemente muestran los pasos que el actor sigue para realizar una operación. si bien puede utilizarse con resultados igualmente satisfactorios con otros paradigmas de programación. un diagrama que muestra la relación entre los actores y los casos de uso en un sistema. Programación de sistemas. Los casos de uso pretenden ser herramientas simples para describir el comportamiento del software o de los sistemas. Ser bastante sencillo como que un desarrollador lo elabore en un único lanzamiento. Un caso de uso extiende otro caso de uso.30 30. donde se originaron. Los más comunes para la captura de requisitos funcionales. Desde una perspectiva tradicional de la ingeniería de software. Los casos de uso no describen ninguna funcionalidad interna (oculta al exterior) del sistema. por ejemplo la especialización y la generalización son relaciones. Un caso de uso debe: • • • Describir una tarea del negocio que sirva a una meta de negocio. Situaciones que pueden darse: • • • Versión 2. ni explican cómo se implementará. un caso de uso describe una característica del 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 diagramas de casos de uso se utilizan para ilustrar los requerimientos del sistema al mostrar cómo reacciona a eventos que se producen en su ámbito o en él mismo. Para la mayoría de proyectos de software. Un actor se comunica con un caso de uso (si se trata de un actor primario la comunicación la iniciará el actor.2 30.

30.6 Plantilla adecuada 1 Versión 2.5 Plantilla no adecuada 30.2 281 de 285 .

el empleado del vídeo–club cancela la operación. apellidos. a continuación este caso de uso termina Precondición Secuencia Normal Postcondición Excepciones Versión 2.7 Plantilla adecuada 2 RF. sexo. imprime el carnet de socio e informa al empleado del vídeo club de que el proceso ha terminado con éxito 7 El empleado del vídeo–club entrega el carnet al nuevo socio El solicitante es socio del vídeo–club y el saldo de su cuenta es 0 Paso Acción 4 Si la documentación aportada no es correcta. nombre. fecha de nacimiento.30.2 282 de 285 .01 Objetivos asociados Requisitos asociados Descripción Alta de socio OBJ–02 Gestionar las socios RI–02 Información sobre socios El sistema deberá comportarse tal como se describe en el siguiente caso de uso cuando alguien solicite su ingreso como socio El solicitante no es un socio del vídeo–club y tiene su documentación disponible Paso Acción 1 El empleado del vídeo–club 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. dirección y teléfonos de contacto 3 El empleado del vídeo–club solicita los datos requeridos y la documentación al nuevo socio 4 El empleado del vídeo–club comprueba que los datos del nuevo socio coinciden con los de la documentación aportada 5 El empleado del vídeo–club proporciona los datos requeridos y solicita al sistema que los almacene 6 El sistema almacena los datos proporcionados.

31 31.3 Programación en java y manejo de swings. Santiago Las parcelas 8080. Tabla: Cliente Campo rut razon_social direccion Tipo varchar(10) varchar(100) varchar(100) PK YES FK rut 44000000 12500000 razon_social AXP Estructuras Metálicas Ltda.1 Trabajo. Maria Luisa Perez Aranguiz direccion Las acacias 1234. Crear a base de datos “tienda” y las siguientes tablas.2 31.2 283 de 285 .1" 3C SO MeeGo Packard Bell Netbook EasyNote Butterfly DOT A-001 AMD Athlon II Neo K125 2GB 320GB 11. Santiago Punta Arenas Versión 2.6" BT HD6310 6C W7St Negro Tipo varchar(4) varchar(100) PK YES FK Tabla: Sucursal Campo codigo_sucursal nombre A1 A2 Tipo varchar(2) varchar(100) PK YES FK Mall Vespucio.6" 6C W7St Sony NTBK VAIO VPC-YB25 AMD Dual Core E350 2Gb 500Gb 11. Adicionales 4 Objetivos Conocimiento previo Base de datos 31. Linares Tabla: Producto Campo codigo_producto nombre codigo_producto nombre AX10 AX20 AZ10 Samsung Netbook N100 Intel Atom 435 1Gb 250Gb 10.

2 284 de 285 .A3 A4 Concepción Santiago Centro Tabla: Sucursal_Producto Campo codigo_sucursal codigo_producto cantidad_en_bodega precio codigo_sucursal A1 A2 A3 A4 A2 A4 A1 A2 A3 Tipo varchar(2) varchar(4) int int codigo_producto AX10 AX10 AX10 AX10 AX20 AX20 AZ10 AZ10 AZ10 cantidad_en_bodega 2 10 20 45 12 3 precio 119990 140000 119990 119990 209990 189990 279990 269990 289990 PK YES YES FK YES: Sucursal(codigo_sucursal) YES: Producto(codigo_producto) Tabla: Moneda Campo tipo_moneda nombre valor_pesos tipo_moneda DO EU YE Tipo varchar(2) varchar(100) double nombre Dólar Euro Yen valor_pesos 456.23 653.94 700 PK YES FK Tabla: Venta Campo id rut codigo cantidad fecha hora tipo_moneda Tipo int varchar(10) varchar(4) int date date varchar(2) YES: Moneda(tipo_moneda) PK YES (Autocorrelativo) YES: Cliente(rut) YES: Producto(codigo) FK Versión 2.

Las ventas pueden ser desarrolladas en los tipos de monedas almacenados en la tabla “Moneda”. 4. Cada sucursal tiene un precio distinto para el mismo producto. 5. 3. Las características específicas son: 1.2 285 de 285 . Versión 2. Los clientes son aquellos que pueden desarrollar compras. Cada venta debe almacenar el día y hora en que se desarrollar el proceso tomando esos datos desde la fecha del servidor de base de datos. 2.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 país. Los productos son ingresados al sistema asignándolos a diferentes sucursales que la tienda tiene a lo largo del país.