Universidad Carlos III de Madrid

Note

An abstract class is a class that declares one or more abstract methods whose implementation is done in the corresponding subclasses. Review the theory if you don't remember this concept.

Note

Notice that two methods have been declared as abstract, therefore they must be implemented in the corresponding subclasses.

Solution

The solution is included in the following listing:

/** Testing class */
public class MainEn {
  public static int MAX_FIGURES = 6;

  // Testing method
  public static void main(String args[]) {
    Figure figures[] = new Figure[MAX_FIGURES];

    // Objects are created
    figures[0] = new Queen(Figure.WHITE);
    figures[1] = new Castle(Figure.WHITE);
    figures[2] = new Castle(Figure.WHITE);
    figures[3] = new Queen(Figure.BLACK);
    figures[4] = new Castle(Figure.BLACK);
    figures[5] = new Castle(Figure.BLACK);

    // Go through the array with the use of references
    // to base class and polymorphism
    for (int i = 0; i < MAX_FIGURES; i++) {
      figures[i].whoAmI();
    }
  }
} // Main

	  

Solution

The solution using an abstract class (inheritance) is included in the following listing:

public abstract class Cypher {

  // Functions that define the encryption and decryption.
  abstract public String encrypt(String string);

  abstract public String decrypt(String string);

  /**
   * 
   * @param args
   *          [0] encrypt/decrypt
   * @param args
   *          [1] string to encrypt/decrypt
   */
  public static void main(String[] args) {
    if (args.length != 2) {
      System.out.println("Usage: java Cypher encrypt/decrypt [string]");
    } else {
      Cypher cc = new CaesarCypher();
      if (args[0].equals("encrypt")) {
        System.out.println(cc.encrypt(args[1]));
      } else if (args[0].equals("decrypt")) {
        System.out.println(cc.decrypt(args[1]));
      } else {
        System.out.println("Usage: java Cypher encrypt/decrypt [string]");
      }
    }
  } // main

} // Cypher

/**
 * Specific implementation for a cypher, which replace each plain-text letter
 * with a fixed number of places down the alphabet.
 * Simple version ignoring punctuation marks.
 */
class CaesarCypher extends Cypher {
  /** Number of places which are going to be used for the replacement */
  private static int CHARS_NUMBER_TO_SHIFT = 10;

  /**
   * Encrypts a string with the basic Caesar's cypher.
   * 
   * @param string
   *          String to encrypt
   * @return Encrypted String
   */
  public String encrypt(String string) {
      String encryptedString = "";
      for (int i = 0; i < string.length(); i++) {
	  char letter = string.charAt(i);
	  letter = (char) (letter + CHARS_NUMBER_TO_SHIFT);
	  if (letter > 'z') {
	      letter = (char) (letter - 'z' + 'a' -1);
	  }
	  
	  encryptedString += letter;
      }
      return encryptedString;
    
  } // encrypt

  /**
   * Decrypts a string with the basic Caesar's cypher.
   * 
   * @param string
   *          String to decrypt
   * @return Decrypted String
   */
   public String decrypt(String string) {
       String decryptedString = "";
       for (int i = 0; i < string.length(); i++) {
	   char letter = string.charAt(i);
	   letter = (char) (letter - CHARS_NUMBER_TO_SHIFT);
	   if (letter < 'a') {
	       letter = (char) (letter + 'z' - 'a' + 1);
	   }
	   
	   decryptedString += letter;
       }
       return decryptedString;
   } // decrypt
    

} // CaesarCypher
	  

The solution using the interface is included in the following listing:

public class Cypher {
  /**
   * 
   * @param args
   *          [0] encrypt/decrypt
   * @param args
   *          [1] string to encrypt/decrypt
   */
  public static void main(String[] args) {
    if (args.length != 2)
      System.out.println("Usage: java Cypher encrypt/decript [string]");
    else {
      Cryptable cc = new CaesarCypher();

      if (args[0].equals("encrypt")) {
        System.out.println(cc.encrypt(args[1]));
      } else if (args[0].equals("decrypt")) {
        System.out.println(cc.decrypt(args[1]));
      } else {
        System.out.println("Usage: java Cypher encrypt/decript [string]");
      }
    }
  } // main
} // Cifrado

