<repo_name>manu-msr/java-noob<file_sep>/Tienda/Aplicacion.java
package Proyecto; //Paquete del archivo

import java.util.Scanner;

/**
 * PROYECTO FINAL - ICC
 * Programa para que maneja una tienda
 * @author <NAME> Ciencias UNAM
 * @version 1.01 Diciembre 2012
 */

public class Aplicacion{
  
  public static void main(String[] args){
    
    /**
     * Clase Tienda, contiene en su constructor
     * los archivos .ser y .txt los cuáles se abren
     * al crear el objeto.
     */
    
    Tienda tienda = new Tienda();
    
    Scanner teclado = new Scanner(System.in);
    
    /**
     * Menú de opciónes para controlar el sistema
     */
    
    int opcion = 1; //Variable que controlará el menú.
    
    do{
      System.out.println("\nSelecciona una Opción: "
                           +"\n[1]Consular existencias de algún artículo."
                           +"\n[2]Dar de alta un nuevo artículo."
                           +"\n[3]Registrar una nueva venta."
                           +"\n[4]Mostrar empleados."
                           +"\n[5]Dar de alta un nuevo empleado."   
                           +"\n[6]Mostrar las ventas."
                           +"\n[7]Salir del sistema.");
      
      String op = teclado.nextLine();
      opcion = Integer.parseInt(op); //Se hace el cambio para evitar posibles errores con las clases
      //y métodos relacionados con la clase Tienda.
      
      switch(opcion){ //Switch para manejar las opciones del menú
        
        //Caso 1: Consular existencias de algún artículo
        case 1:
          tienda.consultarExistencias();
          break;
          
          //Caso 2: Dar de alta un nuevo artículo  
        case 2:
          tienda.darDeAltaArt();
          break;
          
          //Caso 3: Registrar una nueva venta  
        case 3:
          tienda.registrarVenta();
          break;
          
          //Caso 4: Mostrar empleados  
        case 4:
          tienda.mostrarEmpleados();
          break;
          
          //Caso 5: Dar de alta un nuevo empleado  
        case 5:
          tienda.darDeAltaEmp();
          break;
          
          //Caso 6: Mostrar las ventas  
        case 6:
          tienda.mostrarVentas();
          break;
          
          //Salir del sistema
        case 7:
          tienda.salir();
          break;
          
          //En caso de que ponga una opción incorrecta
        default:
          System.out.println("Opción incorrecta");
          break;
      }
    } while (opcion != 7); //Mientras la opción no sea 7
  }
}<file_sep>/Matrices2/TDAMatriz.java
public interface TDAMatriz{
   
 public int getRenglones();
 public int getColumnas();
 public void agrega(int i, int j, Double elemento);
 public Double get(int i, int j);
 public TDAMatriz suma(TDAMatriz otra);
 public TDAMatriz multiplicaEscalar(int e);
 public TDAMatriz traspuesta(); 
 public boolean equals(Object objeto);
}<file_sep>/Tienda/Pelicula.java
package Proyecto; //Paquete donde se encuentra el proyecto

/**
 * Clase Pelicula.
 * Hereda de Disco que a su vez hereda de Articulo
 * @author <NAME> Ciencias UNAM
 * @version 1.04 Diciembre 2012
 */

public class Pelicula extends Disco{
  
  //Atributos
  protected String formato;
  protected String genero;
  protected int anio;
  
  /**
   * Constructor por omisión
   * @throws TiendaException -- De la clase padre
   */
  
  public Pelicula() throws TiendaException{
    super();
    formato = "";
    genero = "";
    anio = 1000;
  }
  
  /**
   * Constructor a partir de siete parámetros
   * Cuatro de la clase padre y tres de la clase hija
   * @param c -- Clave única
   * @param e -- Número de existencia
   * @param p -- Precio
   * @param n -- Nombre
   * @param f -- Formato (DVD, Blu-Ray)
   * @param g -- Genero
   * @param a -- Año de salida
   * @throws TiendaException -- Verifica que el Formato
   * y año de salida se al correcto
   */
  
  public Pelicula(String c, int e, double p, String n, String f, String g, int a) throws TiendaException{
    super(c,e,p,n);
    if((f.equalsIgnoreCase("DVD") || f.equalsIgnoreCase("BLU-RAY")) && a>1000){
      formato = f;
      genero = g;
      anio = a;
    } else {
      throw new TiendaException("El formato debe ser DVD o BLUE-RAY y el año mayor a 1000.");
    }
  }
  
  /**
   * Método de acceso
   * Obtiene el formato
   * @return String -- Formato
   */
  
  public String obtenerFormato(){
    return formato;
  }
  
  /**
   * Método de acceso
   * Obtiene el género
   * @return String -- Género
   */
  
  public String obtenerGenero(){
    return genero;
  }
  
  /**
   * Método de acceso
   * Obtiene el año de salida
   * @return int -- Año de salida
   */
  
  public int obtenerAnio(){
    return anio;
  }
  
  /**
   * Método modificador a partir de un parámetro
   * Establece el Formato
   * @param f -- Formato
   * @throws TiendaException -- Revisa que el formato
   * sea el correcto
   */
  
  public void establecerFormato(String f) throws TiendaException{
    if(f.equalsIgnoreCase("DVD") || f.equalsIgnoreCase("BLU-RAY")) formato = f;
    else throw new TiendaException("El formato debe ser DVD o BLUE-RAY. Intenta de nuevo");
  }
  
  /**
   * Método modificador a partir de un parámetro
   * Establece el género
   * @param g -- Género
   */
  
  public void establecerGenero(String g){
    genero = g;
  }
  
  /**
   * Método modificador a partir de un parámetro
   * Establece el año
   * @param a -- Anio
   * @throws Tienda Exception -- Verifica que el
   * año sea correcto
   */
  
  public void establecerAnio(int a) throws TiendaException{
    if(a>1000) anio = a;
    else new TiendaException("Demasidado antiguo... Prueba con un año mayor que 1000.");
  }
  
  /**
   * Método toString
   * Imprime la Película
   * @return String -- Película
   */
  
  public String toString(){
    return super.toString()+"\nFormato: "+formato+"\nGénero: "+genero+"\nAño de salida: "+anio;
  }
}<file_sep>/Fracciones/PruebaFracciones.java
/**
 * Programa para probar la clase fraccion.
 * @author <NAME>.
 * @version 1.00 Marzo 2013
 */
public class PruebaFracciones {
  
