unidad i-metodologia de programacion

5/16/2018 Unidad I-metodologia de Programacion - slidepdf.com

http://slidepdf.com/reader/full/unidad-i-metodologia-de-programacion 1/285

METODOLOGÍADE

PROGRAMACIÓN

Versión 2.2 1 de 285



Índice de contenido1 Clase.................................................................................................................................................8

1.1 Objetivos..................................................................................................................................8

1.2 Conocimiento previo................................................................................................................8

1.3 Conceptos de encapsulación....................................................................................................8

1.4 Ejemplo..................................................................................................................................10

2 Clase...............................................................................................................................................142.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.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..............................................................................................................................253.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..............................................................................................................284.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.3 Modelos de evaluación 1.......................................................................................................38

6 Clase...............................................................................................................................................42

6.1 Objetivos................................................................................................................................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...............................................................................................................................................477.1 Objetivos................................................................................................................................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.3 Arreglos Bidimensionales......................................................................................................518.4 Inicialización de arreglos bidimensionales............................................................................52

8.5 Ejemplos................................................................................................................................52

8.6 Trabajo 4................................................................................................................................53

9 Clase...............................................................................................................................................54

9.1 Objetivos................................................................................................................................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.............................................................................................................................................7011.1 Objetivos..............................................................................................................................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............................................................................................................................8012 Clase.............................................................................................................................................81




12.1 Objetivos..............................................................................................................................81


12.3 Clases abstractas..................................................................................................................81

12.4 Ejemplo 1.............................................................................................................................83

12.5 Interfaz.................................................................................................................................83

12.6 Polimorfismo.......................................................................................................................87

12.7 Ejemplo 2.............................................................................................................................9013 Clase.............................................................................................................................................92

13.1 Objetivos..............................................................................................................................92


13.3 Modelos de evaluación 3.....................................................................................................92

14 Clase.............................................................................................................................................98

14.1 Objetivos..............................................................................................................................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.......................................................................................................10014.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.3 Map....................................................................................................................................12816.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.3 Modelos de evaluación 4...................................................................................................136

18 Clase...........................................................................................................................................141

18.1 Objetivos............................................................................................................................141

18.2 Conocimiento previo..........................................................................................................14118.3 Colecciones Genéricas.......................................................................................................141




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..........................................................................................................14618.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...............................................................................................................15319 Clase...........................................................................................................................................154

19.1 Objetivos............................................................................................................................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...........................................................................................................................................17320.1 Objetivos............................................................................................................................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..........................................................................................................19321.3 Modelos de evaluación 5...................................................................................................193




22 Clase...........................................................................................................................................194

22.1 Objetivos............................................................................................................................194


22.3 JFormattedTextField..........................................................................................................194

22.4 PasswordField - Separator.................................................................................................197

22.5 JRadioButton.....................................................................................................................198

22.6 CheckBox...........................................................................................................................20122.7 Spinner...............................................................................................................................203

22.8 JTabbedPane......................................................................................................................208

23 Clase...........................................................................................................................................219

23.1 Objetivos............................................................................................................................219


23.3 JTable.................................................................................................................................219

24 Clase...........................................................................................................................................228

24.1 Objetivos............................................................................................................................228


24.3 Evaluación 6......................................................................................................................228

24.4 Evaluación 7......................................................................................................................22925 Clase...........................................................................................................................................231

25.1 Objetivos............................................................................................................................231


25.3 JMenu.................................................................................................................................231

25.4 JTree...................................................................................................................................237

25.5 JScrollPane.........................................................................................................................249

26 Adicionales.................................................................................................................................251

26.1 Objetivos............................................................................................................................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.3 Format................................................................................................................................256

27.4 Locate.................................................................................................................................256

27.5 MessageFormat..................................................................................................................259

27.6 ChoiceFormat.....................................................................................................................259

27.7 NumberFormat...................................................................................................................26327.8 DecimalFormat..................................................................................................................263

27.9 DateFormat........................................................................................................................268

27.10 SimpleDateFormat...........................................................................................................269

28 Adicionales 2..............................................................................................................................272

28.1 Objetivos............................................................................................................................272


28.3 Argumentos variables .......................................................................................................272

28.4 Método main......................................................................................................................272

29 Adicionales 3..............................................................................................................................274

29.1 Objetivos............................................................................................................................274

29.2 Conocimiento previo..........................................................................................................27429.3 Ordenación.........................................................................................................................274




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..............................................................................................................................28030.1 Objetivos............................................................................................................................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.3 Base de datos.....................................................................................................................283




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ónEn programación modular, y más específicamente en programación orientada a objetos, se denominaencapsulamiento al ocultamiento del estado, es decir, de los datos miembros, de un objeto de manera quesó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 propiedadespara concentrarse sólo en cómo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado demaneras imprevistas e incontroladas.

Otra definición un tanto más simple: La encapsulación consiste en ocultar la complejidad de unaclase 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 datosmiembro 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 eldesarrollo.

• 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ónde datos de un objeto.

◦ Mutadores (conocidos como métodos set): Se utilizan de forma estándar para la asignación dedatos a un objeto, bajo ciertas restricciones.




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 inicializadaprivate 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 notapublic 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 dela 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 paraotros casos.

void setNota(double nota){if (nota >=1.0 && nota <=7.0)

this.nota = nota;else

this.nota = 1.0}




1.4 EjemploCrear un programa Java que sea capaz de manejar las ventas de un producto determinado. Para esto, sedeben enviar:

• El código del producto como parámetro de objeto de la clase que encapsula la información deproductos.

•

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 objetode la clase usando su método constructor que debe recibir el código, nombre y precio del producto; usandosu 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;}




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 esfundamental 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);




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 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:


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);

}}




2 Clase2.1 Objetivos

Conversión de tipos de datos.

2.2 Conocimiento previoManejar 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 elpunto de vista de la funcionalidad. Por ejemplo, los tipos primitivos siempre se pasan como argumento a losmétodos por valor, mientras que los objetos se pasan por referencia. De esta manera, no hay forma demodificar en un método un argumento de tipo primitivo y que esa modificación se trasmita al entorno quehizo la llamada.

Una forma de conseguir esto es utilizar un Wrapper, esto es un objeto cuya variable miembro es eltipo primitivo que se quiere modificar. El API de Java incorpora las clases envoltorio (Wrapper class), que noson más que dotar a los datos primitivos con un envoltorio que permita tratarlos como objetos.




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.println("4");}}

Por ende, da lo mismo definir el valor con minúscula que con mayúscula.




Observar que es válido también la combinaciones de letras minúsculas y mayúsculas:

package view;


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;


Boolean o1 = true;Boolean o2 = Boolean.TRUE;if(o1.booleanValue()==true)


System.out.print("2");if(o2.booleanValue()==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();

}




Observar que no se pueden usar combinaciones de minúsculas y mayúsculas en los casos indicados conerror. 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 aplicacionesde tipo web la mayoría de los datos son recuperados como tipo String independientes que los datos seannuméricos.

En diagrama de clases de los datos tipo Objetos (o Wrapper). Podemos apreciar que existe unaclase común Number y que después cada uno de los tipos de datos tiene su propia implementación en suclase.


Number

BigDecimal BigInteger Byte Double Float Integer Long Short

Object



2.6 DoubleManeja objetos numéricos tipo Double. Esta clase provee varios métodos para convertir un double en unString 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 endouble. 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 objetoDouble.

• String Double.toString( ): Retorna un String desde un objeto Double. Por ejemplo, 12.12 lostransforma en “12.12”.

• String Double.toString(double d): Retorna el String que representa al argumento dato primitivodouble.

package view;


double val1 = 12.12;Double val2 = new Double(22.22);Double val3 = new Double("33.33");String val4 = "44.44";

//Transforma en double desde Doubleval1 = val2.doubleValue();System.out.println("val1: " + val1);

//Transforma desde String a double. El más importante de todos




val1 = Double.parseDouble(val4);System.out.println("val1: " + val1);

//Transforma de String a Double. El segundo más importanteval4 = "55.55";val2 = Double.valueOf(val4);System.out.println("val2: " + val2);

//Transforma de Double a Stringval4 = val3.toString();System.out.println("val4: " + val4);

//Transforma de double a Stringval4 = 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 casoparticular:

String s1 = "123"; String s2 = "FF"; String s3 = "10001000";int a1 = Integer.parseInt(s1, 10); //Base 10int a2 = Integer.parseInt(s2, 16); //Base 16int a3 = Integer.parseInt(s3, 2); //Base 2System.out.println(a1 + " - " + a2 + " - " + a3);

2.8 EjemploConsidere 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; }

}




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. Eneste 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 estecaso, 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;




}

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 1Se 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 seindica:• 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





Usar métodos prediseñados.

3.2 Conocimiento previoCreación de métodos.

3.3 Métodos específicosExisten una serie de de métodos en java que nos permiten desarrollar procesos. Sin embargo, esta cantidadde 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'));

}}




3.5.2 isUpperCase

Determina si el carácter especificado en una letra mayúscula. De la misma forma se tiene isUpperCase eisWhitespace().

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 asciiLa siguiente tabla contiene los códigos ascii.




3.7 StringLa 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 charAtRetorna 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;

}}




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 concatString concat(String str): Concatena la cadena especificada “str”al final de otra cadena. El código unevariables String.

