desarrollo de softwarevirtual.senati.edu.pe/curri/file_curri.php/curri/pdsd... · 2016-01-14 ·...

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

MANUAL DE APRENDIZAJE

CÓDIGO: 89001706

Profesional Técnico

DESARROLLO DE SOFTWARE II

DESARROLLO DE SOFTWARE

ÍNDICE

TAREA N° CONTENIDO N° PÁG.

I. ENFOQUE GENERAL DE LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO). 6

1.1. Programación orientada a objetos. 6 1.2. Clases, métodos y formas de creación de objetos. 7 1.3. Estados y comportamientos de una clase. 15 1.4. Diseñar componentes Swing básicos en la POO. 28

II. COMPONENTES BÁSICOS SWING. 48

2.1. Clases y tipos de métodos, ámbitos y atributos dentro de una aplicación Swing. 64

III. ALCANCE DE LA POO. 92 3.1. Invocación de métodos. 92 3.2. Constructores y sobrecarga. 96

IV. MIEMBROS DE CLASES. 104 4.1. Técnicas de abstracción. 104 4.2. Operador THIS. 112 4.3. Eventos de una aplicación GUI. 120

V. HERENCIA Y JERARQUÍA DE CLASES. 132 5.1. Diferencia entre el operador THIS y SUPER. 132 5.2. Herencia en la POO e implementa sobre escritura. 137

VI. INTERFACES. 151 6.1. Implementar interfaces. 151 6.2. Implementar métodos abstractos. 159 6.3. Implementar colección List <T> 163 6.4. Métodos de la clase ITERATOR. 181

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5

DESARROLLO DE SOFTWARE II I. ENFOQUE GENERAL DE LA PROGRAMACIÓN ORIENTADA A

OBJETOS (POO). En esta tarea comprende las siguientes operaciones:

Programación orientada a objetos. Clases, métodos y formas de creación de objetos. Estados y comportamientos de una clase. Diseñar componentes Swing básicos en la POO.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo ó de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web. ORDEN DE EJECUCIÓN: Programación Orientada a objetos. Clases, métodos y formas de creación de objetos. Estados y comportamientos de una clase. Diseñar componentes Swing básicos en la POO. 1.1. PROGRAMACIÓN ORIENTADA A OBJETOS. Si sabes algo sobre programación seguro que has oído hablar de lenguajes de programación orientados a objetos y Java no es la excepción. Pensar en objetos supone tener que cambiar nuestro enfoque para la solución de problemas de una manera distinta a como se ha hecho tradicionalmente. Entonces la primera pregunta sería: ¿Qué es un objeto?


DESARROLLO DE SOFTWARE II Bueno, vamos a usar un ejemplo bien sencillo para responder esta pregunta. Cualquier juego de construcción como los de Lego está formado por elementos Básicos (las piezas). Cada pieza, por sí sola, no tiene mucha utilidad, pero podemos juntarlas para construir lo que quisiéramos. Si podemos construir cosas es porque cada pieza trae una serie de rendijas que encajan en las de las demás. Así que tenemos una serie de objetos (las piezas) con una interfaz común (las rendijas) y que nos permiten realizar una construcción (el programa). Solo que, en este caso, la construcción no tendrá ninguna utilidad práctica, salvo ocupar espacio en la estantería de nuestra habitación, y que nuestras madres tengan un objeto más al que limpiar el polvo. Mediante este ejemplo ya podemos percibir algunas de las características de los objetos: • Realizan una tarea por sí solos. • Proporcionan encapsulación: Es posible ocultar las partes internas de la

implementación de un objeto, permitiendo el acceso sólo a través de una interfaz bien conocida y definida.

• Son reutilizables. • Proporcionan escalabilidad (el programa puede crecer) y modularidad (el

programa se puede dividir en bloques que faciliten su comprensión).

En Java ocurre lo mismo que en el ejemplo anterior. Programaremos una serie de objetos independientes con una funcionalidad determinada, y los juntaremos para crear un programa. Pero, para crear objetos, primero debemos hablar de las clases. 1.2. CLASES, MÉTODOS Y FORMAS DE CREACIÓN DE OBJETOS. Cuando creamos un programa en un lenguaje orientado a objetos, no estamos definiendo objetos, sino clases. Una clase es la unidad fundamental en programación (La pieza de Lego). El problema es que no existe, es una abstracción. Es como una plantilla que utilizaremos posteriormente para crear un conjunto de objetos con características similares.


DESARROLLO DE SOFTWARE II Bien entonces para poder entender vamos a utilizar el ejemplo de los carros, es el mejor ejemplo para definir una clase. Esta no tiene entidad física, porque hablamos de un carro en general, sin especificar de qué tipo de carro se trata, podemos asignarle un comportamiento y una serie de características.

A partir de esa clase Carro, podremos crear nuestros objetos (también llamados instancias), que serían las realizaciones “físicas” de la clase. En el ejemplo, se podrían mostrar las marcas como un Seat Panda, un Opel Corsa, y un Renault Megane. Todos ellos compartirían una serie de características comunes por las que podemos identificarlos como carros. Vemos en la figura que, respecto al comportamiento, podemos Encender y detener nuestro carro. Esos son los métodos de la clase. En cuanto a las características (llamadas atributos), tenemos las variables marca, color, y modelo.

Ejemplo1: Para definir nuestra clase en Java, lo haremos de la siguiente manera. [carro.java]

Nota: Los ejemplos para cada capítulo estarán agrupados por proyectos. 1. Crear el proyecto: “Capitulo1” en el IDE NetBeans



2. Crear la clase : [carro.java]



Digitar el siguiente Método:



Analicemos paso a paso cada parte de la clase:

• Las clases se definen con la palabra reservada class. Todo el código que pertenezca a esa clase se encierra entre dos llaves.

• Los nombres de las clases, por norma, comienzan con mayúscula. • A continuación tenemos tres atributos, definidos por las variables

estadoMotor, color y modelo. Los atributos nos definen las características que tendrá cada objeto de esa clase, y que podrán ser distintas para cada uno de ellos. Es decir, cada carro será de un modelo determinado, de un color, y su motor estará encendido o apagado. Por ahora no nos interesa que los tipos serán String o boolean.

• Por último, tenemos dos métodos, arrancar() y detener(). Los métodos nos definen el comportamiento que tendrán los objetos de esa clase. En nuestro ejemplo, podremos arrancar o detener el motor de nuestros carros.

Ejemplo2: Invocación de Variables y Métodos.

[invocarMetodos.java]

En este segundo ejemplo se explica que una clase, por sí sola, no puede ejecutarse. Para ello vamos a definir un método main que nos cree un objeto de esa clase, con el que podremos trabajar, o bien llamamos a un objeto de esa clase desde otro objeto perteneciente a otra clase. Vamos a coger el ejemplo de la clase carro del ejemplo anterior, y vamos a definir un método main donde podamos instanciar la clase:

