martes, 6 de noviembre de 2012

OBJETO SESSION EN ASP.NET




La necesidad y utilidad del método session para transferir variables


En los programas que hemos visto hasta ahora, hemos utilizado variables que solo existían en el archivo que era ejecutado. Cuando cargábamos otra página distinta, los valores de estas variables se perdían a menos que nos tomásemos la molestia de pasarlos por la URL o inscribirlos en las cookies o en un formulario para su posterior explotación. Estos métodos, aunque útiles, no son todo lo prácticos que podrían en determinados casos en los que la variable que queremos conservar ha de ser utilizada en varios scripts diferentes y distantes los unos de los otros.

Podríamos pensar que ese problema puede quedar resuelto con las cookies ya que se trata de variables que pueden ser invocadas en cualquier momento. El problema, ya lo hemos dicho, es que las cookies no son aceptadas ni por la totalidad de los usuarios ni por la totalidad de los navegadores lo cual implica que una aplicación que se sirviera de las cookies para pasar variables de un archivo a otro no sería 100% infalible.

Nos resulta pues necesario el poder declarar ciertas variables que puedan ser reutilizadas tantas veces como queramos dentro de una misma sesión. Imaginemos un sitio multilingüe en el que cada vez que queremos imprimir un mensaje en cualquier página necesitamos saber en qué idioma debe hacerse. Podríamos introducir un script identificador de la lengua del navegador en cada uno de los archivos o bien declarar una variable que fuese valida para toda la sesión y que tuviese como valor el idioma reconocido en un primer momento.

Estas variables que son válidas durante una sesión y que luego son "olvidadas" son definidas con el objeto Session de la siguiente forma:

Session("nombre de la variable") = valor de la variable

Una vez definida, la variable Session, será almacenada en memoria y podrá ser empleada en cualquier script del sitio web.

La duración de una sesión viene definida por defecto en 20 minutos. Esto quiere decir que si en 20 minutos no realizamos ninguna acción, el servidor dará por finalizada la sesión y todas las variables Session serán abandonadas. Esta duración puede ser modificada con la propiedad Timeout:

Session.Timeout = n° de minutos que queramos que dure

Una forma de borrar las variables Session sin necesidad de esperara que pase este plazo es a partir del método Abandon:

Session.Abandon

De este modo todas las variables Session serán borradas y la sesión se dará por finalizada. Este método puede resultar practico cuando estemos haciendo pruebas con el script y necesitemos reinicializar las variables.

Lo que se suele hacer es crear un archivo en el que se borran las cookies y se abandona la sesión. Este archivo será ejecutado cuando queramos hacer borrón y cuenta nueva:

Ejercicio

anexe una pagina aspx al proyecto llamado calculadora.aspx

en cual diseñe una calculadora con operaciones basicas suma , resta , multiplicacion , division , el igual y limpiar


  • Diseñara una clase llamada operacion en el cual incluiran un metodo de tipo funcion llamada igual



Public Function igual(ByVal n1 As String, ByVal n2 As String, ByVal op As String) As String
        Dim final As String

        Select Case op
            Case "suma"

                final = Str(Val(n1) + Val(n2))

            Case "resta"

                final = Str(Val(n1) + Val(n2))

        End Select

        Return final
    End Function




  • en el webform de la pagina   codigo que incluiras en el boton uno aqui llamada b1 para el numero uno




Protected Sub B1_Click(sender As Object, e As EventArgs) Handles B1.Click
        TextBox1.Text = TextBox1.Text + "1"
    End Sub




  • en el boton de suma


 Session("VALOR") = TextBox1.Text
        Session("OPERADOR") = "suma"
        TextBox1.Text = ""
        MsgBox(Session("VALOR"))


  • en el boton de igualdad


Dim Vvalor As String
        Dim Voperador As String
        Vvalor = Session("VALOR")
        Voperador = Session("OPERADOR")
        MsgBox(Vvalor + "  " + Voperador)
        TextBox1.Text = clase.igual(Vvalor, TextBox1.Text, Voperador)