public class B {public static void main(String[] args) {

String nombre = "Juan";String apellido = "Perez";String espacio = " ";

//Concatena los caracteresString ciudadano = nombre.concat(espacio).concat(apellido);

System.out.println(ciudadano);

}}

3.7.3 equalsboolean 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 subcadenaespecificada.

int indexOf(String str, int fromIndex): Devuelve el índice dentro de esta cadena de la primera aparición dela subcadena especificada, comenzando en el índice especificado.

3.7.5 substringString substring(int beginIndex): Devuelve una nueva cadena que es una subcadena de la cadena desdela 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




System.out.println(nombre.substring(8,nombre.length())); //ez }

}

3.7.6 toLowerCase - toLowerCaseString 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 utilizandolas reglas dado por Locale.

String toUpperCase(): Convierte todos los caracteres letras de String a mayúsculas utilizando las reglas dela localización por defecto.

String toUpperCase(Locale locale): Convierte todos los caracteres letras de String a mayúsculasutilizando las reglas dado por Locale.

Locate: Un objeto Locale representa una determinada región geográfica, política o cultural. Por ejemplo, secrea un objeto Locale para los Estados Unidos y China

Locale.USLocate.CHINA

3.7.7 trimString trim (): Devuelve una copia de la cadena, con espacios en blanco iniciales y finales omitido(eliminados).

3.8 RandomLa clase Random es parte de package java.util.Random y genera números seudoaleatorios que tiene comofin principal la simulación.

3.8.1 nextIntDevuelve 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;


Random r=new Random();for(int i=0; i<10; i++){

System.out.println(r.nextInt(100));}

}}




Posibles resultados, los cuales dependen de la veces que se ejecute el proceso.

Generar 10 números aleatorios enteros entre 1 y 100.



Random r=new Random();for(int i=0; i<10; i++){System.out.println(1+ r.nextInt(100));

}}

}

3.8.2 nextDoubleGenera números aleatorios entre 0 (incluido) y 1 (no incluido); o sea, en el intervalo [0,1).



Random r=new Random();for(int i=0; i<10; i++){

System.out.println(r.nextDouble());}

}}




4 Clase

4.1 ObjetivosUsar objetos de clases para procesos.


4.3 Manejo de objetos StringPara 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;


Referencia

Variable gradosObjeto 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 quedesarrollan 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 laclase, entonces java no agrega un nuevo objeto , sino que utiliza el que hay. Esto se genera únicamentecon 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 distintaspara 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


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 }…


obj1

obj2

abc == trueobj1

obj2

abc

== falsexabc

obj1

obj2

abc equals trueobj1

obj2

abc

equals trueabc



4.4 Objetos InmutablesUn objeto String es inmutable. Por ejemplo, si se asigna un nuevo valor a una variable, entonces se crea unnuevo 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");}}




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 (adiferencia 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 essíncrona, lo que significa que puede haber problemas si es una variable a la que accedan diferentesthreads. Sin embargo, para la mayoría de las aplicaciones (donde se ejecuta un solo hilo) suponeuna 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 deellos va guardando el nuevo contenido. Esto por supuesto no es eficiente, un problema que podemosresolver 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 lascadenas 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 encada iteración del bucle, mejorando aún más el rendimiento.

// creamos espacio para 120 caracteresStringBuffer cadena = new StringBuffer(120);cadena.append(”Cuenta: “);for (int i=0; i<100; i++) {

cadena.append(" " + i + " ");}




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, utilizaremosStringBuffer.




4.6 BigDecimal - RoundingMode

Considerar el siguiente código y el resultado. Como podemos ver el resultado no es el esperado.

package view;


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 eltrabajo de efectuar los cálculos directamente (con su coprocesador matemático) pero como lascomputadoras "piensan" en binario, cometen errores de precisión diferentes a los nuestros. Para solucionar lo anterior podemos proceder como sigue:

package view;


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);}

}




Si hacen sistemas financieros, los pequeños errores de calculo acumulados con varios centavos puedenresultar 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 maslento que "Double/double" los realiza del mismo modo que los humanos (en base 10) y así evitamos elproblema.

Vamos a emplear esta clase para el desarrollo de aproximaciones:

Además consideraremos la clase java.math.RoundingMode que permite el manejo de aproximaciones decifras decimales. Los valores posibles son:

• HALF_DOWN

• HALF_EVEN




• HALF_UP

Así debemos usar HALF_UP.

package view;import java.math.BigDecimal;import java.math.RoundingMode;


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);

}}




Para operar con la clase se debe tener presente lo siguiente. Por ejemplo, se requiere dividir 3 / 243 con 6decimales.

package view;import java.math.BigDecimal;


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;


BigDecimal numero =new BigDecimal("3").divide(new BigDecimal("243"),6, RoundingMode.HALF_UP);

System.out.println(numero);}

}

4.7 Trabajo 2Desarrolle 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.




5 Clase

5.1 ObjetivosPresentar problemas tipo para la evaluación 1. Valor 12.5% de la nota 1.

5.2 Conocimiento previoContenidos de las clases 1, 2, 4 y 3

5.3 Modelos de evaluación 1Problema 1

El cobro de intereses por la venta de un producto está asociado a la relación en días entre la fecha devencimiento 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 lavariable dat.

(b) Crear un método que devuelva un boolean, que recibe como parámetro la variable busca de tipoString y que analiza si está contenida en la variable dat. Por ejemplo, si dat=”Hola Mundo Java” ybusca=”mUndo”, entonces el método devuelve true.

(c) Considerar que variable dat contiene información de fecha en formato dd/mm/aaaa. Crear unmétodo que transforme adecuadamente el contenido de la variable dat a un tipo de variable quemaneje 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 lossiguiente 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.




Problema 4Desarrolle 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íasproducidas.

Problema 5Cree un método que sea capaz de recibir la cantidad de alumnos, simule sus notas de 1 a 7, calcule ymuestre el promedio de estas.

Problema 6Considere 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ásusando 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 7Desarrolle un método que cuente con un parámetro StringBuffer y que sea capaz de almacenar en otravariable StringBuffer el valor numérico que produce la concatenación de las cifras numéricas enviadas en elpará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() {




}

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();




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;

}}




6 Clase

6.1 ObjetivosManejar el concepto de arreglo unidimensional y aplicarlo en el uso de algoritmos.

6.2 Conocimiento previoContenidos de las clases 1, 2, 3 y 4.

6.3 Arreglos unidimensionalesUn 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 encorchetes, 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.




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");




6.5 Recorrer un arregloLas 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 arreglofor(int i=0; i < arrayInt.length; i++)

System.out.println (arrayInt[i]);}

}

Con un while:


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:


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 rangofor(int elemento: arrayInt)

System.out.println (elemento);}

}




6.6 Asignación de arreglosJava 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í, almodificar 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 enotro 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]); }

}}




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);

}}




7 Clase

7.1 ObjetivosManejar el uso de arreglos de objetos.

7.2 Conocimiento previoUso de arreglos unidimensionales y encapsulación de datos.

7.3 Arreglos de objetosSe puede crear una matriz de objetos de cualquier clase. Se procede de la misma manera que se crea unamatriz de números o de caracteres. Por ejemplo, para crear crear una matriz de objetos de la claseCPersona 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 lamatriz 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; }


listaPersonasCPersona[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] = newAlumnoMatrizObjeto(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 sedevuelven por valor y los objetos siempre se devuelven por referencia. Para que un método reciba unarreglo 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 );




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 ArraysEsta 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 quesea 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();




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 3Desarrollar un programa que reciba un arreglo de n números reales correspondientes a las estaturas de npersonas. Se piden crear métodos que reciban un arreglo del tipo citado y sean capaces devolver losolicitado.

(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 esevalor 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 envalor de n = 8.

Considerar dos arreglos unidimensionales x e y de valores decimales y del mismo rango. Calcular losvalores 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.




8 Clase

8.1 ObjetivosManejar el concepto de arreglo bidimensional y aplicarlo en el uso de algoritmos.

8.2 Conocimiento previoUso de arreglos unidimensionales.

8.3 Arreglos BidimensionalesSupongamos que usted tiene un interés en el tiempo, y tiene la intención de registrar la temperatura de cadadía durante un año en 10 ubicaciones geográficas separadas a lo largo del año. Una vez que hayasolucionado 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 valoresestá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]);}

}}

}




En este caso para la contabilización de las columnas se procede:

int a[ ][ ] = new int[10][3];a.length; // resultado 10 → cantidad de filasa[0].length; // resultado 3 → cantidad de columnas

8.4 Inicialización de arreglos bidimensionales

Para el caso de arreglos tipo StringString datos[ ][ ] = {{"A1","A2"},

{"Enlatados","natural"}};

8.5 Ejemplos1. Máximo Matriz, recorrida por filas

public class MaximoMatrizFilas {static int x[][] = {{2,-1,4,3,1,4},

{8,2,-3,9,2,7}};


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);

}}


x00 x01 x02 x03 x04 x05 x.length = 1

2 -1 4 3 1 4 x[ 0] .length = 5

8 2 -3 9 2 7x10 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 elarreglo 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 4Considerar que se requiere un programa java que sea capaz de manejar las ventas de los siguientesproductos. 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. Sedebe mostrar el total sin descuento por cada producto, el total de descuento aplicado a cadaproducto y el total a pagar. En el caso que la cantidad a vender, para cualquiera de los tresproductos, supere el contenido en el stock, entonces el proceso de venta no se llevará a cabo paraninguno 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 enbodega.


