Question

Security is an important feature of information systems. Often, text is encrypted before being sent, and then decrypted upon receipt. We want to build a class (or several classes) encapsulating the concept of encryption. You will need to test that class with a client program where the main method is located.

For this project, encrypting consists of translating each character into another character. For instance, if we consider the English alphabet, including characters a through z, each character is randomly encrypted into another, which could be the same character. (If you like, you can design your program so that no character is encrypted into itself.) To represent this concept, we can have an array of characters for the original alphabet, and another array of characters for the encrypted alphabet.

To encrypt a word, each letter in the word is replaced by the corresponding letter in the encryted alphabet. For example, the word caged would be encrypted into huzsa. To decrypt a word, the letters in the encrypted word are replaced by the corresponding letter in the original alphabet. For example, the encrypted word xssa would be decrypted as feed.

If we have 26 different characters in the original alphabet, then we will have 26 different characters in the encrypted alphabet. Furthermore, the encrypted alphabet should be randomly generated.

In your main method, you should prompt the user for a sentence. Your program should encrypt the sentence, output the encrypted sentence, then decrypt it, and output the decrypted sentence, which should be identical to the original sentence that was input by the user.

-------------------------------------------------------------------------------------------------------

To implement this program, you will have two classes: Cryptogram and Client.

Cryptogram class:

data members:

alphabet array: This is a character array that stores the letters of the alphabet- hard code the values

cryptCode array: This is a character array that stores the code of the replacement letters- just declare it. We will fill it with values in the constructor

Methods

1. Constructor

a. Set the size of the cryptCode array to the same size as alphabet array

b. Copy the contents of alphabet array into cryptCode array

c. Shuffle the letters in the array by moving backward in the array and randomly picking a letter and placing the letter at the end of the subarray

2. toString: Returns the alphabet and the cryptoCode with appropriate labels

3. findCode: Receives the character to encode and returns the index value of the substitution character or -1 if the parameter is not a letter. This method searches the alphabet array for the location of the character received and returns the location that the value was found in the array.

4. encrypt: Receives the phrase to encrypt and returns the encrypted phrase. This method will repeatedly call the findCode method for each letter of the phrase received until all letters of the phrase have been converted. Each time it calls the findCode, it will add to the encrypted phrase.

5. findLetter: Receives the character to decode and returns the index of the substitution character or -1 if the parameter is not a letter. This method searches the cryptoCode array for the location of the character received and returns the location in which it was found

6. decrypt: Receives the encrypted phrase and returns the decrypted phrase. This method will repeatedly call the findLetter method for each letter of the encrypted phrase until all letters of the phrase have been converted back to the original message.

CryptogramClient Class

1. Instantiate Cryptogram

2. Output the toString method of Cryptogram

3. Prompt and accept a phrase to encrypt.

4. Output the encrypted phrase.

5. Output the decrypted phrase.

Answer 1

Cryptogram class:

import java.util.Arrays;
import java.util.Random;

public class Cryptogram {
  
char[] alphabet = {'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'};
char[] cryptCode ;
  
//Constructor
Cryptogram()
{
//Set the size of the cryptCode array to the same size as alphabet array
cryptCode = new char[26];
Random r = new Random();
// Copy the contents of alphabet array into cryptCode array
for (int i = 0; i <26; i++)
cryptCode[i] = alphabet[i];

/*Shuffle the letters in the array by moving backward in the array and randomly picking a letter and placing the letter at the end of the subarray */
for (int i = 26-1; i > 0; i--) {

// Pick a random index from 0 to i
int j = r.nextInt(i);

// Swap cryptCode[i] with the element at random index
char temp = cryptCode[i];
cryptCode[i] = cryptCode[j];
cryptCode[j] = temp;
}

  
}
// toString: Returns the alphabet and the cryptoCode with appropriate labels
public String toString()
{
return "Alphabet: " + Arrays.toString(alphabet) + "\nCryptCode: " + Arrays.toString(cryptCode);
}
/*Receives the character to encode and returns the index value of the substitution character or -1 if the parameter is not a letter. This method searches the alphabet array for the location of the character received and returns the location that the value was found in the array. */
public int findCode(char c)
{
for (int i = 0; i <26; i++)
if(c == alphabet[i])
return i;

return -1;
}
/*Receives the phrase to encrypt and returns the encrypted phrase. This method will repeatedly call the findCode method for each letter of the phrase received until all letters of the phrase have been converted. Each time it calls the findCode, it will add to the encrypted phrase. */
public String encrypt(String phrase)
{
String enc_phrase = "";
for (int i = 0; i <phrase.length(); i++)
{   
int loc = findCode(phrase.charAt(i));
if(loc == -1)
enc_phrase += phrase.charAt(i);
else
enc_phrase += cryptCode[loc];
}
return enc_phrase;
}
/* Receives the character to decode and returns the index of the substitution character or -1 if the parameter is not a letter. This method searches the cryptoCode array for the location of the character received and returns the location in which it was found */
public int findLetter(char c)
{
for (int i = 0; i <26; i++)
if(c == cryptCode[i])
return i;

return -1;
}
/* Receives the encrypted phrase and returns the decrypted phrase. This method will repeatedly call the findLetter method for each letter of the encrypted phrase until all letters of the phrase have been converted back to the original message. */
public String decrypt(String enc_phrase)
{
String dec_phrase = "";
for (int i = 0; i <enc_phrase.length(); i++)
{  
int loc = findLetter(enc_phrase.charAt(i));
if(loc == -1)
dec_phrase += enc_phrase.charAt(i);
else
dec_phrase += alphabet[loc];
}
return dec_phrase;
}
}

CryptogramClient Class:

import java.util.Scanner;

public class CryptogramClient {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// Instantiate Cryptogram
Cryptogram c = new Cryptogram();
//Output the toString method of Cryptogram
System.out.println(c.toString());
//Prompt and accept a phrase to encrypt.
System.out.println(" Enter a senetence: ");
String phrase = sc.nextLine();
String enc = c.encrypt(phrase);
// Output the encrypted phrase.
System.out.println("Encrypted text: " + enc);
String dec = c.decrypt(enc);
//Output the decrypted phrase.
System.out.println("Decrypted text: " + dec);
}
  

OUTPUT: