Field overriding Java vs Scala

Inheritance is one of the foundations of object-oriented programming, it sounds straight forward on paper, but when it comes down the specifics, the rules are subtly different from language to language, and I will compare and demonstrate the subtlety with field overriding in Java and Scala.

Java way

Consider this example for field overriding in Java.

public class Parent {
    protected static String name = "parent";
    public String getName() {
        return this.myName();
    }
}

public class Child extends Parent {
    final static String name = "child";
}

public static void Main(final String[] args) {
    final Parent parent = new Parent();
    final Child child = new Child();

    parent.getName(); // "parent"
    child.getName(); // "parent"
}

If you know Java, it's probably not hard to tell both "getName" results are "parent", and there is a legitimate reason for that, in Java, fields cannot be overridden, but can be "shadowed" in subclasses.

To expand on that, if the subclass has defined a field in the same name as in superclass, the field will hide the one in the superclass, but not overriding it. If the method in superclass is called by an instance of a subclass, the method will access the field in the superclass, instead of the one in the subclass.

So how can the field value be overridden? The answer is through method overriding.
public class Parent {
    protected String myName() {
        return "parent";
    }

    public String getName() {
        return this.myName();
    }
}

public class Child extends Parent {
    @Override
    protected String myName() {
        return "child";
    }
}

Scala way

This shouldn't be a surprise if you have been doing classic Java for some time, but I have to admit I was caught by this today, and I guilty as charged, because I have got quite a few years of Scala experience in my bag, and obviously the rules are a little different: both methods and fields can be overridden in Scala.
class Parent {
  protected val name = "parent"

  def getName: String = name
}

class Child extends Parent {
  override final val name = "child"
}

(new Parent).getName // "parent"
(new Child).getName // "child"
It should be obvious that the "getName" results are respective to whichever class it's called from. And it would be fair to say there are a few rules on Scala filed overriding you should be aware as well:

  • use the override keyword to specify the field to be overridden
  • only immutable fields can be overridden, i.e. only fields specified with val
  • mutable fields can NOT be overridden, i.e. fields specified with var
  • immutable fields can NOT be overridden by mutable fields
If you can't remember these rules, don't worry, compiler will tell you when you've done something wired.

Comments

Post a Comment

Popular posts from this blog

How to: Add Watermark to PDFs Programmatically using iTextSharp

Being able to add text or image watermark to PDF files is one of those handy things you can archive via program. The only library required for the little program is iTextSharp . For those who haven't used it yet, iTextSharp is a C# version of iText , which allows you to generate or manipulate PDFs. So let's cut the chitchat, and go straight to the code. By calling 'AddTextWatermark' or 'AddImageWatermark' function with required parameters supplied, you are ready to rock! public void CreateTemplate(string watermarkText, string targetFileName){     var document = new Document();     var pdfWriter = PdfWriter.GetInstance(document, new FileStream(targetFileName, FileMode.Create));     var font = new Font(Font.FontFamily.HELVETICA, 60, Font.NORMAL, BaseColor.LIGHT_GRAY);     document.Open();     // Specify font and alignment of text watermark     ColumnText.ShowTextAligned(pdfWriter.DirectContent, Element.ALIGN_CENTER, new ...
Read more

A practical guide to Scala Traits

Trait - has a super class of AnyRef   - uses extends  or with for inheriting a trait ( with to inherit multiple traits)   - defines a type   - can be overridden using override  keyword   Trait vs Interface (Java)   - trait can declare fields and main state   - rich vs thin interfaces (every concrete method added to trait makes it richer)   Trait vs Class   - trait can NOT have any class parameters        trait doesn't support coding in this style: class Point(x: Int, y: Int) - super calls are statically bound in classes, but dynamically bound in trait         super.toString  is predicable in classes, but not in trait when mixing   Ordered Trait   Traits as stackable modifications   - order of mixins: right most trait takes effect first   When to use Trait?   - If the behaviour will not be reused, then make it a concrete class   - If it might be reused in multip...
Read more

A Short Guide to AWK

AWK is built to process column-oriented text data, such as tables. In which a file is considered to consist of N records (rows) by M fields (columns) Basic # awk < file ‘{print $2}’ # awk ‘{print $2}’ file file = input file print $2 = 2nd field of the line, awk has whitespace as the default delimiter Delimiter # awk -F: ‘{print $2}’ file -F: = use ‘:’ as delimiter # awk -F ‘[:;]’ ‘{print $2}’ file -F ‘[:;]’ = use multiple delimiter, and parse using EITHER ‘:’ OR ‘;’ # awk -F ‘:;’ ‘{print $2}’ file   -F ‘:;’ = use multiple delimiter, and parse using ':;’ as THE delimiter # awk -F ‘:’+ ‘{print $2}’ file   -F ‘:’+ = use multiple delimiter, to match any number ':' Arithmetic # echo 5 4 | awk '{print $1 + $2}' output is '9', the result of ‘+’ (works as addition) # echo 5 4 | awk '{print $1 $2}' output is '54', to get string concatenation #  echo 5 4 | awk '{print $1, $2}' output is '5 4',...
Read more