Lista Simple

/**
 * @(#)ListaSimple.java
 *
 *
 * @author HERYCK MISAEL MUÑOZ MORA
 * @version 1.00 2014/4/29
 */
import java.util.Scanner;

class Nodo{ //va a estar trabajando mientras el programa se encuentre en ejecucion, es la clase que va a fabricar los NODOS
int elemento;
Nodo siguiente;
//Nodo anterior;

public Nodo (int x){ //constructor
elemento = x;
siguiente = null;
//anterior=null;
}
}



public class ListaSimple {
     
    /**
     * Creates a new instance of <code>ListaSimple</code>.
     */
    private static Nodo frente = null;
private static Nodo fin = null;
   
    public ListaSimple() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner ent = new Scanner (System.in);
        int opcion;
     
        do{
        System.out.println("\n");
        System.out.println("1.- INSERTAR ");
        System.out.println("2.- PRESENTAR ");
        System.out.println("3.-  ELIMINAR ");
        System.out.println("4.- LIMPIAR ");
        System.out.println("5.- TERMINAR");
       
       
        opcion = ent.nextInt();
       
        switch (opcion)
        {
        case 1: Insertar();
        break;
       
        case 2: presentar ();
        break;
       
        case 3: Elim();
        break;
       
        case 4: limp();
        break;
       
        case 5:
        break;
       
        default:
        System.out.println("Opcion equivocada");
       
       
        }         // cierra el switch
       
        }
        while(opcion != 5);         // cierra el do
    }
 
     public static void Insertar()
    {
    int valor;
    Nodo aux;    
    Scanner ent = new Scanner(System.in); // AQUI SE CREA EL OBJETO DE TIPO SCANNER, PARA SER INTRODUCIDO CON EL TECLADO
    System.out.print("Ingrese Elemento: ");
    valor = ent.nextInt();
   
    aux = new Nodo (valor); // creamos un nodo con ambas partes, donde contendra "valor", y en siguiente sera "null"
        if (frente == null)
    frente = aux;
       
    else
      fin.siguiente = aux;
    fin = aux;  
    }
 
     public static void presentar()
    {
    Nodo aux;
    if ( frente == null)
    System.out.println("¡¡¡ La Lista esta VACIA !!!");
       
    for (aux = frente; aux != null;)
    {
    System.out.println("elemento "+aux.elemento);
    aux = aux.siguiente;
    }
    }
 
     public static void Elim ()
    {
    if ( frente == null)
    System.out.println("¡¡¡ La Lista esta VACIA !!!");
   
    else
    {
    System.out.println("elemento "+frente.elemento);
    frente = frente.siguiente;
        }
           
    }
 
     public static void limp()
    {        
   
    for (;frente != null;)
    {
    System.out.println("elemento "+frente.elemento);
    frente = frente.siguiente;
    }
    }  
 
    //tarea eliminar y limpiar
}

Areas con Objetos

/**
 * @(#)areas.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/3/31
 */

public class areas_objetos {
       
    /**
     * Creates a new instance of <code>areas</code>.
     */
    public areas_objetos() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int radio=7, base=8, altura=9, lado=4, l1=5, l2=6;      
       
        Area area = new Area();
        System.out.println("---------------------------------------------"+"\n");
        System.out.println("Area del Cuadrado: "+area.cuadrado(lado)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Rectangulo: "+area.rectangulo(l1,l2)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Triangulo: "+area.triangulo(base,altura)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Circulo: "+area.circulo(radio)+"\n");
        System.out.println("---------------------------------------------"+"\n");
        }
}

class Area{

    public Area(){
    }
   
    public int cuadrado(int lado){
    int ret;
    ret=lado*lado;
    return ret;
    }
    public int rectangulo(int l1, int l2){
    int ret;
    ret=l1*l2;
    return ret;
    }
    public double triangulo(int l1, int l2){
    double ret;
    ret=(l1*l2)/2;
    return ret;
    }
    public double circulo(int radio){
    double ret, pi;
    pi=3.141621;
    ret=radio*radio*pi;
    return ret;
    }
}

Primer Programa para obtener Areas de Figuras Geometricas

/**
 * @(#)areas.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/3/31
 */

