% Activate the following line by filling in the right side. If for example the name of the root file is Main.tex, write
% "...root = Main.tex" if the chapter file is in the same directory, and "...root = ../Main.tex" if the chapter is in a subdirectory.
 
%!TEX root =  ../notas_java.tex

\chapter[Uso de Clases y Objetos]{Uso de Clases y Objetos}
	
 \section{La API de Java}

El API Java es una Interfaz de Programación de Aplicaciones (API: por sus siglas en inglés) provista por los creadores del lenguaje Java, y que da a los programadores los medios para desarrollar aplicaciones Java. Como el lenguaje Java es un Lenguaje Orientado a Objetos, la API de Java provee de un conjunto de clases utilitarias para efectuar toda clase de tareas necesarias dentro de un programa. La API Java está organizada en paquetes lógicos, donde cada paquete contiene un conjunto de clases relacionadas semánticamente.

La dirección donde puedes consultar la Documentación del API de Java Versión 6 es está:

https://docs.oracle.com/javase/8/docs/api/

En la parte superior Izquierda, vienen los paquetes. En la inferior Izquierda vienen las clases, ahí por ejemplo buscas String, le das click, luego en la derecha te aparece toda la descripción de la clase.

1.- El paquete en el que se encuentra

2.- De que clase hereda

3.- Las interfaces que implementa

4.- Una Breve Descripción

5.- Las constantes declaradas en la clase

6.- Los tipos de constructores

7.- Los métodos de la clase, con sus parámetros y lo que regresan

 \section{Creación de objetos}
 
Comenzaremos con una analogía simple, para ayudarle a comprender el concepto de las clases y su contenido. Suponga que desea conducir un automóvil y, para hacer que aumente su velocidad, debe presionar el pedal del acelerador. ¿Qué debe ocurrir antes de que pueda hacer esto? Bueno, antes de poder conducir un automóvil, alguien tiene que diseñarlo. Por lo general, un automóvil empieza en forma de dibujos de ingeniería, similares a los planos de construcción que se utilizan para diseñar una casa. Estos dibujos de ingeniería incluyen el diseño del pedal del acelerador, para que el automóvil aumente su velocidad. El pedal oculta los complejos mecanismos que se encargan de que el automóvil aumente su velocidad, de igual forma que el pedal del freno oculta los mecanismos que disminuyen la velocidad del automóvil y por otro lado, el volante oculta los mecanismos que hacen que el automóvil de vuelta. Esto permite que las personas con poco o nada de conocimiento acerca de cómo funcionan los motores puedan conducir un automóvil con facilidad. 
Desafortunadamente, no puede conducir los dibujos de ingeniería de un auto. Antes de poder conducir un automóvil, éste debe construirse a partir de los dibujos de ingeniería que lo describen. Un automóvil completo tendrá un pedal acelerador verdadero para hacer que aumente su velocidad, pero aún así no es suficiente; el auto- móvil no acelerará por su propia cuenta, así que el conductor debe oprimir el pedal del acelerador.

Ahora utilizaremos nuestro ejemplo del automóvil para introducir los conceptos clave de programación. Para realizar una tarea en una aplicación se requiere de un método. El método describe los mecanismos que se encargan de realizar sus tareas y oculta la tareas complejas que realiza, de la misma forma que el pedal del acelerador de un automóvil oculta al conductor los complejos mecanismos para hacer que el automóvil vaya más rápido. En Java, empezamos por crear una unidad de aplicación llamada clase para alojar a un método, así como los dibujos de ingeniería de un automóvil alojan el diseño del pedal del acelerador. En una clase se proporcionan uno o más métodos, los cuales están diseñados para realizar las tareas de esa clase. Por ejemplo, una clase que representa a una cuenta bancaria podría contener un método para depositar dinero en una cuenta, otro para retirar dinero de una cuenta y un tercero para solicitar el saldo actual de la cuenta.  

