Universidad Carlos III de Madrid

Nota

Una clase abstracta es la que declara uno o más métodos abstractos cuya implementación se realiza en las clases derivadas. Repasa la teoría si no recuerdas este concepto.

Nota

Observa que se han declarado dos métodos abstractos que se implementarán en las clases derivadas correspondientes.

Solución

La solución se puede ver en el siguiente listado:

/** 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

	  

Solución

La solución con la clase abstracta (herencia) se puede ver en el siguiente listado:

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
	  

La solución con la interfaz se puede ver en el siguiente listado:

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