  /**
   * Método main
   */
  public static void main(String[] args) {
    
    /**
     * Crear dos fracciones
     */
    System.out.println("Creando dos fracciones...\n");
    Fraccion uno = new Fraccion(3628800,759374);
    Fraccion dos = new Fraccion(10,5);
    
    /**
     * Mostrar las fracciones
     */
    System.out.println("Las fracciones son: "
                         + "\n" + uno.muestra() + " y " + dos.muestra());
    
    /**
     * Operaciones entre las fracciones
     */
    System.out.println("\nSuma de las dos fracciones: " + uno.suma(dos).muestra());
    System.out.println("Resta de las dos fracciones: "+ uno.resta(dos).muestra());
    System.out.println("Multiplicación de las dos fracciones: "+ uno.multiplica(dos).muestra());
    System.out.println("División de las dos fracciones: "+ uno.divide(dos).muestra());
    
    /**
     * Multiplicar por un escalar
     */
    System.out.println("\nMultiplicamos las fracciones por el entero 2:");
    System.out.println(uno.muestra() + ": "+uno.multiplicaEscalar(2).muestra());
    System.out.println(dos.muestra() +": "+dos.multiplicaEscalar(2).muestra());
    
    /**
     * Saber si las fracciones son propias
     */
    System.out.println("\nLas fracciones son propias?: ");
    System.out.println(uno.muestra() + ": " + uno.esPropia());
    System.out.println(dos.muestra() + ": " + dos.esPropia());
    
    /**
     * Obtener el valor real de las fracciones
     */
    System.out.println("\nValor real de las fracciones: ");
    System.out.println(uno.muestra() + ": " + uno.daValorReal());
    System.out.println(dos.muestra() + ": " + dos.daValorReal());
    
    /**
     * Simplificamos las fracciones
     */
    System.out.println("\nSimplificar las fracciones: ");
    System.out.println(uno.muestra() + ": " + uno.simplifica().muestra());
    System.out.println(dos.muestra() + ": " + dos.simplifica().muestra());
  }
}
<file_sep>/Tienda/VendedorArchivoSecuencial.java
package Proyecto; //Paquete donde se encuentra la clase

//Paquetes para usar serialización
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * Clase para crear un archivo secuencial de Empleados
 * @author <NAME> Ciencias UNAM
 * @version 1.00 Diciembre 2012
 */

public class VendedorArchivoSecuencial{
  
  //Atributos de la clase
  private ObjectOutputStream salida;
  private String archivo;
  
  /**
   * Constructor a partir del nombre del archivo
   * @param n -- Nombre del Archivo
   */
  
  public VendedorArchivoSecuencial(String n){
    archivo = n;
  }
  
  /**
   * Método para abrir el archivo
   */
  
  public void abrirArchivo(){
    try{
      salida = new ObjectOutputStream(new FileOutputStream(archivo, true));
    } catch (IOException io){
      System.out.println("Error al abrir el archivo");
    }
  }
  
  /**
   * Método que obtiene los datos del Empleado
   * @throws TiendaException -- En caso de que ingrese o 
   * introduzca un dato incorrecto.
   */
  
  public Vendedor pedirDatos(){
    
    Vendedor vendedor = null; //Vendedor que devolverá el método
    Scanner teclado = new Scanner(System.in);
    
    try{
      boolean agrego = false;
      
      while(agrego == false){
        vendedor = new Vendedor();
        System.out.print("RFC: ");
        vendedor.establecerRFC(teclado.nextLine());
        System.out.print("Nombre completo: ");
        vendedor.establecerNombre(teclado.nextLine());
        System.out.print("Dirección: ");
        vendedor.establecerDireccion(teclado.nextLine());
        System.out.print("Teléfono: ");
        String telefono = teclado.nextLine();
        vendedor.establecerTelefono(Integer.parseInt(telefono));
        System.out.print("Sección: ");
        vendedor.establecerSeccion(teclado.nextLine());
        System.out.print("Sueldo: ");
        String sueldo = teclado.nextLine();
        vendedor.establecerSueldo(Double.parseDouble(sueldo));
        
        //Obtener la clave del vendedor
        String clave = vendedor.obtenerNombre().substring(0,4) + vendedor.obtenerRFC().charAt(0)+
          vendedor.obtenerRFC().charAt(2)+vendedor.obtenerRFC().substring(4,6);
        clave = clave.toLowerCase();
        
        vendedor.establecerClave(clave);
        
        //Muestra los datos ingresados y pregunta si son correctos
        System.out.println("Haz ingresado el siguiente empleado:\n"+vendedor.toString());
        System.out.println("Los dados son correctos? [S/N]: ");
        String resp = teclado.nextLine();
        if(resp.equalsIgnoreCase("S")){
          agrego = true;
        }
      }
    }catch (TiendaException e){
      System.out.println(e.getMessage());
    }catch (NumberFormatException e){
      System.out.println("Dato Incorrecto");
    } catch (InputMismatchException e){
      System.out.println("Dato Incorrecto");
    }
    
    return vendedor;
  }
  
  /**
   * Método para agregar Vendedores al archivo
   */
  
  public void agregarVendedores(){
    Vendedor vendedor = null;
    Scanner teclado = new Scanner(System.in);
    String opcion = "S";
    
    do{
      System.out.println("Deseas agregar un empleado? [S/N]");
      opcion = teclado.nextLine();
      if(!opcion.equalsIgnoreCase("S")&&!opcion.equalsIgnoreCase("N")){
        System.out.println("Opción incorrecta");
      }else
        if(opcion.equalsIgnoreCase("S")){
        vendedor =  pedirDatos();
        try {
          if (new File(archivo).exists()){
            agregarMasArchivos(vendedor);
          }else    {
            abrirArchivo();
            salida.writeObject(vendedor);
            System.out.println("\nEmpleado agregado exitosamente");
            cerrarArchivo();
          }
        }catch (IOException ex){
          System.out.println("No se pudo escribir en el archivo");
        }
      }
    }while(!opcion.equalsIgnoreCase("N")); 
  }
  
  /**
   * Método que agrega un artículo al archivo, sin escribir un código, para ello
   * Éste método, abre el archivo, añade el objeto al final del archivo y finalmente lo cierra.
   */
  
  public void agregarMasArchivos(Object o){
    try {
      ObjectOutputStreamPropio oos = new ObjectOutputStreamPropio(new FileOutputStream(archivo,true));    
      oos.writeUnshared(o);
      oos.close();
    }catch (Exception e){
      System.out.println("Imposible agregar el articulo al archivo");
    } 
  }
  
  /**
   * Método que cierra el archivo y termina la ejecución
   */
  
  public void cerrarArchivo(){
    try{
      salida.close();
    } catch ( IOException ioe ) {
      System.out.println( "Error al cerrar el archivo." );
    }
  } 
}<file_sep>/Tienda/Tienda.java
package Proyecto; //Paquete donde se encuentra la clase

/**
 * Clase tienda que manejará los artículos y empleados
 * @author <NAME>
 * @version 1.04 Diciembre 2012
 */

import java.util.Scanner;

public class Tienda{
  
  //Atributos de la clase
  ArticuloArchivoSecuencial articuloAgregar; //Agregar articulos
  VendedorArchivoSecuencial vendedorAgregar; //Agregar empleados
  LeerArticuloSecuencial articuloLeer; //Leer artículos
  LeerEmpleadoSecuencial vendedorLeer; //Leer vendedores
  Scanner teclado = new Scanner(System.in); //Leer por teclado
  GuardarVentas ventasGuardar; //Guardar las ventas
  LeerVentas ventasLeer; //Leer las ventas
  
  /**
   * Constructor por omisión
   */
  
  public Tienda(){
    articuloAgregar = new ArticuloArchivoSecuencial("Articulos.ser");
    vendedorAgregar = new VendedorArchivoSecuencial("Empleados.ser");
    articuloLeer = new LeerArticuloSecuencial("Articulos.ser");
    vendedorLeer = new LeerEmpleadoSecuencial("Empleados.ser");
    ventasGuardar = new GuardarVentas("Ventas.txt");
    ventasLeer = new LeerVentas("Ventas.txt");
  }
  
