Week 3 [Mon, Aug 25th] - 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).

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.

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.

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
    

    


    
    
    

An Application Programming Interface (API) specifies the interface through which other programs can interact with a software component. It is a contract between the component and its clients.

When developing large systems, if you define the API of each component early, the development team can develop the components in parallel because the future behavior of the other components are now more predictable.

Java comes with a rich collection of classes that you can use. They form what is known as the Java API (Application Programming Interface). Each class in the API comes with documentation in a standard format.

• List of all Java classes
• Example: API documentation of the String class

String is a built-in Java class that you can use without importing. Given below are some useful String methods:

Find characters of a string

String fruit = "banana";
char letter = fruit.charAt(0);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

char[] fruitChars = fruit.toCharArray()

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Change a string to upper/lower case

String name = "Alan Turing";
String upperName = name.toUpperCase();
System.out.println(name);
System.out.println(upperName);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Alan Turing
ALAN TURING

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

String s = "Ada";
s.toUpperCase(); // no effect
s = s.toUpperCase(); // the correct way

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Replacing parts of a string

String text = "Computer Science is fun!";
text = text.replace("Computer Science", "CS");
System.out.println(text);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

CS is fun!

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Accessing substrings

Searching within strings

Comparing strings

String name1 = "Alan Turing";
String name2 = "Alan Turing";
System.out.println(name1 == name2);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

if (name1.equals(name2)) {
    System.out.println("The names are the same.");
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

String name1 = "Alan";
String name2 = "Ada";
int diff = name1.compareTo(name2);
if (diff == 0) {
    System.out.println("The names are the same.");
} else if (diff < 0) {
    System.out.println("name1 comes before name2.");
} else if (diff > 0) {
    System.out.println("name2 comes before name1.");
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

String s1 = "Apple";
String s2 = "apple";
System.out.println(s1.equals(s2)); //false
System.out.println(s1.equalsIgnoreCase(s2)); //true

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Printing special characters (line breaks, tabs, ...)

System.out.println("First line\nSecond \"line\"");

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

First line
Second "line"

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

System.out.println("First" + System.lineSeparator() + "Second");

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

First
Second

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

String formatting

public static String timeString(int hour, int minute) {
    String ampm;
    if (hour < 12) {
        ampm = "AM";
        if (hour == 0) {
            hour = 12;  // midnight
        }
    } else {
        ampm = "PM";
        hour = hour - 12;
    }

    // returns "07:05 PM"
    return String.format("%02d:%02d %s", hour, minute, ampm);
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Primitive values (like int, double, and char) do not provide methods.

int i = 5;
System.out.println(i.equals(5));  // compiler error

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

But for each primitive type, there is a corresponding class in the Java library, called a wrapper class, as given in the table below. They are in the java.lang package i.e., no need to import.

Double d = new Double(2.5);
int i = d.intValue();
System.out.println(d);
System.out.println(i);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

2.5
2

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Each wrapper class defines constants MIN_VALUE and MAX_VALUE.

System.out.println(Integer.MIN_VALUE + " : " + Integer.MAX_VALUE);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Wrapper classes provide methods for strings to other types e.g., Integer.parseInt converts a string to (you guessed it) an integer. The other wrapper classes provide similar methods, like Double.parseDouble and Boolean.parseBoolean.

Integer.parseInt("1234") 1234

Wrapper classes also provide toString, which returns a string representation of a value.

Integer.toString(1234) "1234"

java.util.Arrays provides methods for working with arrays. One of them, toString, returns a string representation of an array. It also provides a copyOf that copies an array.

int[] a = new int[]{1,2,3,4};

int[] b = Arrays.copyOf(a, 3); // copy first three elements
System.out.println(Arrays.toString(b));

int[] c = Arrays.copyOf(a, a.length); // copy all elements
System.out.println(Arrays.toString(c));

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

[1, 2, 3]
[1, 2, 3, 4]

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Scanner is a class that provides methods for inputting words, numbers, and other data. Scanner provides a method called nextLine that reads a line of input from the keyboard and returns a String. The following example reads two lines and repeats them back to the user:

import java.util.Scanner;

public class Echo {

    public static void main(String[] args) {
        String line;
        Scanner in = new Scanner(System.in);

        System.out.print("Type something: ");
        line = in.nextLine();
        System.out.println("You said: " + line);

        System.out.print("Type something else: ");
        line = in.nextLine();
        System.out.println("You also said: " + line);
    }
}

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Scanner class normally reads inputs as strings but it can read in a specific type of input too.

Scanner in = new Scanner(System.in);

System.out.print("What is your age? ");
int age = in.nextInt();
in.nextLine();  // read the new-line character that follows the integer
System.out.print("What is your name? ");
String name = in.nextLine();
System.out.printf("Hello %s, age %d\n", name, age);

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Proper naming improves the readability of code. It also reduces bugs caused by ambiguities regarding the intent of a variable or a method.

There are only two hard things in Computer Science: cache invalidation and naming things. _{-- Phil Karlton}

Every system is built from a domain-specific language designed by the programmers to describe that system. Functions are the verbs of that language, and classes are the nouns.
_{-- Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship}

Use nouns for classes/variables and verbs for methods/functions.

Distinguish clearly between single-valued and multi-valued variables.

Person student;
ArrayList<Person> students;

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

name = 'Jim'
names = ['Jim', 'Alice']

    

    Copy
    

    


    
    
    
    

    Wrap Text
    

    


    
    
    

Use correct spelling in names. Avoid 'texting-style' spelling. Avoid foreign language words, slang, and names that are only meaningful within specific contexts/times e.g., terms from private jokes, a TV show currently popular in your country.

A name is not just for differentiation; it should explain the named entity to the reader accurately and at a sufficient level of detail.

If a name has multiple words, they should be in a sensible order.

Imagine going to the doctor's and saying "My eye1 is swollen"! Don’t use numbers or case to distinguish names.

While it is preferable not to have lengthy names, names that are 'too short' are even worse. If you must abbreviate or use acronyms, do it consistently. Explain their full meaning at an obvious location.

Related things should be named similarly, while unrelated things should NOT.

Avoid misleading or ambiguous names (e.g., those with multiple meanings), similar sounding names, hard-to-pronounce ones (e.g., avoid ambiguities like "is that a lowercase L, capital I or number 1?", or "is that number 0 or letter O?"), almost similar names.