Overloading vs. Overriding

Overload

Serendigity. “Overload” Online Image. Flickr. Octover 3, 2007. https://www.flickr.com/photos/maleny_steve/1473552769/

Overloading and overriding are two similar concepts -they both are about creating several methods with the same name- but very different when it comes to practical functionality and implementation.

Overloading (formally, static polymorphism) is resolved at compile time, and it is when the methods with the same name are declared in the same class, distinguished only by their signatures (the parameters of the method), so that the compiler knows which method overload you are calling based on the data type of the arguments you are passing.

Overriding (or overwriting, according to ken), is resolved at runtime and it is when you define a method that is already defined in a parent class. It can be resolved because of the data type of the “implicit first parameter” (aka, the object itself).

Java implementation

Overloading

overloading1

Overloading with different data types and number of parameters.

overloading2

Overloading with same data types and number of parameters, but different order.

overloading4

Overloading allow different return types.

overloadingerror1

The return type of the method is not considered when overloading.

Overriding

overriding4.png

In this example of overriding I have the Person abstract class, this class cannot be instantiated, but it provides like a “template” for its children classes. For example, the Person class has a String field “name”, because every person has a name, and a public method “talk” because all persons can talk (ok, almost all), this method prints “I’m a ” to the console, because, like I said, this is like a template, and different persons have different (very interesting) things to say. The method “getName” returns the name of the person. The constructor just takes the String name, although you can’t call this constructor directly, it can be called from its children classes.

It’s children classes are not abstract and extend (are children of) the Person class. They implicitly have “name”, a method “talk” and a method “getName”. Read the code of the Student and the Teacher classes and note how the constructors have a line “super(name)”, this is a call to the parent class constructor, and it will throw an error if it’s not there. Both the Student and the Teacher class Override the talk method, the notation @Override over the talk method just tells the compiler that you are overriding a method (no shit, Sherlock), it’s not required but you should use it to enforce proper overriding of a method. The talk() methods of Student and Teacher call the “super.talk” method (unlike the constructor, you can miss this statement here and there will be no errors), it prints “I’m a “, and then it prints something else. I also included an Overload of an Overriding method (mind blown) in the Student class to show the difference, it just prints “I love” + the argument (there is no call to super.talk()).