> =

<< =

<

descuentoVenta

descuentoVenta

descuentocajasVenta

%10,000.5

%5,000.5000.1

%0,1000



9 Clase

9.1 ObjetivosPresentar problemas tipo para la evaluación 2. Valor 12.5% de la nota 1.

9.2 Conocimiento previoContenidos de las clases 6, 7 y 8

9.3 Modelo de evaluación 2Ejercicio 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 arreglounidimensional 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 elmenor 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




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 quetiene 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 elementosnumé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 elvalor 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




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 2package 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));

}

}




10 Clase

10.1 ObjetivosManejar 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 POONos interesan los desafíos que plantean el desarrollo de lo que llamaremos software de dimensiónindustrial. Aquí se encuentran aplicaciones que mantienen, por ejemplo, la integridad de cientos de milesde registros de información que mientras se permiten actualizaciones y consultas concurrentes; y sistemaspara 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 funcionamientocorrecto.

La característica principal del software de dimensión industrial es que resulta sumamente difícil, si noimposible, para el desarrollador individual comprender todas las partes de su diseño. Para ser claro, lacomplejidad 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.




• 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 estossería muy costoso e indudablemente sería una invitación al fracaso. Asombrosamente, los usuariosde 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 excedenel presupuesto, y que son deficientes respecto a los requerimientos fijados.

10.4 UMLLenguaje Unificado de Modelado (UML, por sus siglas en inglés, Unified Modeling Language) es el lenguajede 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 ydocumentar 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 aspectosconcretos como expresiones de lenguajes de programación, esquemas de bases de datos y componentesreutilizables.

Es importante resaltar que UML es un "lenguaje de modelado" para especificar o para describir métodos oprocesos. Se utiliza para definir un sistema, para detallar los artefactos en el sistema y para documentar yconstruir. 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 soportea una metodología de desarrollo de software (tal como el Proceso Unificado Racional o RUP), pero noespecifica 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 lasentidades representadas. En UML 2.0 hay 13 tipos diferentes de diagramas.




Para el diseño de diagramas puedes emplear diversas aplicaciones que permiten en diversos nivelesdiagramas y controlar el proyecto. Para este curso puedes usar la aplicación “dia” que puede ser bajadadesde 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 enmayúscula. Si el nombre de la clase consta de más de una palabra únalas e inicie cada palabra conmayúscula.

El atributo es una propiedad o característica de una clase y describe un rango de valores que la propiedadpodrá contener en los objetos de la clase. Si el atributo consiste de una sola palabra se escribe enminú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 losatributos. En los paréntesis podrá los parámetros con los cuales funciona la operación junto con su tipo dedato. 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éntesisdobles «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 apartir de otros ya existentes.


http://live.gnome.org/Dia

http://live.gnome.org/Dia



10.5 AgregaciónSe crean objetos de las clases existentes dentro de la nueva clase. Simplemente se está reutilizando (y noespecializando) 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 modelecon 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, lospuntos 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. Esdecir, 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 noson medios de transporte, por ejemplo, ruedas dentadas)




10.6 ComposiciónCon 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 dedestrucción de los objetos. Y a diferencia de la asociación, el ciclo de vida del objeto Area está relacionadocon el del objeto Ruta. Es decir que si la ruta de viaje se levanta, las áreas que surgían a partir de elladesaparecen.

Mucho se ha discutido a cerca de las agregaciones y las composiciones, ya que algunos sostienenque los lenguajes orientados a objetos, tienen garbage collector, por lo que no necesitan métodos dedestrucció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 esmeramente conceptual entre una y otras.




10.7 AsociaciónEs generalmente, una relación estructural entre clases o la conexión conceptual entre dos clases. En elejemplo, existe un atributo “conductor” en la clase MedioDeTransportes, que es del tipo Conductor. Lanavegalidad nos muestra donde esta ubicado el atributo. Es decir, cual es la clase que tiene contiene elatributo si ésta no lo mostrase.

10.8 Multiplicidad




10.9 HerenciaLa reutilización del software se consigue creando nuevas clases, pero en vez de crearlas de la nada, seutilizan clases ya existentes que otras personas ya han construido y depurado (sin modificar el códigoexistentes 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 seconsigue con el concepto de herencia.


Clase: InstrumentoMétodo: Tocar( )

SubClase: CuerdasMétodo: Tocar( )

Contiene generalidades de cómotocar los diversos instrumentos.

Incorpora la forma específicade tocar instrumentos de cuerda.



10.10 Definiciones de herenciaLa herencia es un concepto que tiene relación directa con la reutilización de código. El objetivo es usar lo yahecho 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 LenguajeUnificado 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 laGeneral 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 ("losTres Amigos") para desarrollar UML. Más tarde fusionaron sus metodologías de desarrollo desoftware, OMT, OOSE y Booch en el Proceso Unificado Racional (RUP). En el 2003 se trasladó aIBM, 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.




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 permitecompartir 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 yvariables 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 delcual una clase se deriva de otra, llamada entonces superclase, de manera que extiende sufuncionalidad.

• La idea es la de partir de las situaciones más generales e ir derivando hacia las másparticulares, 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ísticasprincipales (o "pilares") de la programación orientada a objetos. La herencia permite crear nuevasclases que reutilizan, extienden y modifican el comportamiento que se define en otras clases. Laclase cuyos miembros se heredan se denomina clase base y la clase que hereda esos miembros sedenomina clase derivada.

En la ilustración siguiente se muestra una clase WorkItem que representa un elemento detrabajo 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 losconstructores no se heredan. ChangeRequest hereda de WorkItem y representa un tipodeterminado de elemento de trabajo. ChangeRequest agrega dos miembros más a los miembrosque hereda de WorkItem y Object. Debe agregar su propio constructor y también agrega unmiembro que permitirá asociar ChangeRequest al elemento WorkItem original al que se aplica elcambio.




4. Según Sun Mycrosystem (actualmente Oracle)

La herencia es "un mecanismo por el cual una clase está definida en referencia a otras clases lascuales 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




10.11 Relación “es-un”·y “tiene-un”

10.12 SubclasesLas relaciones de herencia forman estructuras jerárquicas similares a árbol. Una superclase existe en unarelación jerárquica con sus subclases:

Ejemplo:

• Una comunidad universitaria típica comprende miles de personas que son miembros de lacomunidad.

•

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.




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 unarueda.

• 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 unfusible.




11 Clase

11.1 ObjetivosManejar y aplicar el concepto de herencia

11.2 Conocimiento previoConceptos de UML.

11.3 extendsSi se requiere que la clase “ComisionEmpleado” herede de la clase “Empleado” en java, se emplea lapalabra 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 puedemodificarlos o sobrescribirlos.

• Por eso, según se va bajando por el árbol de la herencia, las clases se convierten en más y másespecializadas.

Los métodos private se puede sobrescribir




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.




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 puedeacceder 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 lasubclase llamará implícitamente al constructor por omisión de la superclase (constructor sinargumentos).




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.




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 antesde ser usados.

• Se debe generar una superclase Media y una subclase Desviacion, en donde se especialice elmé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);

}}




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:




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




package proc;

public class Jugador {//Conceptos comunes a todos los jugadoresprivate String nombre="";private int numero=0;private int goles=0;

public Jugador() {}//Método para recibir los datos indicadospublic Jugador(String nombre, int numero, int goles) {

setNombre(nombre);setNumero(numero);setGoles(goles);

}//Método propio de todos los jugadorespublic 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 atacantesprivate int pases=0;private int recuperados=0;

public Atacante() {}//Método para recibir los datos indicadospublic 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@Overridepublic int valoracion(){

int val=0;val = super.valoracion() + getPases()*2 + getRecuperados()*3;return val;

}}




package proc;

public class Defensor extends Jugador {//Conceptos propios de los defensoresprivate int pases=0;private int recuperados=0;

public Defensor() {}//Método para recibir los datos indicadospublic 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@Overridepublic 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 porterosprivate int paradas=0;

public Portero() {}//Método para recibir los datos indicadospublic 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@Overridepublic int valoracion(){

int val=0;val = super.valoracion() + getParadas()*5;return val;

}}




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 seasobrescrito.

• 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.


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 5Usando 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:




12 Clase

12.1 Objetivos Aplicar el concepto de clase abstracta, polimorfismo e interfaces.

12.2 Conocimiento previo

Uso de herencia.

12.3 Clases abstractasSon clases que no necesitan ser instanciadas (no se generan objetos de ellas). En UML se denota en letrascursivas o mediante estereotipos.

• Un método abstracto es aquel que está sólo declarado, pero que sus subclases implementen deacuerdo al uso que se quiera dar.

◦ Por ejemplo, si en la clase A se define el método abstracto sueldo, entonces las subclases de Adará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 partede 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 losmé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().




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) ycomportamiento (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 esbastante diferente a dibujar un rectángulo. Los objetos gráficos no pueden compartir estos tipos deestados 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.




12.4 Ejemplo 1Este 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.


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 seespecifica qué se debe hacer pero no su implementación. Serán las clases que implementen estasinterfaces 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).




12.6 Polimorfismo




12.7 Ejemplo 2Suponga que se requiere crear un programa en java que sea capaz de calcular el valor del arriendo dediversos productos. De esta manera, dependiendo del tipo de producto que se necesita arrendar, el métodoprocede 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 arriendopublic 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 requeridoabstract protected int aCobrar (Alquiler a);

}

