TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
Objetivo: Desarrollar soluciones de software utilizando programación concurrente, programación de eventos, que soporte interfaz gráfica y comunicación con dispositivos móviles.
TIPOS DE PROGRAMAS EN FUNCION AL TIPO DE INTERACCION • Secuenciales: reciben los datos de entrada, realizan un conjunto de operaciones o cálculos y muestran la salida por ejemplo: comando “dir” de Ms-Dos • Interactivos: exigen la intervención del usuario en tiempo de ejecución, pero el programa realiza acciones independientemente de las órdenes del usuario - por ejemplo: juego en tiempo real (deportes, estrategia, ...) • Dirigidos por eventos: el programa “espera” la llegada de un evento (orden del usuario, ...), cuando el evento se produce realiza la acción correspondiente y vuelve a esperar - por ejemplo: procesador de texto
PROGRAMACION ORIENTADO A EVENTOS Evento: Acción asíncrona, generalmente provocada por el usuario Ejemplo:
� Pulsación del botón del ratón � Pulsación de tecla � Modificación del estado de un control ( Maximizar, minimizar una ventana ) � Arrastrar el ratón � Introducir texto en un determinado campo
En un programa dirigido por eventos:
� El programador escribe métodos para manejar los eventos � La aplicación espera a que llegue un evento � Cuando el sistema detecta un evento llama a su manejador asociado � El usuario dispara la ejecución de las acciones a diferencia de las aplicaciones “tradicionales” donde
las acciones las iniciaba la propia aplicación Cada vez que se produce un evento, Java crea un objeto de una determinada clase de evento, y este evento es transmitido a un determinado método para que lo gestione. Nota: Podemos decir que la programación orientada a eventos consiste en proporcionar métodos que respondan a dichos mensajes.
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
GENERACION DE EVENTOS
TIPOS DE EVENTOS
� ComponentEvent: Se producirá este tipo de evento cuando el usuario mueva o redimensione un componente.
� FocusEvent: Se producirá este tipo de evento cuando se cambie el foco de un componente.
� KeyEvent: Se producirá cuando el usuario pulse una tecla.
� MouseEvent: Se producirá cuando el usuario efectúe un movimiento con el ratón o haga un click.
� ContainerEvent: Se producirá cuando se añadan o eliminen componentes en el contenedor.
� WindowEvent: Se producirá cuando se realice algún tipo de operación con la ventana como abrirla y cerrarla.
� ActionEvent: Se producirá cuando se efectúe alguna acción sobre un componente, como por ejemplo: la pulsación de un botón.
� AdjustmentEvent: Se ajusta algún valor de un componente.
� ItemEvent: Se ha modificado el estado de algún elemento que pertenece al componente.
� TextEvent: El contenido de texto de algún componente ha cambiado. Para cada evento con nombre xxxEvent, se define una interfaz llamada xxxListener en la que se definen los métodos que van a manejarse relacionados con ese evento
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
ActionEvent -> ActionListener MouseEvent -> MouseListener
ELEMENTOS DEL MODELO DE EVENTOS EN JAVA Este modelo está basado en la delegación (la responsabilidad de gestionar un evento que ocurre en un objeto “source” la tiene otro objeto “listener”)
� Fuentes de Eventos (event sources) � Receptores de Eventos (event listener) � Adaptadores (adapter clases)
Fuente de Eventos (event sources) Son objetos que detectan eventos y notifican a los receptores que se han producido dichos eventos. Ejemplo: Botones sobre los que se pulsa Campos de texto que pierde el foco Campos de texto sobre el que se presiona una tecla Ventanas que se cierran Receptor del Evento (event listener) Para poder capturar todos los eventos, Java proporciona las interfaces las cuales tienen la función de escuchar los eventos que se generan en nuestra aplicación (listeners). Para cada tipo de evento existe una interfaz que escucha. COMO IMPLEMENTAR UNA INTERFAZ EN MI PROGRAMA DENTRO DE LA CLASE JUNTO CON EL COMPONENTE class MiClase implements ActionListener { {
public MiClase() { {
Button btn = new Button("Boton"); btn.addActionListener(this);
}
public void actionPerformed(ActionEvent e) { {
// Aqui va el codigo de la accion!!! }
}
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
DENTRO DE UNA CLASE APARTE class MiClase { {
public MiClase() { {
... Button btn = new Button("Boton"); btn.addActionListener(new MiOyente()); ...
} } class MiOyente implements ActionListener { {
public void actionPerformed(ActionEvent e) { {
// Aqui va el codigo de la accion }
}
EN UNA CLASE INTERNA Button btn = new Button("Boton"); btn.addActionListener( new ActionListener()
{ { public void actionPerformed(ActionEven e) { {
// Aqui va el codigo de la accion }
});
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
Adaptadores (adapter clases) Tienen como objetivo evitar la tediosa tarea de tener que implementar todos los métodos de las interfaces listener Por ello existe una clase adaptadora por cada interface listener que tiene más de un método:
� java.awt.event.ComponentAdapter � java.awt.event.ContainerAdapter � java.awt.event.FocusAdapter � java.awt.event.KeyAdapter � java.awt.event.MouseAdapter � java.awt.event.MouseMotionAdapter � java.awt.event.WindowAdapter
Las clases adaptadoras implementan los métodos de la interface correspondiente como vacios. Ejemplo: class ClaseGestorRaton extends MouseAdapter { {
public void mousePressed (MouseEvent evento) { {
System.out.println ("Boton ratón pulsado"); if ((evento.getModifiers() & InputEvent.BUTTON3_MASK) != 0) { {
System.out.println (”El botón pulsado es el de la derecha"); // mismo comportamiento con InputEvent.META_MASK
} }
} Eventos, interfaces y métodos de escucha
Componentes que lo generan
ActionEvent ActionListener addActionListener()
JButton, JList, JTextField, JmenuItem, JCheckBoxMenuItem, JMenu, JpopupMenu
AdjustmentEvent AdjustmentListener addAdjustmentListener()
JScrollbar y cualquier objeto que implemente la interface Adjustable
ComponentEvent ComponentListener addComponentListener
Component, JButton, JCanvas, JCheckBox, JComboBox, Container, JPanel, JApllet, JScrollPane, Window, JDialog, JFileDialog, JFrame, JLabel, JList, JScrollbar, JTextArea, JtextField
ContainerEvent ContainerListener addContainerListener()
Container, JPanel, JApplet, JScrollPane, Window, JDialog, JFileDialog, JFrame
FocusEvent FocusListener addFocusListener()
Component, JButton, JCanvas, JCheckBox, JComboBox, Container, JPanel, JApplet, JScrollPane, Window, JDialog,
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
JFileDialog, JFrame, JLabel, JList, JScrollbar, JTextArea, JTextField
KeyEvent KeyListener addKeyListener()
Component, JButton, JCanvas, JCheckBox, JComboBox, Container, JPanel, JApplet, JScrollPane, Window, JDialog, JFileDialog, JFrame, JLabel, JList, JScrollbar, JTextArea, JTextField
MouseEvent MouseListener addMouseListener()
Component, JButton, JCanvas, JCheckBox, JComboBox, Container, JPanel, JApplet, JScrollPane, Window, JDialog, JFileDialog, JFrame, JLabel, JList, JScrollbar, JTextArea, JTextField
WindowEvent WindowListener addWindowListener()
Window, JDialog, JFileDialog, JFrame
ItemEvent ItemListener addItemListener()
JCheckBox, JCheckBoxMenuItem, JComboBox, JList
TextEvent TextListener addTextListener()
JTextComponent, JTextArea, JTextField
INTERFACES GRAFICAS DE USUARIO Hasta ahora hemos desarrollado programas que usan la consola para interactuar con el usuario, siendo esta forma de interfaz muy simple y nos ha permitido centrarnos en todo que tiene que ver tan solo la programación orientada a objetos con el lenguaje Java, sin tener que tratar al mismo tiempo con ventanas, botones y otros elementos similares. Las interfaces graficas de usuario (GUI) ofrecen al usuario ventanas, cuadros de dialogo barras de herramientas, botones, listas desplegables y muchos otros elementos con los que ya estamos acostumbrados a manipular. LIBRERIAS JAVA PARA LA CREACION DE GUI’s AWT : Abstract Window Toolkit SWING: Mas moderna, basada en AWT ELEMENTOS DE UNA GUI COMPONENTES Son clases de objetos que permiten utilizar elementos graficos para crear interfaces graficas. Un componente también tiene un representación grafica, que se puede mostrar en pantalla y con la que puede interactuar el usuario. Ejemplos: Botones Campos de texto Etiquetas Casillas de Verificación, etc.
AWT SWING Button JButton Es un botón usado para recibir el clic del raton
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
Canvas Un lienzo o panel usado para dibujar Checkbox JCheckBox Cuadro de verificación. Permite seleccionar Choice JComboBox Es una lista desplegable de elementos estáticos Component Es el padre de todos los componentes AWT Container Dialog JDialog Es un cuadro de dialogo con una ventana con titulo y bordes Frame JFrame Es una marco o una ventana y es la clase de todas las ventanas GUI Label JLabel Es una cadena de texto List JList Componente que tiene un conjunto dinamico de elementos Menu JMenu Es un elemento dentro de la barra de menú, el cual contiene un
conjunto de elementos MenuItem JMenuItem Un elemento dentro del menú Panel JPanel Una clase contenedora básica usanda frecuentemente para crear
diseños complejos Scrollbar JScrollBar Un componente que permite al usuarios hacer una dentro de un
rango de valores ScrolOPane JScrollPAne Clase contenedora que implementa un deslizador horizontal y
vertical para un único componente hijo TextArea JTextArea Un componente que permite al usuario introducir texto en un bloque
o rectangulo VENTANAS: CONFIGURANDO EL LAYOUT DE UN CONTENEDOR
Varias componentes pueden contener otras componentes dentro, para determinar de qué modo esos componentes se organizarán visualmente, entonces se utiliza el concepto de Layout. Por ejemplo, el siguiente código crea un frame y coloca el layout del paño de contenidos (porción central de la ventana) con BorderLayout y finalmente agrega una etiqueta al sur de la ventana.
JFrame frame= new Jframe(); frame.getContentPane().setLayout(new BorderLayout()); JLabel label=new JLabel("yo voy abajo"); frame.add(label, BorderLayout.SOUTH);
A continuación se muestran los diferentes layout estándares de swing.
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
EJERCICIO 1:
Codigo que implementa una calculadora basica con el uso de elementos graficos y realice el manejo de los
eventos necesarios.
/**
*
* @author isctorres
*/
public class Calculadora_10
{ {
char valores[] = {'7','8','9','/','4','5','6','*','1','2','3','','0','.','+','='};
JFrame contenedor;
JPanel superior,inferior;
JTextField resultado;
JButton ArBoton[] = new JButton[16];
public Calculadora_10()
{
PanelSup();
PanelInf();
CrearCal();
}
void PanelSup()
{
superior = new JPanel();
superior.setLayout(new FlowLayout());
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
resultado = new JTextField(20);
resultado.setEnabled(false);
superior.add(resultado);
}
void PanelInf()
{
inferior = new JPanel();
inferior.setLayout(new GridLayout(4, 4));
for( int i=0; i<valores.length; i++ )
{
ArBoton[i] = new JButton(""+valores[i]);
ArBoton[i].addActionListener(new EventosOperandos( valores[i] ));
inferior.add(ArBoton[i]);
}
}
void CrearCal()
{
contenedor = new JFrame();
contenedor.setLayout(new BoxLayout(contenedor.getContentPane(), BoxLayout.Y_AXIS));
contenedor.add(superior);
contenedor.add(inferior);
contenedor.pack();
contenedor.setVisible(true);
contenedor.setDefaultCloseOperation(contenedor.EXIT_ON_CLOSE);
contenedor.setLocation(200, 200);
}
// CLASE PARA EL MANEJO DE LOS EVENTOS
class EventosOperandos implements ActionListener
{
char opc;
public EventosOperandos( char val )
{
opc = val;
}
@Override
public void actionPerformed( ActionEvent e )
{
switch( opc )
{
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case '0':
resultado.setText(resultado.getText()+opc);
break;
case '/': // Realizar la division
case '*': // Realizar la multiplicacion
case '+': // Realizar la suma
case '': // Realizar la resta
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
break; case '.': // Realizar la validacion pertinente break; case '=': // Realizar la operacion correspondiente } } } /** * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here Calculadora_10 obj = new Calculadora_10(); } }
MENUS: Java ofrece varias clases para poner menús en una ventana:
� JMenuBar � JMenu � JMenuItem � JCheckBoxMenuItem � JRadioButtonMenuItem
Un JFrame o JApplet puede guardar una barra de menú donde se cuelgan menús desplegables. Los menús tienen elementos de menú que puede seleccionar el usuario. Las barras de menús se pueden contemplar como una estructura que soporta menús. EJERCICIO 2 Implementar una calculadora mediante el uso de menús donde se realice el manejo de los eventos con el uso de Escuchadores y Adaptadores /** * * @author isctorres */ public class CALCULADORA extends JFrame{ //JFrame contenedor; JMenuBar menu; JPanel pCal; JMenuItem ItmSuma,ItmResta,ItmMulti,ItmDivis,ItmSalir; JTextField ope1,ope2,resultado; JLabel operador,opresul; JMenu opemenu, opesalir; /** * @param args the command line arguments
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
*/ public CALCULADORA() { super("CALCULADORA MENUS"); menu = new JMenuBar(); setJMenuBar(menu); opemenu = new JMenu("Operaciones"); menu.add(opemenu); opemenu.add( ItmSuma = new JMenuItem("Suma",'S')); ItmSuma.addActionListener(new OyenteMenu('+')); opemenu.add( ItmResta = new JMenuItem("Resta",'R')); ItmResta.addActionListener(new OyenteMenu('')); opemenu.add( ItmMulti = new JMenuItem("Multiplicacion",'M')); ItmMulti.addActionListener(new OyenteMenu('*')); opemenu.add( ItmDivis = new JMenuItem("Division",'D')); ItmDivis.addActionListener(new OyenteMenu('/')); opesalir = new JMenu("Salir"); menu.add(opesalir); opesalir.add( ItmSalir = new JMenuItem("Cerrar",'C')); ItmSalir.addActionListener(new OyenteSalir()); pCal = new JPanel(); pCal.setLayout( new FlowLayout()); ope1 = new JTextField(10); ope1.addMouseListener(new AdapRaton()); operador = new JLabel(); ope2 = new JTextField(10); ope2.addMouseListener(new EventoRaton()); opresul = new JLabel("="); resultado = new JTextField(10); pCal.add(ope1); pCal.add(operador); pCal.add(ope2); pCal.add(opresul); pCal.add(resultado); this.add(pCal); this.setDefaultCloseOperation(this.EXIT_ON_CLOSE); this.pack(); this.setVisible(true); } class OyenteSalir implements ActionListener { @Override public void actionPerformed(ActionEvent e)
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
{ System.exit(0); } } class OyenteMenu implements ActionListener { char opc; public OyenteMenu( char opc ) { this.opc = opc; } @Override public void actionPerformed(ActionEvent e) { float val1 = Float.parseFloat(ope1.getText()); float val2 = Float.parseFloat(ope2.getText()); double resul = 0; switch( opc ) { case '+': resul = val1 + val2; break; case '': resul = val1 val2; break; case '*': resul = val1 * val2; break; case '/': resul = val1 / val2; } resultado.setText(""+resul); operador.setText(""+opc); } } class AdapRaton extends MouseAdapter { public void mouseClicked(MouseEvent e) { JOptionPane.showMessageDialog(rootPane, "Generado con Adapter"); } } class EventoRaton implements MouseListener { @Override public void mouseClicked(MouseEvent e) { JOptionPane.showMessageDialog(rootPane, "Van a psaar"); } @Override public void mousePressed(MouseEvent e) {} @Override
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
public void mouseReleased(MouseEvent e) {} @Override public void mouseEntered(MouseEvent e) {} @Override public void mouseExited(MouseEvent e) {} } public static void main(String[] args) { // TODO code application logic here Componentes_SWING obj = new Componentes_SWING(); } } COMPONENTES SWING Implementación con una miscelánea de componentes SWING package compo_swing; import java.awt.BorderLayout; import java.awt.Color; import javax.swing.*; /** * * @author isctorres */ public class Compo_Swing { /** * @param args the command line arguments */ JFrame ventana; JPanel pcompo; JButton boton; JComboBox opciones; JList opciones2; JProgressBar barra; JRadioButton radio1,radio2; JLabel ayuda; JPasswordField pass; public Compo_Swing() { ventana = new JFrame("Componentes Swing"); ventana.setLayout(new BoxLayout(ventana.getContentPane(), BoxLayout.Y_AXIS)); // CREACION DEL PANEL Y MODIFICACION DE SUS PROPIEDADES pcompo = new JPanel(); pcompo.setBackground(Color.red);
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
pcompo.setSize(500, 30); ventana.add(pcompo); // AGREGAMOS UN BOTON boton = new JButton(new ImageIcon("android.png")); boton.setSize(10, 10); ventana.add(boton); //AGREGAMOS UN COMBOBOX String[] paises = {"Mexico","Inglaterra","Japon","Corea","Australia"}; opciones = new JComboBox(paises); ventana.add(opciones); // AGREGAMOS UNA LISTA DE OPCIONES opciones2 = new JList(paises); ventana.add(opciones2); // AGREGAMOS LA BARRA DE PROGRESO barra = new JProgressBar(); barra.setValue(50); // El valor de 50 indica que el progreso es del 50% ventana.add(barra); // AGREGAMOS EL LABEL DE AYUDA ayuda = new JLabel("Etiqueta de ayuda"); ventana.add(ayuda); // AGREGAMOS LOS RADIO BOTONES radio1 = new JRadioButton("M", false); radio2 = new JRadioButton("F", false); ventana.add(radio1); ventana.add(radio2); ButtonGroup btg = new ButtonGroup(); btg.add(radio1); btg.add(radio2); // AGREGAMOS UN CAMPO PARA PASSWORD pass = new JPasswordField("passsword"); ventana.add(pass); ventana.pack(); ventana.setVisible(true); ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE); } public static void main(String[] args) { // TODO code application logic here new Compo_Swing(); } }
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
EJERCICIO DE CLASE:
GENERAR LAS SIGUIENTES APLICACIONES
� CUADRO MAGICO
GRAFICOS Y JAVA 2D En esta sección veremos varias de las herramientas de Java para dibujar figuras bidimensionales, controlar colores y
fuentes.
Para empezar a dibujar en Java, primero debemos entender su sistema de coordenadas, el cual es un esquema
para identificar a cada uno de los posibles puntos en la pantalla. De manera predeterminada, la esquina superior
izquierda de un componente de la GUI (como una ventana) tiene las coordenadas (0,0). Un par de coordenadas
está compuesto por una coordenada x (la coordenada horizontal) y una coordenada y (la coordenada vertical). La
coordenada x es la distancia horizontal que se desplaza hacia la derecha, desde la parte izquierda de la pantalla. La
coordenada y es la distancia vertical que se desplaza hacia abajo, desde la parte superior de la pantalla. El eje x describe cada una de las coordenadas horizontales, y el eje y describe cada una de las coordenadas verticales. Las
coordenadas se utilizan para indicar en dónde deben mostrarse los gráficos en una pantalla. Las unidades de las
coordenadas se miden en píxeles (lo que se conoce como “elementos de imagen”). Un píxel es la unidad más
pequeña de resolución de un monitor de computadora.
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
En la siguiente figura se muestra una parte de la jerarquía de clases de Java que incluye varias de las clases de
gráficos básicas y las clases e interfaces de la API Java 2D. La clase Color contiene métodos y constantes para
manipular los colores. La clase JComponent contiene el método paintComponent, que se utiliza para dibujar
gráficos en un componente. La clase Font contiene métodos y constantes para manejar los tipos de letras. La clase
FontMetrics contiene
métodos y constantes para
manipular tipos de letras. La
clase Graphics contiene
métodos para dibujar
cadenas, líneas, rectángulos
y demás figuras.
La clase Graphics2D, que
extiende a la clase Graphics,
se utiliza para dibujar con la
API Java 2D.
La clase Polygon contiene
métodos para crear
polígonos. La mitad inferior
de la figura muestra varias
clases e interfaces de la API
Java 2D.
La clase BasicStroke ayuda a
especificar las
características de dibujo de
las líneas.
Las clases GradientPaint y
Texture Paint ayudan a
especificar las
características para rellenar
figuras con colores o
patrones.
Las clases GeneralPath,
Line2D, Arc2D, Ellipse2D,
Rectangle2D y
RoundRectangle2D
representan varias figuras
de Java 2D.
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
GRAPHICS Un contexto de gráficos permite dibujar en la pantalla. Un objeto Graphics administra un contexto de gráficos y
dibuja píxeles en la pantalla que representan texto y otros objetos gráficos (como líneas, elipses, rectángulos y
otros polígonos). Los objetos Graphics contienen métodos para dibujar, manipular tipos de letra, manipular colores
y varias cosas más.
La clase Graphics es una clase abstract
La clase JComponent (paquete javax.swing), que hereda de manera indirecta de la clase Component, contiene un
método llamado paintComponent, que puede utilizarse para dibujar gráficos. El método paintComponent toma un
objeto Graphics como argumento. El sistema pasa este objeto al método paintComponent cuando se requiere
volver a pintar un componente ligero de Swing.
El encabezado del método paintComponent es:
public void paintComponent( Graphics g )
EJERCICIO 1
Codifiquemos el siguiente ejemplo
package clasegraphics;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
*
* @author isctorres
*/
// Heredamos de la clas JPanel el cual implementa el metodo paintComponent
public class ClaseGraphics extends JPanel
{ {
@Override
// Sobrecargamos el metodo
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
public void paintComponent( Graphics g ) // Esta linea es cuando se usa la libreria AWT
//public void paint( Graphics g ) // Esta linea es cuando se usa la libreria SWING
{
// Determinamos el color que tendran los elementos que se agreguen al lienzo
// establece nuevo color de dibujo, usando valores enteros
g.setColor( new Color(255, 0 , 0) );
// Dibujamos un rectangulo con el color que se definio anteriormente
g.fillRect(15, 25, 100, 20);
// Ahora dibujamos texto y obtenemos el valor del color definido
g.drawString("RGB ACTUAL"+g.getColor(), 130, 40);
// establece nuevo color de dibujo, usando valores de punto flotante
g.setColor( new Color( 0.50f, 0.75f, 0.0f ) );
g.fillRect( 15, 50, 100, 20 );
g.drawString( "RGB actual: " + g.getColor(), 130, 65 );
// establece nuevo color de dibujo, usando objetos Color static
g.setColor( Color.BLUE );
g.fillRect( 15, 75, 100, 20 );
g.drawString( "RGB actual: " + g.getColor(), 130, 90 );
// muestra los valores RGB individuales
Color color = Color.MAGENTA;
g.setColor( color );
g.fillRect( 15, 100, 100, 20 );
g.drawString( "Valores RGB: " + color.getRed() + ", " + color.getGreen() + ", " + color.getBlue(), 130, 115 );
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
// CREAMOS EL FRAME QUE CONTENDRA EL PANEL
JFrame frame = new JFrame("Ejemplo de Graphics");
// DEFINIMOS LA ACCION QUE SE REALIZARA CUANDO SE CIERRE LA APLICACION
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// INSTANCIAMOS EL PANEL EL CUAL AL MOMENTO DE CARGARSE LLAMA AL METODO paintComponent
ClaseGraphics panel = new ClaseGraphics();
// AGREGAMOS EL PANEL AL JFRAME
frame.add(panel);
// DETERMINAMOS EL TAMANO DEL JFRAME
frame.setSize(400, 180);
// VISUALIZAMOS EL JFRAME
frame.setVisible(true);
}
}
EJERCICIO 2:
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
GENEREMOS LA SIGUIENTE
CODIFIQUEMOS EL PROGRAMA PARA OBTENER LA SIGUIENTE PANTALLA
package graphics_figuras;
import java.awt.Color;
import java.awt.Graphics;
import java.util.Locale;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
*
* @author isctorres
*/
public class Graphics_Figuras extends JPanel
{ {
/**
* @param args the command line arguments
*/
@Override
public void paintComponent( Graphics g )
{
g.setColor(Color.red);
g.drawLine(5,30,380, 30);
g.setColor(Color.BLUE);
g.drawRect( 5, 40, 90, 55 );
g.fillRect( 100, 40, 90, 55 );
g.setColor( Color.CYAN );
g.fillRoundRect( 195, 40, 90, 55, 50, 50 );
g.drawRoundRect( 290, 40, 90, 55, 20, 20 );
g.setColor( Color.GREEN );
g.draw3DRect( 5, 100, 90, 55, true );
g.fill3DRect( 100, 100, 90, 55, false );
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
g.setColor( Color.MAGENTA ); g.drawOval( 195, 100, 90, 55 ); g.fillOval( 290, 100, 90, 55 ); } public static void main(String[] args) { // TODO code application logic here JFrame marco = new JFrame( "Dibujo de lineas, rectangulos y ovalos" ); marco.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); Graphics_Figuras figuras = new Graphics_Figuras(); figuras.setBackground(Color.WHITE); marco.add(figuras); marco.setSize(400,200); marco.setVisible(true); } } ANCHO Y ALTO DEL ARCO PARA LOS RECTANGULOS REDONDEADOS
public void drawLine( int x1, int y1, int x2, int y2 ) Dibuja una línea entre el punto (x1, y1) y el punto (x2, y2).
public void drawRect( int x, int y, int anchura, int altura ) Dibuja un rectángulo con la anchura y altura especifi cadas. La esquina superior izquierda del rectángulo tiene las
coordenadas (x, y). Sólo el contorno del rectángulo se dibuja usando el color del objeto Graphics; el cuerpo del
rectángulo no se rellena con este color.
public void fillRect( int x, int y, int anchura, int altura ) Dibuja un rectángulo relleno con la anchura y altura especificadas. La esquina superior izquierda del rectángulo
tiene las coordenadas (x, y).
public void clearRect( int x, int y, int anchura, int altura ) Dibuja un rectángulo relleno con la anchura y altura especificadas, en el color de fondo actual.
TópicosAvanzadosdeProgramación ����
Isc. Rubén Torres Frías
La esquina superior izquierda del rectángulo tiene las coordenadas (x, y). Este método es útil si el programador
desea eliminar una porción de una imagen.
public void drawRoundRect( int x, int y, int anchura, int altura, int anchuraArco, int alturaArco ) Dibuja un rectángulo con esquinas redondeadas, en el color actual y con la anchura y altura especificadas. Los
valores de anchuraArco y alturaArco determinan el grado de redondez de las esquinas (vea la figura anterior). Sólo
se dibuja el contorno de la figura.
public void fillRoundRect( int x, int y, int anchura, int altura, int anchuraArco,int alturaArco ) Dibuja un rectángulo relleno con esquinas redondeadas, en el color actual y con la anchura y altura especificadas.
Los valores de anchuraArco y alturaArco determinan el grado de redondez de las esquinas (vea la figura anterior).
public void draw3DRect( int x, int y, int anchura, int altura, boolean b ) Dibuja un rectángulo tridimensional en el color actual, con la anchura y altura especificadas. La esquina superior
izquierda del rectángulo tiene las coordenadas (x, y). El rectángulo aparece con relieve cuando b es true y sin
relieve cuando b es false. Sólo se dibuja el contorno de la figura.
public void fill3DRect( int x, int y, int anchura, int altura, boolean b ) Dibuja un rectángulo tridimensional relleno en el color actual, con la anchura y altura especificadas. La esquina
superior izquierda del rectángulo tiene las coordenadas (x, y). El rectángulo aparece con relieve cuando b es true y
sin relieve cuando b es false.
public void drawOval( int x, int y, int anchura, int altura ) Dibuja un óvalo en el color actual, con la anchura y altura especificadas. La esquina superior izquierda del
rectángulo imaginario que lo rodea tiene las coordenadas (x, y). El óvalo toca los cuatro lados del rectángulo
imaginario en el centro de cada uno de los lados (vea la siguiente figura). Sólo se dibuja el contorno de la fi gura.
public void fillOval( int x, int y, int anchura, int altura ) Dibuja un óvalo relleno en el color actual, con la anchura y altura especificadas. La esquina superior izquierda del
rectángulo imaginario que lo rodea tiene las coordenadas (x, y). El óvalo toca los cuatro lados del rectángulo
imaginario en el centro de cada uno de los lados.
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
Top Related