public class areas {
       
    /**
     * Creates a new instance of <code>areas</code>.
     */
    public areas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int a=5, b=10, l1=4, l2=4, l3=8;      
        float areaC, areaR, areaT;
        double pi, radio=4, areaCi;
             
        System.out.println(". . . . .  Area del Cuadrado . . . . . "+"\n");
        System.out.println("el primer lado vale: "+l1+"\n");
        System.out.println("el primer lado vale: "+l2+"\n");
        areaC=l1*l2;
       
        System.out.println("El Area del Cuadrado : "+areaC+"\n\n");
        System.out.println("---------------------------------"+"\n");
        System.out.println(". . . . .  Area del Rectangulo . . . . . "+"\n");
        System.out.println("el primer lado vale: "+l1+"\n");
        System.out.println("el primer lado vale: "+l3+"\n");
        areaR=l1*l3;
       
        System.out.println("El Area del Rectangulo : "+areaR+"\n\n");
        System.out.println("---------------------------------"+"\n");
        System.out.println(". . . . .  Area del Triangulo . . . . . "+"\n");
        System.out.println("el primer lado vale: "+l1+"\n");
        System.out.println("el primer lado vale: "+l2+"\n");
        areaT=(l1*l3)/2;
       
        System.out.println("El Area del Triangulo : "+areaT+"\n\n");
        System.out.println("---------------------------------"+"\n");
        System.out.println(". . . . .  Area del Circulo . . . . . "+"\n");
        System.out.println("el radio vale: "+radio+"\n");
        pi= 3.141621;
        areaCi= pi*radio*radio;
       
        System.out.println("El Area del Circulo : "+areaR+"\n\n");
        System.out.println("---------------------------------"+"\n");      
    }
}

Variables

/**
 * @(#)Variables.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/3/28
 */

public class Variables {
       
    /**
     * Creates a new instance of <code>Variables</code>.
     */
    public Variables() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int entero;
        int entero1;
        float flotante;
        byte bait;
        double doble;
        char caracter;
        long largota;
       
        char [] arreglo = {'h','o','l','a'};
        String cadena = "cadena de caracteres";
       
        entero = 12;
        entero1 = 12;
        flotante = 1;
        bait = 0x00;
        largota = 1200000;
        caracter = 'A';
        doble = 1000000.1000000;
       
        System.out.println(" . . . . . . . . Variables SIMPLES . . . . . . . . ");
        System.out.println("Esto es un Int : "+ entero);
        System.out.println("Esto es un Int : "+ entero1+ " ++entero1 : "); System.out.println(++entero1);
        System.out.println("Esto es un float : "+ flotante);
        System.out.println("Esto es un byte : " +bait);
        System.out.println("Esto es un long : " +largota);
        System.out.println("Esto es un char : " +caracter);
        System.out.println("Esto es un double : "+ doble+"\n");
       
        System.out.println(" . . . . . . . . Variables COMPUESTAS . . . . . . . . ");
        System.out.println("Esto es un String : "+ cadena);
        System.out.println("Esto es el elmemto 0 del ARREGLO : "+ arreglo [0]);
        System.out.println("Esto es el elmemto 3 del ARREGLO : "+ arreglo [3]);
        System.out.println("Esto es la posicion de memoria donde inincia ARREGLO : "+ arreglo);
       
       
       
    }
}

Colas

/**
 * @(#)Colas.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/9
 */

import java.util.Scanner;

public class Colas {
       
    /**
     * Creates a new instance of <code>Colas</code>.
     */
    public Colas() {
    }
   
    /**
     * @param args the command line arguments
     */
   
    public static int frent=0, fin=0;
   
