Abstracción

Es el proceso de simplificar un problema complejo enfocándose tan sólo en los aspectos relevantes para la solución. En el desarrollo de software esto significa centrarse en lo que es y hace un objeto antes de decidir cómo debería ser implementado.

package (palabra clave)

En Java, un paquete (package) es un contenedor para un grupo de clases relacionadas que un programador puede importar.

Una clase puede definirse como perteneciente a un paquete (package) y puede usar otras clases definidas en ese o en otros paquetes. Si una clase no se define en un paquete se dice que esa clase se encuentra en un paquete por omisión (default). Por ejemplo podemos definir a una clase Perro en el paquete Mascotas y a una clase Animal y Elefante en otro paquete denominado Zoológico:

El nombre de una clase debe ser único dentro del paquete donde se define, de tal forma que no válido declarar dos veces la clase Perro en el paquete Mascotas. Por ejemplo:

Sin embargo dos clases con el mismo nombre en dos paquetes distintos pueden coexistir. Esto nos permite reusar el mismo nombre de una clase dada en diversos contextos. Por ejemplo:

Para declarar un paquete utilizamos la palabra clave package seguida del nombre del paquete. Por convención el nombre de los paquetes se escriben en minúsculas.

package nombrePaquete;

Por convención los nombres de los paquetes utilizan el nombre de dominio de Internet con orden inverso. Por ejemplo para el dominio www.profesorjava.com el nombre del paquete quedaría como com.profesorjava. Una vez que se invierte el nombre del dominio, el nombre de la clase quedaría almacenado en com.profesorJava.MiClase.  Finalmente cuando se compila un archivo de Java que contiene una declaración package, el archivo de clase resultante se coloca en el directorio especificado por la declaración. Por ejemplo:

Ejemplo:

/**
 * Ilustra el uso de los paquetes.
 */
Package miPaquete;
public class MiPaqueteClass
{
    public static String imprimir() 
    {
        return "MiPaqueteClass";
    }   //fin del método imprimir
    
    public static void main( String[] args ) 
    {
        System.out.println( "En el interior de " + imprimir() );
    }   //fin del método main
    
}   //fin de la clase MiPaqueteClass

/**
 * Ilustra el uso de los paquetes.
 */
package tuPaquete;
public class TuPaqueteClass
{
    public static String imprimir() 
    {
        return "TuPaqueteClass";
    }   //fin del método imprimir
    
    public static void main( String[] args ) 
    {
        System.out.println( "En el interior de " + imprimir() );
    }   //fin del método main
    
}   //fin de la clase TuPaqueteClass

/**
 * Ilustra el uso de los paquetes.
 */
package tuPaquete;
public class NuestroPaqueteClass
{
    public static String imprimir() 
    {
        return "NuestroPaqueteClass";
    }   //fin del método imprimir
    
    public static void main( String[] args ) 
    {
        System.out.println( "En el interior de " + imprimir() );
    }   //fin del método main
    
}   //fin de la clase NuestroPaqueteClass

enum (palabra clave).

Las enumeraciones nos permiten declarar un conjunto de constantes representadas por identificadores. Una enumeración es un tipo especial de clase, que se introduce mediante la palabra clave enum y un nombre para el tipo. Al igual que con una clase, las llaves ({ y }) delimitan el cuerpo de una declaración de enum. Dentro de las llaves hay una lista, separada por comas, de constantes de enumeración, cada una de las cuales representa un valor único.

Ejemplo.
Veamos un ejemplo que implementa el juego de Craps e ilustra el uso de las enumeraciones.

/**
 * La clase Craps simula el juego de dados Craps
 */
import java.util.Random;

public class Craps
{
    //crea un generador de número aleatorios
    private Random numerosAleatorios = new Random();
    
    //enumeración con constantes que representan el estado del juego
    private enum Estado { CONTINUA, GANO, PERDIO };
    
    private final static int DOS_UNOS = 2;
    private final static int TRES = 3;
    private final static int SIETE = 7;
    private final static int ONCE = 11;
    private final static int DOCE = 12;
    
    public void jugar() {
        int miPunto = 0;    //punto si no gana o pierde en el primer tiro
        Estado estadoJuego; //puede contener CONTINUA, GANO o PERDIO
        
        int sumaDeDados = tirarDados(); //primer tiro de los dados
        
        switch( sumaDeDados ) {
            case SIETE: //gana con 7 en el primer tiro
            case ONCE:  //gane con 11 en el primer tiro
                estadoJuego = Estado.GANO;
                break;
            case DOS_UNOS:  //pierde con 2 en el primer tiro
            case TRES:      //pierde con 3 en el primer tiro
            case DOCE:      //pierde con 12 en el segundo tiro
                estadoJuego = Estado.PERDIO;
                break;
            default: //no ganó ni perdio por lo guarda el punto
                estadoJuego = Estado.CONTINUA;
                miPunto = sumaDeDados;    //guarda el punto
                System.out.printf( "El punto es %d \n", miPunto );
                break;
        }   //fin de la estructura switch
        
        //mientras el juego no esté terminado
        while( estadoJuego == Estado.CONTINUA ) { //no Gano ni Perdio
            sumaDeDados = tirarDados(); //tira los dados de nuevo
            
            //determinar el estado del juego
            if( sumaDeDados == miPunto )    //gana haciendo un punto
                estadoJuego = Estado.GANO;
            else
                if( sumaDeDados == SIETE )  //pierde al tirar 7
                    estadoJuego = Estado.PERDIO;
        }   //fin de la estructura while
        
        //muestra mensaje de que gano o perdio
        if( estadoJuego == Estado.GANO )
            System.out.println( "¡Ganaste!" );
        else    
            System.out.println( "¡Perdiste!" );
    }   //fin del método jugar
    