package owt; //Define el arriendo de Libros implementado el método aCobrar()public class Libros extends Item {

@Overrideprotected 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; }

@Overrideprotected int aCobrar (Alquiler a) {

int total=0;if(this.getTipo()==1){

total = 500 + a.getDias()*1000;}

if(this.getTipo()==2){




total = 500 + a.getDias()*100;}return total;

}}

package owt;

//Ejecuta procesospublic class Ver {

public static void main(String[] args){//3 días de arriendo del tipo de película 2Alquiler 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 1Alquiler 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 libroAlquiler o3 = new Alquiler(10);

Libros p3 = new Libros();System.out.println("Arriendo libro: " + p3.aCobrar(o3));

}}




13 Clase

13.1 ObjetivosDesarrollar la evaluación 3. . Valor 12.5% de la nota 2.

13.2 Conocimiento previoContenidos de las clases 11, 12 y 13.

13.3 Modelos de evaluación 3Ejercicio 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 sueslora en metros.

Un alquiler se calcula multiplicando el número de días de ocupación (incluyendo los días inicial yfinal) 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 defuerza 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 10caballos 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;

}




public void setFin(Date fin) {this.fin = fin;

}

public Date getInicio() {return inicio;

}

public void setInicio(Date inicio) {this.inicio = inicio;

}


}

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;




}

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;

}

@Overridepublic 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;}




public int getCc() {return cc;

}

public void setCc(int cc) {this.cc = cc;

}@Overridepublic 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;

}

@Overridepublic int cobro(){

int valor=0;double caballo = Math.floor(this.getCc() / 10.);valor = (int) (super.cobro() + caballo * 5000 + this.getCamatores() * 1000);return valor;

}}




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 2Usando 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:




Ejercicio 3La empresa “abc” está dedicada por años a la producción y exportación de frutas. Cada una de sus ventaslas maneja con un porcentaje de descuento estándar por volúmenes de ventas; más específicamente, si lasventas son mayores a 20 toneladas y menores o igual a 50, entonces el descuento es de un 10% y si lastoneladas 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 sondesarrolladas a la República Popular China en la 2ra temporada, 1% si las ventas son desarrolladasa Europa en la 1ra temporada, 1.5% si las ventas son desarrolladas a Europa en la 2ra temporada yun % en otros casos.

Todas los trámites de exportación son desarrollados por varios agente que operan en Chile y conrepresentantes 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.




14 Clase

14.1 ObjetivosUsar y definir excepciones.

14.2 Conocimiento previoProgramación en java.

14.3 Manejo de excepcionesExiste una regla de oro en el mundo de la programación: en los programas ocurren errores.




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 delas 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ónCuando 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 elestado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algúncódigo para manejar el error.

En terminología java, crear una objeto exception y manejarlo por el sistema de ejecución se llamalanzar una excepción.

14.5 Captura una excepciónDespués de que un método lance una excepción, el sistema de ejecución entra en acción para buscar elmanejador de la excepción.

Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es elmismo que el de la excepción manejada por el manejador. Así la excepción sube sobre la pila de llamadashasta que encuentra el manejador apropiado y una de las llamadas a métodos maneja la excepción, se diceque 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 sinencontrar el manejador de excepción adecuado, el sistema de ejecución finaliza (y consecuentemente elprograma Java también).




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 bloquecatch, una excepción del tipo “ArrayIndexOutOfBoundsException”, que verifica que el arreglosaludos[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, unaexcepció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 seejecutará.

14.6 Exception - Throwable




Las excepciones en tiempo de ejecución son heredadas desde la clase RuntimeException, las cuales soncapturadas 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 aotros 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, ceroelevado 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 mensajede detalle especificado y la causa

• Exception(Throwable cause)

Métodos de Exception:

• No tiene métodos asociados




Constructores de Throwable

• Throwable()

• Throwable(String message): Construye un nuevo Throwable con el mensaje de detalleespecificado

• Throwable(String message, Throwable cause): Construye un nuevo Throwable con el mensajede 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 detenidoy el hilo no captura esta excepción

• LinkageError : Se produce cuando, por ejemplo, existe incompatibilidad entre clases o el intento decrear un objeto en una clase inexistente

• VirtualMachineError : hay 4 subclases de esta clase que capturan errores catastróficos que puedenocurrir 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 tryproporcioná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 cualquierade 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, entoncescuando el control pase al bloque finally éste también podría lanzar una excepción, en cuyo caso seperderá la primera excepción.


Error

ThreadDeath LinkageError VirtualMachineError



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 throwLa sentencia throw se utiliza para lanzar explícitamente una excepción de tipo Throwable, bien medianteun 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 sussubclases; 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á unaacció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 );

}}




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 Exceptione.printStackTrace();

}}

}

14.10 throwsLista las excepciones que un método puede lanzar. Las excepciones que un método lanza explícitamente oque son lanzadas por métodos invocados por este, deben ser listadas en throws. Para que un método enJava, pueda lanzar excepciones, hay que indicarlo expresamente.

void metodoAsesino() throws NullPointerException, CaidaException

14.11 Ejemplos





CompilaOK

NOEjecuta

NOEjecuta



Indicar que se va a imprimir:




Va a imprimir:


A. 1

B. 1

3

A. 1

4

D. 1

3

4

A. 12

3

4

F. No hay error



Para el caso anterior el Netbeans muestra:




Para el caso anterior el Netbeans muestra




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 defectoheredan 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)




15 Clase

15.1 ObjetivosUso de colecciones y en particular las clase ArrayList.

15.2 Conocimiento previoConceptos de orientación a objetos y encapsulación de datos.

15.3 ColeccionesJava 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 eincorpora (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 largodel 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 asignadopor java el sobrepasado (o hay indicios de que el espacio almacenado no será suficiente) entonces javadesarrolla 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 objetosprivate 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 almacenadospublic ArrayList getDat() {

return dat;

}




//Permite almacenar objetos con datos de la clase Estudiantepublic 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 losdatos lo que hacemos es devolver el nombre del objeto de la colección. Para este ejemplo, lo quese debe devolver es dat.

15.4 Iterator Interfaz que se usa, por lo general, para mostrar elementos uno a uno.




15.5 CollectionInterfaz que define los métodos básicos para el manejo de estructuras de datos. Es la interfaz raíz dentrodel manejo de colecciones.

15.6 ListLa 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.




15.7 ArrayListClase que implementa los métodos de la interfaz List. No tiene ningún método sincronizado (excepto set yget). Por lo tanto, acepta el acceso concurrente a los métodos. De esta manera, desde diversos hilos sepuede 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());}}

}




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 claseEstudiante o = new Estudiante();//Almacena datos en el ArryListo.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 ArrayListSystem.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 EdadSystem.out.println("Incorporación: " + e.getincorpora()); //Muestra incorporaciónSystem.out.println();

}}

}

15.8 SetNo 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 yaexistente 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 laque no importe el orden, pero que necesitemos preguntar si un elemento está o no.




15.9 HashSetImplementa los métodos de la interfaz Set. Usa una tabla de hash. Los elementos no se encuentranordenados y pueden variar su posición de acuerdo al proceso de balanceo de la estructura que desarrolle latabla 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 xya está, habrá que saber si está en esa tabla. ¿En qué posición de la tabla está? HashSet puede saberlo, yaque para un objeto determinado, el hash siempre va a tener el mismo valor. Entonces la función contains deHashSet saca el hash del objeto que le pasan y va con eso a la tabla. En la posición de la tabla hay una listade 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); }

}




package view;import bean.Producto;import java.util.Iterator;

public class MuestraHash {


//Objeto que maneja los elementos de la claseProducto 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 ingresaProducto o1 = new Producto("Leche",19);o.setDat(o1); /Si lo ingresao.setDat(o1); //Esto no lo ingresa

//Muestra la cantidad de objetos almacenados en el HashSetSystem.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 nombreSystem.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidadSystem.out.println();

}}

}

Considerar la siguiente modificación el código anterior.


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 ingresaProducto o1 = new Producto("Leche",19);

o.setDat(o1); //Si lo ingresao.setDat(o1); //Esto no lo ingresaProducto o2 = new Producto("Leche",19);o.setDat(o2); //Si lo ingresa

//Muestra la cantidad de objetos almacenados en el HashSetSystem.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 nombreSystem.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidadSystem.out.println();

}

}}




Observar que el orden no necesariamente es el mismo para los mismos datos.

15.10 TreeSetImplementa 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, locual puede diferir de equals.

TreeSet usa una técnica completamente diferente a la explicada para HashSet. Construye un árbolcon los objetos que se van agregando al conjunto. Un árbol es una forma en computación de tener unconjunto de cosas todo el tiempo en orden, y permitir que se agreguen más cosas y que el orden semantenga. 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 ordennatural de ellos. Una desventaja es que mantener todo ordenado tiene un costo, y esta clase es un pocomenos eficiente que HashSet.

En el siguiente ejemplo, se crea la clase Productos con los atributos nombre y cantidad la cual debeimplementar la interface Comparable que te exige dar implementación al método comparateTo que tiene elcódigo para distinguir entre un objeto y otro de la clase Productos. En este ejemplo la diferencia se le haindicado que sea desarrollada por el nombre.




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 TreeSet getDat() {return dat;}