1 public class invocarMetodos { 2 3 //Definir los atributos 4 boolean estadoMotor = false; 5 String color; 6 String modelo; 7 8 //Tenemos tres métodos: arrancar(), detener() y main(). 9 //Todos los métodos hay que definirlos

10 //dentro de la clase, incluso el main.


DESARROLLO DE SOFTWARE II 11 12 void arrancar(){ 13 if(estadoMotor == true) 14 { 15 System.out.println(“El carro ya está arrancado”); 16 } 17 else 18 { 19 estadoMotor=true; 20 System.out.println(“Carro arrancado”); 21 } 22 } 23 void detener() 24 { 25 if(estadoMotor == false) 26 { 27 System.out.println(“El carro ya está detenido”); 28 } 29 else 30 { 31 estadoMotor=false; 32 System.out.println(“Carro detenido”); 33 } 34 } 35 36 //El main no es obligatorio, pero si no lo definimos aquí, 37 //deberemos hacerlo dentro de otra clase que llame a ésta. 38 public static void main(String args[]) 39 { 40 //Dentro del main, hemos creado una instancia llamada 12étodo12. 41 //La clase invocarMetodos y, por tanto, su instancia ferrari 42 43 invocarMetodos 12étodo12 = new invocarMetodos(); 44 45 //Poseen una variable llamada color. Podemos acceder 46 //a ella utilizando un punto (”.”), con la notación 47 //nombre objeto.variable. 48 //Lo que hemos hecho es asignar a la variable color de nuestro 49 //objeto 12étodo12 el valor “rojo”. 50 51 12étodo12.color=”rojo”; 52 53 //Del mismo modo, asignaremos 54 //el valor “Diablo” a la variable modelo.


DESARROLLO DE SOFTWARE II 55 56 13étodo13.modelo=”Diablo”; 57 58 //La manera de comprobar que ahora esas variables tienen el valor 59 //que les hemos asignado es mostrándolas por pantalla. 60 //Para ello, utilizamos el método System.out.println 61 62 System.out.println(“El modelo del carro es “ + 13étodo13.modelo 63 + “ y es de color “ + 13étodo13.color); 64 65 System.out.println(“Intentando detener el carro…”); 66 67 //Para acceder a los métodos de 13étodo13, el proceso es idéntico 68 //al usado para acceder a las variables: 69 70 13étodo13.detener(); 71 72 System.out.println(“Intentando arrancar el carro…”); 73 13étodo13.arrancar(); 74 } 75 76 } //Fin de la clase invocarMetodos

Resultado:

Simplemente invocamos al método mediante nombre objeto.metodo (), porque hemos definido arrancar () y detener () ¿Qué pasa cuando llamamos a detener ()? Si miramos el código de ese método, vemos que comprueba el valor de la variable booleana estadoMotor. Si el motor ya estaba parado (es decir, si

está a false), simplemente nos informa de ello por pantalla. En caso contrario, pone la variable estadoMotor a false y nos informa de que ha detenido el carro.



Ejemplo3: En ocasiones, puede ocurrir que una variable perteneciente a un objeto mantenga a su vez a otro objeto. [invocarMetodos2.java]

1. Crear la siguiente clase:

2. Luego creamos la clase invocarMetodos2 para que incluya la clase rueda.

1 public class invocarMetodos2 { 2 3 boolean estadoMotor = false; 4 String color; 5 String modelo; 6 7 //Para que nuestra clase ahora tiene ruedas. 8 //Se debe definir una variable neumatico, de tipo Rueda 9 rueda neumatico;

10 11 void arrancar(){ 12 } 13 14 void detener(){ 15 } 16 17 public static void main(String args[]) 18 { 19 invocarMetodos2 ferrari = new invocarMetodos2(); 20 //Se ha instanciado dentro del método main. 21 //Como el objeto neumatico es un atributo más de esta clase 22 //para instanciarla debemos acceder a ella a partir del objeto


DESARROLLO DE SOFTWARE II 23 //de esa clase, escribiendo: ferrari.neumatico = new Rueda 24 25 ferrari.neumatico = new rueda(); 26 27 ferrari.color = "rojo"; 28 ferrari.modelo = "Diablo"; 29 System.out.println("El modelo del carro es " + ferrari.modelo 30 + " y es de color " + ferrari.color); 31 32 //Dentro del método main, queremos acceder a la variable 33 //cubierta de las ruedas del carro. 34 //Así que accedemos escribiendo ferrari.neumatico.cubierta. 35 //Para descender en la jerarquía de objetos, vamos separando 36 //los objetos con puntos. 37 38 ferrari.neumatico.cubierta = "Michelín"; 39 40 System.out.println("La marca de la cubierta del neumático es " 41 +ferrari.neumatico.cubierta); 42 43 } 44 } Resultado:

1.3. ESTADOS Y COMPORTAMIENTOS DE UNA CLASE. Como ya sabemos que los objetos se crean a partir de clases. En esta operación aprenderemos a invocar a los atributos(Estados) y los métodos(Comportamientos) de un objeto. ESTADO. Representa los atributos o características con valores concretos del objeto. Los tipos de datos básicos existen en java y sus características son:



Tipo Formato Descripción (Números enteros) byte 8-bit complemento a 2 Entero de un Byte. short 16-bit complemento a 2 Entero corto. int 32-bit complemento a 2 Entero. long 64-bit complemento a 2 Entero largo. (Números reales) float 32-bit IEEE 754 Coma flotante de precisión simple. double 64-bit IEEE 754 Coma flotante de precisión doble. (otros tipos) char 16-bit Carácter Un sólo carácter (Unicote). boolean true o false Un valor booleano (verdadero o falso).

Vamos catalogar los tipos de datos: • Variable local: La que están dentro de la definición de un método. Sólo es

válida para el código contenido en ese método. • Variable de instancia: Se declaran fuera de los métodos. Generalmente, al

principio de la definición de la clase. El valor de esa variable es válido para toda la instancia, así que la pueden utilizar todos los métodos de esa instancia.

• Variable de clase: Se declara al principio de la clase, como las de instancia. Sin embargo, es válida para para todas las instancias de esa clase. Para diferenciarla de las variables de instancia, se utiliza la palabra reservada static.

Veamos un ejemplo de catalogar los tipos de datos. [ejemploTiposDatos.java]

1 public class ejemploTiposDatos { 2 3 static int semestre = 2015; // Variable de clase 4 int mes = 0; // Variable de instancia 5 void obtenerFechaSemestre(){ 6 //Mostramos el valor de las variables antes de incrementar 7 //ningún valor y vemos que el día 8 //y el mes están inicializados a 0, y el año a 2015. 9 int dia=0; // Variable local.

10 System.out.println("Antes de generar la fecha tenemos: "); 11 System.out.println("dia: "+ dia +" mes: "+ mes + 12 " Año: "+ semestre); 13


DESARROLLO DE SOFTWARE II 14 dia += 18; //incrementar 15 mes += 10; //incrementar 16 System.out.println("La fecha generada es: "+ dia + 17 "/"+ mes +"/"+semestre); 18 } 19 20 public static void main(String args[]){ 21 //En primer lugar, instanciamos un objeto de la clase Fecha, 22 //y le damos el nombre miFecha. 23 ejemploTiposDatos miFecha = new ejemploTiposDatos(); 24 System.out.println("Primera llamada al objeto miFecha:"); 25 System.out.println("----------------------------------"); 26 // A continuación, obtenemos una fecha, 27 // llamando al método obtenerFechaSemestre(), 28 //y nos devuelve la fecha 18/10/2015. 29 miFecha.obtenerFechaSemestre(); 30 System.out.println("Segunda llamada al objeto miFecha:"); 31 System.out.println("----------------------------------"); 32 //Si volvemos a llamar a la función de ese mismo objeto, o sea, 33 //miFecha, comprobaremos que se mantiene el valor de la 34 //variable de instancia 35 miFecha.obtenerFechaSemestre(); // dos llamadas al método del 36 // mismo objeto 37 38 //Si ahora creamos un nuevo objeto de la clase Fecha, otraFecha, 39 //e invocamos a su método para generar fechas, 40 //comprobaremos que la única variable que se mantiene 41 //del caso anterior es la del semestre:2015. 42 //Como el semestre es una variable de clase, su valor se mantiene 43 //para todos los objetos de esa clase. 44 45 ejemploTiposDatos otraFecha = new ejemploTiposDatos(); 46 System.out.println("Llamada al objeto otraFecha:"); 47 System.out.println("----------------------------------"); 48 otraFecha.obtenerFechaSemestre(); 49 } 50 } Resultado:



Formas de acceder a los atributos acceder a la variable: Public: Indica que es un atributo accesible a través de una instancia del objeto. Private: Indica que a través de una instancia no es accesible el atributo. Al heredar el atributo se convierte en inaccesible. Protected: Indica que a través de una instancia no es accesible el atributo. Al heredar si se puede usar desde la clase derivada. Sin especificar: Indica visibilidad de paquete, se puede acceder a través de una instancia, pero sólo desde clases que se encuentren en el mismo paquete. Por ejemplo: public int a = 5, b, c = 4;

Supongamos que tenemos una variable local y otra de instancia, ambas con el mismo nombre. Diremos que la variable local es de ámbito o alcance corto. Entonces, la variable local enmascara a la de instancia. [ejemploAcceder.java]

1 public class ejemploAcceder 2 { 3 int variable = 10; 4 void imprimeVar() 5 { 6 //Cuando imprimamos el valor de la variable, nos devolverá 20, 7 //ya que la variable local oculta a la de instancia. 8 //Del mismo modo, si definimos en una clase una variable que 9 //ya existe en su superclase, enmascararemos

10 //a la de la superclase. 11 int variable = 20; 12 System.out.println("El valor de la variable es: "+variable);



13 } 14 15 public static void main(String args[]) 16 { 17 ejemploAcceder instancia = new ejemploAcceder(); 18 instancia.imprimeVar(); 19 } 20 }

Resultado:

Nota: Todo esto puede dar lugar a errores y confusiones en el código. Por ello, lo más aconsejable es no utilizar nunca el mismo nombre para referirnos a

variables distintas. Ejemplo con protección pública.

Nota: Las clases, métodos y variables con protección pública son visibles a todas las demás clases, dentro o fuera de la clase o paquete actual. 1. Crear la clase [ejemploAccederPublico.java]

2. Ahora crea la clase [llamarPublico.java]



Es importante recordar que, cuando tengamos más de una definición de clase en el mismo archivo java, solamente una de ellas podrá ser pública, y el archivo java deberá llamarse igual que esa clase.

No sólo la clase llamarPublico debe ser de tipo public. También el método, mostrar Mensaje(), deber ser público para que pueda ser accedido desde fuera. De este modo, si tenemos más métodos, definiremos como public sólo aquellos a los que queramos permitir su acceso. Observar también que el método main siempre se define como un método publicó. Resultado

Las características específicas del atributo, son: Static: El atributo pertenece a la clase, no a los objetos creados a partir de ella. Final: El atributo es una constante, en ese caso debe de tener valor inicial obligatoriamente. Por convenio en java las constantes se escriben en mayúsculas. Transient: Marca al atributo como transitorio, para no ser serializado. Lo emplearemos en java beans.


DESARROLLO DE SOFTWARE II Volatile: es un atributo accedido de forma asíncrona mediante hilos, con este atributo se lo notificamos a java.

Vamos a crear una clase que contendrá un atributo contador que indique cuantos números se han creado usando la característica del atributo static.

1. Crear la clase: [ejemploStatic.java]

2. Crear la clase [llamarStatic.java]

Contador debe ser un atributo de clase ya que no es un valor que se deba guardar en cada objeto persona que se crea, por lo tanto se debe declarar static:


DESARROLLO DE SOFTWARE II Public static int contador; Un ejemplo de uso desde fuera de la clase ejemploStatic: ejemploStatic.incrementarContador(); Si lo declaramos como private: private static int contador; Sólo podremos acceder al atributo desde fuera de la clase a través de métodos static: public static void incrementarContador(){ contador++; } public static int mostrarContador() { return contador; } En este caso un ejemplo de uso puede ser: System.out.println(ejemploStatic. mostrarContador()); Si no es private, desde otra clase podemos hacerlo así: ejemploStatic.contadorPersonas++; Si es private, desde otra clase debemos incrementarlo así: ejemploStatic.incrementarContador(); Resultado:



Vamos a crear una clase que contendrá un atributo total que indique un valor como constante usando la característica del atributo final.

1. Crear la clase [ejemploConstantes.java]

2. Ahora crear la clase [llamarConstante.java]

COMPORTAMIENTO. Se define por los métodos u operaciones que se pueden realizar con él. En los ejemplos anteriores en los que aparecen métodos. Sin embargo, eran métodos muy simples que no podrían obtener ni devolver datos. En esta operación vamos a explicar formalmente cómo definirlos, los tipos de métodos existentes, y las operaciones que podemos realizar con ellos.


DESARROLLO DE SOFTWARE II Un método consta de las siguientes partes: • Uno o varios modificadores (public, static, final, etc.). • El objeto o tipo primitivo que devuelve. • El nombre del método. • Un conjunto de parámetros. • La palabra reservada throws, que permite arrojar excepciones, y que se verá

en otro tema más adelante. • El cuerpo del método. Nota: El conjunto formado por el tipo de retorno, el nombre del método y el conjunto de parámetros constituyen lo que se denomina firma del método.

Pasar de argumentos a un método. [usoMetodos.java]

1 public class usoMetodos { 2 3 //En la función se modifican esos valores. Posteriormente, 4 //volvemos al programa principal para comprobar si esas 5 //modificaciones se mantienen. 6 public int modifica(String nombre, int num, String frase){ 7 8 //Observamos que, dentro del método, se han cambiado 9 //los valores de los parámetros. Sin embargo,

10 //al volver a la función principal, sólo se mantienen 11 //los cambios hechos en los Strings. 12 13 if (nombre ==null) 14 return 1; 15 else 16 { 17 System.out.println("Entrando en el método..."); 18 System.out.println("------------------------"); 19 System.out.println("Valor del entero: "+ num); 20 System.out.println("Modificamos entero..."); 21 num=10; 22 System.out.println("Entero modificado: "+ num); 23 System.out.println("\n"); 24 System.out.println("Nombre introducido: "+ nombre);



25 System.out.println("Modificamos el nombre..."); 26 nombre = "SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL"; 27 System.out.println("Nombre modificado: "+nombre); 28 System.out.println("\n"); 29 System.out.println("Valor de la frase= " + frase); 30 System.out.println("Modificamos la frase..."); 31 frase="ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN"; 32 System.out.println("Valor de la frase cambiada="+ frase); 33 return 0; 34 } 35 } 36 37 //Lo que estamos haciendo en el método main de este ejemplo es 38 //asignar unos valores a dos String, un int 39 //y pasarlos como parámetros a una función. 40 41 public static void main(String args[]){ 42 int hayError = 0; 43 int numero = 2; 44 String miNombre = "SENATI"; 45 String sentencia = "ETI"; 46 47 usoMetodos usoMetodo = new usoMetodos(); 48 hayError = usoMetodo.modifica(miNombre,numero,sentencia); 49 if(hayError == 0) 50 { 51 System.out.println("\n"); 52 System.out.println("Saliendo del método..."); 53 System.out.println("----------------------"); 54 System.out.println("Numero devuelto: "+numero); 55 System.out.println("Nombre introducido: "+miNombre); 56 System.out.println("Frase: "+sentencia); 57 } 58 else 59 System.out.println("Ha habido un error al ejecutar el método"); 60 } 61 }

Resultado:



Métodos de clase e instancia. Los métodos de instancia son los métodos con que hemos trabajado hasta ahora: los que se utilizan dentro de una instancia y pueden ser accedidos desde otras clases (dependiendo del modificador public, private, etc). Los métodos de clase están disponibles para cualquier instancia de esa clase y para otras clases, independientemente de si existe, o no, una instancia de esa clase. ¿Qué quiere decir eso?. Existen clases en Java que tienen definidos métodos de clase, a los que podemos acceder sin tener que instanciarla primero. Basta con utilizar el nombre de la propia clase. Diferencias de estos dos tipos de métodos:

Métodos de clase o estáticos Métodos de instancia

Para utilizarlos no se requieren crear un objeto de la clase que los contiene. Ejemplo:

Requieren crear un objeto o instancia de la clase que los contiene para poder utilizarlos. Ejemplo:

eti.brindarCapacitacion(); eti = new eti();

eti.brindarCapacitacion();



Se carga en la memoria en tiempo de compilación. Se carga en la memoria en tiempo de ejecución.

Consume gran parte de la RAM. No consume memoria RAM.

Van precedidos de la palabra reservada static. No van precedidos de la palabra reservada static.

Incrementan la velocidad de ejecución pero se pierde. Se gana flexibilidad se aprovecha la memoria.

Vamos a crear un ejemplo sobre Métodos de clase e instancia. . [metodoClaseIntancia.java]

1 public class metodoClaseInstancia { 2 3 //declaramos e inicializamos la variable estática 4 static int totalalumnos = 1200; 5 6 //Un método estático no puede acceder a ningún componente 7 //(método o variable) no estático. 8 public static int mostrar() 9 {

10 return totalalumnos; 11 } 12 //Un método de instancia para acceder a la variable. 13 public int mostrarTotal() 14 { 15 return totalalumnos; 16 } 17 18 public static void main(String[] args) 19 { 20 metodoClaseInstancia p1= new metodoClaseInstancia(); 21 //De igual manera se puede acceder a un componente estático de 22 //una clase por medio de un objeto de dicha clase, pero recordemos 23 //que dicho valor dependerá de la instancia y todos los métodos o 24 //variables arrojarán el mismo resultado independientemente de qué 25 //objeto lo esté invocando o accediendo. 26 System.out.println("Total con instancia: " + p1.mostrarTotal()); 27 //De manera que no se necesita tener una instancia de la clase para 28 //invocar a un método o acceder a un método estático



29 System.out.println("Total con statico: " + metodoClaseInstancia.mostrar()); 30 } 31 }

Resultado:

Análisis del método main. Siempre que creamos una aplicación en Java, como hemos visto en todos los ejemplos hasta ahora, necesitamos definir, como mínimo, una clase y, dentro de esta, un método main, que sería lo primero que se llama al ejecutar la aplicación.

public static void main(String[] args) Veamos las partes: Public: Evidentemente, el método main debe estar accesible desde fuera de la clase, para poder invocarlo y ejecutar la aplicación. Static: Es un método de clase. Como se comentó anteriormente, un método de clase está disponible independientemente de que esté, o no, instanciada esa clase. En el caso del main no existe previamente una instancia de la clase en la que está definido. Es por ello que, siempre que necesitemos un objeto de la propia clase, debemos instanciarlo dentro del propio main, como hemos venido haciendo hasta ahora en varios ejemplos. Void: El método main no devuelve nada. main: Siempre se llama así. El paso de parámetros mediante un array de Strings ya se explicó en la sección anterior. 1.4. DISEÑAR COMPONENTES SWING BÁSICOS EN LA POO Swing usa diferentes componentes que pueden tomar diferentes formas y comportamientos porque son usados de la biblioteca de clases.


DESARROLLO DE SOFTWARE II La interface gráfica es la parte de la aplicación que permite a interactuar con el usuario. Las interfaces gráfica pueden adoptar muchas formas, que van desde la simple línea de comandos hasta las interfaces gráficas que proporcionan las aplicaciones más modernas. Java Foundation Classes son parte de la API de Java compuesto por clases que sirven para crear interfaces gráficas visuales para las aplicaciones y applets de Java.

Componentes: Los componentes usados en la interface Swing son los elementos básicos de las aplicaciones gráficas en Java. Todo lo que se ve en un GUI de Java es un componente. Los componentes se colocan en otros elementos llamados contenedores que sirven para agrupar componentes. Un administrador de diseño se encarga de disponer la presentación de los componentes en un dispositivo de presentación concreto. La clase javax.swing.JComponent es la clase principal de todos los componentes. A su vez, JComponent desciende de java.awt.container y ésta de java.awt.component. De esto se deduce que Swing es una extensión de AWT, de hecho su estructura es análoga. Contenedores: Son los componentes que permiten almacenar y manejar otros componentes. Los objetos JComponent pueden ser contenedores al ser una clase que desciende de Container que es la clase de los objetos contenedores de AWT. Swing posee algunos contenedores especiales. Algunos son: Existen tres clases contenedores superiores: JFrame


DESARROLLO DE SOFTWARE II Objeto que representa una ventana típica con bordes, botones de cerrar, etc. Es un contenedor permite almacenar nuestros componentes y proporciona un entorno gráfico, digamos que el JFrame es una ventana que tiene propiedades como tamaño, posición, titulo, etc. Ahora vamos a analizar cada una de las propiedades que trae un frame usado en swing que es el JFrame: • JFrame( ) Es el constructor de nuestro frame, aparece sin título y no puede

verse en pantalla hasta que se llame el método para hacerlo visible. • setVisible(booleano) Define si nuestro JFrame puede verse o no, y

únicamente acepta valores booleanos como TRUE o FALSE. • setTitle(String b) Define el nombre del frame (el titulo), y lo que acepta es

una cadena para nombrarla. • setSize (int ancho, int largo) Es la definición del ancho y largo del frame que

vamos a crear. • pack( ) Redefine la ventana para que entre en un espacio determinado. • setLocation (int horizontal, int vertical) Definición de la posición en pantalla

donde va a estar nuestro frame una vez que lo creemos. • setDefaultCloseOperation(int operation) Define la operación que va a tener la

ventana con el boton de cerrar.

Nota: Con estas opciones ya se puede comprender lo que realiza cada opción del primer código mostrado en nuestro curso.

Vamos a crear nuestro primer JFrame. [crearJFrame.java]

1 //Importar la Librería swing 2 import javax.swing.*; 3 /** 4 * Clase Ventana 5 * Muestra la estructura que deberia tener una 6 * Ventana en Java con la libreria Swing 7 */ 8 public class crearJFrame extends JFrame { 9

10 public crearJFrame() { 11 // usamos el contructor de la clase padre JFrame 12 super(); 13 // configuramos la ventana 14 configurarVentana();



15 } 16 17 private void configurarVentana() 18 { 19 // colocamos título a la ventana 20 this.setTitle(".:: Ventana ::."); 21 // colocamos tamanio a la ventana (ancho, alto) 22 this.setSize(310, 210); 23 // centramos la ventana en la pantalla 24 this.setLocationRelativeTo(null); 25 // no usamos ningún layout, solo asi podremos dar posiciones 26 //a los componentes 27 this.setLayout(null); 28 // hacemos que la ventana no sea redimiensionable 29 this.setResizable(false); 30 // hacemos que cuando se cierre la ventana termina todo proceso 31 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 32 } 33 34 public static void main(String[] args) { 35 // creamos una ventana 36 crearJFrame V = new crearJFrame(); 37 // hacemos visible la ventana creada 38 V.setVisible(true); 39 } 40 }

Resultado

JDialog Objeto que representa una ventana típica con bordes, botones de cerrar, etc. Es un contenedor permite almacenar nuestros componentes y proporciona un entorno gráfico, digamos que el JFrame es una ventana que tiene propiedades como tamaño, posición, titulo, etc.



Vamos a crear nuestro primer JDialog. [crearJDialog.java]

1 import java.awt.*; 2 import java.awt.event.*; 3 import javax.swing.*; 4 5 public class crearJDialog extends JDialog implements ActionListener{ 6 public crearJDialog(JFrame jframe, boolean modal){ 7 JButton boton; 8 //Se pone el titulo a la ventana 9 this.setTitle("Mi JDialog");

10 //Se crea un Layout y se agrega al contenedor del dialog 11 this.getContentPane().setLayout(new FlowLayout()); 12 //Se crea el botón 13 boton= new JButton("Probar Mensaje"); 14 //Se agrega el boton al contenedor del dialog 15 this.getContentPane().add(boton); 16 //Se agrega el Listener al botón 17 boton.addActionListener(this); 18 //Se hace la ventana visible 19 this.setBounds(400, 200, 300, 300); 20 //Se hace la ventana visible 21 this.setVisible(true); 22 } 23 public static void main(String args[]) { 24 //Se crea un JDialog Recibe un JFrame y se indica el modal true o false 25 crearJDialog dialogo = new crearJDialog(new JFrame(), true); 26 27 } 28 //Este método ejecuta el código del botón al pulsarlo 29 public void actionPerformed (ActionEvent e){ 30 JOptionPane.showMessageDialog(null,"Escuela de Tecnologias " 31 + "de Información"); 32 } 33 34 }

Resultado:



JApplet Contenedor que agrupa componentes que serán mostrados en un navegador.

Vamos a crear nuestro primer JApplet. [crearJApplet.java]

1 import java.applet.Applet; 2 import java.awt.*; 3 4 public class crearJApplet extends Applet{ 5 Label Texto; 6 TextField CampoDeTexto; 7 int numero; 8 int suma; 9

10 public void init(){ 11 Texto = new Label("Ingrese un numero para ser sumada por otro"); 12 //El valor de un numero sera el ingresado mediante el campo de texto 13 //y este se guardara en como objeto 14 CampoDeTexto = new TextField( 5 ); 15 add(Texto); 16 add(CampoDeTexto); 17 numero = 0; 18 19 } 20 // Evento ENTER 21 public boolean action(Event e, Object o){ 22 // El metodo Integer.toString(suma) Integer se convertira en



23 // String y no se porque la variable suma esta colocado alli. 24 numero = Integer.parseInt(o.toString()); 25 CampoDeTexto.setText(""); 26 suma= numero + suma ; 27 showStatus(Integer.toString(suma)); 28 return false; 29 } 30 31 }

Resultado:

JPanel Se usan para contener muchos objetos, de esta manera se utilizan como cajas donde vas colocando cosas y así poderlos manejar como una agrupación. Por ejemplo, si agrupas una serie de botones dentro de un JPanel y quieres desactivarlos todos de golpe, puedes desactivar el JPanel que los contiene y así todo su contenido queda desactivado. O por si quieres moverlos todos de una vez, etc.

Vamos a crear nuestro primer JPanel. [crearJPanel.java]

1 import java.awt.event.ActionEvent; 2 import java.awt.event.ActionListener; 3 import javax.swing.*; 4 5 public class crearJPanel extends JPanel 6 { 7 public static void main(String[] args)



8 { 9 /**

10 * Armando los componentes 11 */ 12 13 //Creamos un Jframe 14 JFrame frame = new JFrame(); 15 16 //Creamos un Jpanel 17 JPanel panel = new JPanel(); 18 19 //Creamos un Jbutton 20 //Dentro del constructor podria ir el 21 //texto del boton pero en esta ocasion 22 //meteremos una etiqueta 23 JButton boton = new JButton(); 24 25 //Creamos un Jlabel 26 JLabel label = new JLabel("E-T-I"); 27 28 //Le asignamos una accion al Jbutton 29 boton.addActionListener(new ActionListener(){ 30 31 public void actionPerformed(ActionEvent e) { 32 33 JOptionPane.showConfirmDialog(null, "Escuela de Tecnologias " 34 + "de la Información"); 35 } 36 }); 37 //Terminamos de asignar la accion al boton 38 //Metemos la Jlabel al Jbutton 39 boton.add(label); 40 41 //Metemos el Jbutton al Jpanel 42 panel.add(boton); 43 44 //Metemos el Jpanel al Jframe 45 frame.getContentPane().add(panel); 46 47 //Ajustamos el Jframe a su contenido 48 frame.pack(); 49 50 //Hacemos el Jframe visible 51 frame.setVisible(true);


DESARROLLO DE SOFTWARE II 52 53 } 54 }

Resultado:

Layout Managers.

Definición: • Cada contenedor maneja la disposición de sus componentes. • El programador sólo añade componentes, el contenedor se encarga de la

disposición de los mismos. • El contenedor usa un Layout Manager para manejar la disposición de los

componentes en el mismo. • Están disponibles diferentes Layout Managers. • El layout puede ser determinado especificando Layout Managers para los

contenedores. • Hay varios Layout Managers predefinidos en:

FlowLayout (en java.awt) BorderLayout (en java.awt) CardLayout (en java.awt) GridLayout (en java.awt) GridBagLayout (en java.awt) BoxLayout (en javax.swing) OverlayLayout (en javax.swing)

• Cada contenedor tiene un Layout Manager por defecto, aunque se puede

establecer otro LM para el mismo, de forma explícita. • Para anular el LM por defecto se usa el método setLayout (para

contenedores de alto nivel se usa getContentPane().setLayout(). • El Layout Manager intenta ajustar la disposición de los componentes en el

contenedor cuando se añade un nuevo componente o cuando el contenedor cambia de tamaño.

• Puede crear su propio LM. • Organización de los componentes. • Cuando en una ventana hay muchos componentes hay que organizarlos de

algún modo.


DESARROLLO DE SOFTWARE II • Java proporciona diversos esquemas de organización (layout managers) que

pueden ser utilizados para organizar los componentes dentro de los contenedores.

• Los gestores de organización se encargan de reorganizar los componentes en caso de que el usuario cambie el tama˜no de la ventana.

• Los gestores de organización que ofrece Java son: • BorderLayout, FlowLayout, BoxLayout, CardLayout, GridLayout,

GridBagLayout. • El procedimiento es siempre el mismo, se crea un objeto de alguna de estas

clases y se le indica al contenedor que organice los componentes utilizando el objeto (para ello los contenedores disponen del método setLayout (LayoutManager m).

BorderLayout

Se puede utilizar para colocar en un contenedor cinco componentes como máximo ya que proporciona cinco posiciones donde colocar los componentes, estas son: NORTH (arriba), SOUTH (abajo), WEST (izquierda), EAST (derecha) y CENTER (en el centro).

1 2 import java.awt.*;

3 import javax.swing.*; 4 class Ejemplo_swingVentana1 extends JFrame{ 5 public Ejemplo_swingVentana1(){ 6 Container c=getContentPane(); 7 JButton b1=new JButton("A"); 8 JButton b2=new JButton("B"); 9 JButton b3=new JButton("C"); 10 JButton b4=new JButton("D"); 11 JButton b5=new JButton("E"); 12 c.setLayout(new BorderLayout()); 13 c.add(b1,BorderLayout.NORTH); 14 c.add(b2,BorderLayout.SOUTH); 15 c.add(b3,BorderLayout.WEST); 16 c.add(b4,BorderLayout.EAST); 17 c.add(b5,BorderLayout.CENTER); 18 } 19 public static void main(String[]args){ 20 Ejemplo_swingVentana1 v=new Ejemplo_swingVentana1();


DESARROLLO DE SOFTWARE II 21 v.setSize(300,300); 22 v.show(); 23 } 24 } Resultado:


3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_BorderLayout 6 extends JFrame implements ActionListener 7 { 8 private JButton botones[]; 9 private final String nombres[] = { "Ocultar norte", "Ocultar sur", 10 "Ocultar este", "Ocultar oeste", "Ocultar centro" }; 11 private BorderLayout esquema; 12 // configurar GUI y el manejo de eventos 13 public Ejemplo_BorderLayout() 14 { 15 super( "Demostración de BorderLayout" ); 16 // espacios libres de 5 píxeles 17 esquema = new BorderLayout( 5, 5 ); 18 // obtener panel de contenido y establecer su esquema 19 Container contenedor = getContentPane(); 20 contenedor.setLayout( esquema ); 21 // instanciar objetos botón 22 botones = new JButton[ nombres.length ]; 23 for ( int cuenta = 0; cuenta < nombres.length; cuenta++ ) { 24 botones[ cuenta ] = new JButton( nombres[ cuenta ] ); 25 botones[ cuenta ].addActionListener( this ); 26 botones[ cuenta ].setToolTipText("Borra del contenedor al boton " 27 + nombres[cuenta]); 28 } 29 // colocar botones en BorderLayout; no importa el orden

DESARROLLO DE SOFTWARE II 30 contenedor.add( botones[ 0 ], BorderLayout.NORTH ); 31 contenedor.add( botones[ 1 ], BorderLayout.SOUTH ); 32 contenedor.add( botones[ 2 ], BorderLayout.EAST ); 33 contenedor.add( botones[ 3 ], BorderLayout.WEST ); 34 contenedor.add( botones[ 4 ], BorderLayout.CENTER ); 35 setSize( 350, 200 ); 36 setVisible( true ); 37 } // fin del constructor de DemoBorderLayout 38 // manejar eventos de botón 39 public void actionPerformed( ActionEvent evento ) 40 { 41 for ( int cuenta = 0; cuenta < botones.length; cuenta++ ) 42 43 if ( evento.getSource() == botones[ cuenta ] ) 44 botones[ cuenta ].setVisible( false ); 45 else 46 botones[ cuenta ].setVisible( true ); 47 48 // re-esquematizar el panel de contenido 49 esquema.layoutContainer( getContentPane() ); 50 } 51 public static void main( String args[] ) 52 { 53 Ejemplo_BorderLayout aplicacion = new Ejemplo_BorderLayout(); 54 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 55 } 56 } // fin de la clase Resultado:

BoxLayout Aprende a utilizar la clase BoxLayout y el uso de pestañas en tus programas en java.

DESARROLLO DE SOFTWARE II 3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_BoxLayout extends JFrame { 6 // configurar GUI 7 public Ejemplo_BoxLayout() 8 { 9 super( "Demostración de BoxLayout" ); 10 // crear contenedores Box con esquema BoxLayout 11 Box horizontal1 = Box.createHorizontalBox(); 12 Box vertical1 = Box.createVerticalBox(); 13 Box horizontal2 = Box.createHorizontalBox(); 14 Box vertical2 = Box.createVerticalBox(); 15 final int TAMAÑO = 3; // número de botones 16 //en cada contenedor Box 17 // agregar botones al objeto Box horizontal1 18 for ( int cuenta = 0; cuenta < TAMAÑO; cuenta++ ) 19 horizontal1.add( new JButton( "Botón " + cuenta ) ); 20 // crear montante y agregar botones al objeto Box vertical1 21 for ( int cuenta = 0; cuenta < TAMAÑO; cuenta++ ) { 22 vertical1.add( Box.createVerticalStrut( 25 ) ); 23 vertical1.add( new JButton( "Botón " + cuenta ) ); 24 } 25 // crear pegamento horizontal y agregar botones 26 // al objeto Box horizontal2 27 for ( int cuenta = 0; cuenta < TAMAÑO; cuenta++ ) { 28 horizontal2.add( Box.createHorizontalGlue() ); 29 horizontal2.add( new JButton( "Botón " + cuenta ) ); 30 } 31 // crear área rígida y agregar botones al objeto Box vertical2 32 for ( int cuenta = 0; cuenta < TAMAÑO; cuenta++ ) { 33 vertical2.add( Box.createRigidArea( new Dimension( 12, 8 ) ) ); 34 vertical2.add( new JButton( "Botón " + cuenta ) ); 35 } 36 // crear pegamento vertical y agregar botones al panel 37 JPanel panel = new JPanel(); 38 panel.setLayout( new BoxLayout( panel, BoxLayout.Y_AXIS ) ); 39 for ( int cuenta = 0; cuenta < TAMAÑO; cuenta++ ) { 40 panel.add( Box.createGlue() ); 41 panel.add( new JButton( "Botón " + cuenta ) ); 42 } 43 // crear un objeto JTabbedPane 44 JTabbedPane fichas = new JTabbedPane( 45 JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT ); 46 // colocar cada contendor en panel con fichas

DESARROLLO DE SOFTWARE II 47 fichas.addTab( "Cuadro horizontal", horizontal1 ); 48 fichas.addTab( "Cuadro vertical con montantes", vertical1 ); 49 fichas.addTab( "Cuadro horizontal con pegamento", horizontal2 ); 50 fichas.addTab( "Cuadro vertical con áreas rigidas", vertical2 ); 51 fichas.addTab( "Cuadro vertical con pegamento", panel ); 52 // colocar panel con fichas en el panel de contenido 53 getContentPane().add( fichas ); 54 setSize( 400, 220 ); 55 setVisible( true ); 56 } // fin del constructor 57 public static void main( String args[] ) 58 { 59 Ejemplo_BoxLayout aplicacion = new Ejemplo_BoxLayout(); 60 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 61 } 62 } // fin de la clase Resultado:

FlowLayout Coloca los componentes de izquierda a derecha conforme se van añadiendo a la ventana. El tamaño de los componentes se ajusta a su contenido.


3 import javax.swing.*; 4 public class Ejemplo_swingVentana2 extends JFrame { 5 public Ejemplo_swingVentana2() 6 { 7 Container c = getContentPane ( ) ; 8 JButton b1 = new JButton ( "A" ) ; 9 JButton b2 = new JButton ( "B" ) ; 10 JButton b3 = new JButton ( "Boton mas largo") ;


DESARROLLO DE SOFTWARE II 11 JButton b4 = new JButton ( "D" ) ; 12 JButton b5 = new JButton ( "E") ; 13 c.setLayout (new FlowLayout ()) ; 14 c.add ( b1 ) ; 15 c.add ( b2 ) ; 16 c.add ( b3 ) ; 17 c.add ( b4 ) ; 18 c.add ( b5 ) ; 19 } 20 public static void main (String[] args) { 21 Ejemplo_swingVentana2 v = new Ejemplo_swingVentana2() ; 22 v.setSize(200 ,200) ; 23 v.show( ) ; 24 } 25 } Resultado:

GridLayout Coloca los componentes en filas y columnas en función de los valores pasados al constructor. Todas las celdas tendrán el mismo tamaño.


3 import javax.swing.*; 4 public class Ejemplo_swingVentana3 extends JFrame{ 5 public Ejemplo_swingVentana3( ) 6 { 7 Container c = getContentPane ( ) ; 8 JButton b1 = new JButton ( "A" ) ; 9 JButton b2 = new JButton ( "B" ) ; 10 JButton b3 = new JButton ( "C" ) ; 11 JButton b4 = new JButton ( "D" ) ; 12 JButton b5 = new JButton ( "2" ) ;



13 c.setLayout (new GridLayout ( 2 , 3 ) ) ; 14 c.add ( b1 ) ; 15 c.add ( b2 ) ; 16 c.add ( b3 ) ; 17 c.add ( b4 ) ; 18 c.add ( b5 ) ; 19 } 20 public static void main ( String[] args ) { 21 Ejemplo_swingVentana3 v = new Ejemplo_swingVentana3() ; 22 v.setSize(300 ,300); 23 v.show( ) ; 24 } 25 }

Resultado:

GridLayout Se puede utilizar para mostrar de forma condicional unos elementos u otros, de forma que se puede controlar qué elementos serán visibles. Una ilustración es una pila de cartas en las que sólo la superiores visible en un instante dado.


3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_GridLayout 6 extends JFrame implements ActionListener 7 { 8 private JButton botones[]; 9 private final String nombres[] = 10 { "uno", "dos", "tres", "cuatro", "cinco", "seis" }; 11 private boolean alternar = true; 12 private Container contenedor; 13 private GridLayout cuadricula1, cuadricula2; 14 // configurar GUI


DESARROLLO DE SOFTWARE II 15 public Ejemplo_GridLayout() 16 { 17 super( "Demostración de GridLayout" ); 18 // establecer esquemas 19 cuadricula1 = new GridLayout( 2, 3, 10, 10 ); 20 cuadricula2 = new GridLayout( 3, 2 ); 21 // obtener panel de contenido y establecer su esquema 22 contenedor = getContentPane(); 23 contenedor.setLayout( cuadricula1 ); 24 // crear y agregar botones 25 botones = new JButton[ nombres.length ]; 26 for ( int cuenta = 0; cuenta < nombres.length; cuenta++ ) { 27 botones[ cuenta ] = new JButton( nombres[ cuenta ] ); 28 botones[ cuenta ].addActionListener( this ); 29 botones[ cuenta ].setToolTipText 30 ("Cambia el esquema de GridLayout"); 31 contenedor.add( botones[ cuenta ] ); 32 } 33 setSize( 300, 150 ); 34 setVisible( true ); 35 } // fin del constructor de DemoGridLayout 36 // manejar eventos de botón, alternando entre los esquemas 37 public void actionPerformed( ActionEvent evento ) 38 { 39 if ( alternar ) 40 contenedor.setLayout( cuadricula2 ); 41 else 42 contenedor.setLayout( cuadricula1 ); 43 // establecer alternar en el valor opuesto 44 alternar = !alternar; 45 contenedor.validate(); 46 } 47 public static void main( String args[] ) 48 { 49 Ejemplo_GridLayout aplicacion = new Ejemplo_GridLayout(); 50 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 51 } 52 } // fin de la clase

Resultado:


GridBagLayout Este es un organizador complejo que permite ajustar la posición de los componentes. Al colocar los componentes en los contenedores se especifican las restricciones que se deben cumplir (posición del componente, anchura y altura del

componente, separación entre los componentes, posición dentro del espacio que ocupa,...).


3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_GridBag extends JFrame 6 { 7 private Container contenedor; 8 private GridBagLayout esquema; 9 private GridBagConstraints restricciones; 10 // configurar GUI 11 public Ejemplo_GridBag() 12 { 13 super( "GridBagLayout" ); 14 contenedor = getContentPane(); 15 esquema = new GridBagLayout(); 16 contenedor.setLayout( esquema ); 17 // instanciar restricciones de GridBagLayout 18 restricciones = new GridBagConstraints(); 19 // crear componentes de GUI 20 JTextArea areaTexto1 = new JTextArea( "AreaTexto1", 5, 10 ); 21 JTextArea areaTexto2 = new JTextArea( "AreaTexto2", 2, 2 ); 22 String nombres[] = { "Hierro", "Acero", "Cobre" }; 23 JComboBox cuadroCombinado = new JComboBox( nombres ); 24 JTextField campoTexto = new JTextField( "CampoTexto" ); 25 JButton boton1 = new JButton( "Botón 1" ); 26 JButton boton2 = new JButton( "Botón 2" ); 27 JButton boton3 = new JButton( "Botón 3" ); 28 // weightx y weighty para areaTexto1 son 0: 29 // el valor predeterminado 30 // anchor para todos los componentes es CENTER: 31 // el valor predeterminado 32 restricciones.fill = GridBagConstraints.BOTH; 33 agregarComponente( areaTexto1, 0, 0, 1, 3 ); 34 // weightx y weighty para boton1 son 0: 35 // el valor predeterminado 36 restricciones.fill = GridBagConstraints.HORIZONTAL;


DESARROLLO DE SOFTWARE II 37 agregarComponente( boton1, 0, 1, 2, 1 ); 38 // weightx y weighty para cuadroCombinado son 0: 39 // el valor predeterminado 40 // fill es HORIZONTAL 41 agregarComponente( cuadroCombinado, 2, 1, 2, 1 ); 42 // boton2 43 restricciones.weightx = 1000; // puede hacerse más ancho 44 restricciones.weighty = 1; // puede hacerse más largo 45 restricciones.fill = GridBagConstraints.BOTH; 46 agregarComponente( boton2, 1, 1, 1, 1 ); 47 // fill es BOTH para boton3 48 restricciones.weightx = 0; 49 restricciones.weighty = 0; 50 agregarComponente( boton3, 1, 2, 1, 1 ); 51 // weightx y weighty para campoTexto son 0, fill es BOTH 52 agregarComponente( campoTexto, 3, 0, 2, 1 ); 53 // weightx y weighty para areaTexto2 son 0, fill es BOTH 54 agregarComponente( areaTexto2, 3, 2, 1, 1 ); 55 setSize( 300, 150 ); 56 setVisible( true ); 57 } // fin del constructor de DemoGridBag 58 // método para establecer restricciones 59 private void agregarComponente( Component componente, 60 int fila, int columna, int anchura, int altura ) 61 { 62 // establecer gridx y gridy 63 restricciones.gridx = columna; 64 restricciones.gridy = fila; 65 // establecer gridwidth y gridheight 66 restricciones.gridwidth = anchura; 67 restricciones.gridheight = altura; 68 // establecer restricciones y agregar componente 69 esquema.setConstraints( componente, restricciones ); 70 contenedor.add( componente ); 71 } 72 public static void main( String args[] ) 73 { 74 Ejemplo_GridBag aplicacion = new Ejemplo_GridBag(); 75 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 76 } 77 } // fin de la clase Resultado:



1. Escribe un programa basada en tipo de datos texto usando enfoque

orientado a objetos para mostrar su nombre. 2. Escriba un jframe de java para mostrar su edad. 3. Escriba un programa que calcula e imprime el producto de tres números

enteros. 4. Escribir una aplicación que muestre los números del 1 al 4 en la misma

línea, con cada par de números adyacentes separadas por un espacio. Escribe la aplicación mediante las siguientes técnicas: • Utilice una sentencia System.out.println. • Utilice cuatro declaraciones System.out.print. • Utilice un solo metod sin usar la sentencia println.

Ejercicios y tareas de investigación


DESARROLLO DE SOFTWARE II II. COMPONENTES BÁSICOS SWING. En esta tarea trataremos las siguientes operaciones:

Clases y tipos de métodos, ámbitos y atributos dentro de una aplicación

Swing.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo ó de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web.

ORDEN DE EJECUCIÓN: Clases y tipos de métodos, ámbitos y atributos dentro de una aplicación

Swing

2.1. CLASES Y TIPOS DE MÉTODOS, ÁMBITOS Y ATRIBUTOS DENTRO DE UNA APLICACIÓN SWING

JLabel Componente SWING que permite mostrar un texto que no puede editarse, y también permite mostrar imágenes.

Vamos a crear nuestro primer JLabel. [crearJLabel.java]

1 //Importar la Librería swing 2 import javax.swing.*; 3 /** 4 * Clase Ventana 5 * Muestra la estructura que deberia tener una



6 * Ventana en Java con la libreria Swing 7 */ 8 public class crearJLabel extends JFrame { 9

10 private JLabel texto; // etiqueta o texto no editable 11 12 public crearJLabel() { 13 // usamos el contructor de la clase padre JFrame 14 super(); 15 // configuramos la ventana 16 configurarVentana();

17

// inicializamos los atributos o componentes

18 inicializarComponentes(); 19 } 20 21 private void configurarVentana() 22 { 23 // colocamos título a la ventana 24 this.setTitle(".:: Ventana ::."); 25 // colocamos tamanio a la ventana (ancho, alto) 26 this.setSize(310, 210); 27 // centramos la ventana en la pantalla 28 this.setLocationRelativeTo(null); 29 // no usamos ningun layout, solo asi podremos dar posiciones 30 //a los componentes 31 this.setLayout(null); 32 // hacemos que la ventana no sea redimiensionable 33 this.setResizable(false); 34 // hacemos que cuando se cierre la ventana termina todo proceso 35 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 36 } 37

38 private void inicializarComponentes() { 39 // creamos los componentes 40 texto = new JLabel(); 41 // configuramos los componentes 42 // colocamos un texto a la etiqueta 43 texto.setText(" E T I - SENATI"); 44 // colocamos posicion y tamanio al texto (x, y, ancho, alto) 45 texto.setBounds(100, 50, 100, 25); 46 // adicionamos los componentes a la ventana 47 this.add(texto);



48 49 } 50 51 public static void main(String[] args) { 52 // creamos una ventana 53 crearJLabel V = new crearJLabel(); 54 // hacemos visible la ventana creada 55 V.setVisible(true); 56 } 57 }

Resultado:

JTextField Permite al usuario introducir datos mediante el teclado. También se puede utilizar para mostrar texto que puede o no editarse.

Vamos a crear nuestro primer JTextField. [crearJTextField.java]

1 //Importar la Librería swing 2 import javax.swing.*; 3 /** 4 * Clase Ventana 5 * Muestra la estructura que deberia tener una 6 * Ventana en Java con la libreria Swing 7 */ 8 public class crearJTextField extends JFrame { 9

10 private JLabel texto; // etiqueta o texto no editable 11 12 private JTextField caja; // caja de texto, para insertar datos 13



14 public crearJTextField() { 15 // usamos el contructor de la clase padre JFrame 16 super(); 17 // configuramos la ventana 18 configurarVentana(); 19 // inicializamos los atributos o componentes 20 inicializarComponentes(); 21 } 22 23 private void configurarVentana() 24 { 25 // colocamos título a la ventana 26 this.setTitle(".:: Ventana ::."); 27 // colocamos tamanio a la ventana (ancho, alto) 28 this.setSize(310, 210); 29 // centramos la ventana en la pantalla 30 this.setLocationRelativeTo(null); 31 // no usamos ningun layout, solo asi podremos dar posiciones 32 //a los componentes 33 this.setLayout(null); 34 // hacemos que la ventana no sea redimensionable 35 this.setResizable(false); 36 // hacemos que cuando se cierre la ventana termina todo proceso 37 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 38 } 39 40 private void inicializarComponentes() { 41 // creamos los componentes 42 texto = new JLabel(); 43 // configuramos los componentes 44 // colocamos un texto a la etiqueta 45 texto.setText(" E T I - SENATI"); 46 // colocamos posicion y tamaño al texto (x, y, ancho, alto) 47 texto.setBounds(100, 50, 100, 25); 48 49 // adicionamos los componentes a la ventana 50 caja = new JTextField(); 51 caja.setBounds(100, 80, 100, 25); // colocamos posicion y tamaño 52 // a la caja (x, y, ancho, alto) 53 54 this.add(texto); 55 // adicionamos los componentes a la ventana

56 57 this.add(caja);



58 } 59 60 public static void main(String[] args) { 61 // creamos una ventana 62 crearJTextField V = new crearJTextField(); 63 // hacemos visible la ventana creada 64 V.setVisible(true); 65 } 66 }

Resultado:

JButton Un botón es un componente en el que el usuario hace clic para desencadenar una acción específica (genera un evento ActionEvent). Para que el botón pueda permitir la interacción del usuario se debe de crear el ActionListener el cual es un controlador de eventos que ejecuta una tarea cuando una determinada acción se lleva a cabo por el usuario. Esta acción puede ser cualquier cosa que el usuario pueda hacer, como mover el ratón o pulsar una tecla en el teclado.

Vamos a crear nuestro primer JButton. [crearJButton.java]

1 // Importar la Librería swing 2 // para usar eventos

3 import java.awt.event.ActionEvent; 4 import java.awt.event.ActionListener; 5 6 import javax.swing.*; 7 8 // Crear la clase con la implementación de eventos 9 public class crearJButton extends JFrame implements ActionListener {



10 11 private JLabel texto; // etiqueta o texto no editable 12 13 private JTextField caja; // caja de texto, para insertar datos 14 15 private JButton boton; // boton con una determinada accion 16 17 public crearJButton() { 18 // usamos el contructor de la clase padre JFrame 19 super(); 20 // configuramos la ventana 21 configurarVentana(); 22 // inicializamos los atributos o componentes 23 inicializarComponentes(); 24 } 25 26 private void configurarVentana() 27 { 28 // colocamos titulo a la ventana 29 this.setTitle(".:: Ventana ::."); 30 // colocamos tamanio a la ventana (ancho, alto) 31 this.setSize(310, 210); 32 // centramos la ventana en la pantalla 33 this.setLocationRelativeTo(null); 34 // no usamos ningun layout, solo asi podremos dar posiciones 35 //a los componentes 36 this.setLayout(null); 37 // hacemos que la ventana no sea redimiensionable 38 this.setResizable(false); 39 // hacemos que cuando se cierre la ventana termina todo proceso 40 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 41 } 42 43 private void inicializarComponentes() { 44 // creamos los componentes 45 texto = new JLabel(); 46 // configuramos los componentes 47 // colocamos un texto a la etiqueta 48 texto.setText(" E T I - SENATI"); 49 // colocamos posicion y tamaño al texto (x, y, ancho, alto) 50 texto.setBounds(100, 50, 100, 25); 51 52 // adicionamos los componentes a la ventana 53 caja = new JTextField();



54 caja.setBounds(100, 80, 100, 25); // colocamos posicion y tamaño 55 // a la caja (x, y, ancho, alto)

56 57 boton = new JButton(); 58 boton.setText("Mostrar Mensaje"); // colocamos un texto al boton 59 boton.setBounds(60, 120, 200, 30); // colocamos posicion y tamaño 60 // al boton (x, y, ancho, alto) 61 boton.addActionListener(this); // hacemos que el boton tenga una 62 // accion y esa accion estara en 63 // esta clase 64 65 this.add(texto); 66 // adicionamos los componentes a la ventana 67 68 this.add(caja); 69 70 this.add(boton); 71 72 }

73

74 //Crear evento 75 public void actionPerformed(ActionEvent e) { 76 String nombre = caja.getText(); // obtenemos el contenido de 77 // la caja de texto 78 // mostramos un mensaje (frame, mensaje) 79 JOptionPane.showMessageDialog(this, "Hola " + nombre + "."); 80 } 81 82 public static void main(String[] args) { 83 // creamos una ventana 84 crearJButton V = new crearJButton();

85 // hacemos visible la ventana creada 86 V.setVisible(true); 87 } 88 }

Resultado:


DESARROLLO DE SOFTWARE II JComboBox El control JComboBox permite seleccionar un String de una lista. Para inicializar los String que contendrá el JComboBox debemos llamar al método addItem tantas veces como elementos queremos cargar. Un evento muy útil con este control es cuando el operador selecciona un Item de la lista. Para capturar la selección de un item debemos implementar la interface ItemListener que contiene un método llamada itemStateChanged.

Vamos a crear nuestro primer JComboBox. Se cargaran elementos al JComboBox y luego al seleccionar alguno se mostrara en la barra de título del JFrame el String seleccionado. [crearJComboBox.java]

1 // Importar la Librería swing 2 // para usar eventos 3 import java.awt.event.*; 4 import javax.swing.*; 5 6 // Indicamos a la clase que implementaremos la interface ItemListener. 7 public class crearJComboBox extends JFrame implements ItemListener { 8 // etiqueta o texto no editable 9 private JLabel texto;

10 //Declaramos un objeto de la clase ComboBox. 11 private JComboBox combo; 12 13 public crearJComboBox() { 14 // usamos el contructor de la clase padre JFrame 15 super(); 16 // configuramos la ventana 17 configurarVentana(); 18 // inicializamos los atributos o componentes 19 inicializarComponentes(); 20 } 21 22 private void configurarVentana() 23 { 24 // colocamos titulo a la ventana 25 this.setTitle(".:: Ventana ::."); 26 // colocamos tamanio a la ventana (ancho, alto) 27 this.setSize(310, 210); 28 // centramos la ventana en la pantalla 29 this.setLocationRelativeTo(null);



30 // no usamos ningun layout, solo asi podremos dar posiciones 31 //a los componentes 32 this.setLayout(null); 33 // hacemos que la ventana no sea redimiensionable 34 this.setResizable(false); 35 // hacemos que cuando se cierre la ventana termina todo proceso 36 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 37 } 38 39 private void inicializarComponentes() { 40 // creamos los componentes 41 texto = new JLabel(); 42 // configuramos los componentes 43 // colocamos un texto a la etiqueta 44 texto.setText(" E T I - SENATI"); 45 // colocamos posicion y tamaño al texto (x, y, ancho, alto) 46 texto.setBounds(100, 50, 100, 25); 47 //Creamos el objeto de la clase JComboBox 48 combo=new JComboBox(); //Posicionamos el control: 49 combo.setBounds(200,50,80,20); 50 //Añadimos los String al JComboBox. 51 combo.addItem("Redes"); 52 combo.addItem("Ensamblaje"); 53 combo.addItem("Programación"); 54 combo.addItem("AutoCad"); 55 combo.addItem("Web"); 56 //Asociamos la clase que capturará el evento de cambio de item 57 //(con this indicamos que esta misma clase capturará el evento). 58 combo.addItemListener(this); 59 60 // adicionamos los componentes a la ventana 61 this.add(texto); 62 this.add(combo); 63 } 64 65 // El método itemStateChanged que debemos implementar de la 66 //interface ItemListener tiene la siguiente sintaxis. 67 public void itemStateChanged(ItemEvent e) { 68 if (e.getSource()==combo) { 69 //Para extraer el contenido del item seleccionado llamamos 70 //al método getSelectemItem() el cual retorna un objeto 71 //de la clase Object por lo que debemos indicarle que lo 72 //transforme en StrinG. 73 String seleccionado=(String)combo.getSelectedItem();



74 setTitle(seleccionado); 75 } 76 } 77 78 public static void main(String[] args) { 79 // creamos una ventana 80 crearJComboBox V = new crearJComboBox(); 81 // hacemos visible la ventana creada 82 V.setVisible(true); 83 } 84 }

Resultado:

Crear tres controles de tipo JComboBox con valores entre 0 y 255 (cada uno representa la cantidad de rojo, verde y azul). Luego al presionar un botón pintar el mismo con el color que se genera combinando los valores de los JComboBox. [crearJComboBox2.java]

1 // Importamos el paquete java.awt ya que el 2 // mismo contiene la clase Color 3 import javax.swing.*; 4 import java.awt.*; 5 import java.awt.event.*; 6 // Implementaremos la interface ActionListener ya que tenemos 7 // que cambiar el color del botón cuando se lo presione y no 8 // haremos actividades cuando cambiemos items de los controles JComboBox 9 public class crearJComboBox2 extends JFrame implements ActionListener{

10 // Definimos los siete objetos requeridos en esta aplicación 11 private JLabel label1,label2,label3; 12 private JComboBox combo1,combo2,combo3; 13 private JButton boton1; 14 public crearJComboBox2() { 15 setLayout(null);


16 // En el constructor creamos los objetos, primero el control 17 // label1 de la clase JLabel 18 19 label1=new JLabel("Rojo:"); 20 label1.setBounds(10,10,100,30); 21 add(label1); 22 23 // Lo mismo hacemos con el objeto combo1 24 combo1=new JComboBox(); 25 combo1.setBounds(120,10,50,30); 26 // Para añadir los 256 elementos del JComboBox disponemos un for 27 // y previa a llamar al método addItem convertimos el entero a String 28 for(int f=0;f<=255;f++) { 29 combo1.addItem(String.valueOf(f)); 30 } 31 add(combo1); 32 label2=new JLabel("Verde:"); 33 label2.setBounds(10,50,100,30); 34 add(label2); 35 combo2=new JComboBox(); 36 combo2.setBounds(120,50,50,30); 37 for(int f=0;f<=255;f++) { 38 combo2.addItem(String.valueOf(f)); 39 } 40 add(combo2); 41 label3=new JLabel("Azul:"); 42 label3.setBounds(10,90,100,30); 43 add(label3); 44 combo3=new JComboBox(); 45 combo3.setBounds(120,90,50,30); 46 for(int f=0;f<=255;f++) { 47 combo3.addItem(String.valueOf(f)); 48 } 49 add(combo3); 50 boton1=new JButton("Fijar Color"); 51 boton1.setBounds(10,130,100,30); 52 add(boton1); 53 boton1.addActionListener(this); 54 } 55 56 // En el método actionPerformed cuando detectamos que se presionó 57 // el botón procedemos a extraer los tres item seleccionados 58 public void actionPerformed(ActionEvent e) { 59 if (e.getSource()==boton1) {


60 String cad1=(String)combo1.getSelectedItem(); 61 String cad2=(String)combo2.getSelectedItem(); 62 String cad3=(String)combo3.getSelectedItem(); 63 // Los convertimos a entero 64 int rojo=Integer.parseInt(cad1); 65 int verde=Integer.parseInt(cad2); 66 int azul=Integer.parseInt(cad3); 67 // y creamos finalmente un objeto de la clase Color, 68 // el constructor de la clase Color requiere que le pasemos 69 // tres valores de tipo int 70 Color color1=new Color(rojo,verde,azul); 71 // Para cambiar el color de fondo del control JButton 72 // debemos llamar al método setBackground y pasarle el objeto 73 // de la clase Color 74 boton1.setBackground(color1); 75 } 76 } 77 78 public static void main(String[] ar) { 79 crearJComboBox2 formulario1=new crearJComboBox2(); 80 formulario1.setBounds(0,0,400,300); 81 formulario1.setVisible(true); 82 } 83 }

Resultado:

JTextArea El control de tipo JTextArea permite ingresar múltiples líneas, a diferencia del control de tipo JTextField.

Crear una aplicación que permita ingresar la dirección de una página web en un control de tipo JTextField y el cuerpo de la página en un control de tipo JTextArea.[crearJTextArea.java]



1 import javax.swing.*; 2 public class crearJTextArea extends JFrame{ 3 private JTextField textfield1; 4 5 //Declaramos los dos objetos 6 private JScrollPane scrollpane1; 7 private JTextArea textarea1; 8 public crearJTextArea() { 9 setLayout(null);

10 textfield1=new JTextField(); 11 textfield1.setBounds(10,10,200,30); 12 add(textfield1); 13 //Primero creamos el objeto de la clase JTextArea 14 textarea1=new JTextArea(); 15 // Seguidamente creamos el objeto de la clase JScrollPane y 16 // le pasamos como parámetro el objeto de la clase JTextArea 17 scrollpane1=new JScrollPane(textarea1); 18 // Definimos la posición y tamaño del control de tipo JScrollPane 19 // (y no del control JTextArea) 20 scrollpane1.setBounds(10,50,400,300); 21 // Finalmente añadimos el control de tipo JScrollPane al JFrame 22 add(scrollpane1); 23 } 24 25 public static void main(String[] ar) { 26 crearJTextArea formulario1=new crearJTextArea(); 27 formulario1.setBounds(0,0,540,400); 28 formulario1.setVisible(true); 29 } 30 } Resultado:


DESARROLLO DE SOFTWARE II JMenuBar, JMenu, JMenuItem Estos controles permiten implementar un menú horizontal en la parte superior de un JFrame para ello se necesita un objeto de la clase JMenuBar, uno o más objetos de la clase JMenu y por último objetos de la clase JMenuItem. Para interactuar con los eventos debemos implementar la interface ActionListener y asociarlo a los controles de tipo JMenuItem, el mismo se ejecutara al presionar con el mouse el JMenuItem.

Crear un menú de opciones que muestre tres opciones que permita cambiar el color de fondo del JFrame a los colores: rojo, verde y azul. [crearJMenuBar.java]

1 // Importamos el paquete javax.swing ya que en el mismo se encuentran 2 // las tres clases JMenuBar, JMenu y JMenuItem 3 import javax.swing.*; 4 // Importamos java.awt donde se encuentra la clase Color 5 import java.awt.*; 6 // Para la captura de eventos mediante la interface ActionListener 7 // debemos importar el paquete java.awt.event 8 import java.awt.event.*; 9 // Declaramos la clase Formulario, heredamos de la clase JFrame

10 // e indicamos que implementaremos la interface ActionListener 11 public class crearJMenuBar extends JFrame implements ActionListener{ 12 // Definimos un objeto de la clase JMenuBar (no importa que tan 13 // grande sea un menú de opciones solo se necesitará un solo 14 // objeto de esta clase) 15 private JMenuBar mb; 16 // Definimos un objeto de la clase JMenu (esta clase tiene por objeto 17 // desplegar un conjunto de objetos de tipo JMenuItem u otros objetos 18 // de tipo JMenu 19 private JMenu menu1; 20 // Definimos tres objetos de la clase JMenuItem (estos son los que 21 // disparan eventos cuando el operador los selecciona 22 private JMenuItem mi1,mi2,mi3; 23 public crearJMenuBar() { 24 setLayout(null); 25 // En el constructor creamos primero el objeto de la clase 26 // JMenuBar y lo asociamos al JFrame llamando al método setJMenuBar 27 mb=new JMenuBar(); 28 setJMenuBar(mb); 29 // Seguidamente creamos un objeto de la clase JMenu, en el 30 // constructor pasamos el String que debe mostrar y asociamos 31 // dicho JMenu con el JMenuBar llamando al método add de objeto



32 // de tipo JMenuBar (Es decir el objeto de la clase JMenu colabora 33 // con la clase JMenuBar) 34 menu1=new JMenu("Opciones"); 35 mb.add(menu1); 36 // Ahora comenzamos a crear los objetos de la clase JMenuItem y 37 // los añadimos al objeto de la clase JMenu (también mediante 38 // la llamada al método addActionListener indicamos al JMenuItem 39 // que objeto procesará el click 40 mi1=new JMenuItem("Rojo"); 41 mi1.addActionListener(this); 42 menu1.add(mi1); 43 // Lo mismo hacemos para los otros dos JMenuItem 44 mi2=new JMenuItem("Verde"); 45 mi2.addActionListener(this); 46 menu1.add(mi2); 47 mi3=new JMenuItem("Azul"); 48 mi3.addActionListener(this); 49 menu1.add(mi3); 50 } 51 52 //En el método actionPerformed primero obtenemos la referencia 53 // al panel asociado con el JFrame 54 public void actionPerformed(ActionEvent e) { 55 Container f=this.getContentPane(); 56 // Luego mediante if verificamos cual de los tres JMenuItem 57 // fue seleccionado y a partir de esto llamamos al método 58 // setBackground del objeto de la clase Container) 59 if (e.getSource()==mi1) { 60 f.setBackground(new Color(255,0,0)); 61 } 62 if (e.getSource()==mi2) { 63 f.setBackground(new Color(0,255,0)); 64 } 65 if (e.getSource()==mi3) { 66 f.setBackground(new Color(0,0,255)); 67 } 68 } 69 70 public static void main(String[] ar) { 71 crearJMenuBar formulario1=new crearJMenuBar(); 72 formulario1.setBounds(10,20,300,200); 73 formulario1.setVisible(true); 74 } 75 }


DESARROLLO DE SOFTWARE II Resultado:

Crear un menú de opciones que contenga además del JMenu de la barra otros dos objetos de la clase JMenu que dependan del primero. Uno debe mostrar dos JMenuItem que permitan modificar el tamaño del JFrame y el segundo también debe mostrar dos

JMenuItem que permitan cambiar el color de fondo. [crearJMenuBar2.java]

1 import javax.swing.*; 2 import java.awt.*; 3 import java.awt.event.*; 4 public class crearJMenuBar2 extends JFrame implements ActionListener{ 5 // Definimos un objeto de la clase JMenuBar, 3 objetos de la clase 6 // JMenu y finalmente 4 objetos de la clase JMenuItem 7 private JMenuBar mb; 8 private JMenu menu1,menu2,menu3; 9 private JMenuItem mi1,mi2,mi3,mi4;

10 public crearJMenuBar2() { 11 setLayout(null); 12 // Es importante notar el orden de creación de los objetos y 13 // como los relacionamos unos con otros. 14 // Primero creamos el JMenuBar y lo asociamos con el JFrame 15 mb=new JMenuBar(); 16 setJMenuBar(mb); 17 // Creamos el primer JMenu y lo pasamos como parámetro al 18 // JMenuBar mediante el método add 19 menu1=new JMenu("Opciones"); 20 mb.add(menu1); 21 // Ahora creamos el segundo objeto de la clase JMenu y lo asociamos 22 // con el primer JMenu creado 23 menu2=new JMenu("Tamaño de la ventana"); 24 menu1.add(menu2); 25 // En forma similar creamos el tercer objeto de la clase JMenu 26 // y lo asociamos con el primer JMenu creado 27 menu3=new JMenu("Color de fondo"); 28 menu1.add(menu3); 29 // Finalmente comenzamos a crear los objetos de la clase JMenuItem


DESARROLLO DE SOFTWARE II 30 // y los dos primeros los asociamos con el segundo JMenu 31 mi1=new JMenuItem("640*480"); 32 menu2.add(mi1); 33 mi1.addActionListener(this); 34 mi2=new JMenuItem("1024*768"); 35 menu2.add(mi2); 36 mi2.addActionListener(this); 37 // También hacemos lo mismo con los otros dos objetos de tipo 38 // JMenuItem pero ahora los asociamos con el tercer JMenu 39 mi3=new JMenuItem("Rojo"); 40 menu3.add(mi3); 41 mi3.addActionListener(this); 42 mi4=new JMenuItem("Verde"); 43 menu3.add(mi4); 44 mi4.addActionListener(this); 45 } 46 47 public void actionPerformed(ActionEvent e) { 48 // En el método actionPerformed si se presiona el mi1 procedemos 49 // a redimensionar el JFrame llamando al método setSize y le 50 // pasamos dos parámetros que representan el nuevo ancho y 51 // alto de la ventana 52 if (e.getSource()==mi1) { 53 setSize(640,480); 54 } 55 // De forma similar si se presiona el segundo JMenuItem 56 // cambiamos el tamaño de la ventana a 1024 píxeles por 768 57 if (e.getSource()==mi2) { 58 setSize(1024,768); 59 } 60 // Para cambiar de color de forma similar al problema anterior 61 // mediante el método getContentPane obtenemos la referencia al 62 // objeto de la clase Container y llamamos al método setBackground 63 // para fijar un nuevo color de fondo 64 if (e.getSource()==mi3) { 65 getContentPane().setBackground(new Color(255,0,0)); 66 } 67 if (e.getSource()==mi4) { 68 getContentPane().setBackground(new Color(0,255,0)); 69 } 70 } 71 72 public static void main(String[] ar) { 73 crearJMenuBar2 formulario1=new crearJMenuBar2();


DESARROLLO DE SOFTWARE II 74 formulario1.setBounds(0,0,300,200); 75 formulario1.setVisible(true); 76 } 77 }

Resultado:

JCheckBox El control JCheckBox permite crear un cuadro de selección (básicamente un botón de dos estados)

Crear una aplicación que muestre 3 opciones de la clase JCheckBox con etiquetas de tres mensajes. Cuando se seleccione mostrar en el título del JFrame todos los JCheckBox seleccionados [crearJCheckBox.java]

1 // Lo primero y más importante que tenemos que notar que para capturar el 2 // cambio de estado del JCheckBox hay que implementar la interface 3 // ChangeListener que se encuentra en el paquete 4 import javax.swing.*; 5 import javax.swing.event.*; 6 // Cuando declaramos la clase JFrame indicamos que implementaremos 7 // la interface ChangeListener 8 public class crearJCheckBox extends JFrame implements ChangeListener{ 9 // Definimos tres objetos de la clase JCheckBox

10 private JCheckBox check1,check2,check3; 11 public crearJCheckBox() { 12 setLayout(null); 13 // En el constructor creamos cada uno de los objetos de la 14 // clase JCheckBox y llamamos al método addChangeListener 15 // indicando quien procesará el evento de cambio de estado 16 check1=new JCheckBox("Desarrollo de Software"); 17 check1.setBounds(10,10,250,30); 18 check1.addChangeListener(this); 19 add(check1); 20 check2=new JCheckBox("Diseño y Desarrollo Web");


DESARROLLO DE SOFTWARE II 21 check2.setBounds(10,50,250,30); 22 check2.addChangeListener(this); 23 add(check2); 24 check3=new JCheckBox("Redes de Computadoras"); 25 check3.setBounds(10,90,250,30); 26 check3.addChangeListener(this); 27 add(check3); 28 } 29 // El método que debemos implementar de la interface ChangeListener es: 30 public void stateChanged(ChangeEvent e){ 31 // En este mediante tres if verificamos el estado de cada 32 // JCheckBox y concatenamos los String con los valores seleccionados 33 String cad=""; 34 if (check1.isSelected()==true) { 35 cad=cad+"DS-"; 36 } 37 if (check2.isSelected()==true) { 38 cad=cad+"DW-"; 39 } 40 if (check3.isSelected()==true) { 41 cad=cad+"REDES-"; 42 } 43 setTitle(cad); 44 } 45 46 public static void main(String[] ar) { 47 crearJCheckBox formulario1=new crearJCheckBox(); 48 formulario1.setBounds(0,0,300,200); 49 formulario1.setVisible(true); 50 } 51 }

Resultado:



Crear un control JLabel que muestre el siguiente mensaje: "Esta de acuerdo con los servicios de SENATI?", luego un JCheckBox y finalmente un objeto de tipo JButton desactivo. Cuando presionemos el JCheckBox debemos activar el botón. [crearJCheckBox2.java]

1 // También importamos el paquete donde están definidas 2 // las clases JFrame, JButton y JCheckBox 3 import javax.swing.*; 4 // Importamos los paquetes donde se encuentran las interfaces para 5 // captura de eventos de objetos de tipo JButton y JCheckBox 6 import javax.swing.event.*; 7 import java.awt.event.*; 8 // Como debemos implementar dos interfaces las debemos enumerar 9 // después de la palabra implements separadas por coma

10 public class crearJCheckBox2 extends JFrame implements 11 ActionListener, ChangeListener{ 12 // Definimos los tres objetos 13 private JLabel label1; 14 private JCheckBox check1; 15 private JButton boton1; 16 // En el constructor creamos el objeto de tipo JLabel 17 public crearJCheckBox2() { 18 setLayout(null); 19 label1=new JLabel("Esta de acuerdo con los servicios de SENATI?"); 20 label1.setBounds(10,10,400,30); 21 add(label1); 22 // El objeto de tipo JCheckBox 23 check1=new JCheckBox("Acepto"); 24 check1.setBounds(10,50,100,30); 25 check1.addChangeListener(this); 26 add(check1); 27 // y también creamos el objeto de tipo JButton y llamando 28 // al método setEnabled con un valor false luego el botón 29 // aparece desactivo 30 boton1=new JButton("Continuar"); 31 boton1.setBounds(10,100,100,30); 32 add(boton1); 33 boton1.addActionListener(this); 34 boton1.setEnabled(false); 35 } 36 // Cuando se cambia el estado del control JCheckBox se ejecuta el 37 // método stateChanged donde verificamos si está seleccionado 38 // procediendo a activar el botón en caso negativo lo desactivamos



39 public void stateChanged(ChangeEvent e) { 40 if (check1.isSelected()==true) { 41 boton1.setEnabled(true); 42 } else { 43 boton1.setEnabled(false); 44 } 45 } 46 // El método actionPerformed se ejecuta cuando se presiona el objeto 47 // de tipo JButton (debe estar activo para poder presionarlo) 48 public void actionPerformed(ActionEvent e) { 49 if (e.getSource()==boton1) { 50 System.exit(0); 51 } 52 } 53 54 public static void main(String[] ar) { 55 crearJCheckBox2 formulario1=new crearJCheckBox2(); 56 formulario1.setBounds(0,0,350,200); 57 formulario1.setVisible(true); 58 } 59 }

Resultado:

JRadioButton Este control es muy utilizado el cual normalmente muestra un conjunto de JRadioButton y permiten la selección de solo uno de ellos. Tienen que ser agrupados para que funcionen en conjunto, es decir cuando se selecciona uno automáticamente se deben desmarcar los otros.

Crear una aplicación que permita muestrar 3 objetos de la clase JRadioButton que permitan cambair el ancho y alto del JFrame. [crearJRadioButton.java]



1 // Importamos los dos paquetes donde están definidas las clases 2 // e interfaces para la captura de eventos 3 import javax.swing.*; 4 import javax.swing.event.*; 5 // Heredamos de la clase JFrame e implementamos la interface 6 // ChangeListener para capturar el cambio de selección de 7 // objeto de tipo JRadioButton 8 public class crearJRadioButton extends JFrame implements ChangeListener{ 9 // Definimos tres objetos de la clase JRadioButton

10 // y uno de tipo ButtonGroup 11 private JRadioButton radio1,radio2,radio3; 12 private ButtonGroup bg; 13 public crearJRadioButton() { 14 setLayout(null); 15 // En el constructor creamos primero el objeto de la clase ButtonGroup 16 bg=new ButtonGroup(); 17 // Creamos seguidamente el objeto de la clase JRadioButton, 18 // definimos su ubicación, llamamos al método addChangeListener 19 // para informar que objeto capturará el evento y finalmente 20 // añadimos el objeto JRadioButton al JFrame y al ButtonGroup 21 radio1=new JRadioButton("640*480"); 22 radio1.setBounds(10,20,100,30); 23 radio1.addChangeListener(this); 24 add(radio1); 25 bg.add(radio1); 26 // Exactamente hacemos lo mismo con los otros dos JRadioButton 27 radio2=new JRadioButton("800*600"); 28 radio2.setBounds(10,70,100,30); 29 radio2.addChangeListener(this); 30 add(radio2); 31 bg.add(radio2); 32 radio3=new JRadioButton("1024*768"); 33 radio3.setBounds(10,120,100,30); 34 radio3.addChangeListener(this); 35 add(radio3); 36 bg.add(radio3); 37 } 38 // En el método stateChanged verificamos cual de los tres 39 // JRadioButton está seleccionado y procedemos a redimensionar el JFrame 40 public void stateChanged(ChangeEvent e) { 41 if (radio1.isSelected()) { 42 setSize(640,480); 43 } 44 if (radio2.isSelected()) {



45 setSize(800,600); 46 } 47 if (radio3.isSelected()) { 48 setSize(1024,768); 49 } 50 } 51 52 public static void main(String[] ar) { 53 crearJRadioButton formulario1=new crearJRadioButton(); 54 formulario1.setBounds(0,0,350,230); 55 formulario1.setVisible(true); 56 } 57 }

Resultado:

Crear una aplicación que permita muestrar 3 campos de texto [Ejemplo_CampoTexto.java]

1

2 import java.awt.*; 3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_CampoTexto extends JFrame 6 { 7 private JTextField campoTexto1, campoTexto2, campoTexto3; 8 private JPasswordField campoContraseña; 9 // configurar GUI

10 public Ejemplo_CampoTexto() 11 { 12 super( "Prueba de JTextField y JPasswordField" ); 13 Container contenedor = getContentPane(); 14 contenedor.setLayout( new FlowLayout() ); 15 // crear campo de texto con tamaño predeterminado 16 campoTexto1 = new JTextField( 10 ); 17 contenedor.add( campoTexto1 );


DESARROLLO DE SOFTWARE II 18 // crear campo de texto con texto predeterminado 19 campoTexto2 = new JTextField( "Escriba el texto aquí" ); 20 contenedor.add( campoTexto2 ); 21 // crear campo de texto con texto predeterminado, 22 // 20 elementos visibles y sin manejador de eventos 23 campoTexto3 = new JTextField( "Campo de texto no editable", 20 ); 24 campoTexto3.setEditable( false ); 25 campoTexto3.setToolTipText("Esto no se puede editar"); 26 contenedor.add( campoTexto3 ); 27 // crear campo de contraseña con texto predeterminado 28 campoContraseña = new JPasswordField( "Texto oculto" ); 29 contenedor.add( campoContraseña ); 30 // registrar manejadores de eventos 31 ManejadorCampoTexto manejador = new ManejadorCampoTexto(); 32 campoTexto1.addActionListener( manejador ); 33 campoTexto2.addActionListener( manejador ); 34 campoTexto3.addActionListener( manejador ); 35 campoContraseña.addActionListener( manejador ); 36 setSize( 325, 200 ); 37 setVisible( true ); 38 } // fin del constructor de PruebaCampoTexto 39 public static void main( String args[] ) 40 { 41 Ejemplo_CampoTexto aplicacion = new Ejemplo_CampoTexto(); 42 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 43 } 44 // clase interna privada para el manejo de eventos 45 private class ManejadorCampoTexto implements ActionListener 46 { 47 // procesar eventos de campo de texto 48 public void actionPerformed( ActionEvent evento ) 49 { 50 String cadena = ""; 51 // el usuario presione Enter en el objeto 52 // JTextField campoTexto1 53 if ( evento.getSource() == campoTexto1 ) 54 cadena = "campoTexto1: " + evento.getActionCommand(); 55 56 // el usuario presione Enter en el objeto 57 // JTextField campoTexto2 58 else if ( evento.getSource() == campoTexto2 ) 59 cadena = "campoTexto2: " + evento.getActionCommand(); 60 // el usuario presione Enter en el objeto 61 // JTextField campoTexto3


DESARROLLO DE SOFTWARE II 62 else if ( evento.getSource() == campoTexto3 ) 63 cadena = "campoTexto3: " + evento.getActionCommand(); 64 // el usuario presione Enter en el objeto 65 // JTextField campoContraseña 66 else if ( evento.getSource() == campoContraseña ) { 67 cadena = "campoContrasenia: " + 68 new String( campoContraseña.getPassword() ); 69 } 70 JOptionPane.showMessageDialog( null, cadena,"Resultados", 71 JOptionPane.CANCEL_OPTION); 72 } // fin del método actionPerformed 73 } // fin de la clase interna privada ManejadorCampoTexto 74 } // fin de la clase

Resultado:

JTextArea Finalmente veamos un ejemplo donde se muestran la mayoría de los componentes:

1

2 import java.awt.*; 3 import javax.swing.JFrame; 4 import javax.swing.JScrollPane; 5 import javax.swing.JTextArea; 6 public class Ejemplo_JTextArea1{ 7 public static void main (String [] args) 8 { 9 //Método para cambiar la decoración de la ventana en sí,

10 //si ponemos el valor en falso la ventana 11 //se verá de la forma predeterminada de Windows 12 JFrame.setDefaultLookAndFeelDecorated(true); 13 //creamos el JFrame principal donde agregaremos el resto de objetos 14 JFrame marco = new JFrame ("JTextArea Test"); 15 marco.setLayout (new FlowLayout ());



16 marco.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); 17 String text = "Un objeto JTextArea es una área multilínea " 18 + "para escribir texto. " 19 + "Se puede cambiar el número de líneas que se mostrarán, " 20 + "y también el numero de columnas. " 21 + "Puedes cambiar las fuentes y tamaños de letras. " 22 + "Y puedes agregar tu TextArea en un JScrollPane " 23 + "para poder mover las zonas de texto." ; 24 //creamos un area de texto normal no redimensionable 25 JTextArea textAreal = new JTextArea(text,20,10); 26 textAreal.setPreferredSize(new Dimension (10,100)); 27 //creamos otra área de texto con un JScrollPane, sólo es agregado 28 JTextArea textArea2 = new JTextArea(text,20,10); 29 JScrollPane scroll = new JScrollPane(textArea2); 30 marco.getContentPane().add(scroll, BorderLayout.CENTER); 31 marco.add(scroll); 32 //El método setLineWrap lo que hace es ordenar las palabras 33 //para que no se salgan de los márgenes, 34 //si lo desactivamos(false), el texto se escribirá hacia 35 //el lado(en una línea) y no se vería todo si el 36 //texto es muy largo 37 textAreal.setLineWrap (true); 38 textArea2.setLineWrap (true); 39 textAreal.setWrapStyleWord(true); 40 textArea2.setWrapStyleWord(true); 41 //agregamos los area de texto al frame principal, 42 //nota: el textArea2 está dentro de un JScrollPane, 43 //por eso éste es el que agregamos al frame 44 marco.add(textAreal); 45 marco.add(scroll); 46 //el metodo pack sirve para dejar todo dentro del frame 47 marco.pack(); 48 //y finalmente el metodo setVisible 49 //es para que se visualice la ventana 50 marco.setVisible(true) ; 51 } 52 }

Resultado:



JTextArea Objetos de esta clase se utilizan para que el usuario pueda introducir datos tipo texto de gran tamaño.

1 2 import javax.swing.*;

3 import javax.swing.event.*; 4 import java.awt.*; 5 public class Ejemplo_JTextArea2 extends JFrame 6 { 7 public Ejemplo_JTextArea2 () 8 { 9 Container c = getContentPane () ;

10 c.setLayout (new FlowLayout () ) ; 11 JTextArea area = new JTextArea(8,20 ) ; 12 c.add (new JLabel ( "Observaciones" ) ) ; 13 c.add( area ) ; 14 setSize (350 ,200) ; 15 setVisible ( true ) ; 16 } 17 public static void main (String[] args ) 18 { 19 new Ejemplo_JTextArea2() ; 20 } 21 } Resultado:

JDesktopPane y JInternalFrame

Este codigo nos crea una ventana interna con todas las opciones ya mencionadas y ademas se puede minimizar este es el constructor mas completo.



JDesktopPane 1

2 import java.awt.event.ActionEvent; 3 import java.awt.event.ActionListener; 4 import javax.swing.JApplet; 5 import javax.swing.JDesktopPane; 6 import javax.swing.JInternalFrame; 7 import javax.swing.JMenu; 8 import javax.swing.JMenuBar; 9 import javax.swing.JMenuItem;

10 import javax.swing.JScrollPane; 11 import javax.swing.JTextArea; 12 public class Ejemplo_JDesktopPane extends JApplet { 13 JDesktopPane escritorio; 14 int i=0; 15 int intervalo=10; 16 public void init(){ 17 escritorio=new JDesktopPane(); 18 add(escritorio); 19 JMenuBar barra=new JMenuBar(); 20 JMenu archivo=new JMenu("Archivo"); 21 JMenuItem nuevo=new JMenuItem("Nuevo"); 22 nuevo.addActionListener(new ActionListener() { 23 public void actionPerformed(ActionEvent arg0) { 24 i++; 25 JInternalFrame ventanaInterna=new JInternalFrame 26 ("Ventana "+i,true,true,true,true); 27 JTextArea texto=new JTextArea(); 28 JScrollPane scroll=new JScrollPane(texto); 29 ventanaInterna.add(scroll); 30 ventanaInterna.setBounds 31 (0+intervalo,0+intervalo,200,200); 32 intervalo+=10; 33 escritorio.add(ventanaInterna); 34 ventanaInterna.setVisible(true); 35 } 36 }); 37 archivo.add(nuevo); 38 barra.add(archivo); 39 setJMenuBar(barra); 40 } 41 }



JWindow

1 2 import javax.swing.*;

3 import java.awt.*; 4 public class Ejemplo_JWindow extends JWindow { 5 BorderLayout bordeLayout1 = new BorderLayout(); 6 JPanel southPanel = new JPanel(); 7 FlowLayout southPanelFlowLayout = new FlowLayout(); 8 JProgressBar barradeprogreso = new JProgressBar(); 9 ImageIcon imagenIcono;

10 // Constructor 11 public Ejemplo_JWindow() 12 { 13 //this.imagenIcono = imageIcon; 14 dibujaVentana(); 15 } 16 public void dibujaVentana() 17 { 18 // Crear contenedor 19 this.getContentPane().setLayout(bordeLayout1); 20 southPanel.setLayout(southPanelFlowLayout); 21 southPanel.setBackground(Color.BLACK); 22 // Agregar al contenedor 23 this.getContentPane().add 24 (southPanel,BorderLayout.SOUTH); 25 southPanel.add(barradeprogreso, null); 26 // Ejecutar constructor 27 this.pack(); 28 } 29 //Generar los eventos 30 public void ProgresoMaximo(int maxProgress)


DESARROLLO DE SOFTWARE II 31 { 32 barradeprogreso.setMaximum(maxProgress); 33 } 34 public void enviarProgreso(int barra) 35 { 36 final int progreso = barra; 37 barradeprogreso.setValue(progreso); 38 } 39 public void activarProgreso(String mensaje,int barra) 40 { 41 final int progreso = barra; 42 final String theMessage = mensaje; 43 enviarProgreso(barra); 44 barradeprogreso.setValue(progreso); 45 enviarMensaje(theMessage); 46 } 47 private void enviarMensaje(String mensaje) 48 { 49 if (mensaje==null){ 50 mensaje = ""; 51 barradeprogreso.setStringPainted(false);} 52 else{ 53 barradeprogreso.setStringPainted(true);} 54 55 barradeprogreso.setString(mensaje); 56 } 57 ///------------------------------------- 58 public void velocidadDeCarga() 59 { 60 for (int i = 0; i <= 100; i++) 61 {//modifica el numero segun la velidad q desees 62 for (long j=0; j<1000000; ++j) 63 { 64 String msg = " " + (j + i); 65 } 66 // si quieres q muestre los numeros y un mensaje 67 activarProgreso("Conectando..." + i, i); 68 //si no quieres q muestre nada, solo la barra 69 //setProgreso(i); 70 } 71 // Liberar memoria. 72 dispose(); 73 } 74 }

DESARROLLO DE SOFTWARE II 1

2 import javax.swing.UIManager; 3 import javax.swing.ImageIcon; 4 public class Ejemplo_llamarJWindow1 { 5 // Instanciar a la clase. 6 Ejemplo_JWindow ventana; 7 //Constructor 8 public Ejemplo_llamarJWindow1() { 9 // Llamar al método

10 inicioPantalla(); 11 // Llamar al método de la clase 12 // instanciada 13 ventana.velocidadDeCarga(); 14 } 15 private void inicioPantalla() { 16 ventana = new Ejemplo_JWindow(); 17 ventana.setLocationRelativeTo(null); 18 ventana.ProgresoMaximo(100); 19 ventana.setVisible(true); 20 } 21 // Llamar al constructor 22 public static void main(String[] args) 23 { 24 new Ejemplo_llamarJWindow1(); 25 } 26 }

Resultado:

JTabbedPane

1

2 import java.awt.*; 3 import javax.swing.*; 4 public class Ejemplo_JTabbedPane extends JFrame 5 { 6 // configurar GUI 7 public Ejemplo_JTabbedPane() 8 { 9 super( "Ejemplo de JTabbedPane" );


DESARROLLO DE SOFTWARE II 10 // crear objeto JTabbedPane 11 JTabbedPane panelConFichas = 12 new JTabbedPane(); 13 // establecer pane11 y agregarlo 14 // al objeto JTabbedPane 15 JLabel etiqueta1 = new JLabel 16 ( "panel uno", SwingConstants.CENTER ); 17 JPanel panel1 = new JPanel(); 18 panel1.add( etiqueta1 ); 19 panelConFichas.addTab 20 ("Ficha uno", null,panel1,"Primer panel"); 21 // establecer panel2 y 22 // agregarlo al objeto JTabbedPane 23 JLabel etiqueta2 = new JLabel 24 ("panel dos",SwingConstants.CENTER); 25 JPanel panel2 = new JPanel(); 26 panel2.setBackground( Color.YELLOW ); 27 panel2.add( etiqueta2 ); 28 panelConFichas.addTab 29 ("Ficha dos",null,panel2,"Segundo panel"); 30 // establecer panel3 y 31 // agregarlo al objeto JTabbedPane 32 JLabel etiqueta3 = 33 new JLabel("panel tres"); 34 JPanel panel3 = new JPanel(); 35 panel3.setLayout(new BorderLayout()); 36 panel3.add(new JButton("Norte"), 37 BorderLayout.NORTH); 38 panel3.add(new JButton("Oeste"), 39 BorderLayout.WEST); 40 panel3.add(new JButton("Este"), 41 BorderLayout.EAST); 42 panel3.add(new JButton("Sur"), 43 BorderLayout.SOUTH); 44 panel3.add(etiqueta3, BorderLayout.CENTER); 45 panelConFichas.addTab 46 ("Ficha tres",null,panel3,"Tercer panel"); 47 // agregar objeto JTabbedPane al contenedor 48 getContentPane().add(panelConFichas); 49 setSize(250,200); 50 setVisible(true); 51 } // fin del constructor 52 public static void main(String args[]) 53 {


DESARROLLO DE SOFTWARE II 54 Ejemplo_JTabbedPane PanelFichas = 55 new Ejemplo_JTabbedPane(); 56 PanelFichas.setDefaultCloseOperation 57 ( JFrame.EXIT_ON_CLOSE ); 58 } 59 } // fin de la clase

Resultado:

JEditor Pane

1

2 import javax.swing.JEditorPane; 3 import javax.swing.JFrame; 4 import javax.swing.JScrollPane; 5 import javax.swing.WindowConstants; 6 public class EjemploJEditorPaneRtf 7 { 8 public EjemploJEditorPaneRtf() 9 {

10 try 11 { 12 // Preparación de la ventana 13 JFrame v = new 14 JFrame("JEditorPane con RTF"); 15 JEditorPane editor = 16 new JEditorPane(); 17 JScrollPane scroll = 18 new JScrollPane(editor); 19 v.getContentPane().add(scroll); 20 v.setDefaultCloseOperation( 21 WindowConstants.EXIT_ON_CLOSE);


DESARROLLO DE SOFTWARE II 22 // Se le dice al editor que va a usar RTF 23 editor.setContentType("text/rtf"); 24 // Un texto en RTF 25 editor.setText( 26 "{\\rtf1" + 27 "{\\colortbl ;" + 28 "\\red255\\green0\\blue0;}" + 29 "Esto\\par " + 30 "es una \\b prueba\\b0 de " + 31 "\\i cursiva\\i0\\par " + 32 "y \\cf1 todo\\cf0 \\par" + "}"); 33 // Se visualiza 34 v.pack(); 35 v.setVisible(true); 36 } 37 catch (Exception e) 38 { 39 e.printStackTrace(); 40 } 41 } 42 43 public static void main(String[] args) 44 { 45 new EjemploJEditorPaneRtf(); 46 } 47 } Resultado:

JEditorPane

1 2 import javax.swing.JEditorPane;

3 import javax.swing.JFrame; 4 import javax.swing.JScrollPane; 5 import javax.swing.WindowConstants; 6 public class EjemploJEditorPaneHtml 7 {


DESARROLLO DE SOFTWARE II 8 public EjemploJEditorPaneHtml() 9 {

10 try 11 { 12 // Preparamos la ventana de ejemplo 13 JFrame v = 14 new JFrame("JEditorPane con HTML"); 15 JEditorPane editor = 16 new JEditorPane(); 17 JScrollPane scroll = 18 new JScrollPane(editor); 19 v.getContentPane().add(scroll); 20 v.setDefaultCloseOperation 21 (WindowConstants.EXIT_ON_CLOSE); 22 // Marcamos el editor para que use HTML 23 editor.setContentType("text/html"); 24 // Insertamos un texto 25 editor.setText( 26 "<head><base href=\"file:d:/\">" + 27 "</head>"+ 28 "hola " + 29 "adios " + 30 "" + 31 "fuente arial " + 32 "" + 33 "fuente courier " + 34 "fuente grande" + 35 " " + 36 "color rojo" + 37 " "); 38 // Se visualiza la ventana 39 v.pack(); 40 v.setVisible(true); 41 } 42 catch (Exception e) 43 { 44 e.printStackTrace(); 45 } 46 } 47 public static void main(String[] args) 48 { 49 new EjemploJEditorPaneHtml(); 50 } 51 }


JSPLITPANE: JsplitPane se usa para dividir con una barrita divisoria dos y solo dos componentes, mismos que pueden ser alineados de izquierda a derecha o de arriba hacia abajo.

1 2 import java.lang.*;

3 import java.awt.*; 4 import java.awt.event.*; 5 import javax.swing.*; 6 public class Ejemplo_JSplitpane 7 { 8 // declaracion, creacion e 9 // inicializacion de componentes,

10 // objetos y variables 11 static JFrame ventana= new JFrame(); 12 // abajo se creando con orientacion 13 // vertical u horizontal 14 static JSplitPane panel1 = new 15 JSplitPane(JSplitPane.HORIZONTAL_SPLIT); 16 static JLabel jl1 = new 17 JLabel("en split1 label1"); 18 static JLabel jl2 = new 19 JLabel("en split2 label2"); 20 // parte principal de programa 21 public static void main(String[] args) 22 { // area de definicion de 23 // propiedades de el objeto 24 ventana.setTitle("mi programa"); 25 ventana.setDefaultCloseOperation 26 (ventana.EXIT_ON_CLOSE); 27 // cargando splitpanel panel1 28 // con sus dos componentes


DESARROLLO DE SOFTWARE II 29 panel1.add(jl1); panel1.add(jl2); 30 // cargando la ventana con splitpanel 31 ventana.getContentPane().add 32 (panel1,BorderLayout.CENTER); 33 ventana.pack(); 34 ventana.setVisible(true); 35 //area de asociacion de objeto-eventos 36 }; // termina main 37 } // termina clase Resultado:

JInternalFrames como contenedores de aplicación. JInternalFrame


3 import java.awt.event.*; 4 import javax.swing.*; 5 public class Ejemplo_JInternalFrame extends JFrame 6 { 7 private JDesktopPane elEscritorio; 8 // configurar GUI 9 public Ejemplo_JInternalFrame()

10 { 11 super( "Uso de un objeto InternalFrame" ); 12 // crear barra de menús, menu y elemento de menú 13 JMenuBar barra = new JMenuBar(); 14 JMenu menuAgregar = new JMenu( "Agregar" ); 15 JMenuItem nuevoMarco = new JMenuItem( "Marco interno" ); 16 menuAgregar.add( nuevoMarco );


DESARROLLO DE SOFTWARE II 17 barra.add( menuAgregar ); 18 setJMenuBar( barra ); 19 // establecer escritorio 20 elEscritorio = new JDesktopPane(); 21 getContentPane().add( elEscritorio ); 22 // establecer componente de escucha 23 // para elemento de menú nuevoMarco 24 nuevoMarco.addActionListener(new ActionListener() 25 { 26 // mostrar nueva ventana interna 27 public void actionPerformed( ActionEvent evento ) 28 { 29 // crear marco interno 30 JInternalFrame marco = new 31 JInternalFrame("Marco interno", true, true, true, true ); 32 // adjuntar panel al panel de contenido del marco interno 33 Container contenedor = marco.getContentPane(); 34 MiJPanel panel = new MiJPanel(); 35 contenedor.add( panel, BorderLayout.CENTER ); 36 37 // establecer tamaño de marco interno 38 // en el tamaño de su contenido 39 marco.pack(); 40 // adjuntar marco interno al escritorio y mostrarlo 41 elEscritorio.add( marco ); 42 marco.setVisible( true ); 43 } 44 } // fin de la clase interna anónima 45 ); // fin de la llamada a addActionListener 46 setSize( 600, 460 ); 47 setVisible( true ); 48 } // fin del constructor 49 public static void main( String args[] ) 50 { 51 Ejemplo_JInternalFrame aplicacion = new Ejemplo_JInternalFrame(); 52 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 53 } 54 } // fin de la clase DemoEscritorio 55 // clase para mostrar un objeto ImageIcon en un panel 56 class MiJPanel extends JPanel 57 { 58 public MiJPanel() 59 { 60 }


DESARROLLO DE SOFTWARE II 61 public void paintComponent( Graphics g ) 62 { 63 // llamar al método paintComponent de la superclase 64 super.paintComponent( g ); 65 } 66 // devolver dimensiones 67 public Dimension getPreferredSize() 68 { 69 return new Dimension( ); 70 } 71 } // fin de la clase Resultado:

Comentarios: En la línea: elEscritorio = new JDesktopPane(); Se asigna la referencia JdesktopPane (paquete javax.swing), que apunta a la variable elEscritorio, a un nuevo objeto JdesktopPane que se utilizará paraadministrar las ventanas hijas JinternalFrame. En la línea: getContentPane().add( elEscritorio ); Se agrega el objeto al panel de contenido de la ventana de aplicación. De manera predeterminada, el objeto JdesktopPane se agrega al centro del layout BorderLayout del panel de contenido, por lo que el objeto se expande para rellenar toda la ventana de aplicación. El constructor JinternalFrame requiere cinco argumentos: una cadena para la barra de título de la ventana interna, un valor boolean para indicar si el usuario puede: Reajustar el tamaño del marco interno cerrar, el marco interno maximizar el marco interno minimizar el marco interno.



JSlider

1 2 import java.awt.*; 3 import javax.swing.*; 4 public class Ejemplo_JSlider extends JPanel { 5 private int diametro = 10; 6 // dibujar un óvalo del diámetro especificado 7 public void paintComponent( Graphics g ) 8 { 9 super.paintComponent( g );

10 g.fillOval( 10, 10, diametro, diametro ); 11 } 12 // validar y establecer el diámetro, después repintar 13 public void establecerDiametro( int nuevoDiametro ) 14 { 15 // si el diámetro es inválido, 16 // usar valor predeterminado de 10 17 diametro = ( nuevoDiametro >= 0 ? nuevoDiametro : 10 ); 18 repaint(); 19 } 20 // utilizado por el administrador de esquemas 21 // para determinar el tamaño preferido 22 public Dimension getPreferredSize() 23 { 24 return new Dimension( 200, 200 ); 25 } 26 // utilizado por el administrador de esquemas 27 // para determinar el tamaño mínimo 28 public Dimension getMinimumSize() 29 { 30 return getPreferredSize(); 31 } 32 } // fin de la clase



2 import java.awt.*; 3 import java.awt.event.*; 4 import javax.swing.*; 5 import javax.swing.event.*; 6 public class Ejemplo_llamarJSlider extends JFrame { 7 private JSlider sliderDiametro; 8 private Ejemplo_JSlider miPanel; 9 public Ejemplo_llamarJSlider()

10 { 11 super( "Demostración de JSlider" ); 12 // establecer PanelOvalo 13 miPanel = new Ejemplo_JSlider(); 14 miPanel.setBackground( Color.YELLOW ); 15 // establecer objeto JSlider 16 // para controlar el valor del diámetro 17 sliderDiametro = 18 new JSlider( SwingConstants.HORIZONTAL, 0, 200, 10 ); 19 sliderDiametro.setMajorTickSpacing( 10 ); 20 sliderDiametro.setPaintTicks( true ); 21 // registrar componente de escucha de eventos de JSlider 22 sliderDiametro.addChangeListener( 23 // clase interna anónima 24 new ChangeListener() { 25 // manejar cambio en el valor del control deslizable 26 public void stateChanged( ChangeEvent e ) 27 { 28 miPanel.establecerDiametro( sliderDiametro.getValue() ); 29 } 30 } // fin de la clase interna anónima 31 32 ); // fin de la llamada a addChangeListener 33 // adjuntar componentes al panel de contenido 34 Container contenedor = getContentPane(); 35 contenedor.add( sliderDiametro, BorderLayout.SOUTH ); 36 contenedor.add( miPanel, BorderLayout.CENTER ); 37 setSize( 220, 270 ); 38 setVisible( true ); 39 } // fin del constructor de DemoSlider 40 public static void main( String args[] ) 41 { 42 Ejemplo_llamarJSlider aplicacion=new Ejemplo_llamarJSlider(); 43 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 44 }


DESARROLLO DE SOFTWARE II 45 } // fin de la clase Resultado:

JList


3 import java.awt.event.*; 4 import javax.swing.*; 5 import javax.swing.event.*; 6 public class Ejemplo_llamarJSlider extends JFrame { 7 private JSlider sliderDiametro; 8 private Ejemplo_JSlider miPanel; 9 public Ejemplo_llamarJSlider()

10 { 11 super( "Demostración de JSlider" ); 12 // establecer PanelOvalo 13 miPanel = new Ejemplo_JSlider(); 14 miPanel.setBackground( Color.YELLOW ); 15 // establecer objeto JSlider 16 // para controlar el valor del diámetro 17 sliderDiametro = 18 new JSlider( SwingConstants.HORIZONTAL, 0, 200, 10 ); 19 sliderDiametro.setMajorTickSpacing( 10 ); 20 sliderDiametro.setPaintTicks( true ); 21 // registrar componente de escucha de eventos de JSlider 22 sliderDiametro.addChangeListener( 23 // clase interna anónima 24 new ChangeListener() { 25 // manejar cambio en el valor del control deslizable 26 public void stateChanged(ChangeEvent e) 27 { 28 miPanel.establecerDiametro(sliderDiametro.getValue());



29 } 30 } // fin de la clase interna anónima 31 ); // fin de la llamada a addChangeListener 32 // adjuntar componentes al panel de contenido 33 Container contenedor = getContentPane(); 34 contenedor.add( sliderDiametro, BorderLayout.SOUTH ); 35 contenedor.add( miPanel, BorderLayout.CENTER ); 36 setSize( 220, 270 ); 37 setVisible( true ); 38 } // fin del constructor de DemoSlider 39 public static void main( String args[] ) 40 { 41 Ejemplo_llamarJSlider aplicacion = new Ejemplo_llamarJSlider(); 42 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 43 } 44 } // fin de la clase

Reasultado:

JScrollBar

1 package proyecto.modulo.pkg3.capitulo.pkg7; 2 import javax.swing.*; 3 import java.awt.*; 4 import java.awt.event.*; 5 import javax.swing.*; 6 public class Ejemplo_JScrollBar { 7 public static void main(String[] args) { 8 final JFrame marco = new JFrame("Ejemplo JScrollbar"); 9 final JLabel etiqueta = new JLabel( );

10 JScrollBar hbarra=new JScrollBar 11 (JScrollBar.HORIZONTAL, 30, 20, 0, 500); 12 JScrollBar vbarra=new JScrollBar 13 (JScrollBar.VERTICAL, 30, 40, 0, 500); 14 class MyAdjustmentListener implements AdjustmentListener { 15 public void adjustmentValueChanged(AdjustmentEvent e) {


DESARROLLO DE SOFTWARE II 16 etiqueta.setText("La posición es: " + e.getValue()); 17 marco.repaint(); 18 } 19 } 20 hbarra.addAdjustmentListener(new MyAdjustmentListener( )); 21 vbarra.addAdjustmentListener(new MyAdjustmentListener( )); 22 marco.setLayout(new BorderLayout( )); 23 marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 24 marco.setSize(300,200); 25 marco.getContentPane().add(etiqueta); 26 marco.getContentPane().add(hbarra, BorderLayout.SOUTH); 27 marco.getContentPane().add(vbarra, BorderLayout.EAST); 28 marco.getContentPane().add(etiqueta, BorderLayout.CENTER); 29 marco.setVisible(true); 30 } 31 } Resultado:

1. Crear un JFRAME que le pida al usuario que introduzca dos números

enteros, los obtiene del usuario e imprime su suma, producto, la diferencia y cociente (división) utilzando diferentes ámbitos para los métodos.

2. Crear un JFRAME que determine el ganador de ventas realizadas, sería introducir el número de unidades vendidas por cada persona. El vendedor que vende la mayor cantidad de unidades gana. Crear un JFRAME que introduce una determinar cantidad de ventas.

3. Crear un JFRAME que utilice un bucle para imprimir la siguiente tabla.

4.



DESARROLLO DE SOFTWARE II III. ALCANCE DE LA POO (PROGRAMACIÓN ORIENTADA A OBJETOS). En esta tarea trataremos las siguientes operaciones:

Invocación de métodos. Constructores y sobrecarga.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo o de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web. ORDEN DE EJECUCIÓN:

Invocación de métodos. Constructores y sobrecarga. 3.1. INVOCACIÓN DE MÉTODOS. Si una clase tiene métodos múltiples con el mismo nombre pero diferentes parámetros, se conoce como la sobrecarga de métodos. Si tenemos que realizar una sola operación, con el mismo nombre de los métodos aumenta la legibilidad del programa. Ventaja de la sobrecarga de métodos La sobrecarga de métodos aumenta la legibilidad del programa. Diferentes formas de sobrecargar el método Hay dos formas de sobrecargar el método en Java: • Al cambiar el número de argumentos.


DESARROLLO DE SOFTWARE II • Al cambiar el tipo de datos.

Ejemplo de sobrecarga de métodos cambiando el número de argumentos.En este ejemplo, hemos creado dos métodos sobrecargados, primero método de la suma se realiza la adición de dos números y segundo método de la suma que realiza la adición de tres números.

En este ejemplo, hemos creado dos métodos sobrecargados que difiere en el tipo de datos. El primer método suma recibe dos argumentos enteros y segundo método suma recibe dos argumentos dobles.



En Java, la sobrecarga de métodos no es posible al cambiar el tipo de retorno del método porque puede producirse ambigüedad. Vamos a ver cómo se puede producir ambigüedad:

¿Podemos sobrecargar método main ()? Si, por el método de la sobrecarga. Puede tener cualquier número de los principales métodos en una clase por la sobrecarga de métodos. Veamos el ejemplo simple:

Nota: Un tipo se promueve a otro implícitamente si no se encuentra ningún tipo de datos correspondiente. Vamos a entender el concepto de la cifra dada a continuación:



Como se muestra en el diagrama anterior, byte puede ser promovido al short, int, long, float o double. El corto tipo de datos puede ser promovido a int, long, float o double. El tipo de datos char se puede promover a int, long, float o doble y así sucesivamente.

Ejemplo de sobrecarga de métodos para promover los tipos.



Ejemplo de sobrecarga de métodos para promover si encontrados equivalentes Si hay un conjunto de argumentos de tipo en el método, no se

lleva a cabo el promover tipo.

3.2. CONSTRUCTORES Y SOBRECARGA Constructor en Java es un tipo especial de método que se utiliza para inicializar el objeto. Constructor de Java se invoca en el momento de la creación de objetos. Construye los valores es decir, proporciona datos para el objeto es por eso que se le conoce como constructor. Reglas para la creación constructor java. Básicamente, hay dos reglas definidas para el constructor. 1. Constructor debe ser el mismo que su nombre de clase. 2. Constructor debe de tener ningún tipo de retorno explícito. Tipos de constructores java.


DESARROLLO DE SOFTWARE II Hay dos tipos de constructores:

Constructor predeterminado de Java. Un constructor que no tiene ningún parámetro es conocido como constructor por defecto. Sintaxis del constructor por defecto:

<nombre_clase> () { }

Ejemplo de constructor por defecto En este ejemplo, vamos a crear el constructor sin rgumentos en la clase de bicicletas. Se invoca en el momento de la creación de objetos.

Por defecto (sin parámetros)

Con Parámetros.

DESARROLLO DE SOFTWARE II Si no hay un constructor de una clase, el compilador crea automáticamente un constructor por defecto. ¿Cuál es el propósito del constructor por defecto? Por defecto un constructor proporciona los valores por defecto en el objeto como 0, null, etc., dependiendo del tipo.

Ejemplo de constructor por defecto que muestra los valores por defecto.

Nota: En la clase anterior, no estás creando cualquier constructor de modo compilador le proporciona un valor predeterminado constructor.Here 0 y los valores nulos son proporcionados por constructor por defecto. Java constructor parametrizado. Un constructor que tienen parámetros se conoce como constructor parametrizado. ¿Por qué utilizar constructor parametrizado? Constructor parametrizado se utiliza para proporcionar diferentes valores a los objetos distintos.

public class bicicleta { }

Compilador

public class bicicleta { public bicicleta() { } }



Ejemplo de constructor parametrizado. En este ejemplo, vamos a crear el constructor de la clase del estudiante que tiene dos parámetros. Podemos tener cualquier número de parámetros en el constructor.

Sobrecarga Constructor en Java. Sobrecarga Constructor es una técnica en Java en el que una clase puede tener cualquier número de constructores que difieren en la lista de parametros. La diferencia de estos constructores tiene que ver con el número de parámetros en su lista y a su vez su tipo.

Ejemplo de Constructor Sobrecarga

1 public class estudiante2 2 { 3 int id; 4 String nombre; 5 int año; 6 7 estudiante2(int i,String n){ 8 id = i; 9 nombre = n;

10 } 11


DESARROLLO DE SOFTWARE II 12 estudiante2(int i,String n,int a){ 13 id = i; 14 nombre = n; 15 año=a; 16 } 17 18 void mostrar() 19 { 20 System.out.println(id+" "+nombre+" "+año); 21 } 22 23 public static void main(String args[]) 24 { 25 estudiante2 s1 = new estudiante2(111,"ETI"); 26 estudiante2 s2 = new estudiante2(222,"Senati",25); 27 s1.mostrar(); 28 s2.mostrar(); 29 } 30 }

Resultado:

Diferencia entre el constructor y el método en Java

Java Constructor Método Java Constructor se usa para inicializar el estado de un objeto.

Método se utiliza para exponer el comportamiento de un objeto.

Constructor no debe tener tipo de retorno. Método debe tener tipo de retorno. Constructor se invoca implícitamente. Método se invoca explícitamente. El compilador Java proporciona un constructor por defecto si usted no tiene ningún constructor.

Método no es proporcionado por el compilador en cualquier caso.

Nombre del constructor debe ser el mismo que el nombre de la clase.

Nombre de método puede o no ser el mismo que el nombre de clase

Java Copiar Constructor en Java. No hay constructor de copia en java. Pero, podemos copiar los valores de un objeto a otro constructor de copia como en C++. Hay muchas formas de copiar los valores de un objeto a otro en java. Ellos son:


DESARROLLO DE SOFTWARE II • Por constructor • Mediante la asignación de los valores de un objeto en otro • Método clone () de la clase Object

En este ejemplo, vamos a copiar los valores de un objeto en otro usando constructor java.

1 public class copiarconstructor 2 { 3 int id; 4 String nombre; 5 6 copiarconstructor(int i,String n) 7 { 8 id = i; 9 nombre = n;

10 } 11 12 copiarconstructor(copiarconstructor s) 13 { 14 id = s.id; 15 nombre =s.nombre; 16 } 17 18 void mostrar() 19 { 20 System.out.println(id+" "+nombre); 21 } 22 23 public static void main(String args[]) 24 { 25 copiarconstructor s1 = new copiarconstructor(111,"E T I"); 26 copiarconstructor s2 = new copiarconstructor(s1); 27 s1.mostrar(); 28 s2.mostrar(); 29 } 30 }

Resultado:


DESARROLLO DE SOFTWARE II Valores de copia sin constructor. Podemos copiar los valores de un objeto a otro mediante la asignación de los valores de los objetos a otro objeto. En este caso, no hay necesidad de crear el constructor.

1 public class copiarsinconstructor 2 { 3 public static int id; 4 String nombre; 5 copiarsinconstructor(int i,String n){ 6 id = i; 7 nombre = n; 8 } 9

10 copiarsinconstructor(){} 11 void mostrar() 12 { 13 System.out.println(id+" "+nombre); 14 } 15 16 public static void main(String args[]) 17 { 18 copiarsinconstructor s1 = new copiarsinconstructor(111,"E T I"); 19 copiarsinconstructor s2 = new copiarsinconstructor(); 20 id =s1.id; 21 s2.nombre=s1.nombre; 22 s1.mostrar(); 23 s2.mostrar(); 24 } 25 }

Resultado:

¿El constructor devuelve ningún valor? Si, eso es instancia de clase actual (No se puede utilizar el tipo de retorno, sin embargo, devuelve un valor).


DESARROLLO DE SOFTWARE II Puede constructor de realizar otras tareas en lugar de inicialización? Sí, al igual que la creación de objeto usted puede realizar cualquier operación en el constructor a medida que realiza en el método.

1. Crear la clase Cuenta para proporcionar un método que permita retirar

dinero (Use constructor). Asegúrese de que la cantidad de dinero no exceda el saldo de la Cuenta. Si lo hace, el metodo debe dejar sin cambios en la cuenta y el método debe imprimir un mensaje que indica cantidad superó saldo de la cuenta. Crear la clase verificarCuenta para poner a prueba los métodos de la clase Cuenta.

2. Crear una clase llamada Factura que una ferretería podría utilizar para

representar una factura por un artículo vendido en la tienda. Una factura debe incluir cuatro piezas de información como variables un ejemplo el número de pieza (tipo String), una descripción (tipo String), una cantidad del artículo que se compra (tipo int) y un precio por artículo (doble). La clase debe tener un constructor que inicializa las cuatro variables de instancia. Proporcionar un set y un método get para cada variable de instancia. Además, proporcionar un método llamado Calcular Monto que calcula la factura cantidad (es decir, multiplica la cantidad por el precio por artículo), a continuación, devuelve la cantidad como un valor doble. Si la cantidad no es positiva, se debe establecer en 0. Si el precio por artículo no es positivo, se debe establecer en 0,0. Crear un JFRAME que pruébe las capacidades de la clase de la factura.

3. Crear una clase llamada Empleado que incluye tres piezas de información

como las variables de una instancia de nombre (String), un apellido (String) y un salario mensual (doble). La clase debe tener un constructor que inicializa las tres variables de instancia. Proporcionar un set y un método get para cada variable de instancia. Si el mensual salario no es positivo, ajústelo a 0.0. Crear un JFrame de prueba que demuestre las capacidades de la clase empleados. Cree dos objetos de los empleados y mostrar salario anual de cada objeto. A continuación, dar a cada Empleado un aumento de sueldo del 10% y mostrar salario anual de cada empleado nuevo.



DESARROLLO DE SOFTWARE II IV. MIEMBROS DE CLASES. En esta tarea trataremos las siguientes operaciones:

Técnica de Abstracción. Operador This. Eventos en una aplicación GUI.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo ó de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web. ORDEN DE EJECUCIÓN:

Técnica de Abstracción. Operador This. Eventos en una aplicación GUI. 4.1. TÉCNICA DE ABSTRACCIÓN. Cuando una clase se declara con la palabra clave abstract, se conoce como clase abstracta en java. Puede tener métodos abstractos y no abstractos (método creado en el cuerpo del programa). Antes de aprender clase abstracta java, vamos a entender la abstracción en java primero. Abstracción en Java La abstracción es un proceso de ocultar los detalles de implementación y mostrando sólo la funcionalidad para el usuario.


DESARROLLO DE SOFTWARE II Otra forma, que sólo muestra las cosas importantes para el usuario y oculta los detalles internos, por ejemplo, el envío de sms, sólo tiene que teclear el texto y enviar el mensaje. Usted no sabe el procesamiento interno acerca de la entrega de mensajes. Abstracción le permite centrarse en lo que hace el objeto en lugar de cómo lo hace. Maneras de lograr la abstracción Hay dos maneras de lograr la abstracción en java

1. Abstract (0 a 100%) 2. Interface (100%)

Clase abstracta en Java. Una clase que se declara como resumen se conoce como clase abstracta. Es necesario ampliar y su método implementado. No se pueden crear instancias. Ejemplo de clase abstracta

abstract class A {} Método abstracto. Un método que es declarada como abstracta y no tiene aplicación se conoce como método abstracto. Ejemplo método abstracto

abstract void metodo (); // ningún cuerpo y abstracta

Ejemplo de clase abstracta que tiene método abstracto. En este ejemplo, la motocicleta de la clase abstracta contiene un sólo un método abstracto. Su aplicación es proporcionado por la clase Honda.

1 abstract class motocicleta { 2 3 abstract void run(); 4 } 5 6 class Honda extends motocicleta 7 {



8 void run() 9 {

10 System.out.println("Funcionando de manera segura.."); 11 } 12 13 public static void main(String args[]){ 14 motocicleta objeto = new Honda(); 15 objeto.run(); 16 } 17 }

Resultado.

La comprensión de la situación real de la clase abstracta. En este ejemplo, la forma es la clase abstracta, su aplicación es proporcionada por las clases rectangulo y circulo. Sobre todo, que no sabemos acerca de la clase de implementación (es decir, oculta para el usuario final) y el objeto de la clase de implementación es proporcionado por el método de fábrica. Un método de fábrica es el método que devuelve la instancia de la clase. Vamos a aprender sobre el método de fábrica después. En este ejemplo, se crea la instancia de la clase rectangulo, dibujar () de la clase Rectangle se invocará.

1 // Crear la clase abstracta 2 abstract class forma { 3 4 abstract void dibujar(); 5 } 6 7 // La ejecución es proporciona por otros, 8 // es decir, heredado de la clase forma. 9 class rectangulo extends forma

10 { 11 void dibujar () 12 {


DESARROLLO DE SOFTWARE II 13 System.out.println ("Dibujar rectángulo"); 14 } 15 } 16 17 class circulo extends forma 18 { 19 void dibujar() 20 { 21 System.out.println ("Dibujar círculo"); 22 } 23 } 24 25 // El método es llamado por la clase principal 26 class probarabstraccion 27 { 28 public static void main (String args []) 29 { 30 // El objeto se crea a través 31 // de la instancia 32 forma c = new circulo(); 33 forma r = new rectangulo(); 34 // Llamar al método 35 c.dibujar(); 36 r.dibujar(); 37 } 38 }

Resultado:

Otro ejemplo de una clase abstracta:

1 abstract class banco { 2 3 abstract int darinteres(); 4 } 5 6 class interbank extends banco{



7 int darinteres() 8 { 9 return 7;

10 } 11 } 12 13 class continental extends banco 14 { 15 int darinteres() 16 { 17 return 8; 18 } 19 } 20 21 class TestBank 22 { 23 public static void main(String args[]) 24 { 25 //Si objecto es interbank se invocara su método 26 banco b=new interbank(); 27 28 int interes=b.darinteres(); 29 30 System.out.println("El Interes INTERBANK es: "+ interes+" %"); 31 } 32 }

Resultado:

Clase abstracta que tiene constructor, miembro de datos, métodos, etc. Una clase abstracta puede tener miembro de datos, método abstracto, cuerpo del método, constructor y aun método main ().

1 // Crear clase abstracta 2 abstract class motocicleta2 { 3 //Crear contructor 4 motocicleta2(){ 5 System.out.println("Motocicleta esta creado..");



6 } 7 8 abstract void run(); 9 void cambiarllanta()

10 { 11 System.out.println("Llanta cambiada"); 12 } 13 } 14 15 class yamaha extends motocicleta2 16 { 17 void run() 18 { 19 System.out.println("Ejecutado correctamente.."); 20 } 21 } 22 23 class probarabstraccion2 24 { 25 public static void main(String args[]) 26 { 27 motocicleta2 objeto = new yamaha(); 28 objeto.run(); 29 objeto.cambiarllanta(); 30 } 31 }

Resultado:

Crear un programa que utilice clases abstractas para hallar el área de un Rectángulo y de un Triángulo.

1 import java.awt.*; 2 import java.awt.event.*;



3 import javax.swing.*; 4 5 // Se crea una clase abstracta llamada Figuras, la cual contiene dos 6 // variables de tipo double: diametro1 y diametro2. 7 public abstract class Figuras 8 { 9 double diametro1;

10 double diametro2; 11 // En el constructor de la clase se reciben dos variables de tipo 12 // double (a, b) las cuales se asignan a las variables diametro1 13 // y diámetro2 respectivamente. 14 Figuras(double a, double b) 15 { 16 diametro1 =a; 17 diametro2 =b; 18 } 19 // se define el método abstracto area() el cual retorna un 20 // valor double sin implementar. 21 abstract double area(); 22 } 23 // Se crea una clase llamada Rectangulo la cual heredara los objetos de la 24 // clase Figuras. Para crear la herencia se utiliza la palabra reservada extends. 25 class Rectangulo extends Figuras 26 { 27 // En el constructor de la clase se reciben dos parámetros de tipo 28 // double: datoa y datob, los cuales son enviados al constructor de 29 // la clase Figuras 30 Rectangulo(double datoa, double datob) 31 { 32 super(datoa, datob); 33 } 34 // se implementa el método abstracto area() para obtener el area 35 // de un rectángulo. 36 double area(){ 37 return diametro1* diametro2; 38 } 39 } 40 // Se crea una clase llamada Triangulo la cual heredara los objetos 41 // de la clase Figuras. 42 class Triangulo extends Figuras{ 43 // En el constructor de la clase se reciben dos parámetros de 44 //tipo double: datoa y datob, los cuales son enviados al constructor 45 // de la clase Figuras. 46 Triangulo(double datoa, double datob)


DESARROLLO DE SOFTWARE II 47 { 48 super(datoa, datob); 49 } 50 // Sobrescribir el método área para un Triangulo 51 // Se implementa el método abstracto area() para obtener el area 52 // de un triangulo 53 double area() 54 { 55 return (diametro1* diametro2)/2; 56 } 57 } 58 59 class ClasesAbstractas extends JFrame 60 { 61 public ClasesAbstractas() 62 { 63 super("Clases Abstractas"); 64 Container contenedor=getContentPane(); 65 contenedor.setLayout(null); 66 setSize(300,200); 67 setVisible(true); 68 } 69 public void paint(Graphics g) 70 { 71 super.paint(g); 72 // Se crea una instancia rectángulo de tipo Rectangulo donde se 73 // le envían dos valores al constructor de la clase Rectangulo. 74 Rectangulo rectangulo =new Rectangulo (10,8); 75 // Se crea una instancia triangulo de tipo Triangulo donde se le 76 // envían dos valores al constructor de la clase Triangulo. 77 Triangulo triangulo = new Triangulo(10,8); 78 Figuras figurita; //esto es correcto, no se crea ningún objeto 79 // se crea una instancia llamada figurita de la clase Figuras a 80 // la cual se le asigna los valores de las instancias triangulo y 81 // rectángulo para luego ser impresas. 82 figurita =rectangulo; 83 g.drawString("El área del Rectángulo es :"+figurita.area() ,40,60); 84 figurita =triangulo; 85 g.drawString("El área del Triangulo es :" +figurita.area(),40,120); 86 } 87 public static void main(String args[]) 88 { 89 ClasesAbstractas ventana = new ClasesAbstractas(); 90 ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


DESARROLLO DE SOFTWARE II 91 } 92 }

Resultado:

4.2. OPERADOR THIS. Puede haber un montón de uso de java esta palabra clave enn java, pero su uso principal es de referenciar al objeto actual. Uso de java esta palabra clave Aquí está dada la 6 uso de java esta palabra clave. 1. Esta palabra clave puede utilizarse para hacer referencia a variable de

instancia de clase actual. 2. This ( ) puede utilizarse para invocar el constructor de la clase actual. 3. Esta palabra clave se puede utilizar para invocar el método de la clase actual

(implícitamente). 4. Esto puede ser pasado como argumento en la llamada al método. 5. Esto puede ser pasado como argumento en la llamada al constructor. 6. Esta palabra clave puede utilizarse también para devolver la instancia de la

clase actual.

Referencia Variable Objeto 1. Esta palabra clave puede utilizarse para hacer referencia a variable de

instancia de clase actual.

this

Estado

Comportamiento



Si hay ambiguedad entre la variable de instancia y el parámetro, esta palabra clave resuelve el problema de la ambiguedad.

Entender el problema sin esta palabra clave Vamos a entender el problema si no usamos esta palabra clave por el ejemplo dado a continuación:

1 class estudiante01 { 2 int id; 3 String nombre; 4 5 estudiante01(int id,String nombre) 6 { 7 id = id; 8 nombre = nombre; 9 }

10 11 void mostrar() 12 { 13 System.out.println(id+" "+ nombre); 14 } 15 16 public static void main(String args[]){ 17 estudiante01 s1 = new estudiante01(111," E T I "); 18 estudiante01 s2 = new estudiante01(321,"SENATI"); 19 s1.mostrar(); 20 s2.mostrar(); 21 } 22 }

Resultado:

Nota: En el ejemplo anterior, parámetro (argumentos formales) e instancia variables son iguales es por eso que estamos usando esta palabra clave para distinguir entre variable local y variable de instancia. Solución del problema anterior usando la palabra clave this.



1 class estudiante01conthis { 2 int id; 3 String nombre; 4 5 estudiante01conthis(int id,String nombre) 6 { 7 this.id = id;

8 this.nombre = nombre; 9 }

10 11 void mostrar() 12 { 13 System.out.println(id+" "+ nombre); 14 } 15 16 public static void main(String args[]){ 17 estudiante01conthis s1 = new estudiante01conthis(111," E T I "); 18 estudiante01conthis s2 = new estudiante01conthis(321,"SENATI"); 19 s1.mostrar(); 20 s2.mostrar(); 21 } 22 }

Resultado:

Pila de memoria

s1

s2

id=111 nombre=“E T I”

id=321 nombre=“SENATI


DESARROLLO DE SOFTWARE II Si las variables locales (argumentos formales) y las variables de instancia son diferentes, no hay necesidad para utilizar esta palabra clave como en el siguiente programa:

1 class estudiante02 { 2 int id; 3 String nombre; 4 5 estudiante02(int i,String n) 6 { 7 id = i; 8 nombre = n; 9 }

10 11 void mostrar() 12 { 13 System.out.println(id+" "+ nombre); 14 } 15 16 public static void main(String args[]){ 17 estudiante02 s1 = new estudiante02(111," E T I "); 18 estudiante02 s2 = new estudiante02(321,"SENATI"); 19 s1.mostrar(); 20 s2.mostrar(); 21 } 22 }

2. this() puede utilizarse para invocar el constructor de la clase actual.

La palabra clave this() puede utilizarse para invocar el constructor de la clase actual (constructor de encadenamiento). Este enfoque es mejor si tienes muchos constructores en la clase y quiere reutilizar ese constructor.

1 // Programa de this() llamada de 2 //constructor (constructor de encadenamiento) 3 4 class estudiante03 { 5 int id; 6 String nombre; 7 8 public estudiante03() { 9 System.out.println("Invocando al constructor por defecto");

10 }


DESARROLLO DE SOFTWARE II 11 12 estudiante03(int i,String n) 13 { 14 this(); //Se utiliza para invocar el constructor de la clase actual. 15 id = i; 16 nombre = n; 17 } 18 19 void mostrar() 20 { 21 System.out.println(id+" "+ nombre); 22 } 23 24 public static void main(String args[]){ 25 estudiante03 s1 = new estudiante03(111," E T I "); 26 estudiante03 s2 = new estudiante03(321,"SENATI"); 27 s1.mostrar(); 28 s2.mostrar(); 29 } 30 }

Resultado:

¿Dónde usar this() constructor? La llamada al constructor de this() se recomienda reutilizar el constructor en el constructor. Mantiene la cadena entre los constructores, es decir, se utiliza para el constructor de encadenamiento. Veamos el ejemplo siguiente que muestra el uso real de esta palabra clave.

1 class estudiante04 { 2 int id; 3 String nombre; 4 String ciudad; 5



6 estudiante04(int id,String nombre){ 7 this.id = id; 8 this.nombre = nombre; 9 }

10 11 estudiante04(int id,String nombre,String ciudad) 12 { 13 this(id,nombre); // No hay necesidad de inicializar id y nombre 14 this.ciudad=ciudad; 15 } 16 17 void mostrar() 18 { 19 System.out.println(id+" "+nombre+" "+ciudad); 20 } 21 22 public static void main(String args[]) 23 { 24 estudiante04 e1 = new estudiante04(111," E T I"); 25 estudiante04 e2 = new estudiante04(222,"SENATI","SEDE CENTRAL"); 26 e1.mostrar(); 27 e2.mostrar(); 28 } 29 }

Resultado:

3. this se puede utilizar para invocar el método de la clase actual

(implícitamente). Puede invocar el método de la clase actual mediante el uso de esta palabra clave. Si usted no utiliza esta palabra clave, el compilador añade automáticamente esta palabra clave al invocar el método. Veamos el ejemplo.

1 public class agregathis { 2 3 void m(){



4 System.out.println("Invocar este método"); 5 } 6 7 void n(){ 8 this.m();//no necesita porque el compilador lo hace por ti. 9 }

10 11 void p(){ 12 n();//compilador agregará esto para invocar método n() como this.n() 13 } 14 public static void main(String args[]){ 15 agregathis s1 = new agregathis(); 16 s1.p(); 17 } 18 }

Resultado

4. La palabra clave puede ser pasada como argumento en el método.

La palabra clave this también puede pasar como argumento en el método. Se utiliza principalmente en el caso de manipulación. Veamos el ejemplo:

1 public class argumentothis { 2 3 void m(argumentothis objeto){ 4 System.out.println("Invocar este método"); 5 } 6 7 void p(){ 8 m(this); 9 }

10 11 public static void main(String args[]){ 12 argumentothis s1 = new argumentothis(); 13 s1.p(); 14 } 15 }


DESARROLLO DE SOFTWARE II Nota: La aplicación de esto puede ser pasado como argumento: En caso de manipulación en una situación donde tenemos que proporcionar la referencia de una clase a otra. 5. La palabra clave puede ser pasada como argumento en la llamada al

constructor. Podemos pasar esta palabra clave en el constructor también. Es útil si tenemos que usar un objeto en múltiples clases. Veamos el ejemplo:

1 public class claseB { 2 3 claseA objeto; 4 claseB(claseA objeto){ 5 this.objeto=objeto; 6 } 7 8 void mostrar(){ 9 System.out.println(objeto.dato);//usando el miembro de dato de claseA

10 } 11 } 12 13 class claseA{ 14 int dato=10; 15 claseA(){ 19 claseB b=new claseB(this); 20 b.mostrar(); 21 } 22 23 public static void main(String args[]){ 24 claseA a=new claseA(); 25 } 26 }

Resultado:

6. La palabra clave this puede utilizarse para devolver la instancia de la clase

actual.



Podemos volverla palabra clave como una declaración del método. En tal caso, el tipo de valor devuelto del método debe ser el tipo de clase (no primitivo). Veamos el ejemplo:

Sintaxis de esto que pueden devolver como una declaración

return_type method_name(){

return this; }

Ejemplo de esta palabra clave que regresa como una declaración del método

1 public class claseA1 { 2 3 claseA1 retornarA(){ 4 return this; 5 } 6 7 void mensaje(){ 8 System.out.println("SENATI - ETI"); 9 }

10 } 11 12 class probar{ 13 public static void main(String args[]){ 14 new claseA1().retornarA().mensaje(); 15 } 19 }

Resultado:

4.3. EVENTOS EN UNA APLICACIÓN GUI Cambiar el estado de un objeto se conoce como un evento. Por ejemplo, haga click en el botón, arrastrando el ratón, etc. El paquete java.awt.event


DESARROLLO DE SOFTWARE II proporciona muchas clases de eventos e interfaces Listener para control de evento. Asociados por el programador Clases de eventos e interfaces Listener: Clases de evento Interfaces de escucha

ActionEvent ActionListener MouseEvent MouseListener y MouseMotionListener MouseWheelEvent MouseWheelListener KeyEvent KeyListener ItemEvent ItemListener TextEvent TextListener AdjustmentEvent AdjustmentListener WindowEvent WindowListener ComponentEvent ComponentListener ContainerEvent ContainerListener FocusEvent FocusListener

Pasos para realizar Event Handling. Siguientes pasos son necesarios para llevar a cabo la gestión de eventos: 1. Implementar la interfaz Listener y reemplaza sus métodos.

El usuario realiza una acción

(Por ejemplo pulsar un botón)

El sistema crea un evento (Con la información sobre la causa que ha provocado la

creación)

El sistema ejecuta el método creado por el programador

(Pasando como parámetro el evento)


DESARROLLO DE SOFTWARE II 2. Registrar el componente con el oyente. Para registrar el componente con el oyente, muchas clases proporcionan los métodos de registro. Por ejemplo: Botón

public void addActionListener(ActionListener a) {} MenuItem

public void addActionListener(ActionListener a) {} Campo de texto

public void addActionListener(ActionListener a) {} public void addTextListener(TextListener a) {}

TextArea public void addTextListener(TextListener a) {}

Casilla de verificación public void addItemListener(ItemListener a) {}

Opción public void addItemListener(ItemListener a) {}

Lista public void addActionListener(ActionListener a) {} public void addItemListener(ItemListener a) {}

Códigos de EventHandling: Podemos poner el evento manejo de código en uno de los siguientes lugares: • Misma clase. • Otra clase de. • Clase de anónimo.

Ejemplo de evento dentro de la clase. [ejemploevento1.java]

1 // Importar paquetes 2 import java.awt.*; 3 import java.awt.event.*; 4 5 // Crear clase con el evento 6 class ejemploevento1 extends Frame implements ActionListener{ 7 // Crear controles 8 TextField tf; 9 // Crear constructor

10 ejemploevento1(){


DESARROLLO DE SOFTWARE II 11 12 tf=new TextField(); 13 tf.setBounds(60,50,170,20); 14 15 Button b=new Button("Click aquí"); 16 b.setBounds(100,120,80,30); 17 // Agregar evento 18 b.addActionListener(this); 19 // Agregar controles al Frame 20 add(b);add(tf); 21 // Propiedades del Frame 22 setSize(300,300); 23 setLayout(null); 24 setVisible(true); 25 26 } 27 28 // Crear evento click 29 public void actionPerformed(ActionEvent e){ 30 tf.setText("E T I"); 31 } 32 // Ejecutar el constructor 33 public static void main(String args[]){ 34 new ejemploevento1(); 35 } 36 }

Resultado:

Ejemplo de control externo de la clase de eventos. [ejemploevento2.java]

1 import java.awt.*; 2 import java.awt.event.*; 3 public class ejemploevento2 extends Frame{



4 public TextField tf; 5 ejemploevento2(){ 6 7 tf=new TextField(); 8 tf.setBounds(60,50,170,20); 9

10 Button b=new Button("Click aquí"); 11 b.setBounds(100,120,80,30); 12 13 exterior o=new exterior(this); 14 b.addActionListener(o);// Pasando instancia de la clase externa 15 16 add(b);add(tf); 17 18 setSize(300,300); 19 setLayout(null); 20 setVisible(true); 21 } 22 public static void main(String args[]){ 23 new ejemploevento2(); 24 } 25 }

[exterior.java]

1 import java.awt.event.*; 2 class exterior implements ActionListener{ 3 ejemploevento2 obj; 4 exterior(ejemploevento2 obj){ 5 this.obj=obj; 6 } 7 public void actionPerformed(ActionEvent e){ 8 obj.tf.setText("SENATI"); 9 }

10 } Resultado:



Ejemplo de un evento anónimo en una clase de eventos. [ejemploevento3.java]

1 //Importar paquetes 2 import javax.swing.*; 3 import java.awt.event.*; 4 // Crear clase con el evento 5 class ejemploevento3 extends JFrame implements ActionListener{ 6 //Crear controles 7 JRadioButton rb1,rb2; 8 JButton b; 9 //Crear constructor

10 ejemploevento3() 11 { 12 rb1=new JRadioButton("Masculino"); 13 rb1.setBounds(100,50,100,30); 14 15 rb2=new JRadioButton("Femenino"); 16 rb2.setBounds(100,100,100,30); 17 18 // Agrupar RadioButton 19 ButtonGroup bg=new ButtonGroup(); 20 bg.add(rb1);bg.add(rb2); 21 22 b=new JButton("Click aquí.."); 23 b.setBounds(100,150,80,30); 24 b.addActionListener(this); 25 26 add(rb1);add(rb2);add(b); 27 28 setSize(300,300); 29 setLayout(null); 30 setVisible(true); 31 } 32 33 // Crear eventos 34 public void actionPerformed(ActionEvent e){ 35 if(rb1.isSelected()){ 36 JOptionPane.showMessageDialog(this,"Tu eres Masculino"); 37 } 38 if(rb2.isSelected()){ 39 JOptionPane.showMessageDialog(this,"Tu eres femenino"); 40 }


DESARROLLO DE SOFTWARE II 41 } 42 43 //Llamar al constructor 44 public static void main(String args[]){ 45 new ejemploevento3(); 46 } 47 }

Resultado:

Ejemplo que demuestra la implementación de las interfaces MouseListener y MouseMotionListener. [ejemploevento4.java]

1 import java.awt.*; 2 import java.awt.event.*; 3 import javax.swing.*; 4 public class ejemploevento4 extends JFrame 5 implements MouseListener, MouseMotionListener { 6 private JLabel barraEstado; 7 // configurar GUI y registrar manejadores de eventos de mouse 8 public ejemploevento4() 9 {

10 super( "Demostración de los eventos del mouse" ); 11 barraEstado = new JLabel(); 12 getContentPane().add( barraEstado, BorderLayout.SOUTH ); 13 14 addMouseListener( this ); // escucha sus propios eventos de mouse 15 addMouseMotionListener( this ); // y de movimiento de mouse 16 setSize( 300, 125 ); 17 setVisible( true ); 18 } 19 // Manejadores de eventos de MouseListener 20 // manejar el evento cuando el botón del mouse se suelta


DESARROLLO DE SOFTWARE II 21 // inmediatamente después de oprimir 22 public void mouseClicked( MouseEvent evento ) 23 { 24 barraEstado.setText( "Se hizo clic en [" + evento.getX() + 25 ", " + evento.getY() + "]" ); 26 } 27 // manejar evento cuando se oprime el botón del mouse 28 public void mousePressed( MouseEvent evento ) 29 { 30 barraEstado.setText( "Se oprimió en [" + evento.getX() + 31 ", " + evento.getY() + "]" ); 32 } 33 // manejar evento cuando se suelta el botón del mouse después de arrastrar 34 public void mouseReleased( MouseEvent evento ) 35 { 36 barraEstado.setText( "Se soltó en [" + evento.getX() + 37 ", " + evento.getY() + "]" ); 38 } 39 40 // manejar el evento cuando el puntero del mouse entra al área 41 public void mouseEntered( MouseEvent evento ) 42 { 43 barraEstado.setText( "Puntero entro en [" + evento.getX() + 44 ", " + evento.getY() + "]" ); 45 getContentPane().setBackground( Color.GREEN ); 46 } 47 // manejar evento cuando el puntero del mouse sale del área 48 public void mouseExited( MouseEvent evento ) 49 { 50 barraEstado.setText( "Puntero fuera de la ventana" ); 51 getContentPane().setBackground( Color.WHITE ); 52 } 53 // Manejadores de eventos de MouseMotionListener 54 // manejar el evento cuando el usuario arrastra el puntero con el botón 55 // oprimido 56 public void mouseDragged( MouseEvent evento ) 57 { 58 barraEstado.setText( "Se arrastró en [" + evento.getX() + 59 ", " + evento.getY() + "]" ); 60 } 61 // manejar el evento cuando el usuario mueve el puntero del mouse 62 public void mouseMoved( MouseEvent evento ) 63 { 64 barraEstado.setText( "Se movió en [" + evento.getX() +


DESARROLLO DE SOFTWARE II 65 ", " + evento.getY() + "]" ); 66 } 67 public static void main( String args[] ) 68 { 69 ejemploevento4 aplicacion = new ejemploevento4(); 70 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 71 } 72 } // fin de la clase

Resultado:

Ejemplo de uso de una clase interna que maneja los eventos de ItemListener

1 import java.awt.*; 2 import java.awt.event.*; 3 import javax.swing.*; 4 public class eventocasillas extends JFrame { 5 private JTextField campo; 6 private JCheckBox negrita, cursiva; 7 // configurar GUI 8 public eventocasillas() 9 {

10 super( "Prueba de JCheckBox" ); 11 // obtener panel de contenido y establecer su esquema 12 Container contenedor = getContentPane(); 13 contenedor.setLayout( new FlowLayout() ); 14 // configurar objeto JTextField y establecer su tipo de letra 15 campo = new JTextField( "Escuela de Tecnologías de la Información", 25 ); 16 campo.setFont( new Font( "Serif", Font.PLAIN, 14 ) ); 17 contenedor.add( campo ); 18 // crear objetos casilla de verificación 19 negrita = new JCheckBox( "Negrita" ); 20 contenedor.add( negrita ); 21 cursiva = new JCheckBox( "Cursiva" ); 22 contenedor.add( cursiva );


DESARROLLO DE SOFTWARE II 23 // registrar componentes de escucha para los objetos JCheckBox 24 ManejadorCasillaVerificacion manejador = new ManejadorCasillaVerificacion(); 25 negrita.addItemListener( manejador ); 26 cursiva.addItemListener( manejador ); 27 setSize( 300, 100 ); 28 setVisible( true ); 29 } // fin del constructor de PruebaCasillaVerificacion 30 public static void main( String args[] ) 31 { 32 eventocasillas aplicacion = new eventocasillas(); 33 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 34 } 35 36 // clase interna privada para manejo de eventos de ItemListener 37 private class ManejadorCasillaVerificacion implements ItemListener { 38 private int valNegrita = Font.PLAIN; 39 private int valCursiva = Font.PLAIN; 40 // responder a eventos de casilla de verificación 41 public void itemStateChanged( ItemEvent evento ) 42 { 43 // procesar eventos de casilla de verificación negrita 44 if ( evento.getSource() == negrita ) 45 valNegrita = negrita.isSelected() ? Font.BOLD : Font.PLAIN; 46 47 // procesar eventos de casilla de verificación cursiva 48 if ( evento.getSource() == cursiva ) 49 valCursiva = cursiva.isSelected() ? Font.ITALIC : Font.PLAIN; 50 // establecer tipo de letra del campo de texto 51 campo.setFont( new Font( "Serif", valNegrita + valCursiva, 14 ) ); 52 } // fin del método itemStateChanged 53 } // fin de la clase interna privada eventocasillas 54 } // fin de la clase

Resultado:

Ejemplo de uso de una clase adaptadora que maneja eventos de MouseListener. [ejemploevento5.java]



1 // Demostración de los clikcs del mouse y 2 // cómo diferenciar entre los botones del mouse. 3 import java.awt.*; 4 import java.awt.event.*; 5 import javax.swing.*; 6 public class ejemploevento5 extends JFrame { 7 private int xPos, yPos; 8 // establecer cadena barra título; registrar escucha mouse; 9 //ajustar tamaño y mostrar ventana

10 public ejemploevento5() 11 { 12 super( "Clicks y botones del mouse" ); 13 addMouseListener( new manejoclicks() ); 14 setSize( 350, 150 ); 15 setVisible( true ); 16 } 17 // dibujar objeto String en la ubicación donde se hizo clic con el mouse 18 public void paint( Graphics g ) 19 { 20 // llamar al método paint de la superclase 21 super.paint( g ); 22 g.drawString( "Se hizo click en: [" + xPos + ", " + yPos + "]", 23 xPos, yPos ); 24 } 25 public static void main( String args[] ) 26 { 27 ejemploevento5 aplicacion = new ejemploevento5(); 28 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 29 } 30 // clase interna para manejar eventos del mouse 31 private class manejoclicks extends MouseAdapter { 32 // manejar evento de clic del mouse y determinar cuál botón se oprimió 33 public void mouseClicked( MouseEvent evento ) 34 { 35 xPos = evento.getX(); 36 yPos = evento.getY(); 37 String titulo = "Se hizo click " + evento.getClickCount() + "Veces"; 38 39 if ( evento.isMetaDown() ) // botón derecho del mouse 40 titulo += " con el botón derecho del mouse"; 41 42 else if ( evento.isAltDown() ) // botón de en medio del mouse 43 titulo += " con el botón central del mouse"; 44


DESARROLLO DE SOFTWARE II 45 else // botón izquierdo del ratón 46 titulo += " con el botón izquierdo del mouse"; 47 setTitle( titulo ); // establecer barra de título de la ventana 48 repaint(); 49 } // fin del método mouseClicked 50 } // fin de la clase interna privada 51 } // fin de la clase

Resultado:

1. Crear una clase abstracta llamada Fecha que incluye tres piezas de

información como instancia variables de un mes (int), un día (int) y un año (tint). La clase debe tener un constructor que inicializa las tres instancias de variables y se supone que los valores proporcionados son correctos. Proporcionar un set y un método get para cada instancia variable. Proporcionar un método abstracto que muestre el mes, día y año separados por barras inclinadas (/). Crear una programa de prueba que demuestre las capacidades de dicha clase.

2. Crear una clase abstracta llamada libro para representar un libro. Un libro debe incluir cuatro piezas de información como ejemplo variables un nombre de libro, un número, el nombre del autor y un editor. La clase debe tener un constructor que inicializa las cuatro variables de instancia. Proporcionar un método abstracto de consulta para cada variable de instancia. Proporcionar un método denominado que devuelve la descripción del libro como una cadena (la descripción debe incluir toda la información sobre el libro). Se debe utilizar el operador THIS en los métodos de miembros y constructor. Crear una aplicación de prueba para crear una gran variedad de objetos para 30 elementos para la clase de libro para demostrar las capacidades de la clase de libros.



DESARROLLO DE SOFTWARE II V. HERENCIA Y JERARQUÍA DE CLASES. En esta tarea trataremos las siguientes operaciones:

Diferencia entre el operador This y Super. Herencia en la POO e implementa sobre escritura.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo ó de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web.

ORDEN DE EJECUCIÓN:

Diferencia entre el operador This y Super Herencia en la POO e implementa sobre escritura

5.1. DIFERENCIA ENTRE EL OPERADOR THIS Y SUPER. La clave super en java es una variable de referencia que se utiliza para designar el objeto primario inmediato de la clase. Cuando se crea la instancia de la subclase, se crea implícitamente, es decir, referida por la variable de referencia super una instancia de clase padre. Uso de la super clave de java. • Super se utiliza para referirse a variable de instancia de clase primario

inmediato. • Super() se utiliza para invocar el constructor de la clase padre inmediato. • Super se utiliza para invocar el método de la clase padre inmediato.


DESARROLLO DE SOFTWARE II 1. Super es usado para referirse a variable de instancia de clase primario

inmediato. Ejemplo sin la palabra clave super.

1 class ejemplosuper1{ 2 int velocidad=50; 3 } 4 class motocicleta extends ejemplosuper1{ 5 int velocidad=100; 6 void mostrar(){ 7 System.out.println(velocidad);//Imprimir la velocidad 8 } 9 public static void main(String args[]){

10 motocicleta b=new motocicleta(); 11 b.mostrar(); 12 } 13 }

Resultado:

Nota: En el anterior ejemplo ejemplosuper1 y motocicleta ambas clases tienen una velocidad de propiedad común. Variable de instancia de la clase actual es para la referencia de la clase padre es por eso que usar super sirve para distinguir entre variable de instancia de clase actual y variable de instancia de la clase padre. La Solución usando super.

1 class ejemplosuper2{ 2 int speed=50; 3 } 4 5 class motocicleta2 extends ejemplosuper2{ 6 int velocidad=100;



7

8 void mostrar(){ 9 System.out.println(super.velocidad);// Imprime la velocidad

10 } 11 public static void main(String args[]){ 12 motocicleta2 b=new motocicleta2(); 13 b.mostrar(); 14 15 } 16 }

Resultado:

2. Super se utiliza para invocar el constructor de la clase padre.

La palabra clave super puede utilizarse también para invocar constructor de la clase padre tal como se indica a continuación:

1 class ejemplosuper3{ 2 ejemplosuper3(){System.out.println("Constructor fue creado");} 3 } 4 5 class motocicleta3 extends ejemplosuper3{ 6 motocicleta3(){ 7 super(); //Invocar el constructor de la clase padre 8 System.out.println("Motocicleta fue creado"); 9 }

10 public static void main(String args[]){ 11 motocicleta3 b=new motocicleta3(); 12 } 13 }

Resultado:



Nota: super() se agrega en cada constructor de clase automáticamente por el compilador. Bien sabemos que el constructor por defecto es suministrado por el compilador automáticamente pero también agrega super() para la primera declaración. Si está creando su propio constructor y no tienes this() o super() como la primera declaración, el compilador proveerá super() como la primera instrucción del constructor.

Otro ejemplo de la palabra clave super donde super() es suministrado por el compilador implícitamente.

1 class ejemplosuper4{ 2 ejemplosuper4(){System.out.println("Constructor fue creado");} 3 } 4 5 class motocicleta4 extends ejemplosuper4{ 6 int velocidad; 7 motocicleta4(int velocidad){ 8 this.velocidad=velocidad; 9 System.out.println(velocidad);

10 } 11 public static void main(String args[]){ 12 motocicleta4 b=new motocicleta4(10); 13 } 14 }

Resultado:

3. Super se puede utilizar para invocar el método de la clase padre.



La palabra clave super puede utilizarse también para invocar el método de la clase padre. Debe ser usado en caso de subclase contiene el mismo método que la clase padre como en el ejemplo siguiente:

1 class ejemplosuper6{ 2 void mensaje(){System.out.println("E-T-I");} 3 } 4 5 class estudiante6 extends ejemplosuper6{ 6 void mensaje(){System.out.println(" SENATI ");} 7 8 void mostrar(){ 9 mensaje(); //Invocar el método actual de mensaje() clase ejemplosuper6

10 super.mensaje();//Invocar método mensaje() clase 11 } 12 13 public static void main(String args[]){ 14 estudiante6 s=new estudiante6(); 15 s.mostrar(); 16 } 17 }

Resultado:

En el anterior ejemplo estudiante y ejemplosuper6 ambas clases contienen el método mensaje() Si llamamos el método mensaje() de la clase estudiante, llamará al método mensaje() de clase del estudiante no de la clase de ejemplosuper6 porque se da prioridad a lo local. En caso de que no hay ningún método en la subclase como padre, no hay necesidad para utilizar super. En el ejemplo siguiente mensaje() se invoca el método de la clase estudiante pero la clase estudiante no tiene el método mensaje(), por lo que directamente puede llamar al método mensaje(). Super programa en caso no se requiere.

1 class ejemplosuper7{



2 void mensaje(){System.out.println(" ETI - SENATI");} 3 } 4 5 class estudiante7 extends ejemplosuper7{ 6 7 void mostrar(){ 8 mensaje();// invocar el método mensaje() 9 }

10 11 public static void main(String args[]){ 12 estudiante7 s=new estudiante7(); 13 s.mostrar(); 14 } 15 }

Resultado:

5.2. HERENCIA EN LA POO E IMPLEMENTA SOBRE ESCRITURA . Herencia en java es un mecanismo en el cual un objeto adquiere todas las propiedades y comportamientos del objeto primario. La idea de herencia en java es que puede crear nuevas clases que se basan en las clases existentes. Al heredar de una clase existente, puede volver a utilizar métodos y campos de la clase padre, y además podemos agregar los campos y los nuevos métodos también. Herencia representa la relación, también conocida como relación de padre-hijo . Por qué usar herencia en java. • Para el método de reemplazar (por lo que se logra el polimorfismo de tiempo

de ejecución). • Para la reutilización de código.

Sintaxis de Java herencia.


DESARROLLO DE SOFTWARE II Class nombre_subclase extends nombre_subclase { // Métodos y campos } El extends indica que estamos creando una nueva clase que deriva de una clase existente. En la terminología de Java, una clase que hereda se llama una super clase. La nueva clase se llama subclase. Ejemplo simple de la herencia.

Como se muestra en la figura anterior, el TAXI es la subclase y VEHICULO es la superclase. Relación entre dos clases es TAXI - VEHICULO. Esto significa que el TAXI es un tipo de VEHICULO.

En este ejemplo, objeto de programador puede acceder el campo de la propia clase, así como clase de personal es decir, la reutilización de código.

1 // Superclase 2 class personal{ 3 float salario=40000; 4 } 5



6 // Subclase que hereda la Superclase 7 class programador extends personal 8 { 9 int bono=10000;

10 public static void main(String args[]) 11 { 12 programador p=new programador(); 13 System.out.println("El salario del programador es: "+ p.salario); 14 System.out.println("El Bono del programador : "+ p.bono); 15 } 16 } Resultado:

Tipos de herencia en java. Sobre la base de clase, puede haber tres tipos de herencia en java: individuales, multinivel y jerárquica. Herencia Simple: Es cuando una clase hija hereda de una solo clase padre, es decir, hereda datos y métodos de una sola clase.


3 import javax.swing.*;

4 // Se crea una clase llamada Empleado, la cual contiene



5 // tres variables: nombre de tipo String, salario de tipo double 6 //y cargo de tipo String.

7 class Empleado { 8 private String nombre;

9 private double salario;

10 private String cargo;

11

12 //Dichas variables de inicializan por medio del constructor 13 //de la clase. También se declaran tres métodos 14 //(obtenerNombre, obtenerSalario, obtenerCargo) que permiten 15 //retornar los valores de las variables respectivamente. 16 public Empleado(String alias, double sueldo,String cargos) 17 {

18 nombre =alias;

19 salario = sueldo;

20 cargo=cargos;

21 }

22 public String obtenerNombre()

23 {

24 return nombre;

25 }

26 public double obtenerSalario()

27 {

28 return salario;

29 }

30 public String obtenerCargo() 31 {

32 return cargo;

33 }

34 //Por último se crea un método llamado incrementarSalario 35 //de tipo double (retorna valores double) y que recibe 36 //como parámetro la variable porcentaje de tipo double 37 //que contiene el valor del porcentaje en que se va a 38 //incrementar el salario para luego retornar el valor 39 //del salario con el incremento.

40 public double incrementarSalario(double porcentaje) 41 {

42 double incremento = salario * porcentaje / 100; 43 return salario += incremento;

44 }

45 }

46

47 // Se crea una nueva clase llamada Ejecutivo la cual heredara 48 //los objetos de la clase Empleado. Para crear la herencia



49 //se utiliza la palabra reservada extends. 50 class Ejecutivo extends Empleado{ 51 private double bono;

52

53 // Se crea el constructor de la clase Ejecutivo, el cual 54 //recibe tres parámetros: alias de tipo String, sueldo 55 //de tipo double y cargos de tipo String. Dichos valores 56 //son enviados al constructor de la clase Empleados por medio 57 //de la palabra reservada super. Por último se inicializa la 58 //variable bono de tipo double con un valor de cero (0). 59

60 public Ejecutivo(String alias, double sueldo, String cargos) 61 {

62 super(alias, sueldo,cargos);

63 bono = 0;

64 }

65

66 // 28 Se crea el método llamado obtenerSalario(), de tipo 67 //double (retorna un valor double) y no recibe parámetros. 68 //En dicho método en la variable baseSalario de tipo double 69 //se le asigna el valor del salario obtenido por medio del método 70 //obtenerSalario de la clase Empleado utilizando la palabra 71 //reservada super y llamando al método respectivo utilizando el 72 //operador punto (.). Por último retorna el valor de la variable 73 //baseSalario sumado al valor de la variable bono. 74 public double obtenerSalario()

75 {

76 double baseSalario = super.obtenerSalario(); 77 return baseSalario + bono;

78 }

79 // Se crea el método llamado mostrarBono(), de tipo 80 // void ( no retorna valores) y que recibe como parámetro la 81 // variable bonos de tipo double. A la variable bono se le asigna

82 // el valor de la variable bonos.

83 public void mostrarBono(double bonos) 84 {

85 bono = bonos;

86 }

87 }

88 // Se crea una clase Herencia que hereda de la clase JFrame. 89 class Herencia extends JFrame { 90 // Se crea una instancia de la clase Empleado llamada empleados 91 // de tipo array el cual contendrá tres elementos.


92 Empleado[] empleados = new Empleado[3];

93 // Se crea el constructor de la clase Herencia

94 public Herencia() { 95 super("Herencia en Java-Swing"); 96 Container contenedor=getContentPane(); 97 contenedor.setLayout(null);

98 // Se crea una instancia llamada gerente de la clase Ejecutivo, 99 // la cual envía los tres parámetros correspondientes al

100 // constructor de la clase Ejecutivo. 101 Ejecutivo gerente = new Ejecutivo("Rodrigo Narro",2500000,"Gerente"); 102 //En la línea 38 se envía el valor del bono al método 103 //mostrarbono perteneciente a la clase Ejecutivo 104 gerente.mostrarBono(300000);

105 // En las siguientes tres líneas se les asignan valores a las 106 // posiciones de la instancia empleados. 107 empleados[0] = gerente;

108 empleados[1] = new Empleado("Gabriela Saenz", 800000,"Secretaria"); 109 empleados[2] = new Empleado("Angelina Ascona",500000,"Operaria"); 110 setSize(300,300);

111 setVisible(true);

112 }

113 public void paint(Graphics g)

114 {

115 super.paint(g);

116 int y=70;

117 g.drawString("Tabla de Empleados:",30,50); 118 for (int contar = 0; contar < empleados.length; contar++) 119 { // Se crea una instancia imprimirempleados de tipo Empleado 120 //donde se le asignan los valores del arreglo empleados y 121 //por medio de un ciclo se recorre el arreglo con el fin 122 //de imprimir el nombre, el cargo , el salario y nuevo salario 123 //con incremento para el próximo año de cada uno de los empleados. 124 Empleado imprimirempleados = empleados[contar]; 125 g.drawString("Su nombre es:"+imprimirempleados.obtenerNombre(),20,y); 126 y=y+15;

127 g.drawString("Su cargo es:"+imprimirempleados.obtenerCargo(),20,y); 128 y=y+15;

129 g.drawString("El Salario es:"+imprimirempleados.obtenerSalario(),20,y); 130 y=y+15;

131 g.drawString("El salario para el proximo año es:" + 132 imprimirempleados.incrementarSalario (5) ,20, y); 133 y=y+15;

134 }


135 }

136 public static void main(String args[]) 137 {

138 Herencia ventana = new Herencia(); 139 ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 140 }

141 }

Resultado:

Herencia Multinivel y jerárquica: Se pueden contruir jerarquía que contengan tantos niveles de herencia como se desee. No existe límite de profundidad.

1 //Multiniveles de herencia. (subclases de subclases) 2 3 //nivel 1 (base) 4 class papel{ 5 public void start(){ 6 System.out.println("Coger tipo puntero..."); 7 }



8 } 9

10 //nivel 2 (pincel) 11 class pincel extends papel{ 12 public void usarpincel(){ 13 System.out.println("Usar pincel..."); 14 } 15 } 16 17 //nivel 2 (brocha) 18 class brocha extends papel{ 19 public void usarbrocha(){ 20 System.out.println("Usar brocha..."); 21 } 22 } 23 24 //nivel 3 (escribir con pincel) 25 class escribir extends pincel{ 26 public void escritura(){ 27 System.out.println("Escribiendo..."); 28 } 29 } 30 31 //nivel 3 (dibujar con pincel) 32 class dibujar extends pincel{ 33 public void dibujo(){ 34 System.out.println("Dibujando..."); 35 } 36 } 37 38 //nivel 3 (pintar con brocha) 39 class pintar extends brocha{ 40 public void pinta(){ 41 System.out.println("Pintando..."); 42 } 43 } 44 45 //nivel 3 (colorear con brocha) 46 class colorear extends brocha{ 47 public void colorea(){ 48 System.out.println("Coloreando..."); 49 } 50 } 51



52 //Principal 53 class Jerarquia { 54 public static void main(String[] args) { 55 56 System.out.println("1- "); 57 escribir e = new escribir(); 58 e.start(); 59 e.usarpincel(); 60 e.escritura(); 61 62 System.out.println("2- "); 63 dibujar d = new dibujar(); 64 d.start(); 65 d.usarpincel(); 66 d.dibujo(); 67 68 System.out.println("3- "); 69 pintar p = new pintar(); 70 p.start(); 71 p.usarbrocha(); 72 p.pinta(); 73 74 System.out.println("4- "); 75 colorear c = new colorear(); 76 c.start(); 77 c.usarbrocha(); 78 c.colorea(); 79 } 80 }

Resultado:



Como ya conocemos los conceptos de clases y objetos vamos a asumir que necesitamos construir una aplicación sobre los diferentes tipos de carreras existentes, pero para esto necesitamos clasificarlos, en este caso trabajaremos con Desarrollo de Software.

1 // Superclase 2 public class Principal { 3 4 public static void main(String[] args) { 5 System.out.println("Clase Padre Carrera"); 6 // Tenemos una instancia de la clase Carrera, esto lo podemos 7 // traducir como la creación del objeto miCarrera de tipo Carrera, 8 // no olvidemos que esta clase es la clase padre, 9 // por eso al verificar los métodos disponibles

10 Carrera miCarrera = new Carrera(); 11 miCarrera.nombreCarrera="Desarrollo de Software"; 12 //Vemos que nos aparecen las características propias de la clase, 13 //asi como otros métodos de la clase Object (Recordemos que en java todas 14 //las clases heredan de Object) que también podemos usar. 15 System.out.println("usando miCarrera, nombreCarrera : "+miCarrera.nombreCarrera); 16 System.out.println("usando miCarrera llama a: "+miCarrera.mostrarCarrera()); 17 System.out.println(); 18 19 System.out.println("SubClase hija Cursos Extiende de Carreras"); 20 // Al crear otro objeto de la clase Cursos y realizar el mismo proceso 21 // anterior, vemos que ahora tenemos no solo los métodos propios de la clase 22 // sino también los métodos y atributos de la clase Carrera. 23 24 Cursos miCurso= new Cursos(); 25 miCurso.nombreCurso="Fundamento de Programación"; 26 System.out.println("usando miCurso, nombreCarrera : "+ miCurso.nombreCarrera); 27 System.out.println("usando miCurso llama a : "+miCurso.mostrarCarrera()); 28 System.out.println("usando miCurso llama a : "+miCurso.mostrarCurso()); 29 System.out.println(); 30 31 System.out.println("SubClases hijas extienden de la Subclase Padre Cursos"); 32 // Al crear un objeto de la clase Duracion vemos que ahora no solo 33 // tenemos las características de Duracion sino también podemos hacer uso 34 // de las características de Carrera y de Cursos. 35 // Este mismo principio aplica para la otra parte de nuestra jerarquía 36 // donde como mencionamos anteriormente solo podemos acceder a los métodos 37 // y atributos disponibles para ese árbol de herencia. 38 Duracion miDuracion=new Duracion();



39 miDuracion.duracion=4;

40 System.out.println("usando miDuracion, nombreCarrera : "+miDuracion.mostrarCarrera());

41 System.out.println("usando miDuracion llama a : "+miDuracion.mostrarCurso()); 42 System.out.println("usando miDuracion llama a : "+miDuracion.mostrarDuracion()); 43 System.out.println(); 44 45 Horas miHora=new Horas(); 46 47 System.out.println("usando miHora, nombreVehiculo : "+miHora.mostrarCarrera()); 48 System.out.println("usando miHora llama a : "+miHora.mostrarCurso()); 49 System.out.println("usando miHora llama a : "+miHora.mostrarDuracion()); 50 System.out.println("usando miHora llama a : "+miHora.mostrarHoras()); 51 52 System.out.println("SubClase hija Profesor Extiende de Cursos"); 53 Profesor miProfesor= new Profesor(); 54 miProfesor.nombreProfesor="Grabiela Saenz Ascona";

55 System.out.println("usando miProfesor, mostrarCarrera : "+miProfesor.mostrarCarrera());

56 System.out.println("usando miProfesor llama a : "+miProfesor.mostrarCurso()); 57 System.out.println("usando miProfesor llama a : "+miProfesor.mostrarProfesor()); 58

59 System.out.println("SubClases hija Semanas extienden de la Subclase Padre Duracion");

60 Semanas miSemana=new Semanas();

61 System.out.println("usando miSemana, mostrarCarrera : "+miSemana.mostrarCarrera());

62 System.out.println("usando miSemana llama a : "+miSemana.mostrarCurso()); 63 System.out.println("usando miSemana llama a : "+miSemana.mostrarDuracion()); 64 System.out.println("usando miSemana llama a : "+miSemana.mostrarSemanas()); 65 System.out.println(); 66 // Como vemos podemos acceder a los diferentes métodos desde otras clases, 67 // y si nos fijamos bien podemos identificar que siempre usamos la misma 68 // propiedad nombreCarrera de la clase Carrera, lo hicimos usando objetos 69 // diferentes por tal razón el valor de la propiedad depende del asignado 70 // por cada objeto, convirtiéndose en un atributo del objeto y no de la 71 // clase como tal. 72 73 System.out.println("Propiedad de la clase Carreras usada por todas las clases Hijas"); 74 System.out.println("nombre Carreras :"+ miCarrera.nombreCarrera); 75 System.out.println("nombre Cursos :"+ miCurso.nombreCurso); 76 System.out.println("nombre Duracion :"+miDuracion.duracion); 77 System.out.println("nombre Horas :"+miHora.mostrarHoras()); 78 System.out.println("nombre Semanas :"+miSemana.mostrarSemanas()); 79 System.out.println("nombre Profesor :"+miProfesor.mostrarProfesor());



80 81 } 82 } 83 84 //------Clase Padre---------------- 85 class Carrera { 86 87 public int nrocarrera; 88 public String nombreCarrera=""; 89 90 public String mostrarCarrera(){ 91 return "Metodo mostrar clase Carrera"; 92 } 93 } 94 95 // SubClase extiende de Carrera. 96 class Cursos extends Carrera{ 97 98 public String nombreCurso=""; 99

100 public String mostrarCurso(){ 101 return "Método mostrar de clase Cursos"; 102 } 103 } 104 105 // SubClase extiende de Cursos. 106 class Duracion extends Cursos { 107 108 public int duracion=0; 109 110 public String mostrarDuracion(){ 111 return "Método mostrar desde clase Duracion"; 112 } 113 } 114 115 // SubClase extiende de Duracion. 116 class Horas extends Duracion { 117 118 public String mostrarHoras(){ 119 return "Método mostrarHoras clase Horas: 240 horas "; 120 } 121 } 122 123 //SubClase extiende de Duracion.



124 class Semanas extends Duracion{ 125 126 public String mostrarSemanas(){ 127 return "Método mostrarSemanas en clase Semanas: 20 semanas"; 128 } 129 } 130 131 // SubClase extiende de Cursos. 132 class Profesor extends Cursos{ 133 134 public String nombreProfesor=""; 135 public String mostrarProfesor(){ 136 return "Método mostrarProfesor en clase Profesor" + nombreProfesor; 137 } 138 }

Resultado:



1. Crear una super clase llamada de Carros. La clase de coche tiene los

siguientes campos y métodos. • Velocidad (int) • PrecioRegular (Double) • Color (String) • PrecioVenta (Double)

2. Crear clase TiendaAutos que contiene el método main (). Realice el

siguiente dentro del método main (). • Crear una instancia de la clase Sedan e inicializar todos los campos con

los valores adecuados. Utilice el método super (...) en el constructor para inicializar los campos de la superclase.

• Crear dos instancias de la clase Ford e inicializar todos los campos con los valores adecuados. Utilice super (...) método en el constructor para inicializar los campos de la superclase.

• Crear una instancia de la clase e inicializar todos los campos con los valores adecuados. Mostrar los precios de venta de todas las instancias.

3. Crear un applet que pida al usuario que introduzca dos números de punto

flotante, obtener los dos números del usuario y señale la suma, producto (multiplicación), diferencia y cociente (división). Utilice las técnicas mostradas en ejemplo anterior.



DESARROLLO DE SOFTWARE II VI. INTERFACES. En esta tarea trataremos las siguientes operaciones:

Implementar interfaces. Implementar métodos abstractos. Implementar Colección List <t> ArrayList Métodos de la clase Iterator.

EQUIPOS Y MATERIALES: Computadora con microprocesadores core 2 Duo ó de mayor capacidad. Sistema operativo Windows. Acceso a internet. Software de maquetación y desarrollo de páginas web. ORDEN DE EJECUCIÓN:

Implementar interfaces. Implementar métodos abstractos. Implementar Colección List <t> ArrayList Métodos de la clase Iterator. 6.1. IMPLEMENTAR INTERFACES. Una interfaz en Java es un modelo de una clase. Tiene constantes estáticas y métodos abstractos solamente. La interfaz en Java es un mecanismo para lograr la plena abstracción. No puede haber sólo métodos abstractos en el cuerpo de la interfaz de java. Se utiliza para alcanzar plenamente la abstracción y la herencia múltiple en Java. Nota: No se pueden crear instancias como clase abstracta.

DESARROLLO DE SOFTWARE II ¿Por qué utilizar la interfaz Java? Hay principalmente tres razones para utilizar la interfaz. Se les da a continuación. • Se utiliza para alcanzar plenamente la abstracción. • Por interfaz, podemos apoyar la funcionalidad de la herencia múltiple. • Se puede utilizar para lograr la articulación flexible.

El compilador Java añade palabras claves públicas y abstractas antes de que el método de interfaz y las palabras claves públicas, estáticas y finales antes de los miembros de datos. En otras palabras, los campos de interfaz son pordefecto público, estático y final, y los métodos son públicos y abstractos. Entendimiento relación entre clases e interfaces. Como se muestra en la figura dada a continuación, se extiende una clase de otra clase, una interfaz se extiende otra interfaz, sino una clase implementa una interfaz. Extends Implements Extends

interface ejemplo{ int min=5; void imprimir(); }

Compilador

interface ejemplo{ public static final int min=5 public abstract void imprimir(); }

class

class

interface

class

interface

interface



Ejemplo simple de interfaz Java. En este ejemplo, la interfaz de imprimir tiene sólo un método, su aplicación se proporciona en la clase A6.

La herencia múltiple en Java por la interfaz. Si una clase implementa varias interfaces, o una interfaz extiende múltiples interfaces son conocidos como herencia múltiple. Implements extends

interface interface

class

interface interface

interface



La herencia múltiple no se admite a través de clases en java, pero es posible gracias a la interfaz, ¿Por qué? Como hemos visto en el capítulo de la herencia, la herencia múltiple no se admite en el caso de la clase. Pero se admite en caso de interfaz porque no hay ambiguedad en cuanto aplicación es proporcionada por la clase de implementación. Por ejemplo:


DESARROLLO DE SOFTWARE II Como se puede ver en el ejemplo anterior, la interfaz ejemplo3 y ejemplo33 tienen los mismos métodos, pero su aplicación es proporcionada por clase probarinterface, así que no hay ambiguedad. Herencia de interfaz. Una clase implementa una interfaz, pero se extiende otra interfaz.

¿Qué es el marcador o interfaz de etiquetado? Una interfaz que no tiene ningún miembro se conoce como marcador o interfaz de etiquetado. Por ejemplo: Serializable, Cloneable, etc. remoto Se utilizan para proporcionar alguna información esencial para la JVM para que JVM puede realizar alguna operación útil. // ¿Cómo Serializable interfaz que está escrito?


DESARROLLO DE SOFTWARE II public interface Serializable { } Interfaz anidado en Java Nota: Una interfaz puede tener otra interfaz eso es mas conocido decir conocido como interfaz anidado. Vamos a aprender en detalle en el capítulo de clases anidadas. Por ejemplo: interface impresion { void imprimir ();

interface imprimirmensaje {

void mensaje (); }

} Java interface anidada. Un ejemplo de interfaz declarada dentro de otra interfaz o clase se conoce como interfaz anidado. Las interfaces anidados se utilizan para las interfaces relacionados con el grupo de manera que puedan ser fáciles de mantener. La interfaz anidada debe ser referida por la interfaz externa o clase. No se puede acceder directamente. Puntos a tener en cuenta para las interfaces anidadas. Interfaz anidada debe ser pública si se declara dentro de la interfaz puede tener cualquier modificador de acceso si se declara dentro de la clase. Las interfaces anidadas se declaran implícitamente estática. Sintaxis de interfaz anidada que se declara dentro de la interfaz interface nombre_interface { ...

interface nombre_interface_anidada { ... } }


DESARROLLO DE SOFTWARE II Sintaxis de interfaz anidada que se declara dentro de la clase

class nombre_clase { ... Interface nombre_interface_anidada { ... } }

Ejemplo de interfaz anidada que se declara dentro de la interfaz En este ejemplo, vamos a aprender cómo declarar la interfaz anidada y cómo podemos acceder a él.

Como se puede ver en el ejemplo anterior, estamos accediendo a la interfaz Mensaje por su ejemplo55 interfaz externa, ya que no se puede acceder directamente. Es como mirar dentro de la habitación, no podemos acceder a mirar directamente porque hay que entrar en la habitación primero. En la colección frameword, Sun Microsystem ha provisto de una entrada de interfaz anidada. El compilador de Java genera internamente interfaz pública y estática como se muestra a continuación:


DESARROLLO DE SOFTWARE II public static interface ejemplo. Mensaje { public abstract void mensaje(); }

Ejemplo de interfaz anidada que se declara dentro de la clase Vamos a ver cómo podemos definir una interfaz dentro de la clase y cómo podemos acceder a él.

¿Podemos definir una clase dentro de la interfaz? Sí, definimos una clase dentro de la interfaz, el compilador Java crea una clase anidada estática. Vamos a ver cómo podemos definir una clase dentro de la interfaz: interface M { clase A{} }


DESARROLLO DE SOFTWARE II La ventaja principal del uso de interfaces es que una clase interface puede ser implementada por cualquier número de clases, permitiendo a cada clase compartir la interfaz de programación sin tener que ser consciente de la implementación que hagan las otras clases que implementen la interface. La interface debe ser un archivo individual con extensión “.java”.

Crear un programa que utilice una interface Figura para hallar el área de un Rectángulo y de un Triángulo.

6.2. IMPLEMENTAR MÉTODOS ABSTRACTOS. Es cuando un método no tiene implementación y solamente se define con el objetivo de obligar a que en cada subclase que deriva de la clase abstracta se realice la correspondiente implementación, es decir en las subclases se va a sobre-escribir dicho método. Sí se tiene en una clase por lo menos un método abstracto entonces la clase tiene que ser abstracta sino el compilador mostrará un mensaje de error.

Nota: Figura es una clase abstracta porque no tiene sentido calcular su área, pero sí la de un cuadrado o un círculo. Si una subclase de Figura no redefine o sobre-escribe area(), deberá declararse también como clase abstracta.

Implemente la clase abstracta Vehiculo en el paquete padre que contenga el atributo capacidad del vehículo y un método abstracto caracteristicas() que se sobrescribirá en las subclases Carro y Avión. Por último, cree la clase Principal que contiene el actionPerformed() para crear los objetos de tipo Carro y Avión e imprima las caracteristicas de dichos objetos.



1 public abstract class Vehiculo 2 { 3 protected int capacidad; 4 public Vehiculo(int capacidad) 5 { 6 this.capacidad=capacidad; 7 } 8 // Definir método abstracto 9 public abstract String caracteristicas();

10 } 11 12 class Carro extends Vehiculo 13 { 14 public Carro(int cap) 15 { 16 super(cap); 17 } 18 // Sobre-escritura 19 public String caracteristicas() 20 { 21 return "Tengo una capacidad de "+capacidad+ " pasajeros \n"+ 22 "Tengo 4 ruedas y una buena velocidad \n"+ 23 "pero no puedo volar"; 24 } 25 } 26 27 class Avion extends Vehiculo{ 28 public Avion(int cap) { 29 super(cap); 30 } 31 // Sobre-escritura 32 // Crear médoto abstracto 33 public String caracteristicas() 34 { 35 return "Tengo una capacidad de "+capacidad+ "pasajeros \n"+ 36 "Puedo volar, tengo una velocidad enorme \n"+ 37 "pero consumo mucho combustible"; 38 } 39 } 40 41 class principal{ 42 public static void procesar(){ 43 Carro obj1 = new Carro(6); 44 System.out.println("Objeto Carro:");


DESARROLLO DE SOFTWARE II 45 System.out.println(obj1.caracteristicas()); 46 Avion obj2 = new Avion(300); 47 System.out.println("\nObjeto Avión:"); 48 System.out.println(obj2.caracteristicas()); 49 } 50 51 public static void main(String args[]) 52 { 53 procesar(); 54 } 55 }

Resultado:

Crear método abstracto con herencias multiples.

1 public abstract class Mamifero { 2 public String mensaje() { 3 return "soy mamífero"; 4 } 5 // Se define el método abstracto



6 public abstract String hacerRuido(); 7 } 8 9 interface InterfazA {

10 public double vacunaA = 42.75; 11 public String cuidado(); 12 } 13 14 interface InterfazB { 15 public double vacunaB = 96.28; 16 public String peligro(); 17 } 18 19 class Gato extends Mamifero implements InterfazA { 20 public String mensaje() { 21 return "soy gato"; 22 } 23 // Se crea el método abstracto 24 public String hacerRuido() { 25 return "miau"; 26 } 27 public String cuidado() { 28 return "el gato puede tener rabia"; 29 } 30 } 31 32 class Perro extends Mamifero implements InterfazA, InterfazB { 33 // Se crea el método abstracto 34 public String hacerRuido() { 35 return "guau"; 36 } 37 public String cuidado() { 38 return "el perro puede tener rabia"; 39 } 40 public String peligro() { 41 return "el perro muerde"; 42 } 43 } 44 45 class principal2 46 { 47 public static void main(String args[]) 48 { 49 Gato g = new Gato();


DESARROLLO DE SOFTWARE II 50 listado(g); 51 Perro p = new Perro(); 52 listado(p); 53 } 54 55 public static void listado(Mamifero x) { 56 if (x instanceof Gato) 57 System.out.println(">>> objeto GATO"); 58 else 59 System.out.println(">>> objeto PERRO"); 60 System.out.println("mensaje : " + x.mensaje()); 61 System.out.println("hacer ruido : " + x.hacerRuido()); 62 if (x instanceof Gato) 63 System.out.println("cuidado : " + ((Gato) x).cuidado()); 64 else { 65 System.out.println("cuidado : " + ((Perro) x).cuidado()); 66 System.out.println("peligro : " + ((Perro) x).peligro()); 67 } 68 } 69 }

Resultado:

6.3. IMPLEMENTAR COLECCIÓN LIST <T> • La Clase ArrayList implementada por Java permite manipular una colección

de objetos. • Su diseño híbrido le permite comportarse como arreglo (Array) o como lista

(List). Internamente todo es dinámico. • Para tener acceso a la Clase ArrayList es necesario colocar:

import java.util.ArrayList; / import java.util.*;

DESARROLLO DE SOFTWARE II Declaración y Creación. Forma 1: ArrayList <Clase> variable; variable = new ArrayList <Clase> (); Forma 2: ArrayList <Clase> variable = new ArrayList <Clase> (); Ejemplo: ArrayList <Producto> prod; prod = new ArrayList <Producto> (); Ejemplo: ArrayList <Producto> prod = new ArrayList <Producto> (); El objeto prod de tipo ArrayList va almacenar objetos del tipo Producto.

Interpretación gráfica ArrayList <Producto> prod = new ArrayList <Producto> ();

DESARROLLO DE SOFTWARE II La Clase ArrayList inicializa por defecto un arreglo con capacidad inicial para diez objetos del tipo Producto. Al comienzo todas las posiciones apuntan a null. Cuando requiera mayor capacidad ampliará el arreglo en diez elementos más, y así sucesivamente. Métodos de la Clase ArrayList. 1. void add(Object);

Adiciona un objeto en la posición que sigue. Ejemplo:

Producto p1 = new Producto(100,“Pantalón”,60.0,100); prod.add(p1); Producto p2 = new Producto(101,“Camisa”,45.50,150); prod.add(p2);

2. void add(int,Object);

Inserta un objeto en la posición que se indica. Ejemplo: Producto p3 = new Producto(102,“Corbata”,35.0,80); prod.add(0,p3);

3. Object get(int);

Retorna el objeto de la posición que se indica. Ejemplo: Producto x = prod.get(1); // x tiene la dirección del objeto p1



4. void set(int,Object);

Impone un objeto en la posición que se indica. Ejemplo: Producto p4 = new Producto(103,“Polo”,48.0,200); prod.set(0,p4);

5. int size();

Retorna la cantidad de objetos ingresados. Ejemplo:

int cantidad = prod.size(); // cantidad es igual a 3

6. void remove(int);

Elimina físicamente el objeto de la posición indicada. Ejemplo:

prod.remove(0); // elimina el objeto p1 y p2 se ubica en la posición 0


7. void remove(Object);

Elimina físicamente el objeto referenciado. Ejemplo:

prod.remove(p2); // elimina el objeto p2

8. void clear();

Elimina físicamente todos los objetos. Reinicializa el ArrayList Ejemplo: prod.clear();

Java no genérica Vs Colección Genérico. Marco de recopilación de Java era no genérico antes de JDK 1.5. Desde 1.5, es genérico. La colección genérica le permite tener un solo tipo de objeto en la colección. Ahora es el tipo de seguridad por lo que no se requiere encasillamiento en tiempo de ejecución. Vamos a ver el viejo ejemplo no genérico de la creación de la colección de Java. ArrayList edad =new ArrayList (); // crear edad ArrayList no genérico Vamos a ver el nuevo ejemplo genérico de la creación de la colección de Java. ArrayList <String> nombres = new ArrayList <String> (); // crear nuevos

DESARROLLO DE SOFTWARE II ArrayList genérica En la colección genérica, especificamos el tipo entre llaves angulares. Ahora ArrayList está obligado a tener único tipo determinado de objetos en él. Si intenta añadir otro tipo de objeto, se muestra error de tiempo de compilación.

Ejemplo de clase Java ArrayList.

1 // Importar libreria 2 import java.util.*; 3 // Crear clase 4 class ejemploArraylist1{ 5 6 public static void main(String args[]){ 7 8 ArrayList<String> al=new ArrayList<String>();//Crear arraylist 9 al.add("DS");//Adicionar objectos en el arraylist

10 al.add("SOPORTE"); 11 al.add("REDES"); 12 al.add("ENSAMBLAJE"); 13 14 Iterator itr=al.iterator();// Obtener Iterator de ArrayList para recorrer 15 // los elementos 16 while(itr.hasNext()){ 17 System.out.println(itr.next()); 18 } 19 } 20 }

Resultado:

Dos formas de iterar los elementos de la colección en Java. • Por interfaz Iterator.

DESARROLLO DE SOFTWARE II • Por fines de cada bucle.

En el ejemplo anterior, hemos visto recorrer por ArrayList Iterator. Veamos el ejemplo para recorrer elementos ArrayList utilizando el bucle for-each: Recorrer los elementos de la colección con for each.

1 import java.util.*; 2 class ejemploArraylist2{ 3 public static void main(String args[]){ 4 ArrayList<String> al=new ArrayList<String>();//Crear arraylist 5 al.add("DS");//Adicionar objectos en el arraylist 6 al.add("SOPORTE"); 7 al.add("REDES"); 8 al.add("ENSAMBLAJE"); 9 for(String obj:al)

10 System.out.println(obj); 11 } 12 }

Objetos de clases definidas por el usuario en Java ArrayList.

[estudiante.java] 1 public class estudiante{ 2 int nro; 3 String nombre; 4 int edad; 5 estudiante(int nro,String nombre,int edad){ 6 this.nro=nro; 7 this.nombre=nombre; 8 this.edad=edad; 9 }

10 } [ejemploArraylist3.java]

1 import java.util.*; 2 public class ejemploArraylist3{ 3 public static void main(String args[]){ 4 //Creating user-defined class objects 5 estudiante s1=new estudiante(101,"Gabriela",23);

6 estudiante s2=new estudiante(102,"Angelina",21); 7 estudiante s3=new estudiante(103,"Rodrigo",25); 8 9 ArrayList<estudiante> al=new ArrayList<estudiante>();//Crear arraylist

10 al.add(s1);//Adicionar objectos en el arraylist 11 al.add(s2); 12 al.add(s3); 13 14 Iterator itr=al.iterator(); 15 // Obtener Iterator de ArrayList para recorrer 16 // los elementos 17 while(itr.hasNext()){ 18 estudiante st=(estudiante)itr.next(); 19 System.out.println(st.nro+" "+st.nombre+" "+st.edad); 20 } 21 } 22 }

Resultado:

Ejemplo de método addAll (Collection c)

1 import java.util.*; 2 class ejemploArraylist4{ 3 public static void main(String args[]){ 4 5 ArrayList<String> al=new ArrayList<String>(); 6 al.add("DS"); 7 al.add("SOPORTE"); 8 al.add("REDES"); 9

10 ArrayList<String> al2=new ArrayList<String>(); 11 al2.add("ETI"); 12 al2.add("SENATI"); 13 14 al.addAll(al2); //<-------

DESARROLLO DE SOFTWARE II 15 16 Iterator itr=al.iterator(); 17 while(itr.hasNext()){ 18 System.out.println(itr.next()); 19 } 20 } 21 }

Resultado:

Ejemplo de método removeAll ()

1 import java.util.*; 2 class ejemploArraylist5 3 { 4 public static void main(String args[]){ 5 6 ArrayList<String> al=new ArrayList<String>(); 7 al.add("DS"); 8 al.add("SOPORTE"); 9 al.add("REDES");

10 11 ArrayList<String> al2=new ArrayList<String>(); 12 al2.add("ETI"); 13 al2.add("SENATI"); 14 15 al.removeAll(al2); // <-------- 16 17 System.out.println("iteración los elementos después de la eliminación de " 18 + "los elementos de al2 ..."); 19 Iterator itr=al.iterator(); 20 while(itr.hasNext()){ 21 System.out.println(itr.next()); 22 } 23 } 24 }

Ejemplo de método retainAll ()

1 import java.util.*; 2 class ejemploArraylist6{ 3 public static void main(String args[]){ 4 ArrayList<String> al=new ArrayList<String>(); 5 al.add("DS"); 6 al.add("SOPORTE"); 7 al.add("REDES"); 8 al.add("ENSAMBLAJE"); 9 ArrayList<String> al2=new ArrayList<String>();

10 al2.add("ETI"); 11 al2.add("SENATI"); 12 13 al.retainAll(al2); 14 15 System.out.println("iteración los elementos después de retener los " 16 + "elementos de al2 ..."); 17 Iterator itr=al.iterator(); 18 while(itr.hasNext()){ 19 System.out.println(itr.next()); 20 } 21 } 22 }

Resultado:


Clase que maneja un arreglo de objetos de tipo Persona a través de un objeto de tipo ArrayList.

Atributos privados a considerar: • Un objeto de tipo ArrayList Métodos a considerar: • Un constructor sin parámetros que cree el objeto de tipo ArrayList. • Un método "adicionar" que reciba una persona y la adicione al ArrayList. • Un método "eliminar" que reciba una persona y la elimine del ArrayList. • Un método "obtener" que reciba un índice y retorne la persona de esa

posición. • Un método "buscar" que reciba un código y retorne la persona con ese

código. • Un método "tamaño" que retorne la cantidad de personas ingresadas al

ArrayList. • Un método "edadMaxima" que retorne la edad máxima. • Un método "edadMinima" que retorne la edad mánima. • Un método "edadPromedio" que retorne la edad promedio. [Persona.java]

1 public class Persona { 2 // Atributos privados 3 private int codigo; 4 private String nombre; 5 private int edad; 6

7 // Constructor 8 public Persona(int codigo, String nombre, int edad) { 9

this.codigo = codigo;

10

this.nombre = nombre; 11

this.edad = edad;

12 } 13

14 // Métodos de acceso get/set 15 public int getCodigo() { 16

return codigo;

17 }


19 public String getNombre() { 20

return nombre;

21 } 22

23 public int getEdad() { 24

return edad;

25 } 26

27 public void setCodigo(int codigo) { 28

this.codigo = codigo;

29 } 30

31 public void setNombre(String nombre) { 32

this.nombre = nombre;

33 } 34

35 public void setEdad(int edad) { 36

this.edad = edad;

37 } 38 }

[ArrayPersona.java]

1 import java.util.ArrayList; 2

3 public class ArrayPersona {

4

5

private ArrayList<Persona> data = new ArrayList<Persona>(); 6

7

public void agregar(Persona aux){

8

data.add(aux);

9

}

10

public Persona buscar(int pos){

11

return data.get(pos);

12

}

13

public void eliminar(int pos){

14

data.remove(pos);

15

}

16

public void modificar(int pos, Persona aux){

17

data.set(pos, aux);

18

}

19

public int tamaño(){

21

return data.size();

22

}

23

24

//busque por codigo

25

public Persona buscaPersona(int codigo){ 26

for(Persona aux : data){

27

if(aux.getCodigo()== codigo){ 28

return aux;

29

}

30

}

31

return null;//No se encontro

32

}

33

34

//Elimina por codigo

35

public void eliminaPersona(int codigo){ 36


37

if(aux.getCodigo()== codigo){ 38

data.remove(aux);

39

break;

40

}

41

}

42

}

43

//Actualiza persona

44

public void actualizaPersona(Persona per){

45

for(int i=0; i<data.size(); i++){ 46

if(data.get(i).getCodigo()== per.getCodigo()){

47

data.set(i, per); 48

break;

49

}

50

}

51

}

52

//Edad maxima

53

public int edadMaxima(){

54

//Se coge la edad de la primera persona

55

int max = data.get(0).getEdad(); 56

57

//Se compara con todas las otras edades

58


59

if(aux.getEdad() > max){


max = aux.getEdad();

61

}

62

}

63

return max;

64

}

65 }

[EjemploCompleto.java]


3 import javax.swing.*;

4

5 import java.util.ArrayList;

6

7 public class EjemploCompleto extends JApplet implements ActionListener, ItemListener { 8 // Declaración de variables

9 JButton btnBorrar, btnProcesar ,btnAdicional;

10 JLabel lblOpcion, lblCodigo, lblNombre, lblEdad, lblMensaje;

11 JTextField txtCodigo, txtNombre, txtEdad;

12 JComboBox cboOpcion;

13 JTextArea txtS;

14 JScrollPane scpScroll;

15

16 ArrayPersona arreglo = new ArrayPersona();

17

18 // Crea la interfaz gráfica de usuario GUI

19 public void init() {

20

setSize(480,365);

21

getContentPane().setLayout(null);

22

getContentPane().setBackground(new Color(214,211,206));

23

24

lblOpcion = new JLabel("opción");

25

lblOpcion.setBounds(15,15,90,23);

26

getContentPane().add(lblOpcion);

27

28

lblCodigo = new JLabel("código");

29

lblCodigo.setBounds(15,39,90,23);

30

getContentPane().add(lblCodigo);

31

32

lblNombre = new JLabel("nombre");

33

lblNombre.setBounds(15,63,90,23);

34

getContentPane().add(lblNombre);



35

36

lblEdad = new JLabel("edad");

37

lblEdad.setBounds(15,87,90,23);

38

getContentPane().add(lblEdad);

39

40

cboOpcion = new JComboBox();

41

cboOpcion.setBounds(105,15,150,23);

42

cboOpcion.addItem("ingresar");

43

cboOpcion.addItem("modificar");

44

cboOpcion.addItem("eliminar");

45

cboOpcion.addItem("listar");

46

cboOpcion.addItem("reportar");

47

cboOpcion.addItemListener(this);

48

getContentPane().add(cboOpcion);

49

50

txtCodigo = new JTextField();

51

txtCodigo.setBounds(105,39,150,23);

52

getContentPane().add(txtCodigo);

53

54

txtNombre = new JTextField();

55

txtNombre.setBounds(105,63,150,23);

56

getContentPane().add(txtNombre);

57

58

txtEdad = new JTextField();

59

txtEdad.setBounds(105,87,150,23);

60

getContentPane().add(txtEdad);

61

62

btnProcesar = new JButton("Procesar");

63

btnProcesar.setBounds(365,15,101,23);

64

btnProcesar.addActionListener(this);

65

getContentPane().add(btnProcesar);

66

67

btnBorrar = new JButton("Borrar");

68

btnBorrar.setBounds(365,39,101,23);

69

btnBorrar.addActionListener(this);

70

getContentPane().add(btnBorrar);

71

72

txtS = new JTextArea();

73

txtS.setFont(new Font("monospaced",0,12));

74

txtS.setEditable(false);

75

scpScroll = new JScrollPane(txtS);

76

scpScroll.setBounds(15,125,450,227);

77

getContentPane().add(scpScroll);

78 }



79

80 public void actionPerformed(ActionEvent e) {

81

if (e.getSource() == btnProcesar)

82

procesar();

83

if (e.getSource() == btnBorrar)

84

borrar();

85 }

86

87 public void itemStateChanged(ItemEvent e) {

88

if (e.getSource() == cboOpcion)

89

seleccionar();

90 }

91

92 void seleccionar() {

93

switch(cboOpcion.getSelectedIndex()) {

94

case 0:

95

case 1:

96

lblCodigo.setVisible(true);

97

txtCodigo.setVisible(true);

98

lblNombre.setVisible(true);

99

txtNombre.setVisible(true);

100

lblEdad.setVisible(true);

101

txtEdad.setVisible(true);

102

break;

103

case 2:

104

lblCodigo.setVisible(true);

105

txtCodigo.setVisible(true);

106

lblNombre.setVisible(false);

107

txtNombre.setVisible(false);

108

lblEdad.setVisible(false);

109

txtEdad.setVisible(false);

110

break;

111

default:

112

lblCodigo.setVisible(false);

113

txtCodigo.setVisible(false);

114

lblNombre.setVisible(false);

115

txtNombre.setVisible(false);

116

lblEdad.setVisible(false);

117

txtEdad.setVisible(false);

118

}

119 }

120

121 void borrar() {

122

txtCodigo.setText("");


txtNombre.setText("");

124

txtEdad.setText("");

125

txtCodigo.requestFocus();

126 }

127

128 void procesar() {

129

switch(cboOpcion.getSelectedIndex()) {

130

case 0 : ingresar(); break;

131

case 1 : modificar(); break;

132

case 2 : eliminar(); break;

133

case 3 : listar(); break;

134

default: reportar();

135

}

136 }

137

138 int getCodigo() {

139

return Integer.parseInt(txtCodigo.getText());

140 }

141

142 String getNombre() {

143

return txtNombre.getText();

144 }

145

146 int getEdad() {

147

return Integer.parseInt(txtEdad.getText());

148 }

149

150 void imprimir(String s) {

151

txtS.append( s + "\n");

152 }

153

154 void mensaje(String m) {

155

JOptionPane.showMessageDialog(this,m);

156 }

157 /*

158 * Muestra un listado de todas las personas

159 * mostrando todos sus datos.

160 */

161 void listar() {

162

txtS.setText("Codigo\t\tNombre\t\tEdad\n");

163

164

for(int i =0; i<arreglo.tamaño(); i++){

165

Persona p = arreglo.buscar(i);

166

imprimir(p.getCodigo()+"\t\t"+


p.getNombre()+"\t\t"+

168

p.getEdad());

169

}

170

171 }

172 /*

173

* Ingresa una nueva persona evitando que el código se repita.

174

* Seguidamente muestra un listado de todas las personas.

175 */

176 void ingresar() {

177

//La data ingresada de la GUI

178

int cod = getCodigo();

179

String nom = getNombre();

180

int edad = getEdad();

181

182

if( arreglo.buscaPersona(cod) == null){

183

//1 crear el objeto con la data de la GUI

184

Persona p = new Persona(cod, nom, edad);

185

186

//2 agregar al arraylist

187

arreglo.agregar(p);

188

listar();

189

}else{

190

JOptionPane.showMessageDialog(this, "Código ya existe"); 191

}

192

193 }

194

195 void modificar() {

196


197


198

String nom = getNombre();

199

int edad = getEdad();

200

201

if( arreglo.buscaPersona(cod) != null){

202

Persona p = new Persona(cod, nom, edad);

203

arreglo.actualizaPersona(p);

204

listar();

205

}else{

206

JOptionPane.showMessageDialog(this, "Código no existe"); 207

}

208

209

210 }



212 void eliminar() {

213


214


215

216

if( arreglo.buscaPersona(cod) != null){

217

arreglo.eliminaPersona(cod);

218

listar();

219

}else{

220

JOptionPane.showMessageDialog(this, "Código no existe"); 221

}

222

223

224 }

225

226

/*

227

* Muestra un reporte indicando las edades máxima, mínima y promedio.

228

*/

229 void reportar() {

230

imprimir("Edad máxima : " + arreglo.edadMaxima());

231

232 }

233 } Resultado:

6.4. MÉTODOS DE LA CLASE ITERATOR.

A menudo, tendremos que desplazarnos por los elementos de una colección y mostrar cada elemento. La forma más sencilla de hacerlo es utilizar un iterador, que es un objeto que implementa bien el iterador o la interfaz ListIterator.


DESARROLLO DE SOFTWARE II Iterator le permite desplazarse a través de una colección, la obtención o la eliminación de elementos. ListIterator extiende Iterator para permitir el recorrido bidireccional de una lista, y la modificación de elementos. Cada una de las clases de colección proporciona un método iterador () que devuelve un iterador al inicio de la colección. Mediante el uso de este objeto iterador, puede acceder a cada elemento de la colección, un elemento a la vez. En general, para utilizar un iterador para recorrer el contenido de una colección, debemos seguir estos pasos: 1. Obtener un iterador al inicio de la colección llamando al método de la

colección iterador (). 2. Establecer un bucle que hace un llamado a hasNext (). 3. Dentro del bucle, obtener cada elemento llamando next (). Nota: Para las colecciones que implementan Lista, también puede obtener un iterador llamando ListIterator. Métodos declarados por Iterator:

Descripción:

boolean hasNext( ) Devuelve true si hay más elementos. De lo contrario, devuelve false. Object next( ) Devuelve el siguiente elemento. Lanza NoSuchElementException si no hay un siguiente elemento. void remove( ) Elimina el elemento actual. Lanza IllegalStateException si se hace un intento de llamar remove () que no está precedida de una llamada a next ().

Métodos declarados por ListIterator:

Descripción: void add(Object obj)

Inserta obj en la lista delante del elemento que será devuelto por la siguiente llamada a next ().

boolean hasNext( )

Devuelve true si hay un siguiente elemento. De lo contrario, devuelve false.

boolean hasPrevious( )

Devuelve true si hay un elemento anterior. De lo contrario, devuelve false. Object next( ) Devuelve el siguiente elemento. A NoSuchElementException se lanza si no hay un siguiente elemento. int nextIndex( ) Devuelve el índice del siguiente elemento. Si no hay un siguiente elemento, devuelve el tamaño de la lista. Object previous( ) Devuelve el elemento anterior. A NoSuchElementException se lanza si no hay un elemento anterior. int previousIndex( )



Devuelve el índice del elemento anterior. Si no hay un elemento anterior, devuelve -1.

void remove( ) Elimina el elemento actual de la lista. Un IllegalStateException se lanza si remove () es llamado antes del próximo () o anterior () se invoca. void set(Object obj) Asigna obj al elemento actual. Este es el último elemento devuelto por una llamada a cualquiera de next () o anterior ().

Un ejemplo que demuestra tanto Iterator y ListIterator. Utiliza un objeto ArrayList, pero los principios generales se aplican a cualquier tipo de colección.

Nota: Por supuesto, ListIterator está disponible sólo para aquellas colecciones que implementan la interfaz List.

1 import java.util.*; 2 public class EjemploIterator 3 { 4 public static void main(String args[]) 5 { 6 // Crea un ArrayList 7 ArrayList al = new ArrayList(); 8 // Adiciona elementos al ArrayList 9 al.add("Desarrollo de Software");

10 al.add("Soporte"); 11 al.add("Redes"); 12 al.add("Diseño web"); 13 al.add("Diseño Gráfico"); 14 15 // Usar iterator para mostrar el contenido del ArrayList 16 System.out.print("Contenido Original de al: "); 17 Iterator itr = al.iterator(); 18 while(itr.hasNext()) { 19 Object elementos = itr.next(); 20 System.out.print(elementos + " "); 21 } 22 System.out.println(); 23 24 // Modificar objectos usando iterator 25 ListIterator litr = al.listIterator(); 26 while(litr.hasNext()) { 27 Object element = litr.next(); 28 litr.set(element + "+");


DESARROLLO DE SOFTWARE II 29 } 30 System.out.print("Modificar el contenido de al: "); 31 itr = al.iterator(); 32 while(itr.hasNext()) { 33 Object element = itr.next(); 34 System.out.print(element + " "); 35 } 36 System.out.println(); 37 38 // Ahora, mostrar la lista hacia atrás 39 System.out.print("Lista Modificado al revés: "); 40 while(litr.hasPrevious()) { 41 Object element = litr.previous(); 42 System.out.print(element + " "); 43 } 44 System.out.println(); 45 } 46 }

Resultado:

1. El mismo problema. Esta vez utilizar la clase ArrayList en Java. Crear un

método que permita añadir e imprimir la lista. Reutilice lo más que pueda del programa anterior.

2. Escribir un revés método que invierte el orden de los elementos en un ArrayList de cadenas.

3. Crear un programa que solicite al usuario un número entero, luego le pida al

usuario que introduzca muchos valores. Guarde estos valores en un




variedad e imprimir la lista. Entonces revertir los elementos de la lista de modo que el primer elemento se convierte en el último elemento y así sucesivamente. No se limite a invertir el orden en que se imprimen; de hecho cambiar la forma en que se almacenan la lista. Se puede resolver este problema de dos maneras. Al crear una lista temporal y copiar todos los datos de la lista original a la temporal. Que el cambio de la lista original hacia la lista temporal. Imprimir la lista original.

4. Resolver el mismo problema anterios, pero no crear una segunda lista;

simplemente reorganizar los elementos dentro de la lista que tiene. Intercambia los elementos es decir deben cambiar de lugar. Cuando los elementos se han invertido, imprima la lista de nuevo.


desarrollo de softwarevirtual.senati.edu.pe/curri/file_curri.php/curri/pdsd... · 2016-01-14 ·...

Documents