Mini Project 7: Intro to Java and DNA Transcription!

The __init__ constructor takes a DNA sequence string comprised of nucleotide bases 'A', 'T', 'C', and 'G' and creates a new DNA class with that sequence, converting any lower-case bases to upper-case. If given a string with any characters that are not a valid nucleotide base (ignoring letter-casing), the method raises a ValueError with the error message Invalid DNA sequence. Must only contain ATCG bases. Otherwise, the upper-cased sequence string is saved as a single class attribute called seq.

Some examples are provided below:

These two methods provide the string representation of a DNA object and its length. Remember that __len__ is another special method (both __str__ and __len__ are commonly known as "dunder" or "magic" methods) that defines the length of an object when passed to len(...). A class defines a __len__ method with the same syntax as __str__ but returns an int instead of a str.

Some examples are provided below:

This method returns the complement sequence (as a str), which replaces all nucleotide bases with their complement base, maintaining original ordering.

count_occurrences takes a base single-character string and returns the number of times that character occurs in self.seq (ignoring letter-casing). If the given base character is not a valid nucleotide base (ignoring letter-casing), the method raises a ValueError with the message Invalid base..

This method which takes a single-character base string and returns the percentage of that base contained in the DNA sequence (a float between 0.0 and 1.0). A ValueError with the same error message described in the previous problem is raised if given an invalid base. Observe that the count_occurrences method is used to reduce redundancy, and the error-handling is left for that method to handle (it is poor practice to handle it the same way twice). Observe that no try/except is used in this class, since its methods only supporting raising possible errors to a client who passes invalid arguments.

[15]

To get you started with your first Java class, we have provided the empty constructor (and other method stubs) for you. Complete the DNA constructor to have behavior analogous to the constructor in DNA.py. The implementation will look different (Java-specific syntax, and differences in constructor syntax). but should still fundamentally create the same state for a DNA object.

Remember that whereas Python class constructors are defined with __init__(self, ...), Java class constructors are defined with the class name followed by any arguments (e.g. public DNA(String seq)). Remember that Java does not have a self argument for its methods. Whenever you want to refer to a Java object's state (fields or methods), you can refer to them with this.name syntax (replacing name with a defined field or method name in the class).

The DNA constructor in DNA.java should take a DNA sequence String comprised of nucleotide bases 'A', 'T', 'G', and 'T'. Just like the constructor in DNA.py, this constructor should also support lower-cased base characters, converting any such bases to an upper-cased base character (hint: use the s.toUpperCase() method supported for a String s).

If given a string with any characters that are not a valid nucleotide base (ignoring letter-casing), throw a new IllegalArgumentException with the error message Invalid DNA sequence. Must only contain ATCG bases. Observe the differences between the raise ValueError(...) and throw new InvalidArgumentException(...) statements in Python vs. Java. Both raise an exception that a client program is expected to handle, but Java uses the throw new <ExceptionType>(<args>) instead of Python's raise <ExceptionType>(<args>). This is all you really need to know for CS 1, but you should refer to the provided baseComplement method for an example of throwing this exception (your constructor's error message should match the one described here though). Just like in DNA.py, you should not use any try/catch in DNA.java (or mRNA.java). Any Javadoc comments should specify the raised ("thrown") error with the @throws annotation to indicate to the client that they are expected to handle any thrown error in their program.

In the Python implementation, you'll see a loop to check each character; in Java, you'll need to use char ch = s.charAt(index) to get a char in some String s at the passed index (an int). We use ch1 != ch2 in Java to test whether two chars are equal, which we cannot do the same way with the String type in Java. We have provided an example loop you can reference below:

int spaces = 0;
String hello = "Hello CS1 Students!";
for (int i = 0; i < hello.length(); i++) {
    char ch = hello.charAt(i);
    if (ch == ' ') { // remember to use ' quotes for chars in Java!
        spaces += 1; // spaces++ also does the same thing in Java
    }
}
System.out.println("There were " + spaces + " spaces found.");

After checking for a valid String argument, the single seq field should be set to the upper-cased sequence String. Remember that this.val = new_val; is the syntax in Java to update some field val defined in the Java class to a given value (e.g. this.seq = seq;).

For reference, our solution is about 8-10 non-trivial lines (ignoring comments/blank lines).