public void setDat(Productos dat) {this.dat.add(dat);

}

@Overridepublic 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;

}

@Overridepublic 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

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 {


//Objeto que maneja los elementos de la claseProductos o = new Productos();//Almacena datos en el TreeSeto.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 ingresaProductos o1 = new Productos("Leche",19);o.setDat(o1); //No lo ingresao.setDat(o1); //No lo ingresaProductos o2 = new Productos("Arveja",19);o.setDat(o2); //Si lo ingresa//Muestra la cantidad de objetos almacenados en el TreeSetSystem.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 nombreSystem.out.println("Cantidad: " + e.getCantidad()); //Muestra cantidadSystem.out.println();

}}

}




16 Clase

16.1 ObjetivosUso de colecciones y en particular las clase ArrayList y Vector.


16.3 MapDeclara métodos que permiten manejar elementos como para clave valor sin permitir claves duplicadas.


MÉTODOvoid clear()

Elimina todos los elementos boolean containsKey(Object key)

Retorna true si se tiene un elemento para la claveindicada.

boolean containsValue(Object value) Retorna true si se tiene uno o más elementospara 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 nullsi 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 clavevalor

Set setKey()Retorna el conjunto de claves de la lista. Con estemétodo no se obtiene la lista por elemento sinoque 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). Coneste método no se obtiene la lista por elementosino que completa



16.4 HashMapImplementa los métodos declarados en la interfaz Map, que permiten manejar elementos como para clavevalor sin permitir claves duplicadas. Permite valores NULL como claves y valor. No garantiza el orden de loselementos 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 HashMap getDat() {return dat;

}

public void setDat(int corr, Articulos dat) {this.dat.put(corr, dat);

}}




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 HashMapSystem.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 nombreSystem.out.println("Cantidad: " + ee.getCantidad()); //Muestra cantidadSystem.out.println();

}

}}




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 TreeSetSystem.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 claveArticulos ee = (Articulos)e.getValue();System.out.println("Producto: " + ee.getNombre()); //Muestra nombreSystem.out.println("Cantidad: " + ee.getCantidad()); / /Muestra cantidadSystem.out.println();

}

}}




16.5 TreeMapImplementa los métodos declarados en la interfaz Map, que permiten manejar elementos como para clavevalor sin permitir claves duplicadas. Permite valores NULL como claves y valor. Ordena los elementosascendentemente 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 TreeMap getDat() {return dat;

}

public void setDat(String clave, Articulo dat) {this.dat.put(clave, dat);

}}




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 TreeMapSystem.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 nombreSystem.out.println("Cantidad: " + ee.getCantidad()); //Muestra cantidadSystem.out.println();

}}

}




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ánsincronizados. Esto redunda en un mayor costo de proceso pues debe monitorearse permanentemente losbloqueos.

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();


METODOVector()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 ydesplaza 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 10Desarrollar un programa java que sea capaz de generar números aleatorios enteros entre 1 y 100 yalmacenarlos 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 20valores 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 (sieste existe).

• Crear un método que reciba un ArrayList y lo almacene en un TreeSet y muestre su información. Elmétodo debe concatenar la información que llega en el TreeSet.




17 Clase

17.1 ObjetivosDesarrollar la evaluación 4. Valor 12.5% de la nota 2.

17.2 Conocimiento previoContenidos de las clases 16, 17 y 18

17.3 Modelos de evaluación 4Ejercicio 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());




}}

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 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 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 static void main(String[] args) {A o = null;int a = 10;if(a > 10)

o=new A(12);else

System.out.println(o.getVal());}




}

Caso 7:

package view;


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 unacolecció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 losalmacene 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());}




}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 debealmacenar ordenada por rut el cual para cada trabajador en único. La información del trabajador es el rut yel nombre con información inicial:

Rut Nombre

14000000 Juan Perez Ubilla

14500000 Carla Barrera Perez

14200000 Julio Hernan Cardenas Baeza14300000 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 nombrepor 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");




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);}

}}

}




18 Clase

18.1 ObjetivosUso de las colecciones genéricas.

18.2 Conocimiento previoManejo de colecciones no genéricas.

18.3 Colecciones GenéricasConsideremos 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, sise 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(". . ."));




18.4 Ejemplo de usoConsideremos el siguiente código:

Compilación no presenta problemas:

Consideremos ahora el siguiente código:

Nuevamente la compilación no presenta problemas:




Consideremos ahora el siguiente código. Netbeans nos a marcado de inmediato el error en tiempo decompilació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áticamentela capacidad.

• Para indicarle que el aumento sea de 10 objetos podemos definir




Veamos como almacenar un arreglo en una colección genérica y luego desde la colección mostrar susdatos.

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 mostradofor(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 desincronización: Si varios hilos de acceder a un ArrayList ejemplo simultánea, y al menos uno de loshilos modifica estructuralmente la lista, debe ser sincronizado externamente.

• Una aplicación puede aumentar la capacidad de un ArrayList directamente usando el métodoensureCapacity.

18.7.1 addPermite asociar valores a un objeto de un ArrayList.




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 ArrayList<Trabajador> getDatos() {return a;

}

public void setDatos(Trabajador a) {this.a.add(a);

}

}




package view;import bean.Trabajador;import java.util.Iterator;

public class Generico02 {


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 nombreSystem.out.println("Cantidad: " + e.getEdad()); //Muestra edadSystem.out.println();

}

}}

18.7.2 clear Elimina los datos referenciados por un objeto de un ArrayList. Su uso es relevante cuando, por ejemplo, sedeben enviar datos para la construcción de un listado con información; en este caso, se deben limpiar losdatos referenciados por el objeto ArrayList cada vez que se requiere ver nueva información.

18.7.3 contains removeLa 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.


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); }




@Overridepublic 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;

}

@Overridepublic 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.



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 existet.getDatos().remove(new Trabajador("Pedro",42)); //Elimina el objeto

}


}

}}




Considerar este caso en el cual hay dos valores en la lista de los que se necesitan eliminar. Así, sólo seeliminará el primero que encuentre.



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 existet.getDatos().remove(new Trabajador("Pedro",42)); //elimina el objeto

}


}}

}

18.7.4 sizeRetorna 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.


public final class Trabajador implements Comparable{ //El mismo código de la clase anterior ….

}




package view;import bean.Trabajador;


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 getBusca valores dentro de una lista según el índice que se indique.


public final class Trabajador{ //El mismo código de la clase anterior ….

}



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 datosSystem.out.println("Producto: " + e.getNombre()); //Muestra nombreSystem.out.println("Cantidad: " + e.getEdad()); //Muestra edadSystem.out.println();

}

}}




18.7.8 setReemplaza un valor en una posición.


public final class Trabajador{ //El mismo código de la clase anterior ….

}


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 nombreSystem.out.println("Cantidad: " + e.getEdad()); //Muestra edadSystem.out.println();

}}

}

18.8 Iterable<>Esta interfaz contiene un sólo método y se usa para recorrer datos asiendo uso de Iterator<>.




18.9 CollectionEs una interfaz que hereda desde la interfaz Iterable<>.




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




18.12 Map<,>Es una interfaz que no permite claves duplicadas.

18.13 Implementación




19 Clase

19.1 ObjetivosUso de base de datos con Java.

19.2 Conocimiento previoUso de colecciones genéricas

19.3 SQLEn un lenguaje de programación creado para ejecutar consultas a base de datos.

19.3.1 TablaEstructura física que define la forma mediante la cual se almacenarán los datos. Por ejemplo, sinecesitamos 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 MySqlVamos a emplear el MySql 5.x como motor de base de datos. Este se debe bajar desde:

http://www.mysql.com/downloads/mysql/




Para instalar el Motor seguir los siguientes pasos una vez que se ha bajado el archivo indicado.

Paso 1: Seleccionar Next.




Paso 2: Aceptar y seleccionar Next.

Paso 3: Seleccionar Complete:




Paso 4: Seleccionar Install

Paso 5: Seleccionar Next




Paso 6: Seleccionar Next

Paso 7: Seleccionar Finish




Paso 8: Seleccionar Next.

Paso 9: Seleccionar Standard Configuration y luego Next.




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 usaremoscomo password “root”.




Paso 12: Seleccionar execute.

19.3.3 PKEs el identificador de unicidad de cada registro de la tabla. Por ejemplo, para trabajadores de una empresanacional podría ser el rut, el cual identifica de manera única a cada trabajador.

19.3.4 Crear tablaCrear 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)




Para ejecutar este proceso en mysql se debe ingresar a la consola que no solicitará la password que leindicamos.

Luego se debe crear la base de datos. En este caso el nombre será dgac.




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 insertUsar 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);




Esta instrucción tiene por obligación “insert into”, luego entre paréntesis los campos a los cuales se lenecesita ingresar datos, enseguida la palabra “values” para finalizar entre paréntesis con los datosasociados en una relación 1-1 con el nombre de los campos.

19.3.6 updateEsta 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=50where rut='14200000';

19.3.7 deleteEsta 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 selectDa 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;




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 JDBCJava Database Connectivity, más conocida por sus siglas JDBC, es una API que permite la ejecución deoperaciones sobre bases de datos desde el lenguaje de programación Java, independientemente delsistema operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto SQL delmodelo 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 demanejadores de conexión hacia cada modelo específico de base de datos. Un manejador de conexioneshacia un modelo de base de datos en particular es un conjunto de clases que implementan las interfacesJava 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 labiblioteca de conexión apropiada al modelo de su base de datos, y accede a ella estableciendo unaconexión, para ello provee el localizador a la base de datos y los parámetros de conexión específicos. Apartir 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 procedimientosalmacenados en la base de datos, etc.