    public static void main(String[] args) {
        // TODO code application logic here
    Scanner ent = new Scanner (System.in);
        int opcion, max;
        int [] cola;                              
       
        System.out.println("\nCantidad de elementos de la Cola :");  // Ingrese el tamaño de la pila
        max = ent.nextInt();
        cola = new int[max];  // pila es igual a la entrada del tamaño en "n"
        System.out.println("\n Cola creada con exito.....\n");
       
        do{
        System.out.println("\n");
        System.out.println("1.- INSERTAR COLA");
        System.out.println("2.- ELIMINAR COLA");
        System.out.println("3.- PRESENTAR PILA");
        System.out.println("4.- LIMPIAR PILA");
        System.out.println("5.- TERMINAR");
        System.out.println("6.- DEFAULT\n");
       
        opcion = ent.nextInt();
       
        switch (opcion)
        {
        case 1: Insert(cola, max);
        break;
       
        case 2: Elim(cola);
        break;
       
        case 3: presentar (cola);
        break;
       
        case 4: frent=0;
    fin=0;
        break;
       
        case 5:
        break;
       
        default:
        System.out.println("Opcion equivocada");
       
       
        }         // cierra el switch
       
        }
        while(opcion != 5);         // cierra el do
    } // cierra el main
   
    public static void Insert(int [] c, int m)
    {
    Scanner ent = new Scanner(System.in); // AQUI SE CREA EL OBJETO DE TIPO SCANNER, PARA SER INTRODUCIDO CON EL TECLADO
    if (fin < m)
    {
    System.out.print("Ingrese valor :");
    c[fin]=ent.nextInt(); // LEE UN ENTERO, DEPOSITANDOLO EN EL ARREGLO C, DE TIPO ENTERO, CREADO CON EL SCANNER
    fin++;
   
    if (fin == 1)
    {
    frent = fin;
    }
    }
   
    else
    {
    System.out.print("Desbordamiento de Cola \nTodo lleno");
    }
   
    }
   
    public static void Elim (int [] c)
    {
    if(frent > fin || fin == 0)
    {
    System.out.print("Elemento Cola esta vacia \nSin Datos"); // System.out.print("NO HAY DATOS");
    }
   
   
    else
    {
    System.out.println("Se elimina el elemento"+frent); // System.out.print("ELEMENTO A ELIMINAR = " + C [ FRENTE - 1]);
    System.out.println("c [ " + frent + " ] = " + c [ frent-1 ] );
    frent++;
    }
   
    }
   
    public static void presentar (int [] c)
    {
    if (frent > fin || fin == 0)
    {
    System.out.println("COLA VACIA");
    }
    else
    {
   
    for ( int i = frent; i<= fin; i++)
    {
    System.out.println( "cola [ " + i + " ]" + c [i - 1] );
    }
   
    }

     }

}

Arreglo Version Dos

/**
 * @(#)ArregloVersionDos.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/3
 */
import java.util.Scanner;
public class ArregloVersionDos {
       
    /**
     * Creates a new instance of <code>ArregloVersionDos</code>.
     */
    public ArregloVersionDos() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.println("Tamaño del Arreglo :");
        n=entrada.nextInt();
        x=new int [n];
               
        // Crear un metodo de Datos de la variable "X"
        leeDatos (x);      
        // Crear un metodo que muestre los Datos de la variable "X"
        muestraDatos (x);
       
        System.out.println("El menor es : " + menor(x) );
        System.out.println("El mayor es : " + mayor(x) );
        System.out.println("promedio = " + prom (x) );      
       
    }
    public static void leeDatos (int [] a)
    {
    Scanner ent = new Scanner (System.in);
    for (int i=0; i<a.length; i++)
    {
    System.out.print("Ingresa elemento x["+i+"]");
    a [i] = ent.nextInt();
    }    
    System.out.println("-----------------------");
    }
   
     public static void muestraDatos (int [] a)
    {
   
    for (int i=0; i<a.length; i++)
    {
    System.out.println("Muestra elementos a["+i+"]"+a[i]);
   
    }  
    System.out.println("-----------------------");
    }
     
     public static int  menor (int [] a)
     {
      int min = a[0];
      for (int i=0; i<a.length; i++)
      {
      if ( a[i] < min)
      min = a[i];
     
      }
      return min;
     
     }
   
      public static int  mayor (int [] a)
     {
      int may = a[0];
      for (int i=0; i<a.length; i++)
      {
      if ( a[i] > may)
      may = a[i];
      }
      return may;
     
     }
   
public static double  prom (int [] a)
     {
      int prom = a[0];
      for (int i=0; i<a.length; i++)
      {
     
suma+= a[i];                                        
        }
        prom=(suma/a.length);
        return prom;
     }
     
     
   
   
   
}