  /**
   * Método para para consultar
   * las existencias de algún artículo
   */
  
  public void consultarExistencias(){
    int opcion = 1; //Opción que controlará el menú
    
    do{
      System.out.println("\nSeleccione un tipo de búsqueda:" +
                         "\n[1]Por Clave"+
                         "\n[2]Por Tipo de Artículo"+
                         "\n[3]Por Nombre"+
                         "\n[4]Salir"+
                         "\nOpción: ");
      String op = teclado.nextLine();
      opcion = Integer.parseInt(op);
      
      switch(opcion){
        case 1:
          System.out.println("Introduzca la clave del producto");
          articuloLeer.abrirArchivo();
          articuloLeer.buscarPorClave(teclado.nextLine());
          articuloLeer.cerrarArchivo();
          break;
          
        case 2:
          System.out.println("Seleccione el tipo del artículo: "+
                             "\n[1]Libro"+
                             "\n[2]Disco");
          String tip = teclado.nextLine();
          int tipo = Integer.parseInt(tip);
          
          switch(tipo){
            case 1:
              articuloLeer.abrirArchivo();
              articuloLeer.buscarPorTipo("Libro");
              articuloLeer.cerrarArchivo();
              break;
              
            case 2:
              articuloLeer.abrirArchivo();
              articuloLeer.buscarPorTipo("Disco");
              articuloLeer.cerrarArchivo();
              break;
              
            default:
              System.out.println("Opción incorrecta");
          }
          break;
          
        case 3:
          System.out.println("Introducza el nombre del producto:");
          articuloLeer.abrirArchivo();
          articuloLeer.buscarPorNombre(teclado.nextLine());
          articuloLeer.cerrarArchivo();
          break;
          
        case 4:
          System.out.println("Saliendo de busquedas...");
          break;
          
        default:
          System.out.println("Opción incorrecta");
          break;
      }
    } while(opcion != 4);
  }
  
  /**
   * Método para dar de alta un nuevo
   * artículo
   */
  
  public void darDeAltaArt(){
    articuloAgregar.agregarArticulos();
  }
  
  /**
   * Método para registrar una nueva venta
   */
  
  public void registrarVenta(){
    ventasGuardar.abrirArchivo();
    ventasGuardar.agregarVentas();
    ventasGuardar.cerrarArchivo();
  }
  
  /**
   * Método para mostrar todas las ventas
   */
  
  public void mostrarVentas(){
    System.out.println("Selecciona una opción:"
                      +"\n[1]Todas las ventas."
                      +"\n[2]Por fecha.");
    String op = teclado.nextLine();
    int opcion = Integer.parseInt(op);
    
    switch(opcion){
      
      //Mostrar todas las ventas
      case 1:
        ventasLeer.abrirArchivo();
        ventasLeer.leerVentas();
        ventasLeer.cerrarArchivo();
        break;
        
      //Mostrar las ventas de una fecha específica
      case 2:
        System.out.println("Fecha a buscar: ");
        String f = teclado.nextLine();
        ventasLeer.abrirArchivo();
        ventasLeer.leerVentasFecha(f);
        ventasLeer.cerrarArchivo();
        break;
        
      default:
        System.out.println("Opción no válida");
    }
  }
  /**
   * Método que muestra los empleados de la tienda
   */
  
  public void mostrarEmpleados(){
    vendedorLeer.abrirArchivo();
    vendedorLeer.leerArchivos();
    vendedorLeer.cerrarArchivo();
  }
  
  /**
   * Método para dar de alta un nuevo empleado
   */
  
  public void darDeAltaEmp(){
    vendedorAgregar.agregarVendedores();
  }
  
  /**
   * Método para salir del sistema
   */
  
  public void salir(){
    System.out.println("Escriba la fecha");
    String fecha = teclado.nextLine();
    ventasLeer.abrirArchivo();
    ventasLeer.leerVentasDia(fecha);
    ventasLeer.cerrarArchivo();
  }
}<file_sep>/Matrices2/PruebaMatriz.java
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import java.util.Random;
import java.util.Scanner;

/**
 * Parser para crear matrices
 */
public class PruebaMatriz extends DefaultHandler {
   
   /**
    * Para saber si encontró la etiqueta dimensiona.
    */
   boolean dimensiona;
   
   /**
    * Para saber si encontró la etiqueta dimensionb.
    */
   boolean dimensionb;
   
   /**
    * Para saber si encontró la etiqueta elemento.
    */
   boolean elemento;
   
   /**
    * Guarda el parámetro de la etiqueta dimensiona.
    */
   int n;
   
   /**
    * Guarda el parámetro de la etiqueta dimensionb.
    */
   int m;
   
   /**
    * Guarda los elementos como cadena.
    */
   String elementos;
   
   /**
    * Busca las etiquetas.
    */
   public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
      if (qName.equalsIgnoreCase("dimensiona")) {
         dimensiona = true;
      }
      if (qName.equalsIgnoreCase("dimensionb")) {
         dimensionb = true;
      }
      if (qName.equalsIgnoreCase("elementos")) {
         elemento = true;
      }
   }
   
   /**
    * Obtiene los valores de las etiquetas.
    */
   public void characters(char[] ch, int start, int length) throws SAXException {
      if (dimensiona) {
         n = Integer.parseInt(new String(ch,start,length).trim());
         dimensiona = false;
      }
      if (dimensionb) {
         m = Integer.parseInt(new String(ch,start,length).trim());
         dimensionb = false;
      }
      if (elemento) {
         elementos = new String(ch,start,length).trim();
         elemento = false;
      }
   }
   
   /**
    * Construye la matriz.
    */
   public TDAMatriz getMatriz() {
      Double[] arreglo = new Double[elementos.length()];
      elementos = elementos.replace(" ", "");
      for (int i = 0; i < elementos.length(); i++) {
         arreglo[i] = new Double(new String(elementos.charAt(i)+""));
      }
      int contador = 0;
      TDAMatriz nueva = new Matriz(n, m);
      for(int i = 0; i < n; i++) {
         for (int j = 0; j < m; j++) {
            nueva.agrega(i,j, arreglo[contador++]);
         }
      }
      return nueva;
   }
   
   public void parseDocument(InputStream is) {
      SAXParserFactory spf = SAXParserFactory.newInstance();
      try {
         SAXParser sp = spf.newSAXParser();
         sp.parse(is, this);
      }catch(SAXException se) {
         se.printStackTrace();
      }catch(ParserConfigurationException pce) {
         pce.printStackTrace();
      }catch (IOException ie) {
         ie.printStackTrace();
      }
   }
   
   /**
    * Método main.
    */
   public static void main(String args[]) throws IOException {
      
      /* En caso de que no se le pase nada por consola */
      if(args.length == 0){
         System.out.println("Debes pasar algún argumento");
         System.exit(1);
      }
      
      /* Matriz generada a partir del parser */
      FileInputStream fis=new FileInputStream("matriz.xml");
      PruebaMatriz ep= new PruebaMatriz();     
      ep.parseDocument(fis);
      TDAMatriz a = ep.getMatriz();
      
      /* Matriz generada aleatoriamente */
      Random alea = new Random();
      TDAMatriz b = new Matriz(a.getRenglones(),a.getColumnas());
      for (int i = 0; i < b.getRenglones(); i++) {
         for (int j = 0; j < b.getColumnas(); j++) {
            b.agrega(i,j, new Double(alea.nextInt(100)));
         }
      }
      
      /* Mostramos las dos matrices */
      System.out.println("Matriz a");
      System.out.println(a);
      System.out.println("Matriz b");
      System.out.println(b);
      
      Scanner teclado = new Scanner(System.in);
      
      /* Respuesta dependiendo del parámetro */
      switch(args[0]) {
         case "-r":
            System.out.println("Renglones: " + a.getRenglones());
            break;
         case "-c":
            System.out.println("Columnas: " + a.getColumnas());
            break;
         case "-e":
            System.out.print("Introduce la posición i: ");
            int i = teclado.nextInt();
            System.out.print("Introduce la posición j: ");
            int j = teclado.nextInt();
            System.out.println(a.get(i,j));
            break;
         case "-mo":
            System.out.print("Introduce la posición i: ");
            i = teclado.nextInt();
            System.out.print("Introduce la posición j: ");
            j = teclado.nextInt();
            System.out.print("Introduce el nuevo elemento: ");
            double e = teclado.nextDouble();
            a.agrega(i,j, e);
            System.out.println(a);
            break;
         case "-s":
            System.out.println("a + b: ");
            System.out.println(a.suma(b));
            break;
         case "-me":
            System.out.print("Introduce el escalar: ");
            int es = teclado.nextInt();
            System.out.println(a.multiplicaEscalar(es));
            break;
         case "-t":
            System.out.println(a.traspuesta());
            break;
         case "-i":
            if (a.equals(b))
            System.out.println("Son iguales");
            else
               System.out.println("Son distintas");
            break;
      }
   }
}  <file_sep>/Pokedex/Pokedex.java
package pokedex;

