JButton.

Un botón es un componente en el que el usuario hace clic para desencadenar cierta acción. Una aplicación de Java puede utilizar varios tipos de botones, incluyendo botones de comando, casillas de verificación, botones interruptores y botones de opción.

Todos los tipos de botones son subclases de AbstractButton (paquete javax.swing), la cual declara las características comunes para los botones de Swing.

Un botón de comando genera un evento ActionEvent cuando el usuario hace clic en él. Los botones de comando se crean con la clase JButton. El texto de la cara de un objeto JButton se llama etiqueta del botón. Una GUI puede tener muchos objetos JButton, pero cada etiqueta de botón debe generalmente ser única en las partes de la GUI en que se muestre.

Ejemplo.

/**
 * Programa que calcula el doble de un número
 */
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class DobleNumero
{
    JFrame miVentana;
    JButton btnCalcular;
    JLabel lblDisplay;
    
    public DobleNumero() 
    {
        inicializarComponentes();
        mostrarVentana();
    }   //fin del constructor DobleNumero
    
    public void inicializarComponentes() 
    {
        miVentana = new JFrame( "Calcula el doble de un número" );
        btnCalcular = new JButton( "Calcular" );
        lblDisplay = new JLabel( "2", JLabel.CENTER );
        miVentana.add( lblDisplay, BorderLayout.NORTH );
        miVentana.add( btnCalcular, BorderLayout.SOUTH );
        
        //activa el evento escuchador para el botón
        btnCalcular.addActionListener( new Escuchador() );        
    }   //fin del método inicializarComponentes
    
    public void mostrarVentana() 
    {
        miVentana.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 
        miVentana.setSize( 300, 100 );
        miVentana.setVisible( true );
    }   //fin del método mostrarVentana

    private class Escuchador implements ActionListener
    {
        public void actionPerformed( ActionEvent e ) 
        {
            //Recupera el contenido del caption del botón
            String cadNumero = lblDisplay.getText();
            //Convierte a número
            int numero = Integer.parseInt( cadNumero );
            //Realiza el cálculo
            numero = numero * 2;
            //Asigna el resultado al caption del botón
            lblDisplay.setText( Integer.toString( numero ) );                                 
        }   //fin del método actionPerformed 
    }   //fin de la clase Interna Escuchador    
}   //fin de la clase DobleNumero

El ejemplo utiliza un JLabel y un JButton que nos permite calcular el doble de un número y lo despliega en la JLabel. El siguiente código nos probar el código anterior.

/**
 * Ilustra el funcionamiento de la clase DobleNumero.
 */
public class TestDobleNumero
{
    public static void main( String[] args ) {
        DobleNumero app = new DobleNumero();
    }   //fin del método void main
}   //fin de la clase DobleNumero

JFrame.

JFrame es un contenedor donde colocar componentes. La clase JFrame se encuentra en el paquete javax.swing. La mayoría de las ventanas son instancias de la clase JFrame o subclases de JFrame.

JFrame proporciona los atributos y comportamientos básicos de una ventana.

Ejemplo 1.

/**
 * Crea una ventana simple con JFrame.
 */
import javax.swing.*;
public class Ventana
{
    public static void main( String[] args ) 
    {
        JFrame miVentana = new JFrame( "Mi Ventana" );
        miVentana.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
        miVentana.setSize( 300, 200 );
        miVentana.setVisible( true );
    }   //fin del método main
}   //fin de la clase ventana

En el ejemplo utilizamos el constructor JFrame(String título) para establecer el título de la ventana. En la siguiente instrucción indicamos con void setDefaultCloseOperation(int operación) que la aplicación termine si el usuario hace un clic sobre el botón cerrar de la ventana. Otras constantes que podemos utilizar son:

• JFrame.DO_NOTHING_ON_CLOSE
• JFrame.HIDE_ON_CLOSE
• JFrame.DISPOSE_ON_CLOSE
• JFrame.EXIT_ON_CLOSE

Con setSize( int ancho, int alto ) establecemos el tamaño de la ventana que se mide en pixeles y finalmente con setVisible(true) mostramos la ventana.

Ejemplo 2.

/**
 * Crea una ventana simple con JFrame y le agrega unos botones.
 */
import javax.swing.*;
import java.awt.*;
public class Ventana02
{
    public static void main( String[] args ) 
    {
        JFrame miVentana = new JFrame();
        miVentana.setTitle( "Mi Ventana 02" );
        JButton btnUno = new JButton( "Uno" );
        JButton btnDos = new JButton( "Dos" );
        miVentana.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
        miVentana.setLayout( new FlowLayout() );
        miVentana.add( btnUno );
        miVentana.add( btnDos );
        miVentana.pack();
        miVentana.setVisible( true );
    }   //fin del método main
}   //fin de la clase ventana

