poo2_u1_a3_joec
TRANSCRIPT
Encabezado: COMPONENTES Y ESTRUCTURA. 1
Unidad 1. Actividad 3. Componentes y estructura.
Por:
Jorge Ricardo Escobar Carrasco.
Programación orientada a objetos II.
Universidad abierta y a distancia de México.
lunes 30 de junio de 2014
Facilitador:
Christian Leonel Islas Sánchez.
COMPONENTES Y ESTRUCTURA. 2
Tabla de contenido
Sumario............................................................................................................................................3Unidad 1. Actividad 3. Componentes y estructura..........................................................................4Componentes....................................................................................................................................5
JButton........................................................................................................................................5JCheckbox...................................................................................................................................5JComboBox.................................................................................................................................6JList.............................................................................................................................................6JMenu..........................................................................................................................................7JRadioButton...............................................................................................................................7JSlider..........................................................................................................................................8JSpinner.......................................................................................................................................8JTextField....................................................................................................................................8JPasswordField............................................................................................................................9JFrame.........................................................................................................................................9
Estructura algorítmica......................................................................................................................9Estructura sintáctica.......................................................................................................................10
Programa de ejemplo.................................................................................................................10Conclusión.....................................................................................................................................14
COMPONENTES Y ESTRUCTURA. 3
Sumario.
En esta actividad deberás identificar los elementos que componen el manejo de eventos y su
estructura sintáctica y así podrás afirmar tus conocimientos que adquiriste durante toda la unidad.
Propósito:
Realizar una descripción propia de los componentes y estructura de los eventos. Ahora es
necesario que sigas las siguientes instrucciones:
COMPONENTES Y ESTRUCTURA. 4
Unidad 1. Actividad 3. Componentes y estructura.
1. Identifica los componentes y la estructura requerida para el manejo de eventos en los
temas de esta unidad.
2. Desarrolla una descripción con tus propias palabras de los puntos que identificaste en la
indicación anterior.
COMPONENTES Y ESTRUCTURA. 5
Componentes.
Los componentes que he visto hasta ahora son gráficos, marcos, ventanas, botones y
cuadros de texto son componentes gráficos que ayudan al usuario a realizar una tarea
determinada. Y ayudan al desarrollador a crear interfaces de usuario que pueden ser usadas para
que la computadora realice una tarea especifica.
A continuación listo los componentes visuales más comunes en Java:
JButton.
Este componente nos permite definir un botón que se anima al ser presionado (Ver figura
1). Si es usado con eventos de mouse, podemos usarlo para definir comportamientos cuando el
botón es presionado.
JCheckbox.
Este es un componente que sirve para marcar una o varias opciones de tipo encendido o
apagado lo cual es muy útil si queremos hacer una interfaz que el usuario pueda usar para activar
o desactivar uno o varias opciones en un programa. (Ver figura 2)
Figura. 1. Botón con imagen dentro.
Figura. 2. Cuatro componentes JCheckbox en estado activado.
COMPONENTES Y ESTRUCTURA. 6
JComboBox.
Este componente se alimenta de una fuente de datos para almacenar las opciones que
puede mostrar en forma de lista al ser elegido. Al volver a dar clic, se puede apreciar la opcion
elegida. (Ver figura 3)
JList.
Este componente es similar a JcomboBox, pero en esta vez, la lista de opciones siempre
esta expuesta y solo se aprecia el elemento elegido, cuando presionas dicho elemento. (Ver figura
4)
Figura. 3. JComboBox, mostrando sus opciones.
Figura. 4. JList, mostrando una lista de nombres.
COMPONENTES Y ESTRUCTURA. 7
JMenu.
Este componente es el mas complejo de todos, permite definir un menú para tu
aplicación. Puedo agregar imágenes a las opciones e incluso agregar radio y check boxes. Cada
opción del menú puede tener su propia respuesta y con esto tener una funcionalidad compleja
dentro del mismo. (Ver figura 5)
JRadioButton.
Similar al componente JCheckBox, solo que este se liga a otros componentes radiobutton
y esto es para permitir solo uno de ellos como el elegido. Este componente se usa para crear una
lista de opciones de las cuales solo se puede elegir una de de ellas. (Ver figura 6)
Figura. 5. Componente JMenu.
Figura. 6. Componente JRadioButton.
COMPONENTES Y ESTRUCTURA. 8
JSlider.
Este componente me permite definir un componente deslizante que puede ser usado para
definir de forma no exacta el valor de algún parámetro en nuestro programa, por ejemplo el
volumen de audio del sistema. (Ver figura 7)
JSpinner.
Este componente sirve para elegir datos por medio de flechas hacia arriba y abajo que
cambian el valor o valores a mostrar. Este componente es muy útil para elegir valores de rango
bajo o fechas. (Ver figura 8)
JTextField.
Este componente me permite crear un cuadro de texto donde el usuario puede escribir
texto desde el teclado. Este es uno de los componentes más comunes. También se le puede
agregar una etiqueta de texto. (Ver figura 9)
Figura. 7. Componente JSlider.
Figura. 8. Componente JSpinner.
Figura. 9. Componente JTextField.
COMPONENTES Y ESTRUCTURA. 9
JPasswordField.
Este componente sirve para establecer un campo de texto el cual enmascara los caracteres
dentro del mismo, este componente es usado para escribir contraseñas o palabras clave cuyo
contenido debe ser oculto ante ojos curiosos. (Ver figura 10)
JFrame.
Este componente es muy usado para contener los demás componentes. Las ventanas en
Java son frames o marcos los cuales sirven como contenedores de otros componentes. Al menos
este componente debe estar presente en una aplicación Swing. (Ver figura 11)
Estructura algorítmica.
La estructura algorítmica la defino por capas, donde la base o primer capa es el
Figura. 10. Componente JPasswordField.
Figura. 11. Componente JFrame.
Figura. 12. Estructura algorítmica.
COMPONENTES Y ESTRUCTURA. 10
componente JFrame, después de eso, se pueden agregar componentes o incluso otros
contenedores los cuales almacenan sus propios juegos de componentes visuales. En Java, esto
debe ser llevado a cabo con mucho cuidado, ya que los componentes se definen por medio de
código, al menos en Eclipse y Netbeans así es.
Los componentes visuales necesitan ser posicionados usando coordenadas X, Y, donde
por medio de números enteros positivos establecemos el punto de origen de dichos componentes.
Estos componentes pueden tener diferentes tamaños y estos son definidos por medio de código.
Estructura sintáctica.
Los componentes visuales de java son clases, por lo tanto puedo crear objetos y
construirlos por medio de sus constructores base. En el ejemplo siguiente, tengo una porción de
código.
textField = new JTextField(20);
textField.addActionListener(this);
En este código, se crea un componente llamado textField de tipo JTextField. Y le agrega
un action listener el cual es el encargado de escuchar los eventos para el Textfield.
Esta es una forma simple de agregar un componente de texto en un marco o frame.
El siguiente programa crea un JFrame, un JTextBox y un JTextArea. Al escribir un texto y
presionar la tecla intro dentro del componente JTextBox, se escribe el contenido del mismo en el
JTextArea. Es un programa sencillo pero demuestra el uso de los componentes visuales y de los
eventos en un programa.
Programa de ejemplo.
/* TextDemo.java */
COMPONENTES Y ESTRUCTURA. 11
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TextDemo extends JPanel implements ActionListener {
protected JTextField textField;
protected JTextArea textArea;
private final static String newline = "\n";
public TextDemo() {
super(new GridBagLayout());
textField = new JTextField(20);
textField.addActionListener(this);
textArea = new JTextArea(5, 20);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
COMPONENTES Y ESTRUCTURA. 12
//Agrega componentes a este panel.
GridBagConstraints c = new GridBagConstraints();
c.gridwidth = GridBagConstraints.REMAINDER;
c.fill = GridBagConstraints.HORIZONTAL;
add(textField, c);
c.fill = GridBagConstraints.BOTH;
c.weightx = 1.0;
c.weighty = 1.0;
add(scrollPane, c);
}
public void actionPerformed(ActionEvent evt) {
String text = textField.getText();
textArea.append(text + newline);
textField.selectAll();
textArea.setCaretPosition(textArea.getDocument().getLength());
}
private static void createAndShowGUI() {
//Create and set up the window.
COMPONENTES Y ESTRUCTURA. 13
JFrame frame = new JFrame("TextDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JComponent newContentPane = new TextDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
frame.pack();
frame.setVisible(true);
}
public static void main(String[] args) {
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});
}
}
COMPONENTES Y ESTRUCTURA. 14
Conclusión.
Los componentes de java son muy variados y numerosos. Numerarlos todos requeriría
mucho tiempo, pero en esta unidad he podido probar los componentes básicos. Los eventos son
también usados para dar significado, a los componentes visuales. Sin los eventos ni los métodos
ligados a esos eventos, los componentes visuales carecen de significado.
Necesitaré mucho mayor practica con Java para contener cada ventana o pantalla dentro
de una clase. Esto para no saturar una sola clase con todo el código del programa.