Some examples of the expected behavior for your constructor are provided below, using a DNAStudentTester.java program, which is simply a client program that has example calls for your methods (a different program than the DNAClient.java you'll finish to implement a full DNA to protein transcription) or the PartBTester.java which is a completed testing suite you'll test your solutions with after implementing them.

[5]

Next, you'll implement the two methods for the string representation of a DNA object and its length. Similar to how __str__ and __len__ are special Python methods to define the default string representation and length of the object, toString and size are analogous in Java.

Both methods should have the same behavior as __str__ and __len__ in DNA.py and neither takes any arguments. Each method body is also a 1-line solution.

[10]

Next, you'll implement the Java equivalent of the complement method defined in DNA.py. This method should have the same behavior, just in an analogous Java method.

You'll note that the DNA.py class could use a nucleotide basepair dictionary to more cleanly implement base_complement, but unfortunately you won't find this to be as easy in Java (and for the purposes of an exercise in clean porting, we've implemented it without a dictionary). You are welcome to ask El if you'd like to learn about dictionary equivalents in Java, but we encourage you to focus on the requirements of this assignment first :). Use the provided baseComplement method to build the complement String.

For reference, our solution is 5-6 non-trivial lines in the method body.

[5]

The mRNA constructor has behavior analogous to the constructor in DNA.java, but saves a sequence of RNA nucleotides instead (the field should still be called seq, and no other fields should be defined); you will need to declare the private field above the constructor, just as you see in DNA.java. Similar to DNA.java, an IllegalArgumentException should be thrown if given an invalid sequence (remember that mRNA is comprised of 'AUCG' not 'ATCG'). This solution should have the same number of lines as your DNA constructor.

[5]

These methods should behave similarly to the DNA analogs, only for mRNA. When documenting, make sure your Javadoc is updated accordingly (no reference to DNA should be in mRNA documentation).

[15]

In this method, you will implement the final step of DNA to polypeptide translation, which translates an mRNA sequence to a polypeptide chain. Since this is one of the longer methods in this assignment, we have included a series of TODOs in the starter code. If you've been reviewing the materials, working through this method shouldn't take more than 10-15 minutes. As always, make sure to remove the TODO comments in your final submission.

Finish mRNA's toPolypeptide method to process the mRNA's sequence, codon-by-codon. A codon is a special 3-character sequence which maps to an amino acid. Note that since there are 4 bases in mRNA, there are 64 possible codons, 1 of which is a special "start" codon ("AUG", which codes for Met, or "Methionine"), and 3 of which are stop codons (these do not correspond to an amino acid).

To help solve this method, we've provided a CodonMapper class, which is defined in CodonMapper.java. We've started the method with a mapper constructed for you to work with. This class provides functionality to return an amino acid given a codon string. Any codon strings passed to its methods are converted to upper-case to support case-insensitivity. You should not change CodonMapper.java, but here is a summary of its methods:

• CodonMapper mapper = new CodonMapper(): constructs a new CodonMapper called mapper
• mapper.getAA(codon): given a 3-character codon String, returns the abbreviated amino acid name (e.g. 'Met' for 'Methionine'). Note that if one of the three stop codons are passed, the string "Stp" is returned.
• mapper.isStopCodon(codon): a convenience method that returns true iff the passed codon is a stop codon.

You'll see an example use of this class when getting the first amino acid for the start codon (it is commented out, but you can uncomment it as you work through, and use it for reference when getting the other codon amino acids).

Note: Be careful with your indexing here; the result chain should ignore everything until the first start codon, and stop at either the first stop codon, or the last possible codon if none found. This means that your polypeptide will have window / 3 codons, where window is the length of the reading window, starting with the start codon and ending with the stop codon or last 3-character codon in the sequence. The rest of the sequence is ignored in the result. If no stop codon is found, the sequence should only contain the rest of the codons that are possible; so if there are 1-2 characters left after the last valid codon, those would be ignored.

If you've correctly implemented this method, you're ready to take an mRNA sequence and get the result chain of amino acids!

For reference, our solution is about 10-14 non-trivial lines (ignoring comments/blank lines) after the starter code.

[5]

This method should return a new mRNA constructed with the translated DNA sequence. Remember that DNA is translated to mRNA by first getting the complement DNA strand, and then replacing all 'T' bases with 'U'.

For full credit, use your DNA's complement method, and the s.replace(oldCh, newCh) String method which returns a new String replacing all instances of oldChar with newCh in some String s (remember to use the correct quotes for char's in Java!).

The method should return the result translated mRNA without changing the state of the DNA object the method is called on. For reference, our solution is 2-3 lines in the method body.