Week 2 [Mon, Aug 18th] - Topics

Object-Oriented Programming (OOP) is a programming paradigm. A programming paradigm guides programmers to analyze programming problems, and structure programming solutions, in a specific way.

Programming languages have traditionally divided the world into two parts—data and operations on data. Data is static and immutable, except as the operations may change it. The procedures and functions that operate on data have no lasting state of their own; they’re useful only in their ability to affect data.

This division is, of course, grounded in the way computers work, so it’s not one that you can easily ignore or push aside. Like the equally pervasive distinctions between matter and energy and between nouns and verbs, it forms the background against which you work. At some point, all programmers—even object-oriented programmers—must lay out the data structures that their programs will use and define the functions that will act on the data.

With a procedural programming language like C, that’s about all there is to it. The language may offer various kinds of support for organizing data and functions, but it won’t divide the world any differently. Functions and data structures are the basic elements of design.

Object-oriented programming doesn’t so much dispute this view of the world as restructure it at a higher level. It groups operations and data into modular units called objects and lets you combine objects into structured networks to form a complete program. In an object-oriented programming language, objects and object interactions are the basic elements of design.

_{-- Object-Oriented Programming with Objective-C, Apple}

Some other examples of programming paradigms are:

Some programming languages support multiple paradigms.

An object in Object-Oriented Programming (OOP) has state and behavior, similar to objects in the real world.

Every object has both state (data) and behavior (operations on data). In that, they’re not much different from ordinary physical objects. It’s easy to see how a mechanical device, such as a pocket watch or a piano, embodies both state and behavior. But almost anything that’s designed to do a job does, too. Even simple things with no moving parts such as an ordinary bottle combine state (how full the bottle is, whether or not it’s open, how warm its contents are) with behavior (the ability to dispense its contents at various flow rates, to be opened or closed, to withstand high or low temperatures).

It’s this resemblance to real things that gives objects much of their power and appeal. They can not only model components of real systems, but equally as well fulfill assigned roles as components in software systems.

_{-- Object-Oriented Programming with Objective-C, Apple}

OOP views the world as a network of interacting objects.

OOP solutions try to create a similar object network inside the computer’s memory – a sort of virtual simulation of the corresponding real world scenario – so that a similar result can be achieved programmatically.

OOP does not demand that the virtual world object network follow the real world exactly.

Every object has both state (data) and behavior (operations on data).

Every object has an interface and an implementation.

Every real world object has,

• an interface through which other objects can interact with it, and,
• an implementation that supports the interface but may not be accessible to the other object.

Similarly, every object in the virtual world has an interface and an implementation.

Objects interact by sending messages. Both real world and virtual world object interactions can be viewed as objects sending messages to each other. The message can result in the sender object receiving a response and/or the receiver object’s state being changed. Furthermore, the result can vary based on which object received the message, even if the message is identical (see rows 1 and 2 in the example below).

The concept of Objects in OOP is an abstraction mechanism because it allows us to abstract away the lower level details and work with bigger granularity entities i.e., ignore details of data formats and the method implementation details and work at the level of objects.

Encapsulation protects an implementation from unintended actions and from inadvertent access.
_{-- Object-Oriented Programming with Objective-C, Apple}

An object is an encapsulation of some data and related behavior in terms of two aspects:

1. The packaging aspect: An object packages data and related behavior together into one self-contained unit.

2. The information hiding aspect: The data in an object is hidden from the outside world and are only accessible using the object's interface.

Writing an OOP program is essentially writing instructions that the computer will use to,

1. create the virtual world of the object network, and
2. provide it the inputs to produce the outcome you want.

A class contains instructions for creating a specific kind of objects. It turns out sometimes multiple objects keep the same type of data and have the same behavior because they are of the same kind. Instructions for creating a 'kind' (or ‘class’) of objects can be done once and those same instructions can be used to objects of that kind. We call such instructions a Class.

Java is an "object-oriented" language, which means that it uses objects to represent data and provide methods related to them. Object types are called classes e.g., you can use String objects in Java and those objects belong to the String class.

importing

import java.awt.Point;

