Is this a good or bad implementation?

Question

My teacher had us implement a class that does the following:
1) Takes a string and shifts all characters forwards or backwards through an array.
2) Reverses all characters.
3) Reverses all words
4) Returns the encrypted string.
The way I decided to implement it is by create a class StringProcessor that does all of that.
I made all the methods in it private and had a constructor that takes an integer and a string as arguments. The constructor then runs each of the private methods in order to process the string. It has one public query that just returns the finished string. I also stuck a private inner class CharacterArray that basically matches each character in the string with a character in the array and then shifts it the appropriate amount. (by shift I mean a shift of one would mean "a" goes to "b").
The other two classes I made are called StringEncrypter and StringDecrypter. They don't have a constructer, but simply pass the string (with the appropriate changes made to it) to the StringProcessor's constructor.
What I'm not so sure about is if I was right in making those methods private and letting the constructor handle it. My thinking was that it would keep outside classes from knowing what that method is doing and it would leave the processing of that string entirely up to the constructor, which would eliminate a client from messing something up in the processing.
Any advice is appreciated. I will include code if anyone wants to see what I'm babbling about.
Thanks

Answer 1

package stringEncryption;
import myContainers.Queues.*;
import myContainers.Stacks.*;
* This class models a StringProcessor.
* A StringProcessor's job is to
* take a string (supplied by client
* as argument) and split it into
* words. Each of the word's letters are then
* shifted from -5 < 0 < 5 in a character
* array. As each letter is shifted, it is
* added to a stack. Once the word has
* been processed completely, the letters are
* "popped" back out into a string. The result
* is a word whose's letters are shifted
* and whose letters are in reverse order.
* For example,
*   The word "At" with a shift of -1 would give
* the letters "zs" after being shifted.
* Once shifted, the letters would be added to a stack
* and the new finished result would be "sz".
*   This is repeated for every word in the string.
* After all words have been processed, they are put
* into a Stack where they come out in reverse order.
* I chose to make almost all methods private for two
* reasons.
* 1) The methods need to be performed in order, which
* I think is done easily by calling the methods
* in the constructor. That way a user can't make a mistake
* when encrypting/decrypting.
* 2) Seeing as the point of the assignment is to encrypt and
* decrypt a string I feel that the methods should be somewhat
* guarded from outside programs.
public class StringProcessor{
   * Creates a new StringProcessor, shifts
   * and reverses all A to Z and a to z characters,
   * and reverses all words of the sentence.
   * Require:
   *     -5 < shift < 5
   *     string != null
  public StringProcessor(int shift, String string){
    this.stringStack = new StackImplementation<String>();
    this.stringStack.setStackType(1);
    charShift = new CharacterShifter(shift);
    breakString(string);
    while(!this.queue.isEmpty()){
      shiftChars(this.queue.front());
      this.queue.remove();
    assembleString();
   * Return the finished string.
  public String finishedString(){
    return this.completedString;
   * Split the string into tokens
   * and insert each word into a Queue.
   * Require:
   *     string != null
   * Ensure:
   *     !queue.isEmpty()
  private void breakString(String string){
    this.queue = new QueueImplementation<String>();
    this.queue.setQueueType(1);// Creates a LinkedQueue
    int i = 0;
    int j = 0;
    while(j < string.length()){
      if((string.charAt(j) == ' ') ||
         (string.charAt(j) == ',') ||
         (string.charAt(j) == ';') ||
         (string.charAt(j) == '.')){
        this.queue.append(string.substring(i, j) + string.charAt(j));
        j = j + 1;
        i = j;
      else
        j = j + 1;
   * This method takes a string
   * and shifts each character of the
   * string. After each character is
   * shifted, the characters is
   * placed into a DynamicStack
   * and "popped" back out.
   * The result is a word whose
   * letters have been shifted and
   * whose letters are now in reverse
   * order.
   * Require:
   *     string != null
   * Ensure:
   *     if(string.startsWith("x") && string.endsWith("y")
   *        charShift.shift(string.startsWith("y") && string.endsWith("x"))
  private void shiftChars(String string){
    Stack<Character> charStack = new StackImplementation<Character>();
    charStack.setStackType(1);
    char[] charArray = string.toCharArray();
    int i = 0;
    while(i < charArray.length - 1){//length - 1 was chosen because
                                    //the last character is always
                                    //a " " or "," or ";" or "."
                                    // and should never be shifted.
      charStack.push(charShift.shift(charArray));
i = i + 1;
String s = "";
while(!charStack.isEmpty()){
s = s + charStack.top();
charStack.pop();
s = s + charArray[charArray.length - 1];//adds the last (unshifted)
//character to the end of
//the string.
this.stringStack.push(s);
* This method assembles the
* string stored in a stack.
* Ensure:
* !completedString.isEmpty()
private void assembleString(){
this.completedString = "";
while(!this.stringStack.isEmpty()){
completedString = completedString + this.stringStack.top();
this.stringStack.pop();
private CharacterShifter charShift;
private Queue<String> queue;
private Stack<String> stringStack;
private String completedString;
* This class takes a character (supplied
* by a client) and shifts it the appropriate
* number of spaces through the alphabet.
* The number of spaces each character is shifted
* by is supplied by the client upon creation of
* this class.
* For example, "A" with a shift of 3
* would become "D". and "a" with a shift of -3
* would become "X".
private class CharacterShifter{
* The client supplies the amount it would like
* each character to be shifted by as an argument.
* A new character array is created using the letters
* A to Z and a to z.
* Require:
* amount != null
* Ensure:
* charArray[52] = "a" to "z" && "A" to "Z"
public CharacterShifter(int amount){
this.charArray =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
this.shiftAmount = amount;
* Shift this character by the specified amount.
* Require:
* char c != null
* Ensure:
* if(c == charArray[i])
* c = charArray[i + shiftAmount]
public char shift(char c){
int i = 0;
while (i < charArray.length){
if (charArray[i] == c){
if(i + shiftAmount > 51)
i = i - 52;
if(i + shiftAmount < 0)
i = i + 52;
c = charArray[i + shiftAmount];
i = charArray.length;
else
i = i + 1;
return c;
private char[] charArray;
private int shiftAmount;