Una manera de especificar esto es utilizando los diagramas UML (Unified Modeling Language ), el cual permite especificar los métodos y variables para un objeto. Como ejemplo consideremos crear  una objeto LibroCalificaciones, el diagrama para esta clase se muestra en la Figura \ref{fig:LibroCalificaciones}.

\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_3/figuras/LibroCalificaciones.eps, width=10.0cm}}
   \caption{Diagrama UML para el objeto LibroCalificaciones}
   \label{fig:LibroCalificaciones}
\end{figure}

En la Figura \ref{fig:LibroCalificaciones} podemos ver que el diagrama esta dividido en tres partes. La primer parte es la correspondiente al nombre del objeto, la segunda son la variables relacionadas con el objeto y finalmente los métodos. Para cada uno de los métodos se especifica un signo, menos para una variable o método privado y más para publico. Una variable y/o método será pública cuando el programador desea que sea manipulada por el usuario final y en caso contrario la declara privada. En particular existe un método que se utiliza para inicializar las variables del objeto y se conoce como constructor. Un método constructor siempre tiene el nombre del objeto. Adicionalmente podemos ver el tipo de variable con dos puntos y los parámetros que recibe el método (en parentesis) y el tipo que regresa con dos puntos.

La implementación en Java para este objeto es

\begin{verbatim}
public class LibroCalificaciones {
    private String nombreDelCurso; // nombre del curso para este LibroCalificaciones
   // el constructor inicializa nombreDelCurso con el objeto 
   //String que se provee como argumento
   public LibroCalificaciones( String nombre )
   {
      nombreDelCurso = nombre; // inicializa nombreDelCurso
   } // fin del constructor
   // método para establecer el nombre del curso
   
   public void establecerNombreDelCurso( String nombre )
   {
      nombreDelCurso = nombre; // almacena el nombre del curso
   } // fin del método establecerNombreDelCurso
   // método para obtener el nombre del curso
   
   public String obtenerNombreDelCurso()
   {
      return nombreDelCurso;
   } // fin del método obtenerNombreDelCurso
   // muestra un mensaje de bienvenida al usuario de LibroCalificaciones
   
   public void mostrarMensaje()
   {
      // esta instrucción llama a obtenerNombreDelCurso para obtener el
      // nombre del curso que este LibroCalificaciones representa
      System.out.printf("Bienvenido al Libro de calificaciones para\n\%s!\n",
         obtenerNombreDelCurso() );
   } // fin del método mostrarMensaje
} // fin de la clase LibroCalificaciones

\end{verbatim}

La manera de utilizar esta clase es escribiendo otra que tenga el método main, así por ejemplo tenemos

\begin{verbatim}
public class PruebaLibroCalificaciones {
    // el método main empieza la ejecución del programa
    public static void main( String args[] )
    {
      // crea objeto LibroCalificaciones
      LibroCalificaciones libroCalificaciones1 = new LibroCalificaciones(
         "CS101 Introduccion a la programacion en Java" );
      LibroCalificaciones libroCalificaciones2 = new LibroCalificaciones(
         "CS102 Estructuras de datos en Java" );
      // muestra el valor inicial de nombreDelCurso para cada LibroCalificaciones
      System.out.printf("El nombre del curso de libroCalificaciones1 es: \%s\n",
         libroCalificaciones1.obtenerNombreDelCurso() );
      System.out.printf("El nombre del curso de libroCalificaciones2 es: \%s\n",
         libroCalificaciones2.obtenerNombreDelCurso() );
   } // fin de main
} // fin de la clase PruebaLibroCalificaciones
\end{verbatim}

\subsection{Ejemplo de manejo de Números Complejos}

En este ejemplo se pretende escribir el código correspondiente para hacer la implementación de las operaciones básicas para el manejo de números complejos. La descripción de la clase se da en el diagrama UML de la figura \ref{fig:complejo}


\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_3/figuras/complejo.eps, width=7.0cm}}
   \caption{Diagrama UML para manejar números complejos}
   \label{fig:complejo}
\end{figure}

Para este caso el código implementado queda como

\begin{verbatim}
package Capitulo_3.NumerosComplejos;