terminar el ejercicio con los demas botones asi como las operaciones en el metodo de la clase 




CONTENEDORES EN JAVA

CONTENEDORES


Botones

Los botones son de las herramientas principales en cualquier aplicación gráfica, la clase encargada de los botones es JButton, un botón es un contenedor que puede tener tanto una imagen, texto o ambos, dentro de el.Las formas para crear un botón son:


JButton(String texto);
JButton(Icon icono);
JButton(String texto, Icon icono);

La primera opción crea un botón con sólo texto (como lo hemos utilizado), la segunda opción crea un botón con texto e imagen, por ejemplo:

Jbutton boton = JButton("Guardar", new ImageIcon("save.jpg"));

Esto creará un botón como el siguiente:

figura

Los botones responden principalmente a actionListener (aunque obviamente también pueden responder a focusListener), y el método actionPerformed de la interfaz actionListener, corresponde a la acción de presionar el botón.

Algunos métodos importantes de la clase JButton son:
Valor de RetornoNombre del Método
voidsetText(String texto)
cambia el texto al botón.
StringgetText()
Obtiene el texto del Botón.
voidsetIcon(Icon icono)
cambia el ícono al botón.
IcongetIcon()
Obtiene el ícono del Botón.


Existe una clase similar a Button (de hecho forman parte de la clase abstracta AbstractButton) llamada JToggleButton que permite tener la funcionalidad de botones presionados, un ejemplo de esto, son los botones de Negrita, Cursiva, 

Subrayado en los editores de texto comunes.

El JToggleButton es muy similar a JButton de hecho sus constructores son muy parecidos:

JToggleButton(String texto);
JToggleButton(Icon icono);
JToggleButton(String texto, Icon icono);

Un método de los componentes que nos será de utilidad será la de setName(String nombre) este método nos permite darle un nombre (mejor dicho cambiarlo) interno al componente, así por ejemplo si tenemos dos botones, ambos con el mismo nombre (aunque en princpio esto da a lugar a ambigüedades) para diferenciarlos podemos darles nombres internos, con los cuales los reconoceremos dentro del programa, gracias al método setName.


Etiquetas

Las etiquetas nos permiten mostrar información o mostrar una imagen:
JLabel(String texto);
JLabel(String texto, int posicion_horizontal);
JLabel(Icon imagen);
JLabel(Icon imagen, int posicion_horizontal);
JLabel(String texto, Icon imagen, int posicion_horizontal);
Al igual que JButton tenemos métodos para cambiar las etiquetas:
Valor de RetornoNombre del Método
voidsetText(String texto)
cambia el texto de la etiqueta.
StringgetText()
Obtiene el texto de la etiqueta.
voidsetIcon(Icon icono)
cambia el ícono de la etiqueta.
IcongetIcon()
Obtiene el ícono de la etiqueta.

Un método que es útil para fines estéticos es el de setFont(Font), el cuál es de la clase JComponent y funciona para todos los componentes que desplieguen texto.
compomente.setFont(Font f);
Font f = new Font(String nombre_fuente, int estilo, int tamano);

Cajas de Texto

Las cajas de texto permiten introducir información de parte del usuario, son parte también de los componentes más utilizados existen dos tipos de Cajas de Texto las cajas de texto de una sóla línea y las cajas de texto de varias líneas, las primeras son conocidas como: JTextField y las segundas como JTextArea.
JTextField();
JTextField(int columnas);
JTextField(String texto_inicial);
JTextField(String texto_inicial, int columnas);