Arreglo Uni

/**
 * @(#)ArregloUni.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/2
 */
import java.util.Scanner;

public class ArregloUni {
       
    /**
     * Creates a new instance of <code>ArregloUni</code>.
     */
    public ArregloUni() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.println("Tamaño del Arreglo");
        n=entrada.nextInt();
        x=new int [n];
        System.out.println("Arreglo creado de "+n+"posiciones");
       
        // Ingreso de Datos al Arreglo
            for (int i =0; i<n; i++)
            {
            System.out.print("Elemento X[" +i+ "]= " );
        x[i]=entrada.nextInt();
            }
       
        // Salida de Datos del arreglo
        for (int i =0; i<n; i++)
            {
            System.out.println("X[" +i+ "]= " +x[i] );
       
            }
           
          mayorymenor(x);
         
         
         
         
         
         
         
         
        /* Calcular el promedio de los "n" valores introducidos
       
        int suma=0;
        double prom=0;
       
        for (int i=0; i<n; i++)
        {
        suma=suma+x[i];
        prom=suma/n;
        }
        System.out.println("suma =" + suma);
        System.out.println("prom =" + prom);
        */
       
        /* Calcular el promedio de los "n" valores introducidos

for (int i=0; i<n; i++)
        {
        suma+ = x[i];                                           da error en esta linea
        }
        prom=suma/n;
        */
       
       
       
    }
   
    /* public int menor(int[] a)
    {
    int ret[0]; // variable de retorno = ret
    for(int i=0; i<a.length; i++;)  //metodo length proporciona la cantidad de elementos en el arreglo
    {
    if (a[i]<ret)
    ret = a[i];
    }
    return ret;
    }
    */
   
    public static void mayorymenor( int [] a)
    {
    int mayor=0, menor=0;
        for (int i =0; i<a.length; i++)
            {
            if (i==0)
            {
            menor=a[i];
            mayor=a[i];
            }
            else
            {
            if(a[i] < menor)
            menor = a [i];
           
            if(a[i] > mayor)
            mayor = a [i];
                }
            }
        System.out.println("menor =" + menor);
        System.out.println("mayor =" + mayor);
    }
}

Arreglo Ordenado

/**
 * @(#)ArregloOrdenado.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/5
 */

import java.util.Scanner;

public class ArregloOrdenado {
       
    /**
     * Creates a new instance of <code>ArregloOrdenado</code>.
     */
    public ArregloOrdenado() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n;
       
        int []x;
        Scanner entrada = new Scanner (System.in);
       
        System.out.println("Cual sera el tamaño del arreglo :");       //Se introduce el valor de n que sera el espacio del arreglo
        n = entrada.nextInt();
        x = new int [n];
       
        leerdatos (x);
        presentardatos(x);
        ordenardatos(x);
    }
    public static void leerdatos(int [] a)
      {
      Scanner entrada=new Scanner(System.in);
      for (int i=0;i<a.length;i++)
      {
      System.out.print("Ingresa el elemento a["+i+"]");
      a[i]=entrada.nextInt();
      }
    }
   
   
    public static void presentardatos (int [] a)
    {
      for (int i=0;i<a.length;i++)
      {
      System.out.println("los datos ingresados en a["+i+"]"+a[i]);
     
      }
}

public static void ordenardatos (int [] a)
    {
      int aux;
        for(int i=0;i<a.length-1;i++)
            for(int j=0;j<a.length-i-1;j++)                  
                    if(a[j+1]<a[j]) //condición que ordena los datos
                    {
                      aux=a[j+1];
                      a[j+1]=a[j];
                      a[j]=aux;
                    }
       
        for(int k=0; k<a.length; k++)       // Mostrar el arreglo ordenado
        System.out.print(a[k]+" ");
    }
   
}

Arreglo Multidimencional

/**
 * @(#)ArregloMultiDimencional.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/4
 */

import java.util.Scanner;  // Librerias

public class ArregloMultiDimencional {  // Clase publica
       