/**
 * Interfaz para manejar un Pokedex y mostrar los datos de algunos Pokémons.
 * @author <NAME>
 * @version 1.00
 */
public class Pokedex {
    
    /**
     * Método a partir de un parámetro que devuelve el nombre de un pokemon a
     * partir del número que se le pasa como parámetro.
     * @param n -- Número del pokémon.
     * @return Nombre del pokémon.
     */
    public String obtenerPokemon(int n){
        switch(n) {
            case 1:
                return "Bulbasaur";
            case 2:
                return "Ivysaur";
            case 3:
                return "Venusaur";
            case 4:
                return "Charmander";
            case 5:
                return "Charmeleon";
            case 6:
                return "Carizard";
            default:
                return "Pokemon no encontrado";
        }
    }
    
    /**
     * Método para obtener información sobre si el pokémon puede evolucionar
     * @param p -- Nombre del pokémon.
     * @return información sobre este
     */
    public String obtenerEvolución(String n){
        if(n.equalsIgnoreCase("Bulbasaur")) {
            return "Ivysaur";
        }
        if(n.equalsIgnoreCase("Ivysaur")) {
            return "Venusaur";
        }
        if(n.equalsIgnoreCase("Venusaur")) {
            return "That creature has no further evolution.";
        }
        if(n.equalsIgnoreCase("Charmander")) {
            return "Charmelon";
        }
        if(n.equalsIgnoreCase("Charmeleon")) {
            return "Charizard";
        }
        if(n.equalsIgnoreCase("Charizar")) {
            return "That creature has no further evolution.";
        }
        return "That creature is not found in our database.";
    }
}
<file_sep>/RegistroPalabras/Nodo.java
/**
 * Clase para implementar la representacion de un Nodo como un elemento
 * de una Lista Ligada.
 * @author <NAME>
 * @version Junio 2013
 */

public class Nodo {
  protected Object elemento; // elemento a guardar
  protected Nodo siguiente; // nodo que guardará el siguiente elemento
  
  /**
   * Constructor que recibe como parámetro el valor que contendr� el nuevo Nodo.
   * Siguiente se inicializa como null.
   * @param valor -- Elemento que tendrá el nuevo Nodo.
   */
  public Nodo(Object valor) {
    this(valor,null);
  }
  
  /**
   * Constructor que recibe como parámetros el valor del nuevo Nodo y el siguiente
   * Nodo en la Lista que suceder+a al nuevo Nodo.
   * @param valor -- Elemento del nuevo Nodo.
   * @param n -- Siguiente Nodo del nuevo Nodo
   */
  public Nodo(Object valor, Nodo n) {
    elemento = valor;
    siguiente = n;
  }
}<file_sep>/Empleados/Programador.java
package Empleados;

/**
 * Clase para manejar programadores,
 * heredados de la clase Empleado.
 * @author <NAME> ciencias UNAM
 * @version 1.0 Noviembre 2012
 */

public class Programador extends Empleado{
  
  //Atributos
  protected int lineasDeCodigoPorHora;
  protected int lenguajesDomina;
  
  /**
   * Constructor por omisión
   */
  public Programador(){
    lineasDeCodigoPorHora = 0;
    lenguajesDomina = 0;
  }
  
  /**
   * Construtor a partir de seis parámetros
   * @param nombre -- Nombre del programador,
   * hereda de la clase padre.
   * @param cedula -- Cédula del prgoramador,
   * hereda de la clase padre.
   * @param edad -- Edad del programador.
   * hereda de la clase padre.
   * @param salario -- Salario del programador,
   * hereda de la clase padre.
   * @param lineasDeCodigoPorHora -- Líneas de código que 
   * escribe por hora el programador
   * @param lenguajesDomina -- Númerode lenguajes que domina.
   */
  
  public Programador(String nombre, String cedula, int edad, double salario, int lineasDeCodigoPorHora, int lenguajesDomina){
    super(nombre, cedula, edad, salario);
    this.lineasDeCodigoPorHora = lineasDeCodigoPorHora;
    this.lenguajesDomina = lenguajesDomina;
  }
  
  /**
   * Método para obtener el tipo de programador
   * @return String -- Tipo en formato cadena
   */
  
  public String obtenerTipo(){
    String tipo = "";
    if(lenguajesDomina > 3) tipo = "intermedio";
    if(lenguajesDomina > 5) tipo = "avanzado";
    return super.obtenerTipo() + " programador nivel "+ tipo;
  }
  
  /**
   * Método que regresa los datos del prgramador
   * en formato cadena.
   * @return String -- Datos del programador.
   */
  
  public String toString(){
    return super.toString() + "\nLineas de código por hora: "+lineasDeCodigoPorHora+"\nLenguajes que domina: "+lenguajesDomina;
  }
}<file_sep>/DiferenciaFechas/Fecha.java
import java.util.Scanner;
/**
 * Esta clase calcula la diferencia entre los años ingresados, tomará en
 * cuenta los días bisiestos añadiéndolos al cálculo de su diferencia de 
 * dichos años convertidos en días: diferencia de años + dias bisiestos
 */
public class Fecha {
  