JTextArea();
JTextArea(int columnas, int filas);
JTextArea(String texto_inicial);
JTextArea(String texto_inicial, int columnas, int filas);
figura
Los métodos importantes para JTextField son:
Valor de RetornoNombre del Método
intgetColumns()
Obtiene el tamaño de la caja de texto.
intgetColumnWidth()
Obtiene número de caracteres introducidos.
voidsetFont(Font fuente)
cambia la fuente.
voidsetColumns(int columnas)
Establece el ancho de la caja de texto.
Y para JTextArea:
Valor de RetornoNombre del Método
voidappend(String cadena)
Agrega al final del área de texto cadena.
voidinsert(String cadena, int pos)
Agrega la cadena. después de pos
intgetColumns()
Obtiene el tamaño de la caja de texto.
intgetColumnWidth()
Obtiene número de caracteres introducidos.
intgetLineCount()
Obtiene número de líneas.
voidsetFont(Font fuente)
cambia la fuente.
voidsetColumns(int columnas)
Establece el ancho del área de texto.
voidsetRows(int filas)
Establece las filas del área de texto.
Las cajas de texto tienen propieadades interesantes como son:
Valor de RetornoNombre del Método
voidcut()
Corta el texto.
voidcopy()
Copia el texto.
voidpaste()
Pega el texto
voidselect(int inicio, int final)
Selecciona el texto desde la posición inicio hasta la posición final.
voidselectAll()
Selecciona todo el texto.
voidsetSelectedTextColor(Color c)
Asigna el color para el texto seleccionado.
voidsetSelectionColor(Color c)
Asigna el color para la selección.
voidsetSelectionStart(int inicio)
Indica donde debe comenzar la selección.
voidsetSelectionEnd(int final)
Indica donde debe finalizar la selección.

Cuadros de Diálogos

Los cuadros de diálogo proveen otro tipo de interacción con el usuario, los cuadros de diálogo más comunes son los de confirmación:figura Se confirman acciones como borrado, actualización, etc., pero en si un cuadro de diálogo puede tratarse como otra ventana, excepto con una propiedad: El Modal, el modal permite que si se abre un cuadro de diálogo, la ventana que lo creó no pueda ser accesada hasta que el usuario cierre el cuadro de diálogo, esto puede ser muy importante cuando tenemos que confirmar algo antes de que el usuario pueda utilizarlo (por ejemplo, que inicie una sesión dando su nombre de usuario y contraseña), o que el cuadro de diálogo permanezca abierto sin que interfiera con la ventana padre (puede estar desplegando información útil al usuario pero no necesaria para el correcto funcionamiento del programa). Para crear un cuadro de diálogo:
JDialog dialogo = new JDialog(ventana_padre, "Dialogo", yes);
... /*Agregarle al dialogo algunos componentes*/
/*Necesitamos agregarle un manejador de eventos como 
cualquier otra ventana*/
dialogo.addWindowListener(WindowListener al);
dialogo.setSize(200,300); /*En caso de ser necesario*/
dialogo.setVisible(true); /*Funciona como una ventana, el dialogo
                           * existira, pero no sera mostrado.
                           */
...
Dentro de los métodos más usados para los diálogos, están la posibilidad de poner el modal, y el de permitir que se cambie su tamaõ:
Valor de RetornoNombre del Método
voidsetModal(boolean modal)
Cambia el modal con el valor booleano modal
voidsetResizable(boolean resize)
Permite cambiar de tamaño la ventana.
booleangetModal()
Obtiene el valor de modal que tiene asignada la ventana
Nota Si se ejecuta simplmente el método setModal no cambiará en nada el modal real, por lo que hay que ocultar el diálogo, cambiar el modal y después volverlo a mostrar y el modal será asignado correctamente. Hay que aclarar, que puede parecer sencillo, asignarle el mismo objeto WindowListener que usamos para la ventana padre, pero el problema es que la ventana padre termina la ejecución, aparte de liberar recursos. Es mejor utilizar un WindowListener apropiado que en el método windowClosing no termine la aplicación, sino que haga uso del método dispose. Por ejemplo:
/*Extenderla de WindowAdapter que es una clase abstracta
que implementa a WindowListener, y asi evitamos implementar
todos los m\'etodos de WindowListener.
*/
public class CerrarDialogo extends WindowAdapter
{
    public void windowClosing(WindowEvent evt)
    {
       evt.getWindow().dispose();  
    }
}