// Set of methods that specify the possibility of encrypt and decrypt in the
// class that implements it.
interface Cryptable {
  public String encrypt(String string);

  public String decrypt(String string);
}

/**
 * Implementation for a cypher, which replace each plain-text letter with a
 * fixed number of places down the alphabet
 */
class CaesarCypher implements Cryptable {
  /** Number of places which are going to be used for the replacement */
  private static int CHARS_NUMBER_TO_SHIFT = 10;

  /**
   * Characters that can be used for the shift The characters ordering may be
   * changed in the array
   */
  private static char characters[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
      'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
      'w', 'x', 'y', 'z', '_', '-', '.', '#', '@', '&', '%', '/', '(', '(',
      '+', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', '0', '1',
      '2', '3', '4', '5', '6', '7', '8', '9', 'L', 'M', 'N', 'O', 'P', 'Q',
      'R', 'S', 'T', 'U', 'W', 'X', 'Y', 'Z' };

  /**
   * Given a character, this function returns its position in the array if it
   * exists, -1 otherwise
   * 
   * @param character
   * @return
   */
  private int searchCharPosition(char character) {
    int pos = -1;
    boolean found = false;

    int i = 0;
    while ((!found) && (i < characters.length)) {
      found = (characters[i] == character);
      i++;
    }
    if (found) {
      return (i - 1);
    } else {
      return pos;
    }
  } // searchCharPosition()

  /**
   * Replace the given character for the encryption.
   * 
   * @param character
   *          Char to replace
   * @return New (already replaced) character, which was CHARS_NUMBER_TO_SHIFT
   *         positions down the alphabet
   */
  private char encryptReplace(char character) {
    int pos = searchCharPosition(character);
    if (pos == -1) {
      return character;
    } else {
      int replacingCharPosition = 0;
      int newPosition = pos + CaesarCypher.CHARS_NUMBER_TO_SHIFT;
      if (newPosition <= characters.length - 1) {
        replacingCharPosition = newPosition;
      } else {
        replacingCharPosition = newPosition - characters.length;
      }

      return characters[replacingCharPosition];
    }

  } // encryptReplace()

  /**
   * Replace the given character for the decryption.
   * 
   * @param character
   *          Char to replace
   * @return New (already replaced) character, which was CHARS_NUMBER_TO_SHIFT
   *         positions up the alphabet
   */
  private char decryptReplace(char character) {
    int pos = searchCharPosition(character);
    if (pos == -1) {
      return character;
    } else {
      int replacingCharPosition = 0;
      int newPosition = pos - CaesarCypher.CHARS_NUMBER_TO_SHIFT;
      if (newPosition >= 0) {
        replacingCharPosition = newPosition;
      } else {
        replacingCharPosition = characters.length - Math.abs(newPosition);
      }
      return characters[replacingCharPosition];
    }
  } // decryptReplace()

  /**
   * Encrypts a string with the basic Caesar's cypher.
   * 
   * @param string
   *          String to encrypt
   * @return Encrypted String
   */
  public String encrypt(String string) {
    String encryptedString = "";
    for (int i = 0; i < string.length(); i++) {
      char letter = string.charAt(i);
      letter = encryptReplace(letter);
      encryptedString += letter;
    }
    return encryptedString;
  } // encrypt

  /**
   * Encrypts a string with the basic Caesar's cypher.
   * 
   * @param string
   *          String to decrypt
   * @return Decrypted String
   */
  public String decrypt(String string) {
    String decryptedString = "";
    for (int i = 0; i < string.length(); i++) {
      char letter = string.charAt(i);
      letter = decryptReplace(letter);
      decryptedString += letter;
    }
    return decryptedString;
  } // decrypt
} // CifradoCesar