UNIVERSIDAD ABIERTA Y A DISTANCIA DE

MÉXICO

NOMBRE DEL PROGRAMA EDUCATIVO:

INGENIERÍA EN DESARROLLO DE SOFTWARE

NOMBRE DEL ASIGNATURA:

Programación orientada a objetos.

NOMBRE DE LA PRÁCTICA:

Componentes y estructuras de los eventos.

UNIDAD 1

FACILITADOR:

Amadeo Coporo Quintana

INTEGRANTES:

No Matrícula Nombre
1 ES162007075 Maldonado Rodríguez Carlos Eduardo

Julio, 2018
Contenido
Investigación ..................................................................................................................................... 3
Los Componentes Gráficos ........................................................................................................ 3
Contenedores .......................................................................................................................... 3
Componentes Atómicos ....................................................................................................... 4
Componentes de Texto......................................................................................................... 5
Componentes de Menús....................................................................................................... 5
Componentes Complejos ........................................................................................................ 6
Elección de aplicación de la web 2.0 ............................................................................................ 6
Eventos identificados ................................................................................................................... 7
Referencias ..................................................................................................................................... 10
Investigación
Los Componentes Gráficos
Como ya se ha mencionado en trabajos recientes, los eventos son formas en las
que responde el programa a la interacción con el usuario o con otros objetos.
Ahora observaremos la forma en la que interactúan los distintos componentes
dependiendo su categoría.

Cristian Henao en su blog de tutoriales y guías prácticas, lecciones aprendidas en

el desarrollo de software, menciona que: “Los componentes gráficos son estos
elementos que permiten brindar una interacción con el usuario del sistema..... Cada
componente corresponde a una clase en Java, por esta razón cuando desarrollamos
y queremos vincular uno de estos elementos simplemente instanciamos la clase
que necesitamos, es decir, si queremos un Área de texto debemos crear un objeto
de la clase JTextArea.”

Contenedores
Los contenedores son elementos capaces de albergar otros elementos, ya sean
componentes, o incluso otros contenedores.

Los contenedores descienden de la clase padre “container”, la cual, a su vez es

descendiente directa de la clase “component”

java.lang.Object

java.awt.Component

java.awt.Container

Cristian Henao menciona que: Un contenedor es el tapiz donde pintaremos nuestros

componentes gráficos, existen contenedores principales, entre estos se encuentran
JFrame y JDialog pero también existen otros contendedores incluidos dentro de los
mencionados...

 JFrame – Es la Ventana de aplicación, el contenedor principal

P á g i n a 3 | 11
  JDialog – Una ventana de tipo Ventana de diálogo, también puede ser un
contenedor principal.
 JPanel – Permite la creación de paneles independientes donde se
almacenan otros componentes.
 JScrollPane – permite la vinculación de barras de desplazamiento en un
contenedor.
 JSplitPane – permite la creación de un contenedor dividido en 2 secciones.
 JTabbedPane – Permite la creación de pestañas, cada pestaña representa
un contenedor independiente.
 JDesktopPane – Permite crear ventanas dentro de una ventana principal
 JToolBar – Permite introducir una Barra de herramientas

Componentes Atómicos
Son estructuras que permiten almacenar variables o métodos, pero no permiten
almacenar nada de mayor jerarquía.

Como lo menciona Cristian Henao: Los componentes atómicos son los elementos
que no pueden almacenar otros objetos o componentes gráficos, por ejemplo, un
JPanel no es Atómico, ya que en el podemos almacenar JButtons, JTextField entre
otros.

 JLabel – Permite Vincular Etiquetas, tanto de texto como de imágenes

 JButton – Permite vincular Botones simples.
 JCheckBox – Son Casilla de verificación, ideal para selección múltiples.
 JRadioButton – Permite presentar opciones de selección similares a las
checkbox, solo que el enfoque de estas es de única selección.
 JToggleButton – Botón que al oprimirlo se quedará presionado hasta que
se ejecute otro evento.
 JComboBox – Permite mostrar una lista de elementos como un combo de
selección.

P á g i n a 4 | 11
  JScrollBar – Permite mostrar una barra de desplazamiento, regularmente
usada en Áreas de texto o paneles donde el contenido es mayor que el
tamaño del componente.
 JSeparator – Permite separar opciones, es una barra simple.
 JSlider - Permite vincular un Deslizador en nuestra ventana.
 JSpinner – permite vincular una caja de texto con botones integrados para
seleccionar algún valor.
 JProgressBar – Establece una barra de progreso.

Componentes de Texto.
Son todos aquellos que nos permiten procesar cadenas de texto, sea como entrada
o salida de información.

Cristian Henao nos indica los componentes de texto:

 JTextField – Permite introducir un campo de texto simple.

 JFormattedTextField – Permite introducir un campo de texto con formato,