  public int difAnios(int a1, int a2) {
    int anioDif, cta, i, anioDias;
    anioDif = a2 - a1; // para sacar la diferencia de años
    /* Para contar los años bisiestos en un intervalo de fechas */
    cta = 0; // llevará la cuenta de años bisiestos
    /* Recorrerá del a1 al a2 comprobando si existen años bisiestos los años 
       bisiestos son divisibles por 4 y 400, ecluyendo los que sean divisibles
       por 10 */
    for (i = a1; i <= a2; i++) {
      if ((i % 4 == 0) && (i % 100 != 0 || i % 400 == 0)) {
        cta += 1;
      }
    }
    /* La diferencia de años multiplicada por 365 más la cuenta de número de 
       años bisiestos nos dará el número de días que habrá entre los años
       evaluados */
    anioDias = (anioDif * 365) + cta;
    return anioDias;
  }
  
  /**
   * Al primer año se le quitarán los días del intervalo del primer día del
   * año a la primera fecha ingresada.
   */
  public int diasAnioUno(int d1, int me1, int a1) {
    int m1, restoDias1;
    m1 = 0;
    /* Cada número de mes tiene asignado números pre-calculados ya que no
       todos los meses tienen el mismo número de días.
       Se empieza con el día 1 y aumenta de acuerdo al número de días que
       tiene cada mes hasta completar el año */
    switch(me1) {
      case 1:
        m1 = 0;
        break;
      case 2:
        m1 = 31;
        break;
      case 3:
        m1 = 59;
        break;
      case 4:
        m1 = 90;
        break;
      case 5:
        m1 = 120;
        break;
      case 6:
        m1 = 151;
        break;
      case 7:
        m1 = 181;
        break;
      case 8:
        m1 = 212;
        break;
      case 9:
        m1 = 243;
        break;
      case 10:
        m1 = 273;
        break;
      case 11:
        m1 = 304;
        break;
      case 12:
        m1 = 334;
        break;
    }
    /* Dependiendo del mes asignado sus días se sumará con los días ingresados
       de la primera fecha */
    restoDias1 = m1 + d1;
    return restoDias1;
  }
  
  /* Al segundo año se le quitarán los días del intervalo de la segunda fecha
     ingresada hasta el último día de ese mismo año. */
  public int diasAnioDos(int d2, int me2, int a2) {
    int m2, restoDias2;
    m2 = 0;
    /* Cada número de mes tiene asignado números precalculados ya que no todos
       los meses tienen el mismo número de días.
       Se empieza con el día 1 y aumenta de acuerdo al número de días que
       tiene cada mes hasta completar el año. */
      switch (me2){ 
        case 1: 
          m2 = 0; 
          break; 
        case 2: 
          m2 = 31; 
          break; 
        case 3: 
          m2 = 59; 
          break; 
        case 4: 
          m2 = 90; 
          break; 
        case 5: 
          m2 = 120; 
          break; 
        case 6: 
          m2 = 151; 
          break; 
        case 7: 
          m2 = 181; 
          break; 
        case 8: 
          m2 = 212; 
          break; 
        case 9: 
          m2 = 243; 
          break; 
        case 10: 
          m2 = 273; 
          break; 
        case 11: 
          m2=304; 
          break; 
        case 12: 
          m2=334; 
          break;
      }
      restoDias2 = m2 + d2;
      /* Devuelve el valor que se pretendía calcular */
      return restoDias2;
  }
  
  public static void main(String[] args) {
    Fecha f = new Fecha();
    Scanner in = new Scanner(System.in);
    /* Se pedira en esta funcion los datos solicitados por el programa */ 
    int dia1, dia2, mes1, mes2, anio1, anio2, restodias1, restodias2, aniodias, diastotales; 
    /* Anuncia lo que pedira para la primera fecha*/ 
System.out.println ("Ingresara datos de la primera fecha:"); 
System.out.println ("Ingrese el dia"); /* Solicita que ingrese el primer dia */ 
dia1 = in.nextInt();
System.out.println("Ingrese el mes"); /* Solicita que ingrese el primer mes */ 
mes1 = in.nextInt(); 
System.out.println ("Ingrese el anio"); /* Solicita que ingrese el primer anio */ 
anio1 = in.nextInt();
/* Anuncia lo que pedira para la primera fecha*/ 
System.out.println ("Ingresara datos de la segunda fecha:"); 
System.out.println ("Ingrese el dia"); /* Solicita que ingrese el segundo dia */ 
dia2 = in.nextInt();
System.out.println ("Ingrese el mes"); /* Solicita que ingrese el segundo mes */ 
mes2 = in.nextInt();
System.out.println ("Ingrese el anio"); /* Solicita que ingrese el segundo anio */ 
anio2 = in.nextInt();

/*Llamada a la funcion difanios*/ 
aniodias= f.difAnios(anio1, anio2); 
/* Lammada a la funcion diasaniouno*/ 
restodias1=f.diasAnioUno (dia1, mes1, anio1); 
/* Llamada a la funcion diasaniodos*/ 
restodias2=f.diasAnioDos (dia2, mes2, anio2); 
/* Calcula 'diastotales' con los valores que devuelve cada funcion */ 
diastotales= aniodias + (restodias2 - restodias1); 
System.out.println ("\n"); 
System.out.println(diastotales);
  }
}  <file_sep>/Canica/PruebaCanica.java
package canica;

import java.awt.Color;

/**
 * Programa para probar los métodos de la clase canica
 * @author <NAME>
 * @version 1.00 Marzo, 2013
 */
public class PruebaCanica {
    
    public static void main(String[] args){
        
        //Crear dos canicas
        Canica uno = new Canica();
        Canica dos = new Canica();
        
        //Mostrar las canicas
        System.out.println("Las canicas son: \n" + uno.toString() + "\n" 
                + dos.toString());
        
        //Mostrar si son iguales
        System.out.println("\nSon iguales?: " + uno.equals(dos));
        
        //Cambiar el color y número de pasos de las canicas
        uno.setColor(Color.yellow);
        uno.setPasos(10);
        dos.setColor(Color.black);
        dos.setPasos(5);
        
        //Subir la canica amarilla 2 pasos.
        System.out.println("Subió?: " + uno.avanzar("Arriba", 5));
        
        //Mostrar posición de la canica amarilla ahora
        System.out.println("Ahora se encuentra en: " + uno.getPos());
        
        //Bajar la canica amarilla 4 pasos.
        System.out.println("Bajó?: " + uno.avanzar("Abajo", 4));
        
        //Mostrar la posición de la canica amarilla ahora
        System.out.println("Ahora se encuentra en: " + uno.getPos());
        
        //Mover a la derecha la canica negra 2 pasos.
        System.out.println("Se movió?: " + dos.avanzar("Derecha", 2));
        
        //Mostrar posición de la canica negra ahora
        System.out.println("Ahora se encuentra en: " + dos.getPos());
        
        //Mover a la izquierda la canica negra 2 pasos.
        System.out.println("Se movió?: " + dos.avanzar("Izquierda", 2));
        
        //Mostrar la posición de la canica amarilla ahora
        System.out.println("Ahora se encuentra en: " + dos.getPos());
        
        //Mostrar el número de canicas
        System.out.println("\nNúmero de canicas: " + Canica.cuantasCanicas());
    }
}
<file_sep>/Tienda/Disco.java
package Proyecto; //Paquete donde se encuentra  la clase