In the main method of the Person class I declare 2 persons, one teacher and other student, also, I declare a Student as a Student, this sound stupid but actually affects in the code. The preferred way is to declare the variable with the data type of the abstract class and instantiate it as the type that you actually want to use (Declared type on the left  and Actual type on the right so your code is not dependent from a specific implementation of an interface/abstract class. You can read more about this here. You can see that when the talk method is called from both the teacher and the student they print different things. Finally, to call the Overload method “talk(String food)” of “s” (with Declared type Person and Actual type Student) you have to implicitly cast it to Student and then call the method, like ((Student)s).talk(“tacos”), this is because this implementation is not declared in the Declared type of “s”. However, with “c” this does not happen, you can call that overload method because the Declared type of “c” is Student. Anyway, this is not considered a good OO practice, you should avoid writing methods that are not in the parent class, because there is a method specific to the Children class, and therefore making the code dependent from that class, and what you want is to make the code independent from specific implementations of the children classes (like explained in the previous stack overflow link).

11w1f1

tutu sparkles

#WSQ11-Library

And this is the most boring wsq that I have ever done!
Because all it asked of me was filling the blank methods with just some return statements in most cases.
The most interesting I did in this assignment was doing a for loop and throwing some exceptions.

So i entered the WSQ11 blog post in kenscourses and clicked the first link because I’m too lazy to read.
And the first thing I notice is that I don’t know what to do here, obviously, instead of go back and read the instructions I started doing the first assignment.
wut

After some dedication and hard work doing that thing about gravity I realized it was too stupid, so I deleted all the files, including System32.

So now I had the tough task of reading the instructions.
According to the English dictionary of Cambridge, the word “to” is pronounced as “tu”.
The instructions said that I should try to “tutu” the Library assignment.
tutu

All I did in the book class was add some fields, getters and setters.
part1

And in the Library class I just used the Book class to create the simulation of a library.
It also asked me to create a static method, I was so excited.
final

After that I kept reading and clicked on a link, and the first thing a saw was a big message saying “Buy my book!”, it was so gross that I had to leave the site.
buyMyBook

github

Project update #01

the team members are:

  • Hermes Espínola González
  • José Andrés Choza
  • Juan Salvador Fernández
  • Gerardo Cruz

The idea of the project is create a video game where the objective is fight in an arena.
Due to the fact that we don’t know anything about 3D modeling and animation, we will use creative commons assets from the unity asset store.
We have already implemented the movement of the character.

PlayerMovement

For the artificial intelligence we will be using a plugin for unity called RAIN. We are reading the documentation and trying to create our first AI character.

#WSQ09-TheMovies

See the assignment on github.

This assignment has been the hardest so far, I had to read a lot of documentation to complete this one.
I had to learn about these things:

  • About the Scanner class, for reading files and receiving input from the console.
  • About the Set interface and HashSet class, to use it like a dictionary in Python.
  • About the Map interface and HashMap class.
  • About how the String class operates and some methods.
  • About CharSequence, just because String is an implementation of CharSequence.
  • About handling Exceptions, for the file reading and the MovieQuery class.
  • And finally, a little bit about regular expressions, for reading the query.

So when I read the the document in the link of the assignment, it says that we need to do set operations, and I found this on stack overflow.
It turns out that I didn’t need to implement any of the code for set operations, just imported the Set interface and the HashSet class.

SetMethonds

 

The Set interface contains the methods addAll, retainAll and removeAll, which are equivalent to union, intersection and difference set operations, respectively. But the problem said: find the set of actors that the given movies don’t have in common. (or something by the way).
And so, this is equivalent to the difference of the union and the intersection of two sets. (A ∪ B) – (A ∩ B). And this is called the symmetric difference.

So I first created the Movie class and wrote several constructors supporting different data types, because why not. It has two fields, a String; representing the name of the movie, and a Set of Strings; representing the name of the actors. I wrote the methods for the operations I described above. It doesn’t makes much sense because it’s just returning the result of the call to the set methods, but at least I gave these methods a fancier name. But it makes sense in the getActorsNotInCommon method, because the symmetric difference is not implement in the Set interface. I also added getters and setters and bla bla bla.

Before using the File class I tested it.
throwMissing

But the code would not compile, and then, reading the docs of the File class, I realized I had to add “throws Exception” after the method parameters.
justAddthrows
And there are a lot of different implementations of the Exception interface.

In the MovieLibrary class I used a Scanner to read the file where are the actors and movies. And the constructor can throw a FileNotFoundException, and it has to, because the File class can, and so the code where it is used has to as well. The class has a field for storing the movie objects in a Map, using its name as the key, so the program has to store the name of the movie twice, and I though it was stupid, but I didn’t found a better way to do it, but now I’m wondering if it is possible to use something like a pointer to the variable inside the Movie object, to use it as the key of the HasMap, but whatever.

And the code for reading the file with the scanner:
usingScanner

In the constructor of the MovieLibrary two scanners are used, one for reading the lines of the file, and another one for reading that line and separate the actor and movies, and then instantiating a Movie object -only if the name was not already in the map- and then pushing it into that map.
This class use the methods of the Movie class in all the methods.
movieLib

And I tested what I had written up to this point, before moving into implementing the user input:
testsOfTheFinalCode

Then I was writing the main class, TheMovies, according to the description in the assignment (with the menus and option and shit). When I reached the part where says that I should ask the user for an input like: “movieName symbol moviewName”, I realized that it would be too much code, and it would be a mess with all the logic of user input, String processing and the use of the MovieLibrary class. So I decided to write another class.

In the MovieQuery class, given the description of the problem, I though I would need to use Regular Expressions somehow. I found this nice page to learn and test regular expressions.
I didn’t wanted for this class to be instantiated, and I was thinking of something like a “static class”, but it turns out there is no such thing, at least in the Java programming language, but you can simulate this behavior by adding some modifiers, like making the constructor private and some static methods and fields.
The class use a Scanner, with a regex delimiter like this: “( )|&^“. And what this is telling to the scanner is that it should identify a substring of that format, “()” means that the thing inside the parenthesis must appear in the string and the “[]” means that there must be any of the characters inside the braces. And by doing this, when I call the next() method of the scanner it returns the name of the first movie and calling next() again will return the second movie name.
When it finds the two name of the movies it searches for them in the MovieLibrary, and, if some of the movies is not there, throws an RuntimeException, because I don’t want neither keep executing the code nor return an empty Set.
It searches for which command is in the input, calls the appropriate method in the MovieLibrary instance and returns the result.
MovieQuery

And so the only thing the TheMovies class does is using the previous classes to ask and execute the user input.
TheMovies

And here’s the output produced by the command line.

output

#WSQ08-Yo Soy 196

This thing was really weird, I mean, it’s useless but it was interesting.
So a lychrel number is a special number, if the repetitive addition of a number with the number formed with inverse of its digits form a palindrome then it’s not a lychrel number.
So, in example: 196 + 691 = 887, 887 + 788 = 1575, … and so forth.

So here I first programmed the YoSoy186 class, before programming LychrelSequence and LychrelNumber, because I wanted to define how the class would work instead of programming it in the first place.
yosoy196

So because I needed to flip the digits of the numbers, I converted the number to a String. And because in this lynda Java course they said I should use the StringBuilder class to work with string, because it’s expensive to do the string operations with the normal String operators.

And then, in the Lychrel number class, I wrote a lot some fields, getters and setter then I wrote the above algorithm to evaluate if the number is a candidate to be a lychrel number:

public class LychrelNumber {
  private int value;
  private boolean isPalindromeNumber;
  private boolean isLychrel;
 
  public LychrelNumber() {
  }
 
  public LychrelNumber(int number) {
    setValue(number);
  }
 
  public boolean isLychrelNumber() {
    return this.isLychrel;
  }
 
  public boolean isPalindrome() {
    return this.isPalindromeNumber;
  }
 
  public int getValue() {
    return this.value;
  }
 
  private long[] evaluateHelper(long val) {
    StringBuilder reverseStr = (new StringBuilder(Long.
    toString(val))).reverse();
    long reverse = Long.parseLong(reverseStr.toString());
    long add = val + reverse;
    return new long[] {reverse, add};
  }
 
  private void evaluate(long value) {
    long[] r = this.evaluateHelper(value);
    String addStr = Long.toString(r[1]);
    this.isPalindromeNumber = (value == r[0]);
    if (!this.isPalindrome()) {
      for (int i = 0; i < 30; i++) {
        r = evaluateHelper(r[1]);
        addStr = Long.toString(r[1]);
        if (addStr.equals(new StringBuilder(addStr).reverse().toString())) {
          this.isLychrel = false;
          break;
        }
        this.isLychrel = true;
      }
    }
  }
 
  public void setValue(int number) {
    this.value = number;
    this.evaluate((long)this.value);
  }
}

In the code I wrote a private method, which is only called when the setter of the value is called, and another method to reverse and add these numbers. I used a long number because the repetitive addition of the numbers generated huge numbers and the program would run out of memory.

So first, before checking if the number is a lychrel number, I check if it is a palindrome, and then, if it is not, run the code to check if it is a lychrel number (because if it is a palindrome then it’s not a lychrel number). If at some point the addition of the number and the inverse of its digits is a palindrome, the code breaks and sets the isLychrel number variable to true.

For the LychrelNumber class, I used the ArrayList class to be able to append elements to the list, something you can’t do to a normal array easily. I used three lists, for storing the lychrel, non-lychrel, and palindrome sequences. The link says that since the List class is an Interface, you need to declare a specific implementation of this Interface.
All this class does is iterate from the lower bound to the upper bound, and instantiating the LychrelSequence class with that value, and if the number is a palindrome, it’s added to the palindromes list and the non-lychrel list, else, if the number is a lychrel number it is added to the lychrel list, but not all non-lychrel numbers are palindromes).