(si definimos que solo recibe números no permitirá letras...)
 JPasswordField – Campo de texto que oculta los caracteres ingresados.
 JTextArea – Permite vincular un área de texto donde el usuario ingresara
información o simplemente para presentar cadenas de texto.
 JEditorPane –Permite vincular un área de texto con propiedades de formato.
 JTextPane – Similar al anterior, permitiendo otras opciones de formato,
colores, iconos entre otros.

Componentes de Menús.
Estos componentes permiten vincular opciones de menú en nuestras ventanas, tipo
menú principal, como por ejemplo el conocido Inicio, Archivo, Edición etc.

Cristian Henao Menciona:

 JMenuBar – Permite vincular una barra de menús.

P á g i n a 5 | 11
  JMenu– Permite vincular botones o enlaces que al ser pulsados despliegan
un menú principal.
 JMenuItem – Botón u opción que se encuentra en un menú.
 JCheckBoxMenuItem– Elemento del menú como opciones de checkbox.
 JRadioButtonMenuItem– Elemento del menú como botón de selección.
 JPopupMenu– Opciones emergentes del menú.

Componentes Complejos
Estos son componentes un poco más avanzados, cumplen con funciones más
enfocadas a procesos específicos y complejos, como por ejemplo obtener gran
cantidad de información de una base de datos, trabajo con nodos, colores entre
otros.

Cristian Henao menciona:

 JTable – Permite vincular una tabla de datos con sus respectivas filas y
columnas.
 JTree - Carga un árbol donde se establece cierta jerarquía visual, tipo
directorio.
 JList – Permite cargar una lista de elementos, dependiendo de las
propiedades puede tenerse una lista de selección múltiple.
 JFileChooser – Es un componente que permite la búsqueda y selección de
ficheros entre otras.
 JColorChooser – Componente que permite cargar un panel selector de
color
 JOptionPane – No es algo complejo sino más un componente independiente
que permite mostrar un cuadro de diálogo personalizable.

Elección de aplicación de la web 2.0

Las aplicaciones de la web 2.0 se destacan por ser plataformas que permiten la
interacción entre usuarios, el compartir información y la colaboración mutua.

P á g i n a 6 | 11
Marcos Ros-Martín dice: es que en esta nueva concepción de la web, los usuarios
tienen un lugar destacado, ya que participan en la creación y modificación de
contenidos como sucede en la Wikipedia o con la blogosfera, en su categorización
como sucede con las folksonomías y el tagging; y la solicitud de información bajo
demanda como sucede con Youtube, además de la utilización intensiva de la
sindicación de contenidos mediante RSS (Really Simple Syndication).

En mi caso, elegiré como caso de estudio a: “flickr” porque considero que cumple
con los requisitos esperados (además de utilizar varios eventos)

Eventos identificados
Eventos Estructura Sintáctica Estructura
algorítmica
JtextFiel import javax.swing.*; El control JLabel
import java.awt.event.*; public class remplaza a la salida
d Formulario estándar
extends JFrame implements “System.out print”
ActionListener{
private static final long serialVersionUID = 1L; El control de
private final JTextField private final JLabel JtextField cumple la
labe tle1x; tpfierilvda1t;e final JButton función de la clase
boton1; Scanner para la
@SuppressWarnings("LeakingThisInConstruc entrada de datos.
tor")
public Formulario() {
setLayout(null);
label1=new JLabel("Usuario:");
label1.setBounds(10,10,100,30);
add(label1);
textfield1=new JTextField();
textfield1.setBounds(120,10,150,20);
add(textfield1);
boton1=new JButton("Aceptar");
boton1.setBounds(10,80,100,30);
add(boton1);
}boton1.addActionListener(this);
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==boton1) {
String cad=textfield1.getText();
setTitle(cad);
}}

P á g i n a 7 | 11
 public static void main(String[] ar) {
Formulario formulario1=new Formulario();
formulario1.setBounds(0,0,300,150);
formulario1.setVisible(true);
}
}
JCombo private static final long serialVersionUID = 1L; El control
private JComboBox combo1; JComboBox
Box @SuppressWarnings("unchecked") permite seleccionar un
public Formulario() { String de una lista.
setLayout(null); Es un evento
combo1=new JComboBox(); muy útil con este
combo1.setBounds(10,10,80,20); control es cuando el
add(combo1); operador selecciona
combo1.addItem("rojo"); un ítem de la lista.
combo1.addItem("vede");
combo1.addItem("azul"); Para capturar la
combo1.addItem("amarillo"); selección de un
combo1.addItem("negro"); ítem debemos
combo1.addItemListener(this); implementar la
}@Override interface que
public void itemStateChanged(ItemEvent e) { contiene un método
if (e.getSource()==combo1) { llamada
String ItemStateChanged
seleccionado=(String)combo1.getSelectedIte
m();
setTitle(seleccionado);
}}
public static void main(String[] ar) {
Formulario formulario1=new
Formulario();
formulario1.setBounds(0,0,200,150);
formulario1.setVisible(true);
}
}