/**
 * Clase disco que hereda de Artículo
 * @author <NAME> Ciencias UNAM
 * @version 1.03 Diciembre 2012
 */

public class Disco extends Articulo{
  
  //Atributos de la clase
  protected String nombre;
  
  /**
   * Constructor por omisión
   * @throws TiendaException -- De la clase padre
   */
  
  public Disco() throws TiendaException{
    super();
    nombre = "";
  }
  
  /**
   * Constructor a partir de cuatro parámetros
   * tres de la clase padre y uno de la clase hija
   * @param c -- Clase
   * @patam e -- Existencias
   * @param n -- Nombre del disco
   * @trhows TiendaException -- De la clase padre
   */
  
  public Disco(String c, int e, double p, String n) throws TiendaException{
    super(c,e,p);
    nombre = n;
  }
  
  /**
   * Método de acceso para obtener el nombre
   * @return nombre
   */
  
  public String obtenerNombre(){ 
    return nombre;
  }
  
  /**
   * Método modificador para establecer el nombre
   * @param n -- Nombre
   */
  
  public void establecerNombre(String n){
    nombre = n;
  }
  
  /**
   * Método toString
   * @return String -- Disco en formato cadena
   */
  
  public String toString(){
    return "\nNombre: "+nombre+super.toString();
  }
}<file_sep>/Empleados/PruebaEmpleado.java
package Empleados;
import java.util.Scanner;

/**
 * Programa para probar la clase empleado
 * y la clase programa de herencia.
 * @author <NAME> ciencias UNAM
 * @version 1.01 Noviembre 2012
 */

public class PruebaEmpleado{
  
  //Método main
  public static void main(String[] args){
    
    /*Pruebas de la clase Empleado*/
    
    //Crear un objeto Empleado sin errores
    Empleado emp1 = new Empleado("<NAME>", "manumsr93", 19, 5000.00);
    System.out.println(emp1.toString());
    System.out.println();
    
    //Crear un objeto Empleado donde el rango de edad no es válido
    Empleado emp2 = new Empleado("<NAME>", "manumsr93", 15, 5000.00);
    
    //Crear un objeto Empleado donde el rando del salario no es válido
    Empleado emp3 = new Empleado("<NAME>", "manumsr93", 19, 200.00);
    
    /*Pruebas de la clase Programador*/
    
    //Crear un objeto Programador con nivel intermedio
    Programador prog1 = new Programador("<NAME>","manumsr93", 19, 5000.00, 1000, 5);
    System.out.println(prog1.toString());
    System.out.println();
    
    //Crear un objeto Programador con nivel avanzado
    Programador prog2 = new Programador("<NAME>","manumsr93",19, 15000.00, 1000, 10);
    System.out.println(prog2.toString());
  }
}
<file_sep>/Robot/Robot.java
package robot;

/**
 * Clase para manejar los saludos de un robot.
 * @autor <NAME> Ciencias UNAM
 * @version 1.00 Febrero 2013
 */
public class Robot {
  
  /**
   * Variable de clase <code>name</code> que guardará el
   * nombre del robot.
   */
  private String name;
  
  /**
   * Variable de clase <code>greeting</code> que guardará lo que
   * dirá el robot al saluda.
   */
  private String greeting;
  
  /**
   * Constructor a partir de un parámetro.
   * @param nom -- Nombre del robot.
   */
  public Robot(String nom) {
    name = nom;
    greeting = "Konnichiwa";
  }
  
  /**
   * Constructor a partir de dos parámetros.
   * @param nom -- Nombre del robot.
   * @param sal -- Saludo.
   */
  public Robot(String nom, String sal) {
    name = nom;
    greeting = sal;
  }
  
  /**
   * Método que regresa una cadena.
   * @return String -- greeting.
   */
  public String greet() {
    return greeting;
  }
  
  /**
   * Método a partir de un parámetro que regresa
   * una cadena.
   * @param cad -- Cadena que recibe como parámetro.
   * @return String -- resultado de la concatenación.
   */
  public String greetPerson(String cad) {
    return greeting + " " + cad;
  }
  
  /**
   * Método que regresa la concatenación de las variables de clase
   * @return String -- Concatenación de las variables.
   */
  public String fullGreeting() {
    return greeting + ", my name is, " + name
      +"\n\t Nice to meet you";
  }
}<file_sep>/Tienda/LeerEmpleadoSecuencial.java
package Proyecto; //Paquete donde se encuentra la clase

//Paquetes para utilizar serialización
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * Clase para leer los Empleados de un archivo
 * @author <NAME>
 * @version 1.01 Diciembre 2012
 */

public class LeerEmpleadoSecuencial{
  
  //Atributos de la clase
  private ObjectInputStream entrada;
  private String nombre;
  
  /**
   * Constructor a partir de un parámetro
   * @param archivo -- Nombre del archivo.
   */
  
  public LeerEmpleadoSecuencial(String archivo){
    nombre = archivo;
  }
  
  /**
   * Método para abrir el archivo
   */
  
  public void abrirArchivo(){
    try{
      entrada = new ObjectInputStream(new FileInputStream( nombre ));
    } catch (IOException ioe){
      System.out.println("Error al abrir el archivo.");
    } 
  }
  
  /**
   * Método para leer los archivos
   */
  
  public void leerArchivos(){
    Vendedor vendedor;
    try {
      while (true){
        Object objeto =  entrada.readObject();
        if(objeto instanceof Vendedor){
          vendedor = (Vendedor)objeto;
          System.out.println(vendedor.toString());
        }else{
          System.out.println("No es un artículo");
        }
      }
    }catch (EOFException eofe){
      return;
    }catch (ClassNotFoundException cnfe){
      System.out.println("No se pudo crear el objeto.");
    } catch ( IOException ioException ){
      System.out.println("Error al leer del archivo.");
      System.out.println("La causa " +  ioException.toString());
    } 
  }
  
  /**
   * Método para cerrar el archivo
   */
  
  public void cerrarArchivo(){
    try{
      entrada.close();
    } catch (IOException ioException){
      System.out.println( "Error al cerrar el archivo." );
    }
  } 
}<file_sep>/Fracciones/ServFracciones.java
/**
 * Presenta los servicios que ofrece una clase que represente a fracciones.
 * @author <NAME>.
 * @version 0.1.
 * @date Feb 20,2013.
 */
public interface ServFracciones {
  
  /**
   * Le suma una fracción a la fracción this.
   * @param la fracción a sumar.
   * @return la suma de las fracciones.
   */
  public Fraccion suma(Fraccion otra);
  
  /**
   * Le resta una fracción a la fracción this.
   * @param la fracción a sumar.
   * @return la resta de las fracciones.
   */
  public Fraccion resta(Fraccion otra);
  
  /**
   * Multiplica una fraccion por la fraccion this.
   * @param la fraccion a multiplicar.
   * @return la multiplicación de las fracciones.
   */
  public Fraccion multiplica(Fraccion otra);
  