La especificación se encuentra en:

http://java.sun.com/javase/6/docs/technotes/guides/jdbc/




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 generalUn objeto Connection representa una conexión con una base de datos. Una sesión de conexión incluye lasinstrucciones SQL que se ejecutan y los resultados que se devuelven en la conexión. Una sola aplicaciónpuede tener una o más conexiones con una sola base de datos, o puede tener conexiones con muchasbases de datos diferentes.

19.7 Establecer una conexiónLa 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. Laclase DriverManager conocida como la capa de gestión de JDBC, intenta localizar un controlador que puedeconectarse a la base de datos correspondiente a dicha URL. La clase DriverManager mantiene una lista declases Driver registrados, y cuando el getConnection método se llama, comprueba con cada conductor en lalista hasta que encuentre uno que pueda conectarse a la base de datos especificada en la URL. El métodode 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 sepuede utilizar para producir objetos Connection que participan en la agrupación de conexiones y / o objetosConnection que pueden participar en transacciones distribuidas. DataSource es la alternativa preferida parala creación de una conexión.

Una aplicación utiliza un objeto Connection producido por DataSource de manera esencialmente esla misma que utiliza un objeto Connection producido por el DriverManager.

19.8 Liberación DBMS RecursosSe recomienda que los programadores de cerrar explícitamente las conexiones y las declaraciones que hancreado cuando ya no son necesarios.

Un programador de escribir código en el lenguaje de programación Java y que no utilice ninguna derecursos externos, no necesita preocuparse por la gestión de memoria. El recolector de basura eliminaautomáticamente los objetos cuando ya no se utiliza y libera la memoria que se utiliza. Cuando la memoriase está agotando, se reciclan los objetos desechados, haciendo que la memoria que ocupan actualmentedisponible para la reutilización rápida.

Sin embargo, si una aplicación utiliza los recursos externos, como lo hace cuando tiene acceso a unMotor de Base de Datos con la API de JDBC, el recolector de basura no tiene manera de conocer el estadode esos recursos. Por lo tanto, se recomienda que los programadores explícitamente cerrar todas lasconexiones (con el método Connection.close y declaraciones con el método Statement.close) tan prontocomo ya no son necesarios.




19.9 Crear una conexiónPara 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 dgacprivate 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 datosreturn url;

}

public static String getUser() { //Retorna el usuario de conexión a la base de datosreturn user;

}

public static String getPass() { //Retorna el password del usuario de conexión a la base de datosreturn pass;

}}

19.10 Insertar datosDesde 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:




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:




Crear la clase ConexionDB en la package conec:

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




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 procesoString 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) { }

}}




19.11 Driver de ConexiónPara ejecutar el código correctamente es necesario instalar el Driver de conexión de MySQL que se bajadesde :

http://www.mysql.com/downloads/connector/j/

Copiar el Driver dentro dela carpeta del proyecto:

Luego instalarlo para que sea reconocido por NetBeans:




Se tiene:

Después de ejecutar el proceso se tiene:





Uso de componentes básicos de Swings, validaciones y mensajes de cuadros de diálogos.

20.2 Conocimiento previoUso de métodos y colecciones.

20.3 JTextFieldPermite 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 ingresadoJOptionPane.showMessageDialog(null, valor);}




20.4 toolTipTextPermite emitir un mensaje al posición el mouse sobre el objeto al que se le ha asociado la propiedad. Parael ejemplo anterior, aplicaremos el mensaje al JTextField.

20.5 matchesLas 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 datosesté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 unobjeto 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.




[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");}

}




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){



}

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){



}




Validar que una entrada sólo sean sólo letras (no soporte espacios en blanco, ni la letra ñ, ni letrasacentuadas).

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {String val = this.jTextField1.getText();if(val.matches("[a-zA-Z]*") && val.length()>0){



}




Usando el patrón ( “[A-Z][a-zA-Z]*”) en este caso le estamos diciendo que la entrada para ser valida debetener 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 siguientescaracteres van a ser iguales a la expresión previamente indicada, ósea la expresión que esta entrecorchetes 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){



}




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){



}




20.6 JSlider Permiten seleccionar una opción dentro de un aspecto continuo de valores. En Netbeans se maneja con elcomponente:

Considerar la configuración

Se genera el siguiente componente:




Si se necesita que el componente se deslice sólo por los valores, entonces se debe anexar la propiedadsnapToTicks.

También se pueden generar secuencias con otros elementos como letras. Para esto se debe incluir elsiguiente método en el constructor del JFrame, lo cual define las letras y el valor numérico asociadosprivate 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.




Sus constructores son:

Considerar el siguiente formulario:

Para recuperar los valores:




20.7 JListUn 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);




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 laopció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 delbotón es:private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

Object[] valores = jList1.getSelectedValues(); //Recupera los valores seleccionados en JListObject[][] 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;

}}




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 otrosen donde en el segundo JList los datos deben salir ordenados.




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 ordenadospublic 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 setListDataVector<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);}




Ejemplo: Crear un JList que al seleccionar un color de su lista cambie automáticamente el color del objetode 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);}




20.8 Cuadro de diálogoLa 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);




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




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.




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 cadenaprimerNumero = JOptionPane.showInputDialog("Escriba el primer entero:");

// recibir el segundo numero del usuario como una cadenasegundoNumero = JOptionPane.showInputDialog("Escriba el segundo entero :");

// convertir los numeros de tipo String a tipo intnumero1 = 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 resultadosJOptionPane.showMessageDialog(null,

resultado,"Resultados de la comparación",

JOptionPane.INFORMATION_MESSAGE);}




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");}

}




21 Clase

21.1 Objetivos

Desarrollar el trabajo 1. Valor 12.5% de la nota 3.

21.2 Conocimiento previoContenidos del semestre.

21.3 Modelos de evaluación 5Observaciones:

• 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 unaventana 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 queindique 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 cursivatahoma. (10 puntos)

Si el código del cliente existe en la base de datos, entonces el registro no se deben almacenar y se muestrauna 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 letrasminúsculas. Si no cumple esta condición el registro no se debe almacenar y se mostrará una ventana con elerror. (20 puntos)





Uso de componentes Swings.

22.2 Conocimiento previoUso de métodos y colecciones.

22.3 JFormattedTextFieldNo es más que una extensión de JTextField que viene a cubrir algunas de las deficiencias que todosencontrá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 laaplicació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 demostrar un texto con un formato concreto. No hay posibilidad de establecer un control sobre lo que elusuario 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 ypor último 4 números. El formato debe ser: “###-####”. En Netbeans se debe configurar en la propiedad




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 losmá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 usadosson:

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.




• 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:




22.4 PasswordField - Separator El primer componete permite el ingreso de información, el segundo permite el ingreso de texto que se usapara validar el password de un usuario al ingresar al sistema, el tercero permite usar una línea deseparació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#1234if(usuario.equals("JPerez") && analizaPass(pass)){

JOptionPane.showMessageDialog(null,"Ingreso correcto");}else{

JOptionPane.showMessageDialog(null,"Error");}}

//Analizar la password Juan#1234boolean 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;}




22.5 JRadioButtonSirve para manjar una elección desde varias opciones. Para manejar desde Netbeans usamos elcomponente.

Además, se debe acompañar del componente JbuttonGroup que permite agrupar un conjunto decomponentes 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.




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, parapoder verlo se debe usar el Inspector.




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);}




22.6 CheckBoxEste 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:




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);}




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ásusados son:

• getValue(): Permite recuperar el valor seleccionado.

Seleccionar 3 JLabel, 3 JSpinner y un JButton.




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.




Seleccionar el tercer JSpinner, marcar su propiedad Model y proporcionar el siguiente formato.

El formato definitivo es:




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();




val3 = this.jSpinner3.getValue();

Object[] mensaje = {"Selección:",this.jLabel1.getText()+" :"+val1,this.jLabel2.getText()+" :"+val2,this.jLabel3.getText()+" :"+val3};

JOptionPane.showMessageDialog(null,mensaje);}




22.8 JTabbedPaneCon 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 delcomponente 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:




Para conseguir las pestañas se debe agregar JPanel al JTabbedPane

Resultado:




Agregar otro JPanel

Resultado




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 deellas

Observar que el Jpanel1 sebe estar seleccionado para que lo anterior se pueda apreciar:




De la misma forma las pestañas siguientes marcarlas como Ingreso, Eliminación y Actualización con unmensaje apropiado al posarse sobre ellas.

También se les puede agregar un icono a las pestañas en la opción:




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.




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; }

}




La clase Alumno para empaquetar los datospackage 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);

}}




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 JTabbedPanepublic Pruebas() {

initComponents();this.jLabel3.setVisible(false);actualizaTabla();

}




El resultado es:

Observar que si se ingresa un nuevo valor en la pestaña de “Ingreso” la pestaña “Ver” no se actualiza. Paralograr la actualización se debe activar el siguiente método:

private void jTabbedPane1StateChanged(javax.swing.event.ChangeEvent evt) {actualizaTabla();

}