Listas

Swing proporciona las Listas para poder seleccionar datos de entre una serie de posibilidades.Una lista puede ser construida ya sea de un arreglo de datos (de tipo Object) o de un objeto Vector.
La clase JList es creada mediante alguno de estos dos métodos:
new JList(Object[] datos);
new JList(Vector datos);
Entre los métodos más utilizados para la lista son:
Valor de RetornoNombre del Método
voidsetSelectionMode(int modo)
Determina si la seleccion será. (determinada por modo)
ListSelectionModel.SINGLE_SELECTION
Sólo selecciona un valor
ListSelectionModel.SINGLE_INTERVAL_SELECTION
Selecciona varios valores, pero que sean contiguos
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION
Selecciona varios valores, sin depender de la contiguidad
ObjectgetSelectedValue()
Retorna el valor seleccionado.
Object[]getSelectedValues()
Retorna los valores seleccionado.
intgetSelectedIndex()
Obtiene el índice seleccioando.
int[]getSelectedIndices()
Obtiene los índices seleccioandos.
voidsetSelectedIndex(int indice)
Selecciona el índice de la lista
voidsetSelectedIndices(int indices[])
Selecciona los índices de la lista
voidsetSelectedValue(Object elemento)
selecciona el elemento de la lista
La lista sólo se le puede asignar un evento que proviene del paquete javax.swing.event el cuál es el de ListSelectionListener que sólo tiene un método:  public void valueChanged(ListSelectionEvent e)  Que funciona para saber cuándo un elemento ha sido seleccionado.
Y se registra con: addListSelectionListener(ListSelectionListener listener)

JComboBox

los JComboBox son muy parecidos a las Listas, excepto que estos también permiten la introducción de los datos, las maneras para crear son muy similares a las de JList:
new JComboBox();
new JComboBox(Object[] datos);
new JComboBox(Vector datos);
Lo métodos son:
Valor de RetornoNombre del Método
voidaddItem(Object item)
Agrega un elemento al combo
ObjectgetSelectedItem()
Retorna el valor seleccionado.
intgetSelectedIndex()
Obtiene el índice seleccioando.
voidsetEditable(boolean tipo)
Determina si sólo mostrara los valores (false) o si se
pueden escribir nuevos valores (true)
Y al igual que que JList, tiene un Listener que es: ItemListener que sólo implementa un método: public void itemStateChanged(ItemEvent e) que se realiza cuando se cambia a un item.
El registro del Listener se realiza con el método addItemListener de la clase JComboBox

CheckBoxes

Los JCheckBox permite tener botones que pueden ser seleccionados como verdadero o falso.
Se parece mucho a un JButton en la manera de iniciar:
new JCheckBox(String texto);
new JCheckBox(String texto, boolean seleccionado);
new JCheckBox(Icon icono, String texto);
new JCheckBox(Icon icono, String texto, boolean seleccionado);
new JCheckBox(Icon icono);
new JCheckBox(Icon icono, boolean seleccionado);
El manejador de eventos es el de addActionListener para cuando se presione sobre un botón.

JRadioButton

Los botones de radio son útiles cuando seleccionamos entre algunos valores (que no son tantos como para ponerlos en una lista, o en un JComboBox), por ejemplo seleccionar entre Masculino y Femenino ya que un checkbox podría llegar a ser confuso.
Los botones de radio, se inicializan como cualquier boton:
new JRadioButton(String texto);
new JRadioButton(String texto, boolean seleccionado);
new JRadioButton(Icon icono, String texto);
new JRadioButton(Icon icono, String texto, boolean seleccionado);
new JRadioButton(Icon icono);
new JRadioButton(Icon icono, boolean seleccionado);
Salvo que hay que agregarlos todo a un ButtonGroup para que todos los botones de radio de ese grupo sean entre los que se puedan seleccionar.
new ButtonGroup();
y el método importante es:
add(AbstractButton boton);
Además hay que agregar a cada botón de radio, un ActionListener para saber cuál ha sido seleccionado.

