Stack Simulation

[Shadowstyle]

Hey Leute

Ich habe hier etwas in Java geschrieben, was so ungefähr funktionieren soll wie ein Stack. Ich fange grade erst an, nicht so streng sein.
Vielleicht braucht es ja einer.
Einfacher Stack:

/**
 * Die Klasse Stack, dient dazu das Verhalten eines Stacks zu verdeutlichen.
 * @author (Shadowstyle) 
 * @version (1.0.0.2)
 */
public class Stack1
{
    private static final int defaultSize = 20; // Die Standart Größe, wenn man sich nicht entscheiden kann.
    private int freiPos = 0; //Die Freie Position, wo ein Wert draufgelegt wird.
    private int size; // Die Größe des Stacks. 
    private int[] data; //Der Stack.
    
     /**
     * Konstruktor für  den Standart Stack
     */
    public Stack1()
    {
           size = defaultSize;
           data = new int[size];
          
     }

    /**
     * Konstruktor für Stacks nach Wunsch.
     */
    public Stack1(int size)
    {
        this.size = (size < 0)?defaultSize:size;
        data = new int[this.size];
       
    }
    /**
     * Die Methode prüft, ob der Stapel leer ist. 
     */
    public boolean isEmpty()
    {
        return (freiPos == 0);
    }
    /**
     * Die Methode prüft, ob der Stapel voll ist.
     */
    public boolean isFull()
    {
        return (freiPos == size);
    }
    /**
     * Die Methode zeigt den letzten Wert, der auf dem Stack war.
     */
    public int top()
    {
        if (!isEmpty() )
            return (data[freiPos - 1] );
        else
            return (-1); // Vereinbarung, wenn der Stack leer ist.
        }
    /**
     * Mit der Methode, kann man ein Wert vom Stack nehmen.
     */    
    public void pop()
    {
        if (!isEmpty())
        {
         freiPos--;
         data[freiPos] = 0;
         }
        else 
           System.out.println("Der Stack ist leer, " + "der letzte Wert war " + top() + ".");
    }
    /**
     *Durch die Methode, wird ein Wert auf den Stack gelegt. 
     */
    public void push(int stapel_wert)
    {
        if (!isFull() )
        {
          data [freiPos] = stapel_wert;
          freiPos++;
        }
        else 
        System.out.println("Der Stack ist voll, " + "der letzte Wert war " + top() + ".");
    }
    /**
     * Diese Methode zeigt die akutelle Position im Stack.
     */
    public void zeige_Akutelle_Position()
    {
        System.out.println("Deine Akutelle Position im Stack ist " + (freiPos+1)) ;
    }
    
    /**
     * Hier wird aus einer bestimmten Position im Stack, der Wert ausgelesen.
     */
    public void call(int Position)
    {
        System.out.println("Der Wert der Position ist " + data[Position-1] + ".");
    }
    
    /**
     * Mit dieser Methode, werden an allen Positionen im Stack, die Werte ausgegeben
     */
    public void call_all()
      {
         for (int i = 0; i < freiPos; i++)
           {
             System.out.println("An Stelle " + (i+1) + " im Stack, ist der Wert " + data[i]+ ".");
           }
            
      }
}

Double-Stack:

/**
 * Die Klasse simmuliert einen Double Stack.
 * @author (Shadowstyle) 
 * @version (1.0.0.0)
 */
public class Double_Stack
{
    
    private static final int defaultSize = 20;
    private int[] data;
    private int size;
    private int freipos1 = 0;
    private int freipos2;
    
    
    public Double_Stack()
    {
        size = defaultSize;
        data = new int[defaultSize];
        freipos2 = size-1;
        
    }
    
    public Double_Stack(int size)
    {
        this.size = (size < 0)?defaultSize:size;
        data = new int[this.size];
        freipos2 = size-1;
    }
    
    public boolean isEmpty(int stacknumber)
    {
        
        if(stacknumber == 1)
        { 
            return(freipos1 == 0);
        }
        else if(stacknumber == 2)
        {
            return(freipos2 == size-1 );
        }
        return false;
     }
     
    public boolean isFull()
     {
        return (freipos1 > freipos2);
    }
    
    public int top(int stacknumber)
    {
        if(!isEmpty(stacknumber) && stacknumber == 1)
          {
             return (data[freipos1-1] );
            }
        else if(!isEmpty(stacknumber) && stacknumber == 2)
            {
              return (data[freipos2+1] );
            }
        return -1; //Vereinbarung, falls es nicht klappt.
    }
    
    public void push(int stacknumber, int stapel_wert)
    {
        if (!isFull() && stacknumber == 1 )
        {
            data [freipos1] = stapel_wert;
            freipos1++;
        }
        else if (!isFull() && stacknumber == 2 )
        {
            data [freipos2] = stapel_wert; 
            freipos2--;
        }
        else
         System.out.println("Falsche Stacknummer angegeben oder der Stack ist voll");
        }
        
     public void pop(int stacknumber)
    {
        if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            freipos1--;
            
        }
        else if (!isEmpty(stacknumber) && stacknumber == 2)
        {
            freipos2++;
          
        }
        else 
            System.out.println("Falsche Stacknummer angegeben oder der Stack ist leer");
    }
   
    public int groesse(int stacknumber)
    {
       if (stacknumber == 1)
       {
           return freipos1;
        }
       else if (stacknumber == 2)
       {
           return size-1-freipos2;
        }
       return -1; // Vereinbarung, falls kein Ergebnis kommt.
    }

    public void zeigeInhalt(int stacknumber)
    {
        if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            for (int i = 0; i < freipos1; i++)
            {
             System.out.println("An Stelle" + (i+1) + "ist der Wert " + data[i]+ ".");
            }
        }
            else if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            for (int a = 0; a < freipos2; a--) 
            System.out.println("An Stelle" + (a+1) + "ist der Wert " + data[a]+ ".");
        }
        else 
            System.out.println("Der Stack ist Leer");
   }
}