Se ingresar un nuevo dato




Nos cambiamos de pestaña y está el registro ingresado:




23 Clase

23.1 ObjetivosMostrar datos usando JTable.

23.2 Conocimiento previoConexió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 decada 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ásmétodos o recursos de la clase.

Los constructores son:


http://www.java2s.com/Tutorial/Java/0240__Swing/publicJTableVectorrowDataVectorcolumnNames.htm

http://www.magusoft.net/neotrials/pages/start.html


http://www.java2s.com/Tutorial/Java/0240__Swing/publicJTableVectorrowDataVectorcolumnNames.htm




Vamos a considerar en Netbeans la siguiente situación:

Para eliminar las columnas y filas usamos la propiedad “model”




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);

}




En el caso de usar Vector no se puede asignar al Jtable un tipo de dato comoPersona(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. Sepretende esto:




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));




insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'JuanPerez',24,false,1.67,'2000-12-01',4);insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (3,'JuanitaPerez',33,true,1.77,'2000-11-01',1);insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (2,'EstebanPerez',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,'PedroPerez',47,false,1.80,'2000-09-01',2);insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (1,'JonasPerez',55,false,1.77,'2000-12-01',3);insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (5,'SofiaPerez',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,'LeandroPerez',36,false,1.80,'2000-11-01',1);insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (4,'CarlitaPerez',30,true,1.67,'2000-09-01',5);

insert into trabajador (id_dpto,nombre_trab, edad , sexo, estatura, ingreso, id_pais) values (3,'AnibalPerez',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+"'";




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");


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{

}}




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");





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{

}}




24 Clase

24.1 ObjetivosDesarrollar el trabajo 2. Valor 12.5% de la nota 3.

Desarrollar el trabajo 3. Valor 15% de la nota 4.

24.2 Conocimiento previoContenidos del semestre.

24.3 Evaluación 6Observaciones:

• 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 1En una pestaña crear una opción que permita ingresar datos. No se debe validar nada.

(20 puntos)

Proceso 2En 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 seselecciona 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)




Proceso 3En 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 objetosgráficos de la pestaña de ingreso de clientes. Además, si en esta pestaña se selecciona otro código delComboBox, 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 4Se deben mostrar los datos del clientes usando un JTable.

(10 puntos)

Proceso 5Cada vez que se produce un ingreso de cliente y se produce un cambio de pestaña, entonces los datosdeben reflejar esos cambios.

(10 puntos)

24.4 Evaluación 7Observaciones

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');




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));

ProblemaSe le ha solicitado desarrollar un programa java que sea capaz de manejar documentos que son enviados adiversos 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 debepedir el número del documento y mediante un botón se muestran los datos en un JTable.

(30 puntos)




25 Clase

25.1 ObjetivosUso de colecciones y en particular las clase ArrayList y Vector.


25.3 JMenuSeleccionar:

Va a generar:




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:




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:




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:




Vamos a agregar un nueva opción de menú:

Vamos a agregar dos radiobuttom

Vamos a agregar un separador

Vamos a agregar tres checkbox




Se debe agrupar los radio buttom

Marcar ambos radiobuttom y agregar al agrupamiento

Se tiene:




25.4 JTreeSeleccionar:

Se tiene:




Al ejecutarlo se tiene:

Los componentes del árbol se manejan el la propiedad "model"




Generar la siguiente estructura. Considera que un espacio genera un opción dentro de otra.

Se obtiene:




Como ejemplo de aplicación vamos generar el siguiente formulario

Se tiene:




Lanzar un JTree en el lateral izquierdo:

Generar la siguiente estructura:




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:




Vamos a desarrollar un mantenedor con el uso de JTree. Para los formularios se deben usar JPanel. Vamosa Crear los siguientes paneles:




El formulario es:

Tiene las opciones:




El código asociado al primer Jpanel es una variable tipo Vector static para que los datos ingresados desdeeste formulario sean accesibles desde otros formularios

El código asociado al botón de ingreso de datos es:




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”:




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 void setRut(String rut) {

this.rut = rut;}

public int getEdad() {return edad;

}


}}

En la ejecución se tiene:




25.5 JScrollPaneCuando un componente ocupa mucho espacio en pantalla o contiene mucha información, un JScrollPanepermite asociarle una pequeña vista o ventana deslizable o corrediza que permite solo que se vea una partede dicho componente.

Lanzar un componente JScrollPane:

Luego dentro de el, lanzar un JPanel.

Genera algo similar a lo siguiente:




Al agregar algunos componentes se puede tener lo siguiente:




26 Adicionales

26.1 ObjetivosUsar métodos para el manejo de fechas y horas.


26.3 DateRepresenta un momento específico en el tiempo, con precisión de milisegundos. La mayoría de susmétodos están desaprobados. El siguiente código entrega la fecha y hora actual.

package view;import java.util.Date;


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 enteroscomo YEAR , MONTH , DAY , HOUR , y así sucesivamente. Calendar interpretar una Date de acuerdo a lasreglas 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 claseCalendar 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=0y que el día de la semana (que es lunes) es 2.

package view;import java.util.Calendar;


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));

}}




En el siguiente ejemplo sea definido una fecha con hora en duro. Observar que para saber la hora se debeusar AM_PM que es 0 si el horario es AM y 1 si el horario es PM



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;


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;


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);




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ólodiferencia los valores indicados sin considerar los años.



Calendar dat1 = Calendar.getInstance();dat1.set(2005, 10, 20, 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.




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"); }




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 SimpleDateFormatPermite 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ónregional de EE.UU.. La fecha determinada y el tiempo son 07/04/2001 12:08:56 hora local en la zona delPací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.




Ejercicio 1

En una empresa dedicada a la producción de software se necesita controlar las horas de llegadas de lostrabajadores 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 8trabajadores. Para esto usted debe suponer los valores de tipo double en donde, por ejemplo, las08: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 semanade datos.




27 Adicionales 1

27.1 ObjetivosFormatear datos considerando la región.

27.2 Conocimiento previoUso de métodos en Java.

27.3 FormatEs una clase abstracta para dar formato a fechas, mensajes y números. Puede analizar si la información essensible a la localidad.

Las subclases DateFormat, MessageFormat, y NumberFormat formatean, respectivamente fechas,mensajes y números.

27.4 LocateUn objeto de la clase Locale representa una región geográfica específica, política o cultural. Una operaciónque requiere una configuración regional para llevar a cabo su tarea se llama sensible a la localidad y utilizala configuración regional de adaptar la información para el usuario. Por ejemplo, mostrando un número esuna operación sensible a la localidad - el número debe tener un formato acorde a las costumbres yconvenios 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 dedos y de tres letras para la mayoría de lenguas del mundo. La configuración regional de java utiliza loscódigos de dos letras para identificar el idioma de destino. Ver: http://www.loc.gov/standards/iso639-2/php/code_list.php




El argumento país son Código ISO. Estos códigos son las mayúsculas, los códigos de dos letras definidopor 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 USrepresentan a Canadá y los Estados Unidos, respectivamente: La última línea de código anterior muestracómo crear una configuración local con una variante opcional: SiliconValley. Esto es más específica que laprimera instancia. No sólo es la configuración regional de un EE.UU. que hablan Inglés, pero también seasocia con una variante adicional, SiliconValley. Debido a que uno de sus propósitos es proporcionar a losdesarrolladores la capacidad de definir escenarios personalizados, la variante puede ser cualquier cosa queusted 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 dehabla 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 idiomasreconocidos.

Por ejemplo, para obtener la compatibilidad de la clase NumberFormat:

Locale[] localeList = NumberFormat.getAvailableLocales();




Para conocer la configuración se tiene:

package view;import java.util.Locale;

public class Formato12 {


System.out.println(Locale.getDefault());}

}

Observar que depende de la configuración del equipo.




27.5 MessageFormatProporciona un medio para producir mensajes concatenados en forma independiente del idioma. Utilice estaopción para construir mensajes que aparecen para los usuarios finales. MessageFormat toma un conjuntode objetos, les da formato, a continuación, inserta las cadenas de formato en el patrón en los lugaresadecuados.

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 static void main(String[] args) {int numeroErrores = 20;//Sin MessageFormatString mensaje1 = "se han encontrado " + numeroErrores + " errores";

//Con MessageFormatString 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 lacomilla doble (“) le anteponemos \.

package view;import java.text.MessageFormat;


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 ChoiceFormatUn ChoiceFormat le permite adjuntar un formato a un rango de números. Se utiliza generalmente en unMessageFormat para el manejo de los plurales. Al crear un ChoiceFormat, debe especificar una serie deformatos 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 valoresmás pequeños o más grandes.




package view;import java.text.ChoiceFormat;


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 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=fileFormform.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;



Object[] params = new Object[]{new Integer(123), new Integer(1234),new Integer(12345), new Integer(123456)};




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 enterosmsg = MessageFormat.format("There are {0,number,#} a''s and {1,number,#} b''s", params);

System.out.println(msg); //Números decimalesparams = 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);

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

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

}}




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 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);

}

}




27.7 NumberFormatNumberFormat es la clase base abstracta para todos los formatos de número. Esta clase proporciona lainterfaz 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úndecimal.

