IT 114: Introduction to Java

IT 114: Introduction to Java
Class 28

Topics

Review

The Implicit Parameter
Mutators and Accessors
Classes for Other Programs To Use
A New Version of distance_from_origin
Refactoring
Do No Harm

New Material

Printing Objects
The toString Method
Always Create a toString Method
Constructors
Constructor for Point
Classes Without Constructors
Common Programming Error: Using void with a Constructor
Common Programming Error: Redeclaring Fields in a Constructor
The Keyword this

Homework 9

Homework 9 is due this Sunday at 11:59 PM.

You will find the assignment here.

If you have a problem or a question, make a post on the Class Discussion Area.

Review

The Implicit Parameter

The code for an instance method knows about the fields in the object in which it lives
So when you call such a method not have to specify the object in which the values are located
The object is an implicit parameter of the instance method
That means a method does not need a parameter to access the object's fields

Mutators and Accessors

The translate method changes the values contained in the object
Methods that change one or more fields are called mutators
By convention, the names of mutators often begin with the word "set"
For example setID or setTitle
For this reason, mutators are often called setters
The return type of a mutator is usually void
Mutators normally take parameters which are either the new values for the fields
Or values which are used to modify the current value of the fields
A second important category of instance methods are accessors
Accessors return the value of a field without changing that value
The names of accessors sometimes begin with the word "get"
For example getBalance
Accessors are sometimes called getters
If the accessor returns a boolean value the name often begins with "is" ...
For example isEmtpy

Classes for Other Programs To Use

Classes such as Point are used to create objects
A class that creates objects never a program that does something useful
Instead it is used by static, driver classes to do their work
These static classes are sometimes called client programs
If you look at the classes that come with Java you will sometimes find many methods
And some of these methods look so similar that you wonder why they were created
The people who design these classes know that the class will be used by many different programmers
And individual programmers may approach their task in different ways
So the designers tend to create many different methods in the hope that each programmer will find the method they need

A New Version of distance_from_origin

Refactoring

Refactoring is where you take some code the already works properly
And make a series of small changes to make it better
The secret is that the changes are small
So you can test after every small change
And fix any problems you find
The most important feature of any program is that it works
So you should not waste time when writing it to make it easy to read
Or more efficient
Once you have working code you can refactor it to make it better
As time permits

Do No Harm

The second ACM general ethical principle is
```
Avoid harm
```
As examples of harm the ACM gives
- Unjustified physical or mental injury
- Unjustified destruction or disclosure of information
- Unjustified damage to property, reputation, and the environment
Social networks have been used to bully and harass people, especially women and minorities
IT skills have been used for these purposes
They have also been used to invade people's privacy and reveal personal information
Even seemingly neutral activities can have bad consequences
Bitcoin mining uses as much power as a small country according to some estimates

New Material

Printing Objects

Printing is an operation that only works with text
So what happens if we try to print one of our Point objects?

The following code will tell us

public class PrintPoint {
    public static void main (String[] args){
        Point8 p = new Point8();
        p.set_location(3,4);
        System.out.println("p1 is (" + p.get_x() + ", " + p.get_y() + ")");
        
    }
}

$ java PrintPoint
p1 is (3, 4)
Point8@6d06d69c

The result of printing our Point object p, "Point8@6d06d69c" is maybe not what you expected, but the code did not crash
The output tells us it is an object of the Point8 class
And it gives us a unique number to identify this object
How did Java get this value
The full answer involves an understanding of inheritance
Which we will cover in a later class
But in brief, every object has a special method called toString
This method provides a text representation of the object
println needs to turn its argument into text
It knows how to do this for primitive types like int, double and boolean
But it uses toString to do the text conversion with objects

The toString Method

We can do better than "Point8@6d06d69c"
We can define our own version of toString

We do this using the following format


public String toString() {
	STATEMENTS_THAT_RETURN_A_STRING;
}

Notice that toString does not take a parameter
And that it returns a string
Points on the plane are usually represented like this
```
(3,4)
```
where the first value is the x coordinate and the second is the y coordinate

So we can create the following toString method for out Point object

public String toString(){
        return "(" + x + "," + y + ")";
    }

Here is the driver code

public class Point9Driver {
    public static void main (String[] args){
        Point9 p = new Point9();
        p.set_location(3,4);
        System.out.println("p1 is (" + p.get_x() + ", " + p.get_y() + ")");
        System.out.println(p);
    }
}

$ java Point9Driver 
p1 is (3, 4)
(3,4)

Always Create a toString Method

Every class you create should have it's own toString method
What that string contains depends on the circumstances
And what the programmer feels is important about an object of that class
For classes with a fields, you might want to print every value
For classes with many fields you will have to be selective
But almost anything is better than "Point8@6d06d69c"

Constructors

In our current version of the Point class we needed 2 statements to create the object and give it values
```
Point9 p = new Point9();
p.set_location(3,4);
```
It would be much better to combine all of these statements into a single method call like this
```
Point9 p = new Point9(3,4)
```
But for such a statement to work we have to create a special kind of method called a constructor
Constructors do two things
- Create the object
- Assign the object some initial values
A constructor runs whenever a client code uses the new keyword to create an object

Here is the format for a constructor


