topicos avanzados de programacion

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.



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



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!!! }

}



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 }

});



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,



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



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.



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());



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



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



*/ 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)



{ 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



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);



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(); } }



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.



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.



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



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:



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 );



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.



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.

��

topicos avanzados de programacion

Documents