import java.util.List;
import java.util.ArrayList;
 
public class LychrelSequence {
  private int lower;
  private int upper;
  private List<Integer> lyqSeq;
  private List<Integer> nonLyqSeq;
  private List<Integer> palindromeSeq;
 
  public LychrelSequence(int lowerBound, int upperBound) {
    this.lower = lowerBound;
    this.upper = upperBound;
 
    this.lyqSeq = new ArrayList<>();
    this.nonLyqSeq = new ArrayList<>();
    this.palindromeSeq = new ArrayList<>();
 
    LychrelNumber ln = new LychrelNumber();
    for (int i = this.lower; i <= this.upper; i++) {
      ln.setValue(i);
      if (ln.isPalindrome()) {
        palindromeSeq.add(ln.getValue());
        nonLyqSeq.add(ln.getValue());
      } else if (ln.isLychrelNumber()) {
        lyqSeq.add(ln.getValue());
        System.out.println(“Found a Lychrel number candidate: ” + ln.getValue());
      } else {
        nonLyqSeq.add(ln.getValue());
      }
    }
  }
 
  public int getLowerBound() {
    return this.lower;
  }
 
  public int getUpperBound() {
    return this.upper;
  }
 
  public List<Integer> getPalindromeSequence() {
    return this.palindromeSeq;
  }
 