JFame import javax.swing.*; La componente

public class Formulario extends JFrame{ básica que
private static final long requerimos cada
serialVersionUID = 1L; vez que
public Formulario() { implementamos una
setLayout(null); interfaz visual con
} la librería Swing es
public static void main(String[] ar) { la clase Jframe.
Formulario formulario1=new Esta clase
Formulario(); encapsulada a una

P á g i n a 8 | 11
 formulario1.setBounds(10,20,400,300); ventana clásica de
formulario1.setVisible(true); cualquier sistema
}} operativo con
entorno grafico
JButton import java.awt.event.*; El tercer control
public class Formulario extends JFrame visual de uso muy
implements ActionListener { común es el que
private static final long provee la clase
serialVersionUID = 1L; JButton. Este
JButton boton1; control visual
public Formulario() { Muestra un botón.
setLayout(null); El proceso de
boton1=new JButton("Finalizar"); añadir botones a
boton1.setBounds(300,250,100,30); un control Jframe
add(boton1); es similar añadir
boton1.addActionListener(this); } controles de tipo
@Override Jlabel, es decir
public void Java las
actionPerformed(ActionEvent e) { implementa el
concepto de
if (e.getSource()==boton1) {
interfaces para
System.exit(0);
poder llamar a
}}
métodos de una
public static void main(String[] ar) {
clase existente a
Formulario formulario1=new Formulario();
una clase
formulario1.setBounds(0,0,450,350);
desarrollada
formulario1.setVisible(true);
}
JCheckB import java.awt.Component; El control
import javax.swing.*; JCheckBox permite
ox import javax.swing.event.*; implementar un
public class Formulario extends JFrame cuadro de selección
implements ChangeListener{ básicamente un
private static final long serialVersionUID = 1L; botón de dos
private JCheckBox check1,check2,check3; estados
public
Formulario() {
scehtLecaky1o=unt(enwul
lJ);CheckBox("Inglés");
check1.setBounds(10,10,150,30);
check1.addChangeListener(this);
add(check1);
check2=new JCheckBox("Francés");
check2.setBounds(10,50,150,30);
check2.addChangeListener(this);
Component add = add(check2);
check3=new JCheckBox("Alemán");
P á g i n a 9 | 11
 check3.setBounds(10,90,150,30);
check3.addChangeListener(this);
add(check3);
}
@Override
cpaudb=lic"" ;void
stateChanged(ChangeEvent e){ String
if (check1.isSelected()==true) {
cad += "Inglés-";
}
if (check2.isSelected()==true) {
cad += "Francés-";
}i
f (check3.isSelected()==true) {
cad += "Alemán-"; }
setTitle(cad); }
public static void main(String[] ar) {
Formulario formulario1=new
Formulario();
formulario1.setBounds(0,0,300,200);
formulario1.setVisible(true); }}

Referencias
 UnADM (s/f), Unidad 1. Eventos, recuperado de:
https://unadmexico.blackboard.com/bbcswebdav/institution/DCEIT/2016_S2
_B1/DS/03/DPO2/U1/Unidad_1_Eventos.pdf
 Cristian Henao (01 septiembre 2013), Componentes en Java Swing,
recuperado de: http://codejavu.blogspot.com/2013/09/componentes-java-
swing.html
 CeSAr (27 octubre 2010), Contenedores en Java, recuperado de:
http://ccrpoo.blogspot.com/2010/10/contenedores-en-java.html
 Belmonte Oscar (s/f), Programación Avanzada, Interfaces gráficas de
usuario, Swing: Contenedores y componentes. Univeritat Jaume,
reucperado de:
http://www3.uji.es/~belfern/Docencia/Presentaciones/ProgramacionAvanzad
a/Tema3/swing.html#1

P á g i n a 10 | 11
 Cristian Henao (08 octubre 2013), Contenedores en Java Swing,
recuperado de: http://codejavu.blogspot.com/2013/10/contenedores-java-
swing.html
 Cristian Henao (07 septiembre 2013), Componentes Atómicos Java Swing
en Java Swing, recuperado de:
http://codejavu.blogspot.com/2013/09/componentes-atomicos-java-
swing.html
 Marcos Ros-Martin (09 diciembre 2006), La web 2.0 y algunas de sus
aplicaciones, recuperado de:
http://www.documentalistaenredado.net/452/la-web-20-y-algunas-de-sus-
aplicaciones/


P á g i n a 11 | 11