/**
 *
 * @author felix
 */
public class Complejo {
    private double real;
    private double imaginaria;
    
    Complejo(double r, double i) {
        real = r;
        imaginaria = i;
    }
    
    static public Complejo Conjugado(Complejo a) {
        return new Complejo(a.real, -a.imaginaria);
    }
    
    public double Angulo() {
        return Math.atan2(imaginaria, real);
    }
    
    static public Complejo Division(Complejo a, Complejo b) {
        double r, i, mag;
        
        mag = b.real*b.real + b.imaginaria*b.imaginaria;
        
        r = a.real*b.real + a.imaginaria*b.imaginaria;
        i = -a.real*b.imaginaria + a.imaginaria*b.real;
        
        return new Complejo(r/mag, i/mag);
    }

    static public Complejo Suma(Complejo a, Complejo b) {
        double r, i;
        
        r = a.real + b.real;
        i = a.imaginaria + b.imaginaria;
        
        return new Complejo(r, i);
    }

    static public Complejo Resta(Complejo a, Complejo b) {
        double r, i;
        
        r = a.real - b.real;
        i = a.imaginaria - b.imaginaria;
        
        return new Complejo(r, i);
    }
    
    public double Real() {
        return real;
    }
    
    public double Imaginaria() {
        return imaginaria;
    }

    static public Complejo Multiplica(Complejo a, Complejo b) {
        double r, i;
        
        r = a.real*b.real - a.imaginaria*b.imaginaria;
        i = a.real*b.imaginaria + a.imaginaria*b.real;
        
        return new Complejo(r, i);
    }
    
    public double Magnitud() {
        return Math.sqrt(real*real + imaginaria*imaginaria);
    }
    
    @Override
    public String toString() {
        String aux = "";
        aux += real;
        if (imaginaria < 0) 
            aux += " - j "+(-imaginaria);
        else if(imaginaria > 0)
            aux += " + j " + imaginaria;
        return aux;
    }
}
\end{verbatim}

Su uso dentro de otro programa se puede hacer de la siguiente manera

\begin{verbatim}
package Capitulo_3.NumerosComplejos;

import static Capitulo_3.NumerosComplejos.Complejo.Conjugado;
import static Capitulo_3.NumerosComplejos.Complejo.Division;
import static Capitulo_3.NumerosComplejos.Complejo.Multiplica;
import static Capitulo_3.NumerosComplejos.Complejo.Resta;
import static Capitulo_3.NumerosComplejos.Complejo.Suma;

/**
 *
 * @author felix
 */
public class prueba {
    static public void main(String args[]) {
        Complejo a = new Complejo(3, 4);
        Complejo b = new Complejo(3, -1);
        
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        
        System.out.println("Parte real de a = " + a.Real());
        System.out.println("Parte imaginaria de a = " + a.Imaginaria());
        System.out.println("Magnitud de a = " + a.Magnitud());
        System.out.println("Angulo de a = " + a.Angulo());
        System.out.println("Conjugado de a = " + Conjugado(a));
        
        System.out.println("a + b = " + Suma(a, b));
        System.out.println("a - b = " + Resta(a, b));
        System.out.println("a * b = " + Multiplica(a,b));
        System.out.println("a / b = " + Division(a, b));
    }
}
\end{verbatim}

Como resultado de la ejecución tenemos

\begin{verbatim}
a = 3.0 + j 4.0
b = 3.0 - j 1.0
Parte real de a = 3.0
Parte imaginaria de a = 4.0
Magnitud de a = 5.0
Angulo de a = 0.9272952180016122
Conjugado de a = 3.0 - j 4.0
a + b = 6.0 + j 3.0
a - b = 0.0 + j 5.0
a * b = 13.0 + j 9.0
a / b = 0.5 + j 1.5
\end{verbatim}

\subsection{Ejemplo de una Cuenta Bancaria}

Escribir un el código Java para hacer la representación del objeto Cuenta tal como se describe en el diagrama UML de la Figura \ref{fig:Cuenta}.

