noam's blog.a.lish

spanish french italian german 1/10/2008 11:56:13 AM

Boxing, Shadowing, Overriding and Overloading

This is more of a reference post. I really like to ask object oriented programming questions when I do technical interviews mainly because I believe that the most basic, and probably the most important, concept of computer science is object oriented design and programming. I frequently like to ask the interviewee to model a league of their favorite sport (as a side note the most popular sports that have been modeled during this interview question are Cricket, Soccer, and Basketball...) and then take the model and refer to it (classes, interfaces, delegates etc.) in following questions.

You can easily take this question and expand it to fit almost anything you want to focus on. I like to work it into an exercise where the interviewee is building a game for EA Sports where they have to consume an EA webservice for online gaming. From there I go into serialization, soap, WSE and other fun stuff.

What I've found from doing this exercise for a couple of months now is that many engineers with over 2 years of experience have problems with collections (more specifically the System.Collections and System.Collections.Generic libraries). Most interviewees will choose an ArrayList to model a list of Players in a Team (this obviously applies to most sports, yes even tennis, think Davis Cup). The natural question that follows a design choice of an ArrayList is what happens when a consumer of your class decides to add a Referee or a Coach into your list of Players? How can you protect access to and from this collection? These questions either lead to an interesting discussion or to the following question: What is the underlying type of an ArrayList anyway? You'd be surprised how many 2+ year engineers have said String... yeah, sad.

Boxing

When you use an ArrayList (that is a collection of Object types, if you didn't already know that) you are using an Object (or reference type). So when you add a primitive (or value type) to your ArrayList like:

ArrayList players = new ArrayList();
int p1 = 12;
players.add(p1);

What actually happens behind the scenes? Since p1 is a primitive how is it stored on the heap? boxing, which means the primitive gets converted to an object. That's all it is. The opposite of boxing would be unboxing or the process of taking an object and converting it into a primitive (reference type to value type conversion).

Shadowing

Shadowing is an interesting concept in .NET because, unlike Java, C# methods aren't implicitly virtual. So if you create a base class (which isn't abstract) and you want to override methods in sub classes (child classes) you need to use the virtual keyword, but what happens when you don't have access to the base/super class? what happens when you MUST override a method that's not marked virtual? You can use the new keyword and use shadowing.
Override redefines an inherited method which is marked as virtual or abstract, and its access level must be the same as the method it overrides. New allows you to completely hide an inherited member and create a different implementation of it with whatever attributes you chooses. Shadowing is another name for disabling an inherited method and redefining it.

public class A  {
    public virtual string doStuff() {
         return "doing stuff in A";
    }

    public string doSomeOtherStuff() {
         return "doing some other stuff in A";
    }
}

public class B : A {
     // overriding
     public override string doStuff() {
         return "doing stuff in B";
    }

    // shadowing
     new public string doSomeOtherStuff() {
         return "doing some other stuff in B";
    }
}

public class test {
    public static void Main(string[] args) {
         A myA = new A();
         Console.WriteLine(myA.doStuff());  // will output "doing stuff in A"
         Console.WriteLine(myA.doSomeOtherStuff());  // will output "doing some other stuff in A"

         B myB = new B();
         Console.WriteLine(myB.doStuff());   // will output "doing stuff in B"
         Console.WriteLine(myB.doSomeOtherStuff());  // will output "doing some other stuff in B"

         A myAB = new B();
         Console.WriteLine(myAB.doSomeOtherStuff());  // will output "doing some other stuff in A"
    }
}

Overriding vs. Overloading

Overridng vs. Overloading seems to be a little problematic for some people, and it can get a little confusing when you're not in front of your IDE. So in general:

Overriding

Any time you have a class that inherits a method from a superclass, you have the opportunity to override the method (unless the method is marked sealed). The key benefit of overriding is the ability to define behavior that's specific to a particular subclass type.

Overloading

Overloaded methods let you reuse the same method name in a class, but with different arguments (and optionally, a different return type). Overloading a method often means you're being a little nicer to those who call your methods, because your code takes on the burden of coping with different argument types rather than forcing the caller to do conversions prior to invoking your method.

Since Java is virtual be default overloading vs. overriding can play tricks on you if you don't notice what's going on, but in C# it's a little simpler because you can easily tell overloading from overriding because of the virtual and override keywords:

public class Test {
 public static void Main(string[] args){
    Human h = new Noam();
    h.eat();  //this will print Noam class enjoying breakfast at cafe Hillel.
    h.eat("lunch");  //this is a call to an overload and is NOT legal
                     //you get a compile error:
                     //Test.cs(9,5): error CS1501: No overload for method 'eat' 
	             //takes '1' arguments
 }
}


class Human{
   public virtual void eat(){
        Console.WriteLine("Generic human eating");
   }
}
 
class Noam : Human{
   public override void eat(){               //notice the signature is identical to the super class
        Console.WriteLine("Noam class enjoying breakfast at cafe Hillel.");
  }

  //overload no keyword needed
  public void eat(string meal){
  	Console.WriteLine("Noam class enjoying " + meal + " at cafe Hillel.");
  }
}

Post View

noam's blog.a.lish

Boxing, Shadowing, Overriding and Overloading

Boxing

Shadowing

Overriding vs. Overloading

Overriding

Overloading

Search blog.a.lish

Step 1: Full Text Indexing

Step 2: Writing your SQL

Step 3: Writing your WebService

Step 4: Javascript and JSON

MIX 08 - Reviewed

Highs

Lows

My Favorite C# Features - Part 1: Generics

Introduction

Side Note

Favorite #1 - Generics

Short Comings

Array.ForEach on Primitives

Syndication .NET 3.5 Style

Post Your Comment

Thanks for contacting me. I will get back to you as soon as I can.

Latest blog entries.

Shared Items

YUI

shirt.woot.com

Powered by Reditus Catalog | YUI