IT 114: Introduction to Java

IT 114: Introduction to Java
Class 29

Topics

Review

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

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 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

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

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;
    }

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;
    }

We would really like to use the parameter names x and y
But still refer to the fields as x and y
We can do this using the keyword this
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

New Material

Scope

When a method runs, it gets it own bit of RAM
Inside that memory space it creates its own variables
These variables disappear when the method finishes
And the RAM space for the memory vanishes
But can a method use variables found in other parts of the code?
To answer this question, we need to learn about scope
Scope applies to the things in Java we declare
Like variables and methods
Scope is the part of a program in which a particular declaration of a thing is valid.
Scope applies to both variables and methods
And there a different rules for each

Scope Within Instance Methods

As we have seen, an instance method can access any field in its own object

We can see this in Point2

public class Point2{
    int x;
    int y;

    public void translate(int dx, int dy) {
        x += dx;
        y += dy;
    }
}

public class Point2Driver{
    public static void main(String[] args) {
        Point2 p = new Point2(); 
        p.x = 7; 
        p.y = 2; 
        System.out.println("p is (" + p.x + ", " + p.y + ")"); 
        p.translate(-2, 3);
        System.out.println("p is (" + p.x + ", " + p.y + ")"); 
    } 
}

$ java Point2Driver 
p is (7, 2)
p is (5, 5)

Scope Within the Same Method

Within the same method, the scope rule for variables is simple
The scope starts when the the variable is declared
And ends with the right curly brace, } closing the section of the code in which is is defined
To keep things simple, we will demonstrate this with examples in the main method
But the same principle applies to instance methods

To use a variable inside a loop, we must define it before the loop

public class VarScope {
    public static void main (String[] args){
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            
        }
        System.out.println("sum: " + sum);
    }
}

$ java VarScope
sum: 5

It also means that you cannot use the loop variable in a for loop outside the loop

public class VarScope2 {
    public static void main (String[] args){
        for (int i = 0; i < 5; i++) {
            System.out.println("i: " + i);
        }
        System.out.println("i: " + i);
    }
}

Because it will not compile

$ javac VarScope2.java 
VarScope2.java:6: error: cannot find symbol
        System.out.println("i: " + i);
                                   ^
  symbol:   variable i
  location: class VarScope2
1 error

But the scope rule applies wherever we have curly braces

public class VarScope3 {
    public static void main (String[] args){
        int var = 0;
        {
            var += 1;
            System.out.println("var: " + var);
            {
                var += 2;
                System.out.println("var: " + var);
            }
        }
        System.out.println("var: " + var);
    }
}

$ java VarScope3
var: 1
var: 3
var: 3

Method Scope

The scope rules for methods is simple
The scope for a method is the entire class in which it is defined

So it does not matter the order in which methods are defined

public class MethodScope {
    public static void main (String[] args){
        method_1();
    }

    public static void method_1(){
        method_2();
    }

    public static void method_2(){
        System.out.println("Hello from method_2");
    }
}

$ java MethodScope
Hello from method_2

Shadowing

But what happens if you have two variable with the same name but in different scopes?
Within the same method you cannot declare two variables with the same name

If you try you will get an error

public class VarScope4 {
    public static void main (String[] args){
        
        for (int i = 0; i < 5; i++) {
            int sum = 5;
            System.out.println("sum: " + sum);
        }
        System.out.println("sum: " + sum);
    }
}

$ javac VarScope4.java 

                ^
1 error

But variables inside instance methods can have the same name as the fields

Here is an example

public class Greeting {
    String greeting = "Hello";

    public void say_something(){
        String greeting = "Goodbye";
        System.out.println(greeting);
    }
}

We can compile the code

$ javac Greeting.java 

$ ls Greeting.*
Greeting.class Greeting.java

And running the driver shows that this works

public class GreetingDriver {
    public static void main (String[] args){
        Greeting g = new Greeting();
        g.say_something();
    }
}

$ java GreetingDriver
Goodbye

When Java uses a local variable with the same name as an instance variable, we call this shadowing