\begin{verbatim}
public class Cuenta {
    private double saldo; // variable de instancia que almacena el saldo

    public Cuenta( double saldoInicial )
    {
      // valida que saldoInicial sea mayor que 0.0;
      // si no lo es, saldo se inicializa con el valor predeterminado 0.0
      if ( saldoInicial > 0.0 )
         saldo = saldoInicial;
    } // fin del constructor de Cuenta
    
    // abona (suma) un monto a la cuenta
    
    public void abonar( double monto )
    {
      saldo = saldo + monto; // suma el monto al saldo
    } // fin del método abonar
    
    // devuelve el saldo de la cuenta
    
    public double obtenerSaldo()
    {
      return saldo; // proporciona el valor de saldo al método que hizo la llamada
    } // fin del método obtenerSaldo
} // fin de la clase Cuenta
\end{verbatim}

\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_3/figuras/Cuenta.eps, width=10.0cm}}
   \caption{Diagrama UML para el objeto Cuenta}
   \label{fig:Cuenta}
\end{figure}

Para probar escribimos el siguiente código

\begin{verbatim}
 import java.util.Scanner;
 

 public class PruebaCuenta {
 // el método main empieza la ejecución de la aplicación de Java
    public static void main( String args[] )
    {
        Cuenta cuenta1 = new Cuenta(50.00);
        Cuenta cuenta2 = new Cuenta(-7.53);
        
        System.out.println("Saldo de cuenta1: " + cuenta1.obtenerSaldo());
        System.out.println("Saldo de cuenta2: " + cuenta2.obtenerSaldo());
        
        Scanner entrada = new Scanner(System.in);
        double montoDeposito;
        System.out.print("Escriba el monto a depositar en cuenta1: ");
        montoDeposito = entrada.nextDouble();
        System.out.println("Sumando saldo de cuenta1 " + montoDeposito);
        cuenta1.abonar(montoDeposito);
        
        System.out.println("Saldo de cuenta1 " + cuenta1.obtenerSaldo());
        System.out.println("Saldo de cuenta2 " + cuenta2.obtenerSaldo());
        
        System.out.print("Escriba el monto a depositar en cuenta2: ");
        montoDeposito = entrada.nextDouble();
        System.out.println("Sumando saldo de cuenta2 " + montoDeposito);
        cuenta2.abonar(montoDeposito);
        
        System.out.println("Saldo de cuenta1 " + cuenta1.obtenerSaldo());
        System.out.println("Saldo de cuenta2 " + cuenta2.obtenerSaldo());
        
    }
}
\end{verbatim}

\section{La clase String}
 
Dentro de un objeto de la clases String o StringBuffer, Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. A este array se accede a través de las funciones miembro de la clase.

Los strings u objetos de la clase String se pueden crear explícitamente o implícitamente. Para crear un string implícitamente basta poner una cadena de caracteres entre comillas dobles. Por ejemplo, cuando se escribe
\begin{verbatim}
	System.out.println("El primer programa");
\end{verbatim}

Java crea un objeto de la clase String automáticamente.

Para crear un string explícitamente escribimos

\begin{verbatim}
	String str=new String("El primer programa");
\end{verbatim}

También se puede escribir, alternativamente

\begin{verbatim}
	String str="El primer programa";
\end{verbatim}

Para crear un string nulo se puede hacer de estas dos formas

\begin{verbatim}
	String str="";
	String str=new String();
\end{verbatim}

Un string nulo es aquél que no contiene caracteres, pero es un objeto de la clase String. Sin embargo,

\begin{verbatim}
	String str;
\end{verbatim}

está declarando un objeto str de la clase String, pero aún no se ha creado ningún objeto de esta clase.
 
 \subsection{Operaciones básicas, comunes a String y StringBuffer}

Existen una serie de métodos que son comunes a ambas clases.

Los siguientes métodos de acceso a las cadenas:

    int length(); Devuelve el número de caracteres de la cadena.

    char charAt( int i ); Devuelve el carácter correspondiente de índice i.

