Object Oriented Programming Lesson One

Encapsulation is a big deal!

Important! Encapsulation means wrapping up together data and the functions that operate on that data into a single package, which we call "Objects".

As a first illustration, we consider an implementation in Java of the C++ struct Pos you all remember fondly from IC210/SI204. Recall that we are interested in row/column positions and being able to do things like step in some direction to change our position. If we translate this from C++ into Java in the same procedural way we've done so far, we end up with the two Java files Pos.java and PosFuncs.java as shown in the table below.

No encapsulation: data and functions separate		First step towards encapsulation

This is just a first step towards encapsulation, however, because although we've packaged the Pos data together in the same class as the functions that operate on Pos objects, another aspect of encapsulation is that we want to distinguish between methods (aka functions) that belong to the class Pos from methods that are better viewed as belonging to each instance of class Pos. So let's look at that ...

The mechansim: how instance methods (a.k.a. non-static member functions) work

First let's recall how instance data works. Imagine you have a class Point defined as follows:

public class Point
{
  public double x, y;
}

Point A = new Point();
Point B = new Point();
A.x = 10.0; ← which "x" changes? The x belonging to the A.  The x belonging to B is unchanged.
B.y = -1.5; ← which "y" changes? The y belonging to the B.  The y belonging to A is unchanged.
x = y + .2; ← ERROR!  The names "x" and "y" on their own have no meaning. You must specify which Point you are talking about.
	

A function defined without the modifier static, called an instance method, works the same way. If we add to the class Point like this

public class Point
{
  public double x, y;
  public void scale(double fact) {
    x *= fact;
    y *= fact;
  }
}

Point A = new Point();
A.x = 3.0;
A.y = -.5;

Point B = new Point();
B.x = 1.0;
b.y = 1.2;

A.scale(.5);  ← Which "x" is changed inside scale? The notation tells us that we are calling the
                scale() method belonging to A, so when we refer to x inside scale(), it means the x belonging to A.  So
                after this call, A's x and y are 1.5 and -.25.

B.scale(10);  ← Which "x" is changed inside scale? The notation tells us that we are calling the
                scale() method belonging to B, so when we refer to x inside scale(), it means the x belonging to B.  So
                after this call, B's x and y are 10 and 12.

A.scale(.5)

B.scale(.5)

Underneath the hood with instance methods

public void addToMe(Point B) { x += B.x; y += B.y; } same as public void addToMe(Point B) { this.x += B.x; this.y += B.y; }

So, to clarify, when we make a call to a non-static member function (instance method in Java parlance), the object we call with, i.e. the object before the ".", is implicitly an extra parameter named "this". Hopefully the illustration below clarifies things.

Point.java	call stack during call a.addToMe(b)

You are free to use the this reference in your code even if it is not needed. Sometimes you really need it, sometimes it just makes the code a bit easier to read.

Better encapsulation in the Pos class

• public static String toString(Pos p)
  Remember, instance methods "belong" to the instance. In this case, the Pos instance we want to turn into a String is the parameter p, and it makes sense to think of toString() belonging to p. So we rewrite as:

  public String toString() { ... }

  Which means that if A is a Pos object, then we call the method as A.toString().
• public static Pos read(Scanner sc)
  This method doesn't have any parameters of type Pos, which means we can't reasonably make it an instance method. The Pos object is created within the function, rather than existing prior to the function call.
• public static void step(Pos p, char dir)
  The whole purpose of this method is to modify Pos p, so it makes sense to make step an instance method belonging to the Pos instance we want to modify:

  public void step(char dir) { ...}

• public static int distance(Pos p, Pos q)
  This is a tricky call. We have two Pos parameters, either one of which could turn into "this". But there is no obvious concept of distance() belonging more to p than to q. So what to do? It is standard in cases in like this where there is no compelling reason to make a method static, but equally well no compelling reason to make the method an instance method to, default to making the method an instance method. We'll chose to turn p into "this":

  public int distance(Pos q)

No encapsulation: data and functions separate		First step towards encapsulation		Second step: use instance methods