• Author / Uploaded
• Daniel Montiel

Citation preview

INSTITUTO TECNOLOGICO SUPERIOR DE POZA RICA

ALUMNO: MONTIEL GONZALEZ DANIEL FLORES PARADA NICOLAS

TRABAJO: CÓDIGOS DE COMPONENTES VISUALES Y NO VISUALES

MATERIA: TOPICOS AVANZADOS DE PROGRAMACIÓN

DOCENTE: LIC. SANTA VALLEJO FIGUEROA

CARRERA: ISC SEMESTRE Y GRUPO: 4° “A”

CÓDIGOS Evento de botones 1.-Se crea la clase y se extiende de JFrame para que sea gráfico.

2.-Se crea un constructor de la clase y lo primero que tendra dentro el constructor sera la línea de código para que aparezca de nombre en la ventana.

3.-Se crea un objeto Container que lo referencia la variable contenedor, el cual servirá para agregar los botones que se crearan más adelante.

4.-Se declaran dos botones y se importan sus librerías.

5.-Se crea el primer botón y se agrega al contenedor.

6.-Se crea el segundo botón y se agrega al contenedor.

7.-Se crea una instancia de la clase interna MenejadorBoton el cual permitirá el manejo de los botones creados anteriormente.

8.-Se agregan las líneas de código de setSize para dar el tamaño a la ventana que se mostrara y el setVisible con una valor de true es para que se muestre la ventana, y ahí termina el constructor.

9.-Se crea el método main en el cual se harán referencias al JFrame.

10.-Por último se crea la clase interna ManejadorBoton la cual manejara los botones como su nombre lo indica y el código que contendrá será el siguiente:

A continuación se mostraran las ventanas que se visualizan al ejecutar el código terminado. Primera ventana que se visualiza.

Mensaje que se visualiza al oprimir el botón “Botón simple”.

Mensaje que se visualiza al oprimir el botón “Botón elegante”.

Campos de texto 1.-Primero se crea la clase del programa, en este caso CampoTexto, se extiende de JFrame y se importa la librería del JFrame

. 2.-Se crean las variables para los campos de texto, y se importan las librerías.

3.-Se crea un constructor de la clase, en este caso CampoTexto y se le pone lo que será el título que mostrara la ventana.

4.-Se crea un contenedor para los campos de texto y posteriormente se importan las librerías correspondientes.

5.-Se crean dos campos de texto, uno con un tamaño predeterminado, el otro campo con texto predeterminado y ambos campos de texto se agregaran al contenedor.

6.-Se crea un campo de texto con texto y tamaño predeterminado y sin manejador de eventos, también al momento de pasar el mouse sobre el campo de texto se visualizara un comentario.

7.-Se crea un campo de texto en el cual momento de escribir no se visualizaran las letras que contiene.

8.-Se registran el manejador de los eventos de cada campo, marcara error porque aún no se crea el manejador de eventos, y se pone el tamaño y que la ventana será visible.

9.-Se crea el método main el cual maneja el JFrame, así como el llamado al constructor que se creó.

10.-Se crea una clase interna para el manejo de los eventos que tendrán los campos de texto, posteriormente se importan las librerias que se requieran para los eventos y aquí termina el código del programa.

A continuación se mostraran la ventana y mensajes que aparecerán al ejecutar el código. Ventana que visualiza al ejecutar el código

Al escribir sobre el primer campo de texto y el mensaje que manda al dar enter.

Al dar enter estado en el segundo campo de texto este es el mensaje que mostrara.

A poner el puntero sobre el tercer campo de texto no editable mostrara un comentario.

Por ultimo al dar enter en campo de texto que no se visualizan las letras, mostrara un mensaje de lo que contiene este campo escrito en el.

Letras en cursiva y negritas 1.-Se crea la clase, en este caso será Casillas extendido de JFrame, con la posterior importación de sus librerias.