Los siguientes métodos para crear cadenas derivadas:

    String toString(); Devuelve una copia del objeto como una String.

    String substring( int i, int fin ); Devuelve una instancia de la clase String que contenga una subcadena desde la posición ini, hasta la fin (si no se indica hasta el final de la cadena), del objeto cadena que invoque el método.

Y el método para transformar la cadena en un vector de caracteres:

    void getChars(int ini, int fin, char[] destino, int destIni); Convierte la cadena en un vector de caracteres destino.

\subsection{Métodos de la clase String}

\subsubsection{Constructores}

La clase String proporciona cadenas de sólo lectura y soporta operaciones con ellas. Se pueden crear cadenas implícitamente mediante una cadena entrecomillada o usando + ó += con dos objetos String.

También se pueden crear objetos String explícitamente con el mecanismo new.

La clase String soporta multitud de constructores.

    String(); Constructor por defecto. El nuevo String toma el valor "".

    String( String s ); Crea un nuevo String, copiando el que recibe por parámetro.

    String( StringBuffer s ); Crea un String con el valor que en ese momento tenga el StringBuffer que recibe como parámetro.

    String( char[] v ); El nuevo String toma el valor de los caracteres que tiene el vector de caracteres recibido por parámetro.

    String( byte[] v ); El nuevo String toma el valor de los caracteres que corresponden a los valores del vector de bytes en el sistema de caracteres de la ordenador en que se ejecute.

\subsubsection{Búsqueda en cadenas String}

Además presenta los siguientes métodos para buscar caracteres o subcadenas en la cadena, y devuelven el índice que han encontrado o el valor –1 si la búsqueda no ha sido satisfactoria:

    int indexOf( char ch, int start ): Devuelve el índice correspondiente a la primera aparición del carácter ch en la cadena, comenzando a buscar desde el carácter start (si no se especifica se busca desde el principio).

    int indexOf( String str ): Devuelve el índice correspondiente al carácter en que empieza la primera aparición de la subcadena str.

    int lastIndexOf( char ch, int start ): Devuelve el índice correspondiente a la última aparición del carácter ch en la cadena, comenzando a buscar desde el carácter start (si no se especifica se busca desde el final).

    int lastIndexOf( String str ): Devuelve el índice correspondiente al carácter en que empieza la última aparición de la subcadena str.

\subsubsection{Comparaciones de cadenas String}

Java no trabaja con el código ASCII habitual, sino con el código avanzado Unicode.

El código Unicode (código universal) se caracteriza, sobre todo, por el uso de dos bytes por carácter. Esto permite aumentar los caracteres hasta 65000, y así se pueden representar los caracteres que componen las lenguas, vivas o muertas, más importantes del mundo.

Hay que tener en cuenta que si nos salimos del rango 0-255 que coincide con el código ASCII puede que las comparaciones no sean las esperadas.

Las funciones de comparación son las siguientes:

    boolean equals( Object o ); Devuelve true si se le pasa una referencia a un objeto String con los mismos caracteres, o false si no.

    boolean equalsIgnoreCase( String s ); Compara cadenas ignorando las diferencias de ortografía mayúsculas/minúsculas.

    boolean regionMatches( boolean b, int o, String s , int i, int n ); Compara parte de dos cadenas, carácter a carácter.

    boolean startsWith( String s, int i ); Comprueba si la cadena tiene el prefijo s desde i.

    boolean endsWith( String s ); Comprueba si la cadena termina con el sufijo s.

    int compareTo( Object o ); Devuelve un entero que es menor, igual o mayor que cero cuando la cadena sobre la que se le invoca es menor, igual o mayor que la otra. Si el parámetro es un String, la comparación es léxica.

    int compareToIgnoraCase( String s ); Compara lexicográficamente, ignorando las diferencias de ortografía mayúsculas/minúsculas.
    
 \section{Paquetes}
 
Los paquetes son el mecanismo por el que Java permite agrupar clases, interfaces, excepciones y constantes. De esta forma, se agrupan conjuntos de estructuras de datos y de clases con algún tipo de relación en común.