Menús

Para agregar el menú que ya conocemos a una ventana instancia JFrame basta crear una objeto de tipo JMenuBar y con el método setJMenuBar(menuBar) de JFrame lo insertamos en la ventana; o si lo prefiere, con el métodogetContentPane().add(Component) podemos agregarlo en la posición que queramos. Un JMenuBar se compone de un conjunto de Menús instancias de JMenu. Cada JMenu se compone de elementos (item) que pueden ser instancias de JMenuItem (los elementos que se pueden seleccionar en el menú) y de instancias de JMenu (en caso de que se quiera un submenú). Para que se vea más claro veamos el siguiente ejemplo que crea los menú clásico de Archivo y Edicion
import javax.swing.*;
import java.awt.event.*;
public class SimpleMenu {
   public static JMenuBar creaMenu() { 
      JMenuBar menubar = new JMenuBar();
      JMenu menu = new JMenu("Archivo");
      JMenuItem item = new JMenuItem("Abrir");
      menu.add(item);
      item = new JMenuItem("Salir");
      menu.add(item);
      menubar.add(menu);
      menu = new JMenu("Edicion");
      item = new JMenuItem("Cortar");
      menu.add(item);
      item = new JMenuItem("Copiar");   
      menu.add(item);
      menubar.add(menu);
      return menubar; 
   }
   public static void main(String[] pars) {
      JFrame frame = new JFrame("Ejemplo simple de un menu");
      frame.setJMenuBar(creaMenu());
      frame.setSize(400, 300);
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent we) {
            System.exit(0);
         }
      });
      frame.setVisible(true);   
   }
}


Figura: Jerarquía de la clase JMenuItem
\includegraphics[]{menus01.ps}
Como se puede observar en la figura anterior los items de menús son simples botones, y por lógica, los eventos que actúa sobre cada item se manejan igual que los botones. Además hay que observar que existe el JCheckboxMenuItem yJRadioButtonMenuItem lo cual son items de los menús, que tienen la misma apariencia que los checkbox clásicos y el RadioButton, respectivamente.Y por si fuera poco se utilizan de la misma forma.

Menús emergentes

Por lo regular los menús emergentes se despliegan normalmente cuando presionamos el botón derecho del mouse sobre cierto componente, si es así, para crear uno es necesario agregar un listener del ratón a el(los) componente(s) que queremos que se vea(n) afectado por dicha situación. El menú que aparece no es una instancia de JMenu, sino una de JPopupMenu, y se le agregan los elementos de la misma forma que a un JMenu. Este sería el código para crear una instancia de JPopupMenu con las opciones {Azul, Verde, Rojo}.
JPopupMenu popup = new JPopupMenu();
JMenuItem menuItem = new JMenuItem("Azul");
popup.add(menuItem);
menuItem = new JMenuItem("Verde");
popup.add(menuItem);
menuItem = new JMenuItem("Rojo");
popup.add(menuItem);
Ahora para el manejo del evento del mouse, una implementación sencilla sería la siguiente:
class PopupListener extends MouseAdapter {
    public void mousePressed(MouseEvent e) {
        maybeShowPopup(e);
    }
    public void mouseReleased(MouseEvent e) {
        maybeShowPopup(e);
    }
    private void maybeShowPopup(MouseEvent e) {
        if (e.isPopupTrigger()) {
            popup.show(e.getComponent(), e.getX(), e.getY());
        }
    }
}
Ahora, a cualquier componente que queramos que tenga su menú emergente basta agregarle una instancia de la clase creada antes para el manejo del evento del mouse(). El código necesario es el siguiente:
MouseListener popupListener = new PopupListener();
component.addMouseListener(popupListener);