  /**
   * Multiplica un entero por la fracción this.
   * @param el entero a multiplicar.
   * @return el resultado de la multiplicación, que es una fracción.
   */
  public Fraccion multiplicaEscalar(int valor);
  
  /**
   * Divide la fracción this entre la fracción dada.
   * @param la fraccion entre la cual dividir..
   * @return El resultado de la division de las fracciones.
   */
  public Fraccion divide(Fraccion otra);
  
  /**
   * Responde si la fraccion this es propia o no.
   * @return true si la fraccion es propia.
   */
  public boolean esPropia();
  
  /**
   * Lleva a cabo la división del numerador entre el denominador de
   * la fracción this.
   * @return el real que es resultado de la división
   */
  public double daValorReal();
  
  /**
   * Simplifica la fracción this.
   * @return la fracción simplificada.
   */
  public Fraccion simplifica();
  
  /**
   * Construye una cadena con una representación adecuada de la fracción this.
   * @return la fracción simplificada
   */
  public String muestra();
}
<file_sep>/Baraja/Carta.java
/**
 * Carta.java
 * La clase Carta representa una carta de juego.
 * @author <NAME>
 * @version 1.00 Octubre 2014
 */
public class Carta {

   /** 
    * Cara de la carta ("As", "Dos",...).
    */
   private String cara;

   /**
    * Palo de la carta ("Corazones", "Diamantes", ...).
    */
   private String palo;

   /**
    * Constructor a partir de dos parámetros.
    * @param cara Cara de la carta
    * @param palo Palo de la carta
    */
   public Carta(String cara, String palo) {
      this.cara = cara;
      this.palo = palo;
   }

   /**
    * Representación de una carta como cadena.
    * @return String - Carta en formato cadena
    */
   public String toString() {
      return cara + " de " + palo;
   }
}<file_sep>/Robot/PruebaRobot.java
package robot;

/**
 * Programa que maneja dos robots.
 * @author <NAME> Ciencias UNAM
 * @version 1.00 Febrero 2013.
 */
public class PruebaRobot {
  
  /**
   * Método main
   */
  public static void main(String[] args) {
    Robot uno = new Robot("GLaDOS", "Welcome to Apperture Science");
    Robot dos = new Robot("Wheatly", "Hola amigo!, abre la puerta!");
    
    /**
     * Probar los métodos
     */
    System.out.println(uno.greet());
    System.out.println(uno.greetPerson("Manuel"));
    System.out.println(uno.fullGreeting());
    
    System.out.println(dos.greet());
    System.out.println(dos.greetPerson("Manuel"));
    System.out.println(dos.fullGreeting());    
  }
}<file_sep>/GUI/LabelFrame.java
import java.awt.FlowLayout; // especifica como se van a ordenar los componentes
import javax.swing.JFrame; // proporciona las características básicas de una ventana
import javax.swing.JLabel; // muestra texto e imágenes
import javax.swing.SwingConstants; // constantes comunes utilizadas con Swing.
import javax.swing.Icon; // interfaz utilizada para manipular imágenes
import javax.swing.ImageIcon; // carga las imágenes

/**
 * Programa que muestra texto e imágenes en una ventana.
 * Objetivo: Introducir el concepto de GUI.
 * @author <NAME>
 * @version 1.00
 */
public class LabelFrame extends JFrame {
  
  private JLabel etiqueta1; // JLabel sólo con texto;
  private JLabel etiqueta2; // JLabel construida con texto y un icono
  private JLabel etiqueta3; // Jlabel con texto adicional e icono
  
  /**
   * El constructor de LabelFrame agrega objetos JLabel a JFrame
   */
  public LabelFrame() {
    super("Prueba de JLabel");
    setLayout(new FlowLayout()); // establece el esquema del marco
    
    // Constructor de JLabel con un argumento String
    etiqueta1 = new JLabel("Etiqueta con texto");
    etiqueta1.setToolTipText("Esta es etiqueta1");
    add(etiqueta1);
    
    /* Constructor de JLabel con argumentos de cadena, Icono y 
       alineación */
    Icon unam = new ImageIcon(getClass().getResource("unam.jpg"));
    etiqueta2 = new JLabel("Etiqueta con texto e icono", unam,
                           SwingConstants.LEFT);
    etiqueta2.setToolTipText("Esta es etiqueta2");
    add(etiqueta2);
    
    etiqueta3 = new JLabel(); // Constructor de JLabel sin argumentos
    etiqueta3.setText("Etiqueta con icono y texto en la parte inferior");
    etiqueta3.setIcon(unam);
    etiqueta3.setHorizontalTextPosition(SwingConstants.CENTER);
    etiqueta3.setVerticalTextPosition(SwingConstants.BOTTOM);
    etiqueta3.setToolTipText("Esta es etiqueta3");
    add(etiqueta3);           
  }
  
  public static void main(String[] args) {
    LabelFrame marcoEtiqueta = new LabelFrame();
    marcoEtiqueta.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    marcoEtiqueta.setSize(275, 180);
    marcoEtiqueta.setVisible(true);
  }
}<file_sep>/Tienda/Juego.java
package Proyecto; //Paquete donde se encuentra la clase

/**
 * Clase Juegos
 * Hereda de disco y esta a su vez hereda de Artículo
 * @author <NAME> Ciencias UNAM
 * @version 1.02 Diciembre 2012
 */

public class Juego extends Disco{
  
  //Atributos
  protected String tipo;
  protected String consola;
  
  /**
   * Constructor por omisión
   * @throws Tienda Exception -- De la clase padre
   */
  
  public Juego() throws TiendaException{
    super();
    tipo = "";
    consola = "";
  }
  
  /**
   * Constructor a partir de seis parámetros.
   * Tres de la clase padre y tres de la clase hija.
   * @param c -- Clave.
   * @param e -- Número de Existencia.
   * @param p -- Precio.
   * @param n -- Nombre.
   * @param t -- Tipo.
   * @param j -- Consola.
   * @param TiendaException -- Exception de la clase padre.
   */
  
  public Juego(String c, int e, double p, String n, String t, String j) throws TiendaException{
    super(c,e,p,n);
    tipo = t;
    consola = j;
  }
  
  /**
   * Método de acceso
   * Obtiene el tipo de juego
   * @return String -- Tipo de juego
   */
  
  public String obtenerTipo(){
    return tipo;
  }
  
  /**
   * Método de acceso
   * Obtiene la consola
   * @return String -- Consola
   */
  
  public String obtenerConsola(){
    return consola;
  }
  
  /**
   * Método modificador a partir de un parámetro
   * Establece el tipo de juego
   * @param t -- Tipo de juego
   */
  
  public void establecerTipo(String t){
    tipo = t;
  }
  
  /**
   * Método modificador a partir de un parámetro
   * Establece la consola
   * @param c -- Consola
   */
  
  public void establecerConsola(String c){
    consola = c;
  }
  
  /**
   * Método toString
   * Imprime el videojuego
   * @return String -- Juego
   */
  
  public String toString(){
    return super.toString()+"\nTipo: "+tipo+"\nConsola: "+consola;
  }
}<file_sep>/RegistroPalabras/RegistroPalabras.java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;

/**
 * Clase que cuenta el número de palabras con un tamaño específico de un
 * texto.
 * @author <NAME>
 * @version Junio 2013
 */