public class Main{
    public static void main(String[] args) {
        Point spot = new Point(3, 4);
        int x = spot.x;
        System.out.println(x);
   }
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

new operator

Point spot = new Point(3, 4);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Variables that belong to an object are called attributes (or fields).

To access an attribute of an object, Java uses dot notation.

Point spot = new Point(3, 4);
int sum = spot.x * spot.x + spot.y * spot.y;
System.out.println(spot.x + ", " + spot.y + ", " + sum);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

3, 4, 25

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

You can an object by assigning a different value to its attributes.

Point spot = new Point(3, 4);
spot.x = 5;
System.out.println(spot.x + ", " + spot.y);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

5, 4

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Java uses the dot notation to invoke methods on an object too.

Point spot = new Point(3, 4);
System.out.println(spot.x + ", " + spot.y);
spot.translate(5,5);
System.out.println(spot.x + ", " + spot.y);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

3, 4
8, 9

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

You can pass objects as parameters to a method in the usual way.

public static void printPoint(Point p) {
    System.out.println("(" + p.x + ", " + p.y + ")");
}

public static void main(String[] args) {
    Point spot = new Point(3, 4);
    printPoint(spot);
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

(3, 4)

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

You can return an object from a method too.

public static Point findCenter(Rectangle box) {
    int x = box.x + box.width / 2;
    int y = box.y + box.height / 2;
    return new Point(x, y);
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

null and NullPointerException

Point spot = null;
int x = spot.x;          // NullPointerException
spot.translate(50, 50);  // NullPointerException

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

public static Point createCopy(Point p) {
    if (p == null) {
        return null; // return null if p is null
    }

    // create a new object with same x,y values
    return new Point(p.x, p.y);
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Point result = createCopy(null);
System.out.println(result);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

null

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

It is possible to have multiple variables that refer to the same object.

Point p1 = new Point(0,0);
Point p2 = p1;
System.out.println("p1: " + p1.x + ", " + p1.y);
System.out.println("p2: " + p2.x + ", " + p2.y);
p1.x = 1;
p2.y = 2;
System.out.println("p1: " + p1.x + ", " + p1.y);
System.out.println("p2: " + p2.x + ", " + p2.y);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

p1: 0, 0
p2: 0, 0
p1: 1, 2
p2: 1, 2

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Java does not have explicit pointers (and other related things such as pointer de-referencing and pointer arithmetic). When an object is passed into a method as an argument, the method gains access to the original object. If the method changes the object it received, the changes are retained in the object even after the method has completed.

public static void swapCoordinates(Point p){
    int temp = p.x;
    p.x = p.y;
    p.y = temp;
}

public static void main(String[] args) {
    Point p3 = new Point(2,3);
    System.out.println("p3: " + p3.x + ", " + p3.y);
    swapCoordinates(p3);
    System.out.println("p3: " + p3.x + ", " + p3.y);
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

p3: 2, 3
p3: 3, 2

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

What happens when no variables refer to an object?

Point spot = new Point(3, 4);
spot = null;

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

The first line creates a new Point object and makes spot refer to it. The second line changes spot so that instead of referring to the object, it refers to nothing. If there are no references to an object, there is no way to access its attributes or invoke a method on it. From the programmer’s view, it ceases to exist. However, it’s still present in the computer’s memory, taking up space.

In Java, you don’t have to delete objects you create when they are no longer needed. As your program runs, the system automatically looks for stranded objects and reclaims them; then the space can be reused for new objects. This process is called garbage collection. You don’t have to do anything to make garbage collection happen, and in general don’t have to be aware of it. But in high-performance applications, you may notice a slight delay every now and then when Java reclaims space from discarded objects.

As you know,

• Defining a class introduces a new object type.
• Every object belongs to some object type; that is, it is an instance of some class.
• A class definition is like a template for objects: it specifies what attributes the objects have and what methods they have.
• The new operator instantiates objects, that is, it creates new instances of a class.
• The methods that operate on an object type are defined in the class for that object.

public class Time {
    private int hour;
    private int minute;
    private int second;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

You can give a class any name you like. The Java convention is to use format for class names.

The code is placed in a file whose name matches the class e.g., the Time class should be in a file named Time.java.

When a class is public (e.g., the Time class in the above example) it can be used in other classes. But the that are private (e.g., the hour, minute and second attributes of the Time class) can only be accessed from inside the Time class.

Constructors

public Time() {
    hour = 0;
    minute = 0;
    second = 0;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

public Time(int h, int m, int s) {
    hour = h;
    minute = m;
    second = s;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

this keyword

public Time(int hour, int minute, int second) {
    this.hour = hour;
    this.minute = minute;
    this.second = second;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

public Time() {
    this(0, 0, 0); // call the overloaded constructor
}

public Time(int hour, int minute, int second) {
    // ...
}


    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

public int secondsSinceMidnight() {
    return hour*60*60 + minute*60 + second;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Time t = new Time(0, 2, 5);
System.out.println(t.secondsSinceMidnight() + " seconds since midnight!");

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

As the instance variables of Time are private, you can access them from within the Time class only. To compensate, you can provide methods to access attributes:

public int getHour() {
    return hour;
}

public int getMinute() {
    return minute;
}

public int getSecond() {
    return second;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Methods like these are formally called “accessors”, but more commonly referred to as getters. By convention, the method that gets a variable named something is called getSomething.

Similarly, you can provide setter methods to modify attributes of a Time object:

public void setHour(int hour) {
    this.hour = hour;
}

public void setMinute(int minute) {
    this.minute = minute;
}

public void setSecond(int second) {
    this.second = second;
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

While all objects of a class have the same attributes, each object has its own copy of the attribute value.

However, some attributes are not suitable to be maintained by individual objects. Instead, they should be maintained centrally, shared by all objects of the class. They are like ‘global variables’ but attached to a specific class. Such variables whose value is shared by all instances of a class are called class-level attributes.

Similarly, when a normal method is being called, a message is being sent to the receiving object and the result may depend on the receiving object.

However, there can be methods related to a specific class but not suitable for sending messages to a specific object of that class. Such methods that are called using the class instead of a specific instance are called class-level methods.

Class-level attributes and methods are collectively called class-level members (also called static members sometimes because some programming languages use the keyword static to identify class-level members). They are to be accessed using the class name rather than an instance of the class.

The content below is an extract from -- Java Tutorial, with slight adaptations.

public class Bicycle {

    private int gear;
    private int speed;

    // an instance variable for the object ID
    private int id;

    // a class variable for the number of Bicycle
    //   objects instantiated
    private static int numberOfBicycles = 0;
        ...
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

public class Bicycle {

    private int gear;
    private int speed;

    private int id;

    private static int numberOfBicycles = 0;


    public Bicycle(int startSpeed, int startGear) {
        gear = startGear;
        speed = startSpeed;

        numberOfBicycles++;
        id = numberOfBicycles;
    }

    public int getID() {
        return id;
    }

    public static int getNumberOfBicycles() {
        return numberOfBicycles;
    }

    public int getGear(){
        return gear;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public int getSpeed() {
        return speed;
    }

    // ...

}

    

    Copy
    

    


    
    
    
    

    Wrap Text