lunes, 5 de noviembre de 2012

JFRAME EN JAVA




JFRAME EN JAVA

La clase JFrame implementa un objeto ventana, JFrame es una extensión de la clase Frame del paquete AWT.
Para crear una ventana, existen dos formas principales de hacerlo:

  1. Crear un objeto de la clase JFrame
  2. Extender la clase JFrame
El último método es muy útil cuando se crean ventanas personalizadas que se invocan repetidamente (como ventanas de error, o de información).
Crearemos una ventana con el primer método:

ventana = new JFrame();

Una vez creado una ventana JFrame, ésta obtiene el tamaño necesario para mostrar los componentes que existen dentro de la aplicación, como en nuestro ejemplo no existe componente, cambiaremos su tamaño inicial, con el método:

setSize(int ancho, int largo)
ventana.setSize(200,300);

Después cambiaremos su título para que sea el nombre de nuestra aplicación con el método: setTitle(String titulo)

ventana.setTitle("Hola mundo Swing");

El objeto existe, pero no es mostrado por defecto, entonces se hace la llamada a: setVisible(boolean)

ventana.setVisible(true);

con esto tendremos nuestra primera aplicación en Swing.

Código:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Window extends JFrame
{
    public Window()
    {
        this.setSize(400,500);
        this.setTitle("Primer Aplicacion Swing");
        this.setVisible(true);
    }
 
    public static void main(String []args)
    {
        new Window();
  
        JFrame jFrameWindow = new JFrame();
  
        jFrameWindow.setSize(400,500);
        /* se puede sustituir  por pack() para
         * que java calcule automaticamente el tama\~no
         * que necesita.
         */
        jFrameWindow.setTitle("Segunda Aplicacion Swing");
        jFrameWindow.setVisible(true);
    }
}

Se debe notar que aquí están los dos métodos de creación de ventanas, el primero es extendiendo la clase JFrame y el segundo por medio de la creación de un objeto jFrameWindow.

Hasta aquí hemos creado una aplicación sencilla, pero hemos de notar que la ventana no termina cuando damos click en el botón cerrar, esto es debido a que no hemos definido ningún evento.



Delegación de Eventos

Debido a la programación en objetos, Java ha logrado adaptar el enfoque orientado de eventos al paradigma de orientado a objeto, esto se logra mediante la creación de clases xxxAdapter que procesen información de teclado, ratón o de las ventanas mismas.Debido al enfoque multiplataforma de Java, esencialmente son interfases las que procesan la información del teclado o de ratón y son llamados Listeners, pero también se hacen implementaciones de esas interfases en clases Event.
Siempre hay que generar una clase heredada de algún xxxAdapter o implementarla desde su interfaz (que comúnmente es xxxListener) para procesar los eventos ocurridos. Una vez creada una clase heredada, hay que registrarla en el componente que queremos procese esos eventos, por ejemplo:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class EventoBoton implements ActionListener 
{
    public EventoBoton(){}
    
    public void actionPerformed(ActionEvent evt)
    {
        System.out.println("Evento: " + evt.getActionCommand());
    }
}

class Window extends JFrame
{
    ...
    JButton boton;
    ...
    