Con la idea de mantener la reutilización y facilidad de uso de los paquetes desarrollados es conveniente que las clases e interfaces contenidas en los mismos tengan cierta relación funcional. De esta manera los desarrolladores ya tendrán una idea de lo que están buscando y fácilmente sabrán qué pueden encontrar dentro de un paquete.

Creación de un paquete

a.) Declaración

Para declarar un paquete se utiliza la sentencia package seguida del nombre del paquete que estemos creando:

package NombrePaquete;

La estructura que ha de seguir un fichero fuente en Java es:

    Una única sentencia de paquete (opcional).

    Las sentencias de importación deseadas (opcional).

    La declaración de una (y sólo una) clase pública (public).

    Las clases privadas del paquete (opcional).

Por lo tanto la sentencia de declaración de paquete ha de ser la primera en un archivo fuente Java.

Nomenclatura

Para que los nombres de paquete puedan ser fácilmente reutilizados en toda una compañía o incluso en todo el mundo es conveniente darles nombres únicos. Esto puede ser una tarea realmente tediosa dentro de una gran empresa, y absolutamente imposible dentro de la comunidad de Internet.

Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro de Internet. Se verá un ejemplo para un dominio que se llamase japon.magic.com, un nombre apropiado sería com.magic.japon.paquete.

Subpaquetes

Cada paquete puede tener a su vez paquetes con contenidos parecidos, de forma que un programador probablemente estará interesado en organizar sus paquetes de forma jerárquica. Para eso se definen los subpaquetes.

Para crear un subpaquete bastará con almacenar el paquete hijo en un directorio Paquete/Subpaquete.

Así una clase dentro de un subpaquete como Paquete.Subpaquete.clase estará codificada en el fichero Paquete/Subpaquete.java.

El JDK define una variable de entorno denominada CLASSPATH que gestiona las rutas en las que el JDK busca los subpaquetes. El directorio actual suele estar siempre incluido en la variable de entorno CLASSPATH.

Uso

Con el fin de importar paquetes ya desarrollados se utiliza la sentencia import seguida del nombre de paquete o paquetes a importar.

Se pueden importar todos los elementos de un paquete o sólo algunos.

Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter *:

import PaquetePrueba.*;

También existe la posibilidad de que se deseen importar sólo algunas de las clases de un cierto paquete o subpaquete:

import Paquete.Subpaquete1.Subpaquete2.Clase1;

Para acceder a los elementos de un paquete, no es necesario importar explícitamente el paquete en que aparecen, sino que basta con referenciar el elemento tras una especificación completa de la ruta de paquetes y subpaquetes en que se encuentra.

\begin{verbatim}
Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento
\end{verbatim}

En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden incluir en cualquier aplicación (o applet) Java que se desarrolle. 

Ámbito de los elementos de un paquete

Al introducir el concepto de paquete, surge la duda de cómo proteger los elementos de una clase, qué visibilidad presentan respecto al resto de elementos del paquete, respecto a los de otros paquetes...

Ya en la herencia se vieron los identificadores de visibilidad public (visible a todas las clases), private (no visible más que para la propia clase), y protected (visible a clases hijas).

Por defecto se considera los elementos (clases, variables y métodos) de un mismo paquete como visibles entre ellos (supliendo las denominadas clases amigas de C++).

 \section{La clase Random}
 
La clase Random proporciona un generador de números aleatorios. Para crear una secuencia de números aleatorios tenemos que seguir los siguientes pasos:

    Proporcionar a nuestro programa información acerca de la clase Random. 
    
    1.- Al principio del programa  escribiremos la siguiente sentencia.
    
\begin{verbatim}
	import java.util.Random;
\end{verbatim}

    2.- Crear un objeto de la clase Random
    
    3.- Llamar a una de las funciones miembro que generan un número aleatorio
    
    4.- Usar el número aleatorio.

La clase dispone de dos constructores, el primero crea un generador de números aleatorios cuya semilla es inicializada en base al instante de tiempo actual.