Of course, we can always use the keyword this to access the object's fields

public class Greeting2 {
    String greeting = "Hello";

    public void say_something(){
        String greeting = "Goodbye";
        System.out.println(this.greeting);
        System.out.println(greeting);
    }
}

public class Greeting2Driver {
    public static void main (String[] args){
        Greeting2 g = new Greeting2();
        g.say_something();
    }
}

$ java Greeting2Driver.java 
Hello
Goodbye

Localization

Since instance_variables can be used by all methods in a class why don't we use them instead of local variables?
This is not a good idea
In general a variable should be declared where it is needed and used
This is called localization
Why should we do this?
Since fields are available to all methods, any method could change them
That means we have to be very careful which method changes an instance method
With mutators that is not a problem because that is their job
But if we use a field to where a local method would do we run a risk
Each method could change the field which is an invitation to trouble

Static Variables

Variables can also be static
A static variable is shared by all objects created by the class
Any object can change the value of a static variable
And that change will be visible to all other objects
You declare a static variable using the following format
```
static DATA_TYPE  VARIABLE_NAME;
```
Why would you want to use such a variable?
What if you wanted to keep track of something
Say the number of cars sold
You might have a Sale class
Which would have a sell method
Each time a car was sold a static variable could be updated

Here is an example

public class Sale {
    s

    public Sale(){
        number_sold += 1;
    }

    public int sales(){
        return number_sold;
    }
}

public class SaleDriver {
    public static void main (String[] args){
        Sale s1 = new Sale();
        System.out.println(s1.sales());
        Sale s2 = new Sale();
        System.out.println(s2.sales());
        Sale s3 = new Sale();
        System.out.println(s3.sales());
    }
}

$ java SaleDriver
1
2
3

Constants

Some things never change
The number of days in a week
The number of days in a year
The number of innings in a baseball game
Some languages have constants
A constant is a value that can never change
In Java you can declare constant using the following format
```
public static final DATA_TYPE VARIABLE_NAME = VALUE;
```

Here is a silly example class that uses a constant

public class DayOfWeek {
    public static final int days_in_week = 7;
    String day_name;

    public DayOfWeek(String name){
        day_name = name;
    }

    public String toString(){
        return day_name + " is one of the " + days_in_week + " days in the week";
    }
}

An here is a driver

public class DayOfWeekDriver {
    public static void main (String[] args){
        DayOfWeek mon = new DayOfWeek("Monday");
        System.out.println(mon);
        DayOfWeek tsd = new DayOfWeek("Tuesday");
        System.out.println(tsd);
        DayOfWeek wed = new DayOfWeek("Wednesday");
        System.out.println(wed);
    }
}

$ java DayOfWeekDriver
Monday is one of the 7 days in the week
Tuesday is one of the 7 days in the week
Wednesday is one of the 7 days in the week

Multiple Constructors

A class can have more than one constructor
Let's create another constructor for our Point class
This constructor will not take x and y parameters

It will simply create a point at the origin

    public Point12(){
        x = 0;
        y = 0;
    }

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

The driver can use both constructors

public class Point12Driver {
    public static void main (String[] args){
        Point12 p1 = new Point12();
        System.out.println(p1);
        Point12 p2 = new Point12(3,4);
        System.out.println(p2);
    }
}

$ java Point12Driver
(0,0)
(3,4)

Wouldn't the default constructor do this for us?
Yes
But once we define a constructor in our class, Java will no longer supply the default constructor

Overloading

Java let us create two different constructors for our Point12 class because they looked different to the Java compiler
They looked different different because they had different signatures
The signature is the combination of the method name
And the data type of the parameter list
We could create two different constructors because they had different signatures
They had the same name, but the data types of their parameter lists were different
```
Point12()
Point12(int x, int y)
```
When you create two different method of the same name but different signatures it is called overloading
Overloading can be used for any methods, not just constructors

So we can create a Point13 class with two different version of set_location

    public void set_location(){
        x = 0;
        y = 0;
    }

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

Here is the driver

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

$ java Point13Driver
(0,0)
(3,4)
(0,0)