    public Window()
    {
        ... /*Inicializacion de la ventana y el boton*/
        boton.addActionListener(new EventoBoton());
        ...
    }
}
Entre las interfaces importantes tenemos:
ActionListener
Esta interfaz permite crear clases para todos los eventos de acción tales como botones (el único método provisto por esta interfaz es: actionPerformed(ActionEvent evt).
FocusListener
Interfaz para los eventos de Foco.
ItemListener
Interfaz para los eventos de cambios de Items (para listas).
KeyListener
Interfaz para los eventos de teclado.
MouseListener
Interfaz para los eventos de ratón.
WindowListener
Interfaz para los eventos de ventana.
Una vez con estos conceptos, nos detendremos en la Interfaz ActionListener, la cual sólo provee un método: void actionPerformed(ActionEvent evt), la clase ActionEvent provee los siguientes métodos:
Valor de RetornoNombre del Método
StringgetActionCommand()
Regresa la cadena de comando asociada con esta acción.
intgetModifiers()
Regresa las llaves modificadoras que se presionaron
durante la acción.
longgetWhen()
Regresa la hora cuando el evento ocurrió.
StringparamString()
Regresa una cadena de paraámetros identificando la acción.
ObjectgetSource()
Regresa el objeto que originó la acción.



El último método es de la clase EventObject de la que provienen todos los xxxEvents, cada uno de estos métodos nos permitirá conocer más acerca de los componentes que originaron el evento.
Supóngase que tenemos dos botones:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class EventoBoton implements ActionListener 
{
    public EventoBoton(){}
    
    public void actionPerformed(ActionEvent evt)
    {
        if (evt.getSource().toString().indexOf("boton1") != -1)
         System.out.println("Se presiono el boton1");
        else
         if (evt.getSource().toString().indexOf("boton2") != -1)
          System.out.println("Se presiono el boton2");         
         else
          System.out.println("Boton desconocido");
    }
}

class Window extends JFrame
{
    ...
    JButton boton1;
    JButton boton2;
    EventoBoton eventos;
    ...
    
    public Window()
    {
        ... /*Inicializacion de la ventana y el boton*/
        eventos = new EventoBoton();
        boton1.addActionListener(eventos);
        boton2.addActionListener(eventos);
        ...
    }
}
Con esta versión modificada de EventoBoton podemos obtener la fuente y hacer operaciones específicas para cada botón.



Tarea


  • tipea el siguiente programa y explica linea x linea lo que realiza



import javax.swing.*;
public class Formulario extends JFrame{
    public Formulario() {
        setLayout(null);
    }

    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(10,20,400,300);
        formulario1.setVisible(true);
    }
}


Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa
y explique para que sirve


import javax.swing.*;
public class Formulario extends JFrame {
    private JLabel label1,label2;
    public Formulario() {
        setLayout(null);
        label1=new JLabel("Sistema de Facturación.");
        label1.setBounds(10,20,300,30);
        add(label1);
        label2=new JLabel("Vesion 1.0");
        label2.setBounds(10,100,100,30);
        add(label2);
    }
   
    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,300,200);
        formulario1.setResizable(false);
        formulario1.setVisible(true);
    }
}





  • Crear tres objetos de la clase JLabel, ubicarlos uno debajo de otro y mostrar nombres de tres canciones de ADELE




  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve





import javax.swing.*;
import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener{
    private JTextField textfield1;
    private JLabel label1;
    private JButton boton1;
    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);
    }
   
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton1) {
            String cad=textfield1.getText();
            setTitle(cad);
        }
    }
   
    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,300,150);
        formulario1.setVisible(true);
    }
}






  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve



import javax.swing.*;

import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener{
    private JTextField textfield1,textfield2;
    private JButton boton1;
    public Formulario() {
        setLayout(null);
        textfield1=new JTextField();
        textfield1.setBounds(10,10,100,30);
        add(textfield1);
        textfield2=new JTextField();
        textfield2.setBounds(10,50,100,30);
        add(textfield2);
        boton1=new JButton("Sumar");
        boton1.setBounds(10,90,100,30);
        add(boton1);
        boton1.addActionListener(this);
    }
   
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton1) {
            String cad1=textfield1.getText();
            String cad2=textfield2.getText();
            int x1=Integer.parseInt(cad1);
            int x2=Integer.parseInt(cad2);
            int suma=x1+x2;
            String total=String.valueOf(suma);
            setTitle(total);
        }
    }
   
    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,140,150);
        formulario1.setVisible(true);
    }
}




  • Realizar un programa :