\begin{verbatim}
    	Random rnd = new Random();
\end{verbatim}

El segundo, inicializa la semilla con un número del tipo long.

\begin{verbatim}
   	Random rnd = new Random(3816L);
\end{verbatim}

El sufijo L no es necesario, ya que aunque 3816 es un número int por defecto, es promocionado automáticamente a long.

Aunque no podemos predecir que números se generarán con una semilla particular, podemos sin embargo, duplicar una serie de números aleatorios usando la misma semilla. Es decir, cada vez que creamos un objeto de la clase Random con la misma semilla obtendremos la misma secuencia de números aleatorios. Esto no es útil en el caso de loterías, pero puede ser útil en el caso de juegos,  exámenes basados en una secuencia de preguntas aleatorias, las mismas para cada uno de los estudiantes, simulaciones que se repitan de la misma forma una y otra vez, etc.

Algunos métodos de la clase Random son:

\begin{center}
\begin{tabular}{|c|c|}
\hline
Método & Descripción\\
\hline
setSeed(int n) & cambia la semilla \\
nextInt() & genera un número aleatorio entero \\
nextLong() & genera un número aleatorio long\\
nextFloat() & genera un número aleatorio flotante entre 0.0 y 1.0\\
nextDouble() & genera un número aleatorio doble entre 0.0 y 1.0\\
nextGaussian() & genera un número entre 0 y 1 con distribución \\
& Normal con media cero y varianza 1\\
\hline
\end{tabular}
\end{center}

\subsection{Ejemplo 1}

Escribir un código  para generar una secuencia de 10 números aleatorios entre 0.0 y 1.0 escribimos

\begin{verbatim}
import java.util.Random;


public class NumerosFlotantesAleatorios {
    
    static public void main(String args[]) {
        int i;
        Random rnd = new Random();
        
        for (i = 0; i < 10; i++) {
            System.out.println(rnd.nextDouble());;
        }
    }
}
\end{verbatim}

\subsection{Ejemplo 2}

Crear una secuencia de 10 números aleatorios enteros comprendidos entre 0 y 9 ambos incluidos escribimos:
\begin{verbatim}
import java.util.Random;

public class NumerosEnterosAleatorios {
    static public void main(String args[]) {
        int i;
        Random rnd = new Random();
        
        for (i = 0; i < 10; i++) {
            System.out.println(	(int)(rnd.nextDouble() * 10.0));
        }
    }
}
\end{verbatim}

\section{La clase Math}

La clase Math es una clase estática ya que no necesita que se instancie una variable para poder ser utilizada. La clase Math representa la librería matemática de Java, en donde se compilan la mayoría de la funciones matemáticas mas conocidas. Algunas de las funciones que están en esta clase son:

\begin{center}
\begin{tabular}{|c|c|}
\hline
Funciones & Descripción\\
\hline
Math.abs( x ) & valor absoluto\\
Math.sin( double ) & seno de un ángulo\\
Math.cos( double ) & coseno de un ángulo\\
Math.tan( double ) & tangente de un ángulo\\
Math.asin( double ) & seno inverso\\
Math.acos( double ) & coseno inverso\\
Math.atan( double ) & tangente inversa\\
Math.atan2( double,double ) & tangente inversa \\
Math.exp( double ) & antilogaritmo \\
Math.log( double )  & logaritmo \\
Math.sqrt( double ) & raiz cuadráda\\
Math.ceil( double ) & redondeo de un número\\
Math.floor( double ) & parte fraccionaria de un número\\
Math.rint( double )& entero mas cercano\\
Math.pow( a,b ) & potenciación \\
Math.round( x )   & redondeo \\
Math.random()   & numero alatorio entre 0 y 1\\
Math.max( a,b )  & máximo de dos números \\
Math.min( a,b )  & minimo de dos números\\
Math.E  & base exponencial\\
Math.PI    & valor de $\pi$\\
\hline
\end{tabular}
\end{center}

\section{Formateo de Salida}

