Bueno, ya conociendo el algoritmo, se puede hacer en Java:

class converpostultima{
 public static void main (String args[])
  {

    String expr = new String("");
    String exprpost = new String("");
    char ch;
    int max;
    System.out.print("Dame la Expresion en Infijo: ");
    expr =Leer.dato();
    max=expr.length();
    operapilaschar obj1 = new operapilaschar(max);
    System.out.println();
    System.out.println();
    System.out.println("La Expresion en Postfijo es :");
    obj1.push('('); // inserta '(' a la PILA
    expr+=')'; // inserta ')' al final de Q
    for (int i=0;i=precedencia(ch) && obj1.pila[obj1.tope]!='('))
 	  	   {
 	  	    obj1.pop();
 	  	    exprpost+=obj1.dret;
 	  	   }
 	  	   obj1.push(ch);
                break;
 	case ')': while (obj1.pila[obj1.tope] != '(')
 	          {
 	  	    obj1.pop();
 	  	    exprpost+=obj1.dret;
 	  	  }
 	  	   obj1.pop();
 	  	  break;
 	  	  default : exprpost+=ch;
    } 	       	    	                     

  }
  while (!(obj1.pila_Vacia(obj1.tope)))
    {
      obj1.pop();
      if (obj1.dret!= '(')
      exprpost+=obj1.dret;
    }
  System.out.println(exprpost);
} 	

 public static int precedencia(char ch)
 {
 	int aux = 0;
 	switch (ch)
 	 {
 	 	case '^' : aux = 4;
 	 	           break;
 	 	case '*' : case '/' : aux = 3;
 	 	           break;
 	 	case '+' : case '-' : aux = 2;
 	 	           break;
 	 	case '(' : aux = 1;
 	 	           break;
 	 }
 	 return aux;
 }
}

Cabe aclarar que el código no lo hice yo, si no que me lo pasaron para entender el algoritmo.

Aquí esta la clase operapilaschar

class operapilaschar

  {

    public static char dret;

    public static int max;

    public static char pila[];

    public static int tope = -1;

    public operapilaschar()

      {

 	max=20;

 	pila=new char [max];

      }

    public operapilaschar(int n)

      { 

 	 max=n-1;

 	 pila = new char [max];

      } 	 	

 public static boolean pila_Llena(int tope,int max)

  {

  	 boolean llena;

  	 if (tope==max)

  	      llena=true;

  	    else

  	      llena=false;

  	 return llena;

  }	        

 public static boolean pila_Vacia(int tope)

  {

 	 boolean vacia;

 	 if (tope == -1)

 	    vacia=true;

 	   else

 	    vacia=false;

 	 return vacia;

  }

 public static void push(char dato)

 {

 	if(pila_Llena(tope,max))

 	  System.out.println("!Cuidado!, Desbordamiento!!!!!");

 	   else

 	     {

 	     	tope++;

 	     	pila[tope]=dato;// pone el nuevo dato en la pila

 	     }

 }	     	

public static void pop()

 {

 	if (pila_Vacia(tope))

 	   System.out.println("!Cuidado!, Subdesbordamiento!!!!!");

 	else {

 		  dret=pila[tope];

 	      tope--;

 	      }// actualiza tope y se elimina elemento en el tope

 }

public static boolean compara(int dret,int ch)

 {

	if (dret=='(' && ch==')' || dret=='{' && ch=='}' || dret=='[' && ch==']')

	  return true;

	  else 

	  return false;

 }

 public static void estado()

  {

  	int i;

  	System.out.println(" El estado de la pila es : ");

  	System.out.println(" --------------------------");

  	for(i=0;i<=tope;i++)

  	 {

  	 	System.out.println("pila["+i+"] : "+pila[i]);

  	 }

  }
}

Bueno, ya después del programa de pilas que puse hace poco (es el articulo pasado), sigue lo de pasar una expresión infija a posfija (luego pongo la de posfija a infija) que también se hace mediante pilas, pero en esta se hace manualmente (es decir, lápiz y papel). Aquí están los pasos (algoritmo) que hay que seguir:

ALGORITMO: POLACA(Q,P). Suponemos que Q es una expresión aritmética escrita en notación infija. Este algoritmo encuentra su expresión postfija P.

1.- Meter “(” en PILA y añadir “)” al final de Q.
2.- Examinar Q de izquierda a derecha y repetir los pasos 3 a 6 para cada elemento de Q hasta que la PILA esté vacía.
3.- Si se encuentra PARÉNTESIS IZQ., meterlo en PILA.
4.- Si se encuentra un OPERADOR entonces:
(a) Repetidamente sacar de PILA y añadir a P cada operador (de la cima de PILA) que tenga la misma precedencia o mayor que el operador.
(b) Añadir OPERADOR a PILA.
[FIN de condicional]
5.- Si se encuentra un PARÉNTESIS DER., entonces:
(a) Repetidamente sacar de PILA y añadir a P cada operador (de la cima de PILA) hasta que se encuentre un paréntesis izquierdo.
(b) Eliminar el PARÉNTESIS IZQ.(no añadir el paréntesis izquierdo a P).
[Fin de condicional]
6.- Si se encuentra un OPERANDO, añadirlo a P.

[Fin del Bucle]
7.- Salir.

Los operadores siguen la siguiente jerarquía (El de arriba es el que tiene mayor jerarquía hasta abajo el que tiene la menor):
^
* /
+ -
(

Ejemplo:

A+(X/Y)*B^C

Este es un ejemplo demasiado sencillo, pero explica los pasos a seguir, y como se puede ver en la ultima fila de la tabla esta el resultado.