En el ejemplo utilizamos el método setTitle( título ) para especificar el título del objeto JFrame. Luego creamos dos botones que serán agregados al JFrame con el método add( Component componente). Cambiamos el administrador de esquema por default que es BorderLayout por FlowLayout utilizando el método setLayout( LayoutManager manejador ). Finalmente utilizamos el método pack() para redimensionar automáticamente el tamaño de la ventana al espacio ocupado por los botones.

Ejemplo 3.

/**
 * Ilustra cómo crear una ventana heredando de JFrame.
 * 
 */
import java.awt.*;
import javax.swing.*;
public class Ventana03 extends JFrame
{
    public Ventana03( String titulo ) 
    {
        setTitle( titulo );
        inicializarComponentes();
        mostrarVentana();
    }   //fin del constructor Ventana03

    public void inicializarComponentes() {
        setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
        JButton btnUno = new JButton( "Uno" );
        JButton btnDos = new JButton( "Dos" );
        setLayout( new FlowLayout() );
        add( btnUno );
        add( btnDos );
    }   //fin del método inicializarComponentes
    
    public void mostrarVentana() 
    {
        setSize( 300, 200 );
        setVisible( true );
    }   //fin del método mostrarVentana
}   //fin de la clase Ventana03

En el ejemplo mostramos como crear una subclase de JFrame. El código es similar al mostrado en el Ejemplo 2, solo que necesitaremos otra clase con el método main para verificar su funcionamiento:

/**
 * Ilustra el funcionamiento de la clase Ventana03.
 */
public class TestVentana03
{
    public static void main( String[] args ) {
        Ventana03 uno = new Ventana03( "Ventana 01" );
        Ventana03 dos = new Ventana03( "Ventana 02" );
    }   //fin del método void main
}   //fin de la clase TestVentana03

Véase

Operadores aritméticos.

Para hacer operaciones matemáticas en las aplicaciones Java debemos emplear los operadores aritméticos de Java. Los operadores aritméticos son binarios, ya que funcionan con dos operandos.

Los operadores aritméticos son + (suma), - (resta), * (multiplicación), / (división) y % (residuo).

Ejemplo.

/**
 * Ilustra los operadores aritméticos con valores enteros.
 */
import java.util.Scanner;
public class CalculadoraSimple
{
    public static void main( String args[] ) 
    {
        //crea objeto Scanner para obtener la entrada de la consola
        Scanner entrada = new Scanner( System.in );

        int numeroUno;  //primer número a leer
        int numeroDos;  //segundo número a leer
        
        System.out.print( "Escribe el primer entero: " );   //indicador
        numeroUno = entrada.nextInt();  //lee el primer número del usuario
        
        System.out.print( "Escribe el segundo entero: " );   //indicador
        numeroDos = entrada.nextInt();  //lee el primer número del usuario
                
        //Realiza los calculos
        int suma = numeroUno + numeroDos;
        int resta = numeroUno - numeroDos;
        int multiplicacion = numeroUno * numeroDos;
        int division = numeroUno / numeroDos;
        int residuo = numeroUno % numeroDos;
        
        //Imprime los resultados
        System.out.printf( "%d + %d = %d %n", numeroUno, numeroDos, suma );
        System.out.printf( "%d - %d = %d %n", numeroUno, numeroDos, resta );
        System.out.printf( "%d x %d = %d %n", numeroUno, numeroDos, multiplicacion );
        System.out.printf( "%d / %d = %d %n", numeroUno, numeroDos, division );
        System.out.printf( "%d mod %d = %d", numeroUno, numeroDos, residuo );
        
    }   //fin del método main  
}   //fin de la clase CalculadoraSimple

La división de enteros produce un cociente entero: por ejemplo, la expresión 7 / 4 da como resultado 1, y la expresión 17 / 5 da como resultado 3. Cualquier parte fraccionaria en una división de enteros simplemente se descarta (es decir, se trunca); no ocurre un redondeo. El operador residuo, %, produce el residuo después de la división. La expresión 7 % 4 produce 3, y 17 % 5 produce 2.

Véase

Entrada estándar.