    /**
     * Creates a new instance of <code>ArregloMultiDimencional</code>.
     */
    public ArregloMultiDimencional() { // constructor, debe llamarse = q la clase
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int [][] x; // arreglo de 2 dimenciones de tipo entero, llamado "X"
        int n, m;
        Scanner ent=new Scanner (System.in);
       
        System.out.print ("Ingreses num. de renglones :");
        n=ent.nextInt(); //lee del teclado datos enteros, para depositar en "n"
        System.out.print ("Ingreses num. de columnas :");
        m=ent.nextInt();
       
        x= new int [n][m]; // arreglo llamado "X" tipo entero, de dimencion "n", "m"
        leerdatos (x);
        presentar (x);
   
    }
   
    public static void leerdatos ( int [] [] a)
    {
    Scanner ent = new Scanner (System.in);
   
    System.out.print ("Ingreses los Datos :");
        for (int i=0; i<a.length; i++)  //recorrido de la cantidad de renglones obtenidos en el primer arreglo
        {
        for (int j=0; j<a[i].length;j++) //recorrido de la cantidad de columnas obtenidas
        {
        System.out.print("a[" +i+ "][" +j+ "]= ");
        a[i][j]=ent.nextInt();
        }
        }
    }
   
    public static void presentar ( int [] [] a)
    {
    for (int i=0; i<a.length; i++)  //recorrido de la cantidad de renglones obtenidos en el primer arreglo
        {
        for (int j=0; j<a[i].length;j++) //recorrido de la cantidad de columnas obtenidas
        {
        System.out.print(a[i][j] + "  ");
        }
        System.out.println();
        }
    }
   
    public static void burbuja(int [] A)
    {
         int i, j, aux;
         for (i=0; i<A.length-1; i++)
              for (j=0; j<A.length-i-1; j++)
                   if (A [j+1] < A [j])
                    {
                      aux = A [j+1];
                      A [j+1] = A [j];
                      A [j] = aux;
                    }
}

}

programa para obtener las áreas algunas figuras geometricas, mediante un metodo

/**
 * @(#)Area_objetos2.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/3/31
 */
import matematicas.*;
public class Area_objetos2 {
       
    /**
     * Creates a new instance of <code>Area_objetos2</code>.
     */
    public Area_objetos2() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
                int radio=7, base=8, altura=9, lado=4, l1=5, l2=6;      
       
        Area area = new Area();
        System.out.println("---------------------------------------------"+"\n");
        System.out.println("Area del Cuadrado: "+area.cuadrado(lado)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Rectangulo: "+area.rectangulo(l1,l2)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Triangulo: "+area.triangulo(base,altura)+"\n");
        System.out.println("---------------------------------------------"+"\n");
                System.out.println("Area del Circulo: "+area.circulo(radio)+"\n");
        System.out.println("---------------------------------------------"+"\n");

    }
}

Programa para realizar una Cola Circular en programación con JCreator

/**
 * @(#)ColaCircular.java
 *
 *
 * @author
 * @version 1.00 2014/4/11
 */

import java.util.Scanner;

public class ColaCircular {
       
    /**
     * Creates a new instance of <code>ColaCircular</code>.
     */
    public ColaCircular() {
    }
   
    /**
     * @param args the command line arguments
     */
     public static int frente = 0, fin = 0;
   
    public static void main(String[] args) {
        // TODO code application logic here
        int max, op;
        int [] ColaC;
        Scanner ent = new Scanner (System.in);
        max = ent.nextInt();
        ColaC = new int[max];
       
        do
        {
        System.out.println("1.- Insertar");
        System.out.println("2.- Extraer");
        System.out.println("3.- Presentar");
        System.out.println("4.- Limpiar");
        System.out.println("5.- Salir");
       
        op = ent.nextInt();
       
        switch(op)
        {
        case 1: Insertar (ColaC, max);
        break;
       
        /* case 2: Extraer (ColaC);
        break;
       
        case 3: Presentar (ColaC);
        break;
        */
        case 4: frente = 0;
        fin = max;
        break;
       
        case 5: break;
       
        default: System.out.println("Opcion equivocada");
        break;

        }


        }
       
        while (op != 5);
    }
   
     public static int Sig (int pos, int m)
    {
    return pos % m;
   
    }
   