  public List<Integer> getLychrelSequence() {
    return this.lyqSeq;
  }
 
  public List<Integer> getNonLychrelSequece() {
    return this.nonLyqSeq;
  }
 
 
  public int getNumPalindromes() {
    return this.palindromeSeq.size();
  }
 
  public int getNumLychrels() {
    return this.lyqSeq.size();
  }
 
  public int getNumNonLychrels() {
    return this.nonLyqSeq.size();
  }
}

Something weird I noticed is that you have to use the Integer class when declaring the list, instead of the primitive type int.

onlyInteger

And the here’s the Github repository of this homework.

#WSQ07-Babylonian Square Root


First of all, the Babylonian square root is a Babylonian algorithm for calculating the Babylonian Square Root (duh…) of a given number, say n, but in a non conventional way. This algorithm consists of making a guess (i.e.: think of an approximate value to the actual square root), say g, then, you add g, to the ratio of the number and the guess, and divide that by 2.
So, this is:

Babylonian square root equation

And the result of this equation is the new guess.
We do this process several times and then the final guess is the result of the square root.

This is the class, without the method for calculating the square root.

Screenshot from 2016-02-04 12:14:39

So the algorithm says that we need to pick a near number to the actual square root. So I imported the Random class to pick some random number near the half of the number, because YOLO. Then I used that number as the first guess and executed the algorithm.

And here’s the final code.

finalwsq07

And the github repository.

#WSQ06 Greatest Common Divisor

I was not sure if I should write the GCD method by myself or if I could use an already implemented method.

Of course I read about The Euclidean GCD algorithm because I am too lazy to search it in the Tec library. And this is also interesting, the pseudo-code algorithm and a formal proof of correctness from proofwiki.

This recursive algorithm is basically a method for finding the greatest common divisor of two integers. So you take two integers a and b such that |a| > |b|, then you calculate the remainder, call it r, of a/b. Next, set a = b and b = r

And i was writing the GCD class, but then I told myself:

Why should I write this if someone else has already did?

And of course also because this class is about Object Oriented Programming and not about Algorithms, and also, that’s one of the big advantages of OOP, you can use someone else’s code without worrying if your code will be compatible with other persons’ code, because it should

And after all these philosophical thoughts I decided to keep it simple and just use the BigInteger java class I found here get gcd java and here Big Integer Class.

Screenshot from 2016-02-04 11:54:28

I also pushed it to GitHub here: WSQ06-GCD.

Screenshot from 2016-02-08 12:40:06