Trouble understanding type casting and interfaces from Java Data Structures course

I'm having a lot of trouble understanding how to use type casting and when to use it. In the java data structures course, we went over it and it seems to me that basically you change a class to hold not only its own methods and fields, but also the ones of a parent or child class. Is this correct? I am wondering if someone can explain in the most simple terms how some of my code works? I am going to past some of the code written from Java Data Structures course focusing on type casting and interfaces when writing the "Treet" program. I'm wondering if anyone can kind of go through what I paste if they did those courses? Any help is much appreciated!

@Override
  public int compareTo(Object obj) {
    Treet other = (Treet) obj;
    if (equals(other)) {
      return 0;
    }
    int dateCmp = mCreationDate.compareTo(other.mCreationDate);
    if (dateCmp == 0) {
      return mDescription.compareTo(other.mDescription);
    }
    return dateCmp;
  }

and we use this code to help sort our Treets by their creation date using:

    Treet[] treets = {secondTreet, treet};
    Arrays.sort(treets);
    for (Treet exampleTreet : treets) {
     System.out.println(exampleTreet);

So in here I know we are first overriding the .compareTo method that is in the Object class because it compares just letters or numbers or whatnot. So in this method we are making a new way to compare by using @Override to compare the creation date, correct?

After that, we start our method that creates an integer object from the "Object" class called "obj". We are going to compare things within this method to obj, correct? In the method we declare a new instance of Treet called "other" which we type cast obj as well to the Treet class. This is where I get confused. Is other taking methods from obj? Or is obj now becoming a part of the Treet class so we can use those methods on it?

The next lines are just comparing 'obj' to 'other'. I have no idea how they compare them because we don't compare their creation dates here! It literally just states to compare them, so I'm guessing the "Treets" would have to be identical in what they say (hopefully people reading this have done the course so they know what I mean). After that, we create a new variable 'dateCmp' which will store the .compareTo's output (-1, 0, or 1) after comparing the creation date to 'other''s creation date. How come we compare the private variable mCreationDate to 'other''s creation date? When does 'other' even receive a creation date if it is not defined anywhere else in our code?

Anyways, moving on, I would love if someone can explain this whole part of the code to me. When I type it out it seems so jumbled and makes no sense.

The other part of the code also confuses me since it is in the Example.java file and part of the Example class. I never mentions running the compareTo code so I'm not sure how it knows to output the Treets in order of their creation date. How does this happen! Java is so confusing, someone help me! For reference, I will post the entire code at the end of this post. Sorry for its length!

Example.java code:

import java.util.Arrays;
import java.util.Date;

import com.teamtreehouse.Treet;

public class Example {

  public static void main(String[] args) {
    Treet treet = new Treet(
                            "arthurpodkowiak",
                            "Want to be famous?",
                            new Date(1421849732000L)
                           );
    Treet secondTreet = new Treet(
    "journeytocode",
      "@treehouse makes learning Java sooooo fun! #treet",
      new Date(1421878747000L)
    );
    System.out.printf("This is a new Treet:  %s %n", treet);
    System.out.println("The words are:");
    for (String word: treet.getWords()) {
      System.out.println(word);
    }
    Treet[] treets = {secondTreet, treet};
    Arrays.sort(treets);
    for (Treet exampleTreet : treets) {
     System.out.println(exampleTreet);
    }
  } 
}

Treet.java code:

package com.teamtreehouse;

import java.util.Date;

public class Treet implements Comparable {

  private String mAuthor;
  private String mDescription;
  private Date mCreationDate;

  public Treet(String author, String description, Date creationDate) {
    mAuthor = author;
    mDescription = description;
    mCreationDate = creationDate;
  }

  @Override
  public String toString() {
    return String.format("Treet:  \"%s\" by %s on %s",
                         mDescription, mAuthor, mCreationDate); 
  }

  @Override
  public int compareTo(Object obj) {
    Treet other = (Treet) obj;
    if (equals(other)) {
      return 0;
    }
    int dateCmp = mCreationDate.compareTo(other.mCreationDate);
    if (dateCmp == 0) {
      return mDescription.compareTo(other.mDescription);
    }
    return dateCmp;
  }

  public String getAuthor() {
    return mAuthor; 
  }

  public String getDescription() {
    return mDescription; 
  }

  public Date getCreationDate() {
    return mCreationDate; 
  }

  public String[] getWords() {
    return mDescription.toLowerCase().split("[^\\w#@']"); 
  }

}

Edit: I just looked at the code again and do realize that we can use compareTo because we implemented the Comparables into Treet class. Does this mean that every treet instance created will undergo any Comparables code automatically? how does the Example code know how to sort what was compared? We don't tell it to sort by creation date, we're just comparing in the Treet class so I don't understand how it can work. Also, since we are comparing two instances of Treets, will it compare multiple ones? Do they all go through the process every time a Treet is created? I'm guessing no since our array for Treets only spans 2 lengths so it only compares how many we have in there, correct?