     public static void Insertar (int [] c, int m)
    {
    Scanner ent = new Scanner(System.in);
    if (frente == Sig (Sig (fin, m), m))
    {
    System.out.print("Cola llena...");
   
    }
   
    else
    {
    System.out.print("Ingrese Valor: ");
    c[fin] = ent.nextInt();
    fin++;
    }
   
    }
   
   
   
}

Formulas para obtener las Áreas de las figuras Geométricas

/**
 * @(#)Area.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/3/31
 */


package matematicas;

public class Area {

    public Area() {
    }
    public int cuadrado(int lado){
    int ret;
    ret=lado*lado;
    return ret;
    }
    public int rectangulo(int l1, int l2){
    int ret;
    ret=l1*l2;
    return ret;
    }
    public double triangulo(int l1, int l2){
    double ret;
    ret=(l1*l2)/2;
    return ret;
    }
    public double circulo(int radio){
    double ret, pi;
    pi=3.141621;
    ret=radio*radio*pi;
    return ret;
    }
}

Programa para calcular el Área de una figura Geométrica

/**
 * @(#)Figuras_Geometricas.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/1
 */

import matematicas.Area;   //crear un menú que pida el nombre de la figura y pida intruducir los valores
import java.util.Scanner;

public class Figuras_Geometricas {
       
    /**
     * Creates a new instance of <code>Figuras_Geometricas</code>.
     */
    public Figuras_Geometricas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
               
        int Sel, l1, l2, lado, base, altura, radio;;
        Scanner entrada = new Scanner(System.in);
        Area area = new Area ();
       
        do
        {
       
        System.out.println("Elija una entrada");
        System.out.println("1.- Cuadrado");
        System.out.println("2.- Rectangulo");
        System.out.println("3.- Circulo");
        System.out.println("4.- Triangulo");
        System.out.println("5.- Elegir otra Figura");
        System.out.println("Seleccione :");
        Sel=entrada.nextInt();
       
        switch (Sel)
        {
        case 1 :
        System.out.println("Cuadrado");
        System.out.print("Introduce el valor del Lado " );
lado=entrada.nextInt();
System.out.println("El Area es : "+area.cuadrado(lado));
        break;
       
        case 2 :
        System.out.println("Rectangulo");
        System.out.print("Introduce el valor de la Altura :" );
l1=entrada.nextInt();
System.out.print("Introduce el valor de la Base :" );
l2=entrada.nextInt();
System.out.println("El Area es : "+area.rectangulo(l1,l2));
        break;        
       
        case 3 :
        System.out.println("Circulo");
        System.out.print("Introduce el valor del Radio" );
radio=entrada.nextInt();
System.out.println("El Area es : "+area.circulo(radio));
        break;
       
        case 4 :
        System.out.println("Triangulo");
        System.out.print("Introduce el valor dela  Altura " );
base=entrada.nextInt();
System.out.print("Introduce el valor de la Base " );
altura=entrada.nextInt();
System.out.println("El Area es : "+area.triangulo(base,altura));
        break;
       
        case 5 :
        System.out.println("¿Desea Elegir otra Figura?");
        // System.out.print("Introduce el valor dela  Altura " );
       
        break;
        default:
        System.out.print("Seleccion incorrecta"+"\n");
        }      

       
        }
       // while (Sel == 5);
//        System.out.print("Usted a Salido del Programa de Areas"+"\n" );
       
        while (Sel == 0);
        System.out.print("Usted a Salido del Programa de Areas"+"\n" );
       
    }
}

Programación de "Pilas" en JCreator

/**
 * @(#)Pilas.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/8
 */

import java.util.Scanner;

public class Pilas {
       
    /**
     * Creates a new instance of <code>Pilas</code>.
     */
    public Pilas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner ent = new Scanner (System.in);
        int opcion, n, cima=0;
        int [] pila;                              
       
        System.out.println("\n\nCantidad de elementos de la Pila :");  // Ingrese el tamaño de la pila
        n = ent.nextInt();
        pila = new int[n];  // pila es igual a la entrada del tamaño en "n"
        System.out.println("\n\n Pila creada con exito.....\n\n\n\n");
       