Para dar formato de Salida se utilizan los métodos format y printf en lugar de las instrucciones de print y println anteriormente utilizadas. Los métodos format y printf tienen la misma sintaxis y pueden ser utilizados indistintamente. En el siguiente ejemplo se muestra su uso:

\begin{verbatim}
import java.util.*;

public class PruebaFormato {
    
    public static void main(String[] args) {
      long n = 461012;
      System.out.format("%d%n", n); 
      System.out.format("%08d%n", n);
      System.out.format("%+8d%n", n);
      System.out.format("%,8d%n", n);
      System.out.format("%+,8d%n%n", n);
      
      double pi = Math.PI;
      System.out.format("%f%n", pi);
      System.out.format("%.3f%n", pi);
      System.out.format("%10.3f%n", pi);  
      System.out.format("%-10.3f%n", pi);  
      System.out.format(Locale.FRANCE, "%-10.4f%n%n", pi);

      Calendar c = Calendar.getInstance();
      System.out.format("%tB %te, %tY%n", c, c, c);
      System.out.format("%tl:%tM %tp%n", c, c, c);
      System.out.format("%tD%n", c);
    }
}
\end{verbatim}

Otro ejemplo mas elaborado es el que se muestra a continuación

\begin{verbatim}
import java.text.DecimalFormat;

public class FormatoDecimal {

   static public void FormatoAjustable(String pattern, double value ) {
      DecimalFormat myFormato = new DecimalFormat(pattern);
      String output = myFormato.format(value);
      System.out.println(value + "  " + pattern + "  " + output);
   }

   static public void main(String[] args) {

      FormatoAjustable("###,###.###", 123456.789);
      FormatoAjustable("###.##", 123456.789);
      FormatoAjustable("000000.000", 123.78987);
      FormatoAjustable("$###,###.###", 12345.67);  
   }
}
\end{verbatim}

Los símbolos utilizados para hacer la conversión y el formato se muestran en la siguiente tabla

\begin{center}
\begin{tabular}{|c|c|c|}
\hline
Conv. &	Band. 	& Explicación \\
\hline
d  & 	&  	Un entero decimal.\\
\hline
f  &	 & 	Un flotante.\\
\hline
n &  &  nueva línea apropiado \\
\hline
tB 	& &  	Conversión de fecha y hora \\
& & nombre completo del mes específico a la localidad.\\
\hline
td, t e & &	  Conversión de fecha y hora\\
& & día del mes de 2 dígitos. td tiene ceros \\
& & a la izquierda según se necesite, te no.\\
\hline
ty, tY 	& &  	Conversión de fecha y hora—ty = año de 2 dígitos, \\
& &tY = año de 4 dígitos.\\
\hline
tl 	& &  	Una conversión de fecha y hora—hora en reloj de 12 horas.\\
\hline
tM 	 & &	Conversión de fecha y hora—minutos en 2 dígitos, \\ 
& & con ceros a la izquierda según sea necesario.\\
\hline
tp 	 & &	Conversión de fecha y hora \\
& &—am/pm específico a la localidad (minúsculas).\\
\hline
tm 	 & & 	Conversión de fecha y hora \\
& &meses en 2 dígitos, con ceros \\
& & a la izquierda según sea necesario.\\
\hline
tD 	  &	& Conversión de fecha y hora—la fecha como \%tm\%td\%ty\\
\hline
  & 	08 & 	Ocho caracteres en longitud, con ceros \\
  & & a la izquierda según sea necesario.\\
\hline
  &	 + &	Incluye el signo, ya sea positivo o negativo.\\
\hline
  &	, & 	Incluye caracteres de agrupación específicos a la localidad.\\
\hline
  &  -  &	Justificado a la izquierda.\\
\hline
  & 	.3 & 	Tres cifras después del punto decimal.\\
\hline
  & 	10.3 & 	Diez caracteres en longitud, justificado a la derecha, \\
  & &con tres cifras después del punto decimal. \\
  \hline
\end{tabular}
\end{center}