    //tira los dados, calcula la suma y muestra los resultados
    public int tirarDados() {
        //selecciona valores aleatorios para los dados
        int dado1 = 1 + numerosAleatorios.nextInt( 6 );    //1..6
        int dado2 = 1 + numerosAleatorios.nextInt( 6 );    //1..6
        
        int suma = dado1 + dado2;
        
        System.out.printf( "El jugador tiro %d + %d = %d \n",
            dado1, dado2, suma );
        
        return suma;
        
    }   //fin del método tirarDados
    
}   //Fin de la clase Craps

Observa que por convención las constantes de enumeración se escriben en mayúsculas. Es importante que tengas en cuenta lo siguiente: Java no proporciona una manera fácil de convertir un valor int en una constante enum específica. La aplicación para probar la clase Craps se muestra a continuación:

public class PruebaCraps
{
    public static void main( String[] args ) 
    {
        Craps app = new Craps();
        app.jugar();
    }  //fin de main
}  //fin de la clase PruebaCraps

Al igual que las clases, todos los tipos enum son tipos por referencia. Un tipo enum se declara con una declaración enum, la cual es una lista separada por comas de constantes enum; la declaración puede incluir, de manera opcional, otros componentes de las clases tradicionales, como constructores, campos y métodos. Cada declaración enum declara a una clase enum con las siguientes restricciones:

1. Los tipos enum son implícitamente final, ya que declaran constantes que no deben modificarse.
2. Las constantes enum son implícitamente static.
3. Cualquier intento por crear un objeto de un tipo enum con el operador new produce un error de compilación.

Las constantes enum pueden usarse en cualquier parte en donde puedan usarse las constantes, como en las etiquetas case de las instrucciones switch, y para controlar las instrucciones for mejoradas.

Ejemplo.
Veamos otro ejemplo sobre enum.

/**
 * Declara un tipo enum con constructor y variables de instancia,
 * junto con métodos de acceso para los
 * factores de conversión de pies a pulgadas, pies, yardas,
 * centímetros y metros
 */
public enum ConversionPies
{
    //Declara constantes tipo enum
    PULGADA( 12.0 ),
    YARDA( 1.0/3.0 ),
    CENTIMETRO( 30.48 ),
    METRO( 30.48 / 100.0 );

    //variables de instancia
    private final double valor;
    
    ConversionPies( double v ) 
    {
        valor = v;
    }   //fin del constructor ConversionPies

    public double getValor() 
    {
        return valor;        
    }   //fin del método getValor
            
}   //fin enum ConversionPies

Observa que cada constante enum va seguida opcionalmente por los argumentos que se pasan al constructor de enum. Al igual que los constructores de una clase, un constructor enum puede especificar cualquier número de parámetros, y puede sobrecargarse. Veámos a continuación la aplicación que prueba a la enum ConversionPies.

/**
 * Dado un número n de pies calcula su equivalente en pulgadas,
 * yardas, centimetros y metros
 */
import java.util.Scanner;
public class LongitudEnPies
{
    public static void main( String[] args ) 
    {
        Scanner entrada = new Scanner( System.in );
        
        System.out.println( "<<--Calcula la longitud equivalente-->>" );
        System.out.print( "Número de pies? " );
        double nPies = entrada.nextDouble();
        
        //calcula e imprime las equivalencias
        for( ConversionPies pies: ConversionPies.values() ) 
            System.out.printf( "%s = %f\n", pies, nPies * pies.getValor() );        
    }
}   //fin de la clase LongitudEnPies

Para cada enum, el compilador genera el método estátic values que devuelve un arreglo de constantes de enum en el orden que se declararon. Observa que cuando se convierte una constante enum en un objeto String, el identificador de la constante se utiliza como la representación String.

Ejemplo.
El siguiente ejemplo ilustra cómo utilizar el método static range de la clase EnumSet (declarada en el paquete java.util) para mostrar un rango de las constantes de una enum. El método recibe dos parámetros (la primera y la última constantes enum en el rango) y devuelve un objeto EnumSet que contiene todas las constantes entre estas dos constantes.

/**
 * Ilustra el uso de los enums.
 */
import java.util.EnumSet;
public class TipoCambio
{
    //crea una Enumeración
    enum Moneda { PESO, EURO, DOLAR, YEN, LIBRA_ESTERLINA }
    
    public static void main( String[] args ) 
    {
        Moneda tipoMoneda = Moneda.PESO;
        
        System.out.printf( "La moneda es %s\n", tipoMoneda );

        System.out.println( "Las monedas disponibles:" );
        //imprime todas las monedas
        for( Moneda m : Moneda.values() ) 
        {
            System.out.println( m );
        }
        
        System.out.println( "\nMostrar un rango de constantes" );
        //imprime las primeras cuatro monedas
        for( Moneda m : EnumSet.range( Moneda.PESO,Moneda.YEN ) ) 
        {
            System.out.println( m );
        }
    }  //fin del método main
}   //fin de la clase TipoCambio

Véase en YouTube:

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.