public CLASS_NAME(DATA_TYPE PARAMETER_NAME, ...) {
	STATEMENT;
	STATEMENT;
	...
}

The header begins with the keyword public followed by the name of the class
This is followed by the parameter list
This header looks just like the declaration for a method with the same name as the class
But there is a subtle difference
The method header has no return type
And a constructor never has a return statement

Constructor for Point

Here is our constructor for Point

public Point10(int x_init, int y_init) {
        x = x_init;
        y = y_init;
    }

And here is the driver

public class Point10Driver {
    public static void main (String[] args){
        Point10 p = new Point10(3,4);
        System.out.println(p);
    }
}

$ java Point10Driver
(3,4)

When the driver ran the following statement
```
Point10 p = new Point10(3,4);
```
three things happened
- A new Point10 object was created in memory
- Values were assigned to the x and y fields
- A reference variable was created and given the address of the object

Classes Without Constructors

What happens when the programmer does not create a constructor for a class
In that case Java automatically supplies a default constructor with no parameters
The default parameter initializes all fields to the default values it uses when creating an array

Type Value

int 0

double 0.0

char '\0'

boolean false

objects null
null is a special value used for variables that point to objects
Normally such variable contain an address in RAM
But what about situations where an object has not been created for some reason?
In that case the value given to the variable is null
null has the same function that 0 has for numbers
It indicates nothing
Or a pointer to nowhere
When a class has a constructor Java does not supply the default constructor

Type	Value
int	0
double	0.0
char	'\0'
boolean	`false`
objects	`null`

Common Programming Error: Using `void` with a Constructor

Constructors are different from other methods in many ways
The most important difference is that they create objects
And give them their initial values
But they are also different in their method headers
- The method name of a constructor is the same as the class name
- Constructors do not have a return type
If you give the constructor a return type of void you've created a problem that is very hard to spot

Consider the following class

public class BadPoint {
    int x;
    int y;

    public void BadPoint(int x_init, int y_init) {
        x = x_init;
        y = y_init;
    }
}

This code can be compiled

$ javac BadPoint.java 

$ ls BadPoint.*
BadPoint.class BadPoint.java

Here is a driver to use this class

public class BadPointDriver {
    public static void main (String[] args){
        BadPoint p = new BadPoint(3,4);
        System.out.println(p);
    }
    
    public String toString(){
        return "(" + x + "," + y + ")";
    }
}

But the driver code will not compile

$ javac BadPointDriver.java 
BadPointDriver.java:3: error: constructor BadPoint in class BadPoint cannot be applied to given types;
        BadPoint p = new BadPoint(3,4);
                     ^
  required: no arguments
  found: int,int
  reason: actual and formal argument lists differ in length
1 error

The problem is very subtle
Remember, constructors are not supposed to have return types
We gave our constructor a return type of void
So the interpreter thinks this is a method, not a constructor
Since we did not give the class a constructor, Java supplies the default constructor
The default constructor takes no arguments
But the drive called the constructor with two arguments

Hence the error message


  required: no arguments
  found: int,int
  reason: actual and formal argument lists differ in length

Common Programming Error: Redeclaring Fields in a Constructor

There is another bug encountered when defining constructors that is hard to count
It occurs when you make the mistake of declaring the variables you set in the

In other word, instead of writing

x = x_init;
y = y_init;

we write

int x = x_init;
int y = y_init;

Once again the class code will compile

$ javac BadPoint2.java 

$ ls BadPoint2.*
BadPoint2.class BadPoint2.java

Here is our driver

public class BadPoint2Driver {
    public static void main (String[] args){
        BadPoint2 p = new BadPoint2(3,4);
        System.out.println(p);
    }
}

It will compile

$ javac BadPoint2Driver.java 

$ ls BadPoint2Driver.*
BadPoint2Driver.class BadPoint2Driver.java

But when we run it we get
```
$ java BadPoint2Driver
(0,0)
```
Again the issue is subtle
By declaring x and y inside the method, we made them local variables
In other words, these are not the field variable x and y
They are variables with the same name that only exit when the constructor is run
The field variables are not set
So they retain their default values of o

The Keyword `this`

Look at the code for the constructor of our version of in the Point10 class

public Point10(int x_init, int y_init) {
        x = x_init;
        y = y_init;
    }

The names of the parameters x_init and y_init are awkward and somewhat confusing
and easy to misspell

We'd really like to write something like

public Point10(int x, int y_init) {
        x = x;
        y = y;
    }

But of course that won't work
We would really like to use the parameter names x and y
But still refer to the fields as x and y
It turns out that we can do this
But we have to use the keyword this
Remember the implicit parameter?
Every method in a object, knows where its object lives in memory
This is called the implicit parameter
The keyword this is the implicit parameter
It is a pointer to the object that you are working with

So we can rewrite our constructor like this

    public Point11(int x, int y) {
        this.x = x;
        this.y = y;
    }

Here x and y are the local parameters that get their value from the call to the constructor
And this.x and his.y = y; are the fields

Here is the driver

public class Point11Driver {
    public static void main (String[] args){
        Point11 p = new Point11(3,4);
        System.out.println(p);
    }
}

$ java Point11Driver
(3,4)