Buenas a todos!!!
Hace dias q ue estoy tratando de resolver este problema y no le doy solucion aun es por eso q recurro aca!!!

mi problema es este   Pila1(3 elementos)+Pila2(5elementos)=PIla3(8elementos aca el detalle que me vote los elemntos ordenados en una tercera pila)
Mi codigo:
la parte combinar busque manera de hacerlo esa parte no sta bien q digamos.

package tad_pila;
 
 
/**
 *
 * @author Administrador//algoritmo 3.3
 * apilar = cuando almacenamos valores
 * lalalalalalala gracias
 * desapliar=cuando retiramos los valores
 */
public class TADPila{
 
    private int TOPE;
    private int MAX=10;
    private int [] Datos;
    private int bandera;
 
 
    //contructor
    public TADPila(){
        Datos= new int[MAX];//crear la pila
 
 
    }
 
    public boolean pilaVacia() {
        //throw new UnsupportedOperationException("Not supported yet.");
        if(TOPE==0)
            return true;
        else
            return false;
    }
 
    public boolean pilaLlena() {
        //throw new UnsupportedOperationException("Not supported yet.");
        if(TOPE==MAX)
            return true;
        else
            return false;
    }
 
    public void apilar(int dato) {
        //throw new UnsupportedOperationException("Not supported yet.");
        if(pilaLlena()){
            System.out.println("Desbordamiento..... Pila Llena:");
        }else{
            TOPE+=1;
            Datos[TOPE]=dato;
        }
    }
 
    public int desapilar() {
        //throw new UnsupportedOperationException("Not supported yet.");
        int dato=-999;
        if(pilaVacia()){
            System.out.println("Underflow.. Pila Vacia:");
        }else{
            dato= Datos[TOPE];
            TOPE-=1;
        }
        return dato;
 
    }
 
      public void escribirPila2 (TADPila pila)
      {
            int elem;
            if (!pila.pilaVacia ())
            {
 
                elem = pila.desapilar ();
                System.out.println(elem);
                escribirPila2 (pila);
                pila.apilar (elem);
            }
 
        }
      public void imprimirPila()
    {
 
            int dato=0;
 
        for(int i=TOPE; i>0;i--){
 
            dato= Datos[i];
            System.out.println(dato);
        }
 
    }
 
 
    public void combinar(TADPila p1,TADPila p2)
    {
 
        int f,t;
 
        for(int i=TOPE; i>0;i--){
 
 
        System.out.println(   f= p1.desapilar());
             System.out.println(   t= p2.desapilar());
 
             if(f<t)
                 p1.apilar(t);
             else if(t>t)
                 p1.apilar(t);
 
             System.out.println(p1);
 
 
        }
 
 
 
     }

Mi main donde llamo mis metodos

public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
       TADPila p1= new TADPila();
        TADPila p2= new TADPila();
        TADPila p3= new TADPila();
 
        p1.apilar(9);
        p1.apilar(1);
        p1.apilar(3);  //3
        p1.apilar(5); //1
        p1.apilar(-1);
        p2.apilar(2);
        p2.apilar(8);
        p2.apilar(77);
 
       p1.imprimirPila();
       p1.combinar(p1, p2);

Sí, lo cierto y verdad es que el código está algo mal. Por ejemplo el método escribirPila2 no se que utilidad podrías darle, ya que cada pila tiene su propio método imprimir 

Por otro lado el método combinar tienes varios fallos:

public void combinar(TADPila p1,TADPila p2)
{
        int f,t
        for(int i=TOPE; i>0;i--){
                System.out.println(   f= p1.desapilar());
                System.out.println(   t= p2.desapilar());
                if(f<t)
                     p1.apilar(t);
                 else if(t>t)
                     p1.apilar(t);
 
                  System.out.println(p1);
        }
}

Por un lado estás suponiendo que P1 y P2 van a tener el mismo TOPE que la pila con la que realizas la llamada, cosa que no es ni por asomo segura.

Yo lo que haría sería pasar tan solo un argumento, y combinar la pila con la que se realiza la llamada al método, y la pila que se pasa como parámetro. Dentro del método tendría que construir una nueva pila vacía, e ir llenandola con los elementos correspondientes, podría ser algo así:

public TADPila combinar(TADPila p1){
        TADPila resul = new TADPila();
        while(!p1.pilaVacia() && !pilaVacia()){
                int a, b;
                a = p1.desapilar();
                b = desapilar();
                if(a<b){
                        resul.apilar(a);
                        apilar(b);
                }
                else if(a>=b){
                        resul.apilar(b);
                        p1.apilar(a);
                }
        }
        //Aquí tendrías que comprobar si se han sacado todos los elementos de las dos pilas, si no, quedará alguna con elementos, los metes de golpe y ya está.
}

El método que te he puesto supone que la insercción de los elementos en cada pila se ha hecho en orden, es decir, antes de llamar al método combinar se han insertado elementos en ambas pilas y se ha hecho de forma ordenada (ascendente). Si no habría que hacerlo de otra forma.

Saludos.

Revisando tu codigo me di cuenta de que nunca inicias el int TOPE, no te da error esa variable?.

Si pero creo que eso depende de la versión de java que uses, y por eso no suele ser muy buena práctica dejarlo sin inicializar.