Análogo a la salida System.out, tenemos System.in para la entrada. Llamamos a la técnica para producir datos usando System.in entrada estándar. System.in acepta entradas desde el teclado. Usar System.in para las entradas es un poco más complicado que usar System.out para las salidas. System.in es una instancia de la clase InputStream que proporciona sólo la facultad de introducir un byte a la vez con su método read (leer). Sin embargo InputStream cuenta con pocos métodos útiles para leer el teclado. Afortunadamente en Java existen clases como InputStreamReader, BufferedReader, FileReader, Scanner que nos facilitan la tarea de leer desde teclado.

Scanner.

Java proporciona una clase precompilada llamada Scanner, que permite obtener entradas ya sea del teclado o de un archivo.

Ejemplos:

/**
 * Este programa despliega un saludo personalizado.
 */
import java.util.Scanner;
public class Saludo
{
    public static void main( String[] args )
    {
        Scanner entrada = new Scanner( System.in );
        String nombre;        
        System.out.print( "¿Cuál es tu nombre?" );
        nombre = entrada.nextLine();                     
        System.out.printf( "¡Hola %s!", nombre );        
    }   //fin del método main
}   //fin de la clase Saludo

/**
 * Este programa calcula e imprime la cantidad de una orden de compra.
 */
import java.util.Scanner;
public class CalcularPrecio
{
    public static void main( String[] args )
    {
        //variables locales
        Scanner entrada = new Scanner( System.in );
        double precio;  //precio de compra del artículo
        int cantidad;   //número de artículos comprados
        double total;   //el cálculo de la orden de compra
        
        //lectura
        System.out.print( "Precio de compra? " );
        precio = entrada.nextDouble();
        System.out.print( "Cantidad? " );
        cantidad = entrada.nextInt();
        
        //cálculos
        total = precio * cantidad;
        
        //impresión de resultados
        System.out.printf( "Total de orden de compra = $%.2f", total );        
    }   //fin del método main

}   //fin de la clase CalcularPrecio

/**
 * Programa que ilustra la lectura desde el teclado.
 */
import java.util.Scanner;
public class Lectura
{
    public static void main( String[] args )
    {
        Scanner entrada = new Scanner( System.in );

        System.out.print( "Teclea dos números enteros (por ejemplo 3, 4 )" );
        System.out.println( " separados por dos o más espacios:" );
        int n1 = entrada.nextInt();                     
        int n2 = entrada.nextInt();
        System.out.printf( "Ingresaste el número %d y %d %n", n1, n2 );

        System.out.print( "Ingresa dos números (por ejemplo 4.3, 3, -5.4)" );
        System.out.println( "separados por dos o más espacios:" );
        double d1 = entrada.nextDouble();
        double d2 = entrada.nextDouble();
        System.out.printf( "Ingresaste el número %f y %f %n", d1, d2 );

        System.out.println( "Teclea dos palabras (por ejemplo hola mundo):" );
        String palabra1 = entrada.next();
        String palabra2 = entrada.next();
        System.out.printf( "Ingresaste las palabras \" %s \" y \" %s \" %n",
            palabra1, palabra2 );

        String junk = entrada.nextLine(); //obtiene un '\n'

        System.out.println( "Ingresa una línea de texto:" );

        String linea = entrada.nextLine();

        System.out.printf( "Tecleaste: \" %s \" %n", linea );
        
    }   //fin del método main
    
}   //fin de la clase Lectura

/**
 * Programa que ilustra la lectura desde el teclado.
 */
import java.util.Scanner;
public class Lectura02
{
    public static void main( String[] args )
    {
        String cadena = "Linea01 \nLinea02 \nLinea03";
        Scanner entrada = new Scanner( cadena );      
        while(entrada.hasNext())
        {
           String token = entrada.next();
           System.out.println( token );        
        }
    }   //fin del método main
}    //fin de la clase Lectura02

Véase:

Salida estándar.

A la técnica de producir datos usando System.out se lo conoce como salida estándar. La salida estándar se vincula con la ventana de comandos (consola, ventana terminal, Shell, símbolo del sistema, ventana de salida estándar) a través de System.out.

Podemos utilizar el método print y println para producir un mensaje o resultado de un cálculo en la ventana de comandos.

Ejemplo:

System.out.print( "¿Cómo estás?" );
System.out.print( "Mi nombre es profesor java" );

System.out.println( "¿Cómo estás?" );
System.out.println( "Mi nombre es profesor java" );

La palabra System se refiere a la computadora. System.out se refiere a la salida estándar en el sistema de cómputo: el monitor. La palabra print o println (print line) se refiere al método de impresión de un mensaje en la pantalla de la computadora. El paréntesis que aparece después del método println contiene el mensaje que será impreso. Observa el uso de las comillas dobles que se usan para formar una cadena literal.