2.-Se declaran las variables para el campo de texto y las casillas de las opciones (negritas, cursivas), posteriormente se importaran las librerias.

3.-Se crea un constructor de la clase Casillas y adentro las primeras líneas de código del constructor serán las que le pondrá un título a la ventana principal.

4.-Se crea un contenedor donde se colocaran el campo de texto (JTextField) y los JCheckBox, posteriormente se importaran sus librerias.

5.-Se configura el campo de texto, se establece el tipo de letra, se agrega al contenedor el campo de texto y se importa una librería (java.awt.Font).

6.-Se crean los objetos de verificación de las casillas negritas y cursivas y después se agregan al contenedor.

7.-Se registran los componentes para los objetos JCheckBox y se da tamaño a la ventana, así como para que se visualice; marcara error en el código porque aún no se crea la clase interna ManejadorCasilla.

8.-Se crea el método main el cual llamara al constructor Casillas.

9.-Se crea la clase interna ManejadorCasilla, la cual contendrá los eventos.

A continuación se mostraran las ventanas de como corre el programa.

Ventana cuando se selecciona la casilla Negrita

Ventana cuando se deselecciona Negrita y se selecciona la casilla Cursiva.

Ventana cuando se seleccionan las dos casillas.

Etiquetas 1.-Se crea la clase Etiqueta extendida de JFrame, posteriormente se importa la librería de JFrame.

2.-Se declaran tres etiquetas y se importa la librería correspondiente.

3.-Se crea un constructor de la clase y al principio se pone la línea de código para poner el nombre del encabezado en la ventana.

4.-Se crea un contenedor para las etiquetas y se importan las librerías correspondientes.

5.-Se crea una etiqueta con argumento y se agrega al contenedor.

6.-Se crea la segunda etiqueta con argumentos y una imagen que tendrá, la imagen se pondrá dentro de nuestro paquete en el que este la clase.

7.-Se crea la etiqueta tres y se dice la alineación y una imagen.

8.-Se ponen las siguientes líneas de códigos para determinar el tamaño y que sea visible la ventana.

9.-Se crea el método main el cual llamara al constructor de la clase.

Visualización de la ventana al ejecutar el código.

Ventana cuando el puntero del mouse esta sobre la etiqueta1.

Ventana cuando se coloca el puntero sobre la imagen y en el texto de la etiqueta2.

Ventana cuando se coloca el puntero sobre la imagen perteneciente a la etiqueta3 o sobre la etiqueta3.

Menú 1.-Se crea la clase menú extendida de JFrame e implementada por ActionListener, y posteriormente se importan las librerías.

2.-Se crean variables con valores ya definidos para el tamaño de la ventana (marco) y posicionamiento del mismo.

3.-Se declaran variables para JLabel y JMenu, posteriormente se importan las librerías correspondientes.

4.-Se crea el método main el cual llamara al constructor menú de la clase que se creara más adelante.

5.-Se crea el constructor Menu() de la clase y se crea un contenedor, posteriormente se importara la librería del contenedor.

6.-Se establecen las propiedades del marco, así como su posición y así mismo se importara la librería java.awt.BorderLayout.

7.-Se llama al método crearMenu().

8.-Se la variable menú a la variable barraMenu que referencia al componente JMenuBar.

9.-Se crea y se ubica la etiqueta respuesta.

10.-Se crea el método crearMenu() de tipo privado.

11.-Se crean las opciones que tendrá nuestro menú y posteriormente se importara la librería javax.swing.JMenuItem.

12.-Se agrega una línea horizontal para separar.

13.-Se agrega la última opción de en el menú.

14.-Se da sobrescribe el método actionPerformed y en el mismo se declarara el evento que hará el programa y con esto se termina el código del programa.

Ventana que se visualiza al correr el programa.

Ventana con el menú desplegado.

Ventana al dar click en Nuevo.

Ventana al dar click en Abrir...

Ventana al dar click en Guardar.

Ventana en dar click en Guardar como…