public class RegistroPalabras {
  
  /**
   * Lista para guardar las palabras del archivo.
   */
  private Lista palabras;
  
  /**
   * Matriz que guardará los datos.
   */
  private int[][] tabla;
  
  /**
   * Variable que guarda el tamaño de la palabra de mayor tamaño.
   */
  private int mayor;
  
  /**
   * Constructor por omisión.
   */
  public RegistroPalabras() {
    palabras = new Lista();
    mayor = 0;
  }
  
  /**
   * Método que lee el archivo y guarda las palabras en la lista.
   * @param archivo -- Nombre del archivo a leer
   */
  public void leerArchivo(File lectura) throws IOException {
    BufferedReader entrada = new BufferedReader(new FileReader(lectura));
    String renglon;
    String cadena = ""; // cadena que guardará las palabras
    while ((renglon = entrada.readLine()) != null) {
      for (int i = 0; i < renglon.length(); i++) {
        cadena += renglon.charAt(i); // arma la cadena
        System.out.print(renglon.charAt(i));
        if(renglon.charAt(i) == ' ') {
          agregarLista(cadena); //agrega la cadena a la lista
          cadena = ""; // vacía la cadena para armar otra palabra
        }
      }
      agregarLista(cadena);
      System.out.println("");
    }
  }
  
  /**
   * Agregar los datos de la lista en la tabla.
   */
  public void crearTabla() {
    int contador = 0;
    tabla = new int[2][mayor]; // crea una tabla de 2 x el tamaño mayor
    for(int i = 0; i < mayor; i++) { // llena primera fila
      tabla[0][i] = (i+1);
    }
    for(int i = 0; i < mayor; i++) { // llena segunda fila
      tabla[1][i] = (palabras.cuenta(i+1));
    }
  }
  
  /**
   * Método que recorre la tabla y muestra los datos almacenados en ella
   */
  public void mostrarTabla() {
    for(int i = 0; i < 2; i++) {
      if(i == 0) {
        System.out.print("Tamaño:\t");
      } else {
        System.out.print("Numero:\t");
      }
      for(int j = 0; j < mayor; j++) {
        System.out.printf("%d\t",tabla[i][j]);
      }
      System.out.println();
    }
  }
  
  /**
   * Método privado para agregar la cadena que se le pasa como parámetro.
   * @param cadena -- Cadena que se agregará a la Lista
   */
  private void agregarLista(String cadena) {
    cadena = modificaCadena(cadena); // corrige la cadena
    palabras.agregar(cadena.length()); // agrega el tamaño de la cadena
    if(cadena.length() > mayor) {
      mayor = cadena.length(); // asigna el tamaño a la variable mayor
    }
  }
  
  /**
   * Método que modifica una cadena para evitar que se cuenten espacios en
   * blanco y signos de puntuación.
   * @param cadena -- Cadena a modificar
   * @return String -- Cadena modificada
   */
  private String modificaCadena(String cadena) {
    String nueva = cadena;
    nueva = nueva.replace(".", " ");
    nueva = nueva.replace(",", " ");
    nueva = nueva.replace(";", " ");
    nueva = nueva.replace("(", " ");
    nueva = nueva.replace(")", " ");
    nueva = nueva.trim();
    return nueva;
  }
  
  /**
   * Pruebas de la clase
   */
  public static void main(String[] args) {
    RegistroPalabras dePrueba = new RegistroPalabras();
    File archivo = new File("archivo.txt");
    try {
      System.out.println("Texto original\n");
      dePrueba.leerArchivo(archivo);
      System.out.println();
      dePrueba.crearTabla();
      dePrueba.mostrarTabla();
    } catch(IOException ioe) {
      System.out.println("Error.");
    }
  }
}<file_sep>/Caracteres/PruebaCaracteres.java
public class PruebaCaracteres {
  
  public static void main(String[] args) {
    Caracteres meeel = new Caracteres();
    System.out.println(meeel.revString("ola k ase? %$#$&%$#&//%&)$#W"));
  }
}
<file_sep>/Reloj/Reloj.java
import java.util.Date;

/**
 * Clase para manejar un reloj con apoyo de la clase Date
 * de Java.
 * @author <NAME>
 * @version 1.00 Junio 2014
 */
public class Reloj {

	/**
	 * Objeto Date para obtener las fechas.
	 */
	private Date fecha;

	/**
	 * Constructor por omisión.
	 * Inicializa los atributos en un estado válido.
	 */
	public Reloj() {
		this.fecha = new Date();
	}

	/**
	 * Devuelve la hora en Buenos Aires.
	 * @return Cadena con la hora en Buenos Aires.
	 */
	public String horaBuenosAires() {
		return daHora(3);
	}

	/**
	 * Devuelve la hora en Canberra.
	 * @return Cadena con la hora en Caberra.
	 */
	public String horaCanberra() {
		return daHora(16);
	}

	/**
	 * Devuelve la hora en Brazilia.
	 * @return Cadena con la hora en Brazilia.
	 */
	public String horaBrazilia() {
		return daHora(2);
	}

	/**
	 * Devuelve la hora en Otawa.
	 * @return Cadena con la hora en Otawa.
	 */
	public String horaOtawa() {
		return daHora(2);
	}

	/**
	 * Devuelve la hora en Santiado.
	 * @return Cadena con la hora en Santiago.
	 */
	public String horaSantiago() {
		return daHora(2);
	}

	/**
	 * Devuelve la hora en Bogotá.
	 * @return Cadena con la hora en Bogotá.
	 */
	public String horaBogota() {
		return daHora(1);
	}

	/**
	 * Devuelve la hora en La Habana.
	 * @return Cadena con la hora en La Habana.
	 */
	public String horaLaHabana() {
		return daHora(1);
	}

	/**
	 * Devuelve la hora en Madrid.
	 * @return Cadena con la hora en Madrid.
	 */
	public String horaMadrid() {
		return daHora(7);
	}

	/**
	 * Devuelve la hora en París.
	 * @return Cadena con la hora en París.
	 */
	public String horaParis() {
		return daHora(7);
	}

	/**
	 * Devuelve la hora en Tokio.
	 * @return Cadena con la hora en Tokio.
	 */
	public String horaTokio() {
		return daHora(15);
	}

	/**
	 * Devuelve la hora en México D.F.
	 * @return Cadena con la hora en México D.F.
	 */
	public String horaMexicoDF() {
		return daHora(0);
	}

	/**
	 * Devuelve la hora en Nueva York.
	 * @return Cadena con la hora en Nueva York.
	 */
	public String horaNuevaYork() {
		return daHora(1);
	}

	private String daHora(int param) {
		if (param < 0) // validamos el parámetro
			param = 0;
		int i = (fecha.getHours() + param) % 24;
		String str1 = Integer.toString(i); // obtiene la hora
		if (str1.length() == 1) // agrega un 0 para mejorar el formato
			str1 = "0" + str1;
		String str2 = Integer.toString(fecha.getMinutes()); // obtiene los minutos
		if (str2.length() == 1)
			str2 = "0" + str2; // mejora el formato
		return str1 + ":" + str2 + "hrs"; // regresa la hora con formato
	}
}