Ingresar el nombre de usuario y clave en controles de tipo JTextField. Si se ingresa las cadena (usuario: juan, clave=abc123) luego mostrar en el título del JFrame el mensaje "Correcto" en caso contrario mostrar el mensaje "Incorrecto".





  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve




import javax.swing.*;
public class Formulario extends JFrame{
    private JTextField textfield1;
    private JTextArea textarea1;
    public Formulario() {
        setLayout(null);
        textfield1=new JTextField();
        textfield1.setBounds(10,10,200,30);
        add(textfield1);
        textarea1=new JTextArea();
        textarea1.setBounds(10,50,400,300);
        add(textarea1);
    }

    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,540,400);
        formulario1.setVisible(true);
    }  
}




  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve



import javax.swing.*;
public class Formulario extends JFrame{
    private JTextField textfield1;
    private JScrollPane scrollpane1;
    private JTextArea textarea1;
    public Formulario() {
        setLayout(null);
        textfield1=new JTextField();
        textfield1.setBounds(10,10,200,30);
        add(textfield1);
        textarea1=new JTextArea();      
        scrollpane1=new JScrollPane(textarea1);  
        scrollpane1.setBounds(10,50,400,300);
        add(scrollpane1);
    }

    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,540,400);
        formulario1.setVisible(true);
    }  
}



  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve



import javax.swing.*;
import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener{
    private JScrollPane scrollpane1;
    private JTextArea textarea1;
    private JButton boton1;
    public Formulario() {
        setLayout(null);
        textarea1=new JTextArea();
        scrollpane1=new JScrollPane(textarea1);
        scrollpane1.setBounds(10,10,300,200);
        add(scrollpane1);
        boton1=new JButton("Verificar");
        boton1.setBounds(10,260,100,30);
        add(boton1);
        boton1.addActionListener(this);
    }
   
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton1) {
            String texto=textarea1.getText();
            if (texto.indexOf("argentina")!=-1) {
                setTitle("Si contiene el texto \"argentina\"");
            } else {
                setTitle("No contiene el texto \"argentina\"");          
            }
        }
    }
   
    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,400,380);
        formulario1.setVisible(true);
    }      
}



  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve



import javax.swing.*;
import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener {
    JButton boton1;
    public Formulario() {
        setLayout(null);
        boton1=new JButton("Finalizar");
        boton1.setBounds(300,250,100,30);
        add(boton1);
        boton1.addActionListener(this);
    }
   
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton1) {
            System.exit(0);
        }
    }
   
    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,450,350);
        formulario1.setVisible(true);
    }
}


  • Tipee el siguiente programa y explique que objeto nuevo  se esta incluyendo en este programa y explique para que sirve



import javax.swing.*;
import java.awt.event.*;
public class Formulario extends JFrame implements ActionListener{
    private JButton boton1,boton2,boton3;
    public Formulario() {
        setLayout(null);
        boton1=new JButton("1");
        boton1.setBounds(10,100,90,30);
        add(boton1);
        boton1.addActionListener(this);
        boton2=new JButton("2");
        boton2.setBounds(110,100,90,30);
        add(boton2);
        boton2.addActionListener(this);
        boton3=new JButton("3");
        boton3.setBounds(210,100,90,30);
        add(boton3);
        boton3.addActionListener(this);        
    }
   
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton1) {
            setTitle("boton 1");
        }
        if (e.getSource()==boton2) {
            setTitle("boton 2");
        }
        if (e.getSource()==boton3) {
            setTitle("boton 3");
        }      
    }
   
    public static void main(String[] ar){
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,350,200);
        formulario1.setVisible(true);
    }
}



  • Investigar los siguientes objetos


JFrame
JLabel
JButton
JTextField
JTextArea