        do{
        System.out.println("\n\n\n");
        System.out.println("1.- PUSH");
        System.out.println("2.- POP");
        System.out.println("3.- PRESENTAR PILA");
        System.out.println("4.- LIMPIAR PILA");
        System.out.println("5.- TERMINAR");
        System.out.println("6.- TERMINAR");
       
        opcion = ent.nextInt();
       
        switch (opcion)
        {
        case 1: //push (pila);
        cima=push(pila, cima);
        break;
       
        case 2: //pop (pila);
        cima=pop(pila, cima);
        break;
       
        case 3: presentar (pila, cima);
        break;
       
        case 4: cima=0;
        System.out.println("Pila Vacia");
        break;
       
        case 5: break;
       
        default:
        System.out.println("Opcion equivocada");
       
       
        }         // cierra el switch
       
        }
        while(opcion != 5);         // cierra el do
    } // cierra el main
   
    public static int push(int [] p, int c)
    {
    Scanner ent = new Scanner(System.in);
    if(c<p.length)
    {
    c++; // (mas mas)incrementa en 1 el elemento
    System.out.print("Ingrese elemento"+c+" :");
    p[c-1]= ent.nextInt();
    }
   
    else
    {
    System.out.print("Elemento Pila ya esta hasta el Tope \nElimine un elemento o Salga");
    }
   
    return c;
    }
   
    public static int pop(int [] p, int c)
    {
    if(c !=0)
    {
    System.out.print("Se elimina el elemento"+c+" = "+p[c-1]);
    c--; // (menos menos) decrementa en 1 el elemento
    }
   
    else
    {
    System.out.print("Elemento Pila esta vacia \nSin Datos");
    }
   
    return c;
    }
   
    public static void  presentar (int [] p, int c)
    {
    if (c !=0)
    {
    System.out.println("Mostrando datos de Pila");
    for ( int i=c-1; i>=0; i--)
    {
    System.out.println("elemento"+i+": "+p[i]);
    }
   
    }
   
    else
    {
    System.out.println("PILA VACIA");
    }
    }
   
   
   
   
}

/* 1.- PUSH (ingresar datos a pila)
 * 2.- POP  (eliminar datos de pila)
 * 3.- PRESENTAR PILA
 * 4.- LIMPIAR PILA
 * 5.- SALIR
 *
 *
 * cima estara en el ultimo elemento del arreglo
 * cima es el apuntodor del arreglo
 *
 */

Metodo de la Burbuja con Arreglos

/**
 * @(#)ArregloOrdenado.java
 *
 *
 * @author Heryck Misael Muñoz Mora
 * @version 1.00 2014/4/5
 */

import java.util.Scanner;

public class ArregloOrdenado {
       
    /**
     * Creates a new instance of <code>ArregloOrdenado</code>.
     */
    public ArregloOrdenado() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n;
       
        int []x;
        Scanner entrada = new Scanner (System.in);
       
        System.out.println("Cual sera el tamaño del arreglo :");       //Se introduce el valor de n que sera el espacio del arreglo
        n = entrada.nextInt();
        x = new int [n];
       
        leerdatos (x);
        presentardatos(x);
        ordenardatos(x);
    }
    public static void leerdatos(int [] a)
      {
      Scanner entrada=new Scanner(System.in);
      for (int i=0;i<a.length;i++)
      {
      System.out.print("Ingresa el elemento a["+i+"]");
      a[i]=entrada.nextInt();
      }
    }
   
   
    public static void presentardatos (int [] a)
    {
      for (int i=0;i<a.length;i++)
      {
      System.out.println("los datos ingresados en a["+i+"]"+a[i]);
     
      }
}

public static void ordenardatos (int [] a)
    {
      int aux;
        for(int i=0;i<a.length-1;i++)
            for(int j=0;j<a.length-i-1;j++)                  
                    if(a[j+1]<a[j]) //condición que ordena los datos
                    {
                      aux=a[j+1];
                      a[j+1]=a[j];
                      a[j]=aux;
                    }
       
        for(int k=0; k<a.length; k++)       // Mostrar el arreglo ordenado
        System.out.print(a[k]+" ");
    }
   
}

// Gracias!!!