@@ -1,7 +1,7 @@
 Defining Classes in Java
 ========================
 
-You have already seen how to define classes in Java. Its unavoidable for
+You have already seen how to define classes in Java. It's unavoidable for
 even the simplest of programs. In this section we will look at how we
 define classes to create our own data types. Lets start by creating a
 fraction class to extend the set of numeric data types provided by our
@@ -25,20 +25,84 @@ language. The requirements for this new data type are as follows:
 Here is a mostly complete implementation of a Fraction class in Python
 that we will refer to throughout this section:
 
-.. literalinclude:: fraction.py
+.. activecode:: fraction
    :language: python
-   :linenos:
 
+   class Fraction:
+       def __init__(self, num, den):
+           """
+           :param num: The top of the fraction
+           :param den: The bottom of the fraction
+           """
+           self.num = num
+           self.den = den
+
+       def __repr__(self):
+           if self.num > self.den:
+               retWhole = int(self.num / self.den)
+               retNum = self.num - (retWhole * self.den)
+               return str(retWhole) + " " + str(retNum) + "/" + str(self.den)
+           else:
+               return str(self.num) + "/" + str(self.den)
+
+       def show(self):
+           print(self.num, "/", self.den)
+
+       def __add__(self, other):
+           # convert to a fraction
+           other = self.toFract(other)
+           newnum = self.num * other.den + self.den * other.num
+           newden = self.den * other.den
+           common = gcd(newnum, newden)
+           return Fraction(int(newnum / common), int(newden / common))
+
+       __radd__ = __add__
+
+       def __lt__(self, other):
+           num1 = self.num * other.den
+           num2 = self.den * other.num
+           return num1 < num2
+
+       def toFract(self, n):
+           if isinstance(n, int):
+               other = Fraction(n, 1)
+           elif isinstance(n, float):
+               wholePart = int(n)
+               fracPart = n - wholePart
+               # convert to 100ths???
+               fracNum = int(fracPart * 100)
+               newNum = wholePart * 100 + fracNum
+               other = Fraction(newNum, 100)
+           elif isinstance(n, Fraction):
+               other = n
+           else:
+               print("Error: cannot add a fraction to a ", type(n))
+               return None
+           return other
+
+
+   def gcd(m, n):
+       """
+       A helper function for Fraction
+       """
+       while m % n != 0:
+           oldm = m
+           oldn = n
+           m = oldn
+           n = oldm % oldn
+       return n
+
+   print(sorted([Fraction(5, 16), Fraction(3, 16), Fraction(1, 16) + 1]))
 
 The instance variables (data members) we will need for our fraction
 class are the numerator and denominator. Of course in Python we can add
 instance variables to a class at any time by simply assigning a value to
-``objectReferenc.variableName`` In Java all data members must be
+``objectReference.variableName``, whereas in Java all data members must be
 declared up front.
 
 The declarations of instance variables can come at the beginning of the
-class definition or the end. Cay Horstman, Author of the *Core Java*
-books puts the declarations at the end of the class. I like them at the
+class definition or the end. Cay Horstman, author of `the "Core Java"
+books <https://horstmann.com/corejava/index.html>`_ puts the declarations at the end of the class. I like them at the
 very beginning so you see the variables that are declared before you
 begin looking at the code that uses them. With that in mind the first
 part of the Fraction class definition is as follows:
@@ -52,8 +116,6 @@ part of the Fraction class definition is as follows:
     public class Fraction {
         private Integer numerator;
         private Integer denominator;
-
-
     }
 
 Notice that we have declared the numerator and denominator to be