27.8 DecimalFormatDecimalFormat es una subclase concreta de NumberFormat que da formato a los números decimales. Tieneuna variedad de características diseñadas para permitir a los números de analizar y dar formato encualquier lugar, incluido el apoyo a Occidente, el árabe, y los dígitos índicos. También es compatible condiferentes tipos de números, incluyendo números enteros (123), números de punto fijo (123.4), la notacióncientí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 demostrar los números debemos usar una función que nos permita redondear estos en el formato adecuadode 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 static void main(String[] args) {//Región: se usa la , para separador de miles y el . para decimalesLocale.setDefault(Locale.CANADA);

//El símbolo 0 muestra un cero cuando no exista un dígito//Notar que el número se ha redondeadoNumberFormat formatter = new DecimalFormat("000000");String s = formatter.format(-1234.567); // -001235System.out.println("000000 : " + s);

//El simbolo # muestra un digito nada sino existe un digitoformatter = new DecimalFormat("##");

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




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

//El simbolo . muestra el punto decimalformatter = new DecimalFormat(".00");

s = formatter.format(-.567); // -.57System.out.println(".00 : " + s);

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

formatter = new DecimalFormat("#.#");s = formatter.format(-1234.567); // -1234.6System.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.567System.out.println(".###### : " + s);

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

//El simbolo , se usa para agrupar numerosformatter = new DecimalFormat("#,###,###");s = formatter.format(-1234.567); // -1,235

System.out.println("#,###,### : " + s); s = formatter.format(-1231231234567.890); // -1,231,231,234,568System.out.println("#,###,### : " + s);

}}




Para:

Locale.setDefault(Locale.ITALIAN);

package view;import java.text.DecimalFormat;import java.text.NumberFormat;

import java.text.ParseException;import java.util.Locale;


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}




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




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.56inglé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




español (Costa Rica): #,##0.### -> -1,234.56 -> -1234.56

español (Chile): #,##0.### -> -1.234,56 -> -1234.56

….......

27.9 DateFormatDateFormat 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 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: MEDIUMs = DateFormat.getDateInstance().format(date);

System.out.println("Valores por defecto: " + s);// Valores por defecto: MEDIUMs = DateFormat.getDateInstance(DateFormat.DEFAULT).format(date);System.out.println("Valores por defecto: " + s);

// Parsetry {

date = DateFormat.getDateInstance(DateFormat.DEFAULT).parse("25-02-2011");System.out.println("parse: " + date);

} catch (ParseException e) { System.out.println("Error"); }

}

}




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 SimpleDateFormatSimpleDateFormat 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, esLocale.ENGLISH). Si el ejemplo se ejecuta en una localidad diferente, el texto (por ejemplo, nombres de losmeses) 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 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.




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 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 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.");}

}}




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 static void main(String[] args) throws ParseException {//Fecha -> StringCalendar now = new GregorianCalendar();SimpleDateFormat name, standar;String nameFormat, standarFormat;

//Obtener la fecha actual en un calendarioDate nowDate = now.getTime();

//Definimos dos formatos para mostrar fechasname = 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);

}}




28 Adicionales 2

28.1 ObjetivosCaracterísticas adicionales de Java.

28.2 Conocimiento previoUso de métodos en Java.

28.3 Argumentos variablesJava permite pasar un número variable de argumentos a un método. Esto se consigue mediante laexpresió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 detipo 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 mainpublic static void main(String[] args)

El método main recibe un arreglo de String como único argumento. Este es un vector de cadenas decaracteres representa que los parámetros opcionales que le podemos pasar por la línea de comando.




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);}

}




29 Adicionales 3

29.1 Objetivos Analizar e implementar algoritmos de ordenación y búsqueda.

29.2 Conocimiento previoProgramación en java.

29.3 OrdenaciónLa ordenación o clasificación de datos (sort, en inglés) es una operación consistente en disponer unconjunto —estructura— de datos en algún determinado orden con respecto a uno de los campos deelementos del conjunto. Por ejemplo, cada elemento del conjunto de datos de una guía telefónica tiene uncampo nombre, un campo dirección y un campo número de teléfono; la guía telefónica está dispuesta enorden alfabético de nombres; los elementos numéricos se pueden ordenar en orden creciente o decrecientede 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 suelección. ¿Cómo se sabe cuál es el mejor algoritmo? La eficiencia es el factor que mide la calidad yrendimiento de un algoritmo. En el caso de la operación de ordenación, dos criterios se suelen seguir a lahora de decidir qué algoritmo —de entre los que resuelven la ordenación— es el más eficiente: 1) tiempomenor de ejecución en computadora; 2) menor número de instrucciones.

29.4 Algoritmo de la burbujaEn 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 elementoes mayor que el segundo elemento. Al final de cada pasada, el elemento mayor ha «burbujeado» hasta lacima de la sublista actual. Las etapas del algoritmo son:

El ejemplo siguiente ilustra elfuncionamiento del algoritmo de laburbuja con un array de 5 elementos A = (50, 20, 40, 80, 30), donde seintroduce una variable interruptor

para detectar si se ha producidointercambio en la pasada.




La codificación en C es:

29.5 algoritmo de ordenaciónEl algoritmo de ordenación tal vez más sencillo sea el denominado de intercambio que ordena los elementosde 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 cuandoel 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. Elalgoritmo realiza n − 1 pasadas (3 en el ejemplo), siendo n el número de elementos, y ejecuta las siguientesoperaciones.




El método ordIntercambio utiliza dos bucles anidados. Suponiendo que la lista es de tamaño n, el rango delbucle 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 queutiliza el algoritmo siguiente:

aux = a[i];

a[i] = a[j];

a[j]= aux ;

El algoritmo en C es:




29.6 Búsqueda en listasCon mucha frecuencia los programadores trabajan con grandes cantidades de datos almacenados en arraysy registros, y por ello será necesario determinar si un array contiene un valor que coincida con un ciertovalor clave. El proceso de encontrar un elemento específico de un array se denomina búsqueda. En estasecció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 secuencialLa búsqueda secuencial busca un elemento de una lista utilizando un valor destino llamado clave. En unabúsqueda secuencial (a veces llamada búsqueda lineal), los elementos de una lista o vector se exploran (seexaminan) en secuencia, uno después de otro. La búsqueda secuencial es necesaria, por ejemplo, si sedesea encontrar la persona cuyo número de teléfono es 958-220000 en un directorio o listado telefónico desu ciudad. Los directorios de teléfonos están organizados alfabéticamente por el nombre del abonado enlugar 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 elelemento a buscar pueda ser el primer elemento, el último elemento o cualquier otro. De promedio, almenos el programa tendrá que comparar la clave de búsqueda con la mitad de los elementos del array. Elmétodo de búsqueda lineal funcionará bien con arrays pequeños o no ordenados.

29.8 Búsqueda binariaSe sitúa la lectura en el centro de la lista y se comprueba si la clave coincide con el valor del elementocentral. Si no se encuentra el valor de la clave, se sigue la búsqueda uno en la mitad inferior o superior delelemento central de la lista. En general, si los datos de la lista están ordenados se puede utilizar esainformación para acortar el tiempo de búsqueda.




Codificación en C:

29.9 EjerciciosCodificar cada uno de los algoritmos en Java y desarrollar pruebas para datos de tipo numéricos y decaracteres, midiendo los tiempos de ejecución.




30 Adicionales 4

30.1 ObjetivosUso de casos de uso para la definición de requerimientos.

30.2 Conocimiento previoProgramación de sistemas.

30.3 Caso de usoUn caso de uso es una descripción de los pasos o las actividades que deberán realizarse para llevar acabo 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 sedesarrollarán entre un sistema y sus actores en respuesta a un evento que inicia un actor principal sobreel propio sistema.

Los diagramas de casos de uso sirven para especificar la comunicación y el comportamiento deun 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 entrelos elementos del modelo, por ejemplo la especialización y la generalización son relaciones. Los diagramasde casos de uso se utilizan para ilustrar los requerimientos del sistema al mostrar cómo reacciona a eventosque se producen en su ámbito o en él mismo.

Los más comunes para la captura de requisitos funcionales, especialmente con el desarrollo delparadigma de la programación orientada a objetos, donde se originaron, si bien puede utilizarse conresultados igualmente satisfactorios con otros paradigmas de programación.

30.4 Normas de aplicaciónLos 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 delsistema. Para la mayoría de proyectos de software, esto significa que quizás a veces es necesarioespecificar diez o centenares de casos de uso para definir completamente el nuevo sistema. El grado de laformalidad de un proyecto particular del software y de la etapa del proyecto influenciará el nivel del detallerequerido en cada caso de uso.

Los casos de uso pretenden ser herramientas simples para describir el comportamiento del softwareo de los sistemas. Un caso de uso contiene una descripción textual de todas las maneras que los actoresprevistos podrían trabajar con el software o el sistema. Los casos de uso no describen ningunafuncionalidad interna (oculta al exterior) del sistema, ni explican cómo se implementará. Simplementemuestran 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 lainiciará 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.




30.5 Plantilla no adecuada

30.6 Plantilla adecuada 1




30.7 Plantilla adecuada 2


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 enel 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 losdatos

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 ObjetivosTrabajo.

31.2 Conocimiento previoProgramación en java y manejo de swings.

31.3 Base de datosCrear 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 2GB320GB 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




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)




El diagrama relacional es:

Se necesita un sistema que sea capaz de manejar el stock de productos y las ventas de estos en una tiendacomerciales 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.

unidad i-metodologia de programacion

Documents