IT 114: Introduction to Java

IT 114: Introduction to Java
Class 30

Topics

Review

Scope
Scope Within Instance Methods
Scope Within the Same Method
Method Scope
Shadowing
Localization
Static Variables
Constants
Multiple Constructors
Overloading

New Material

Encapsulation
Changing Fields Directly Is A Bad Idea
Data Hiding
Data Validation in Classes
Throwing an Exception
Constructor Throwing Exception
Refactoring the Time Constructor
Hiding Methods
Time Accessors
Time Mutators
Changing Internal Implementations

Homework 10

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

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

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 use a variable inside a loop, we must define it before the loop
It also means that you cannot use the loop variable in a for loop outside the loop
Because it will not compile
The scope rule applies wherever we have curly braces

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

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

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

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

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

Multiple Constructors

A class can have more than one 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

New Material

Encapsulation

We live in a world awash with information
So much information is available to us that is sometimes makes it harder to find exactly what we want
Experienced information architects have a saying
"Less is more"
This is particularly true in programming
The average big application has dozens and dozens of fields
You might think that all programmers should have access to all these fields
But experience shows this is a bad idea
To keep programmers from mucking about with things they don't understand many languages employ the principle of encapsulation
Encapsulation means hiding the details of how a class works from the clients that use the class
A programmer who is writing a client class does not need to know how a class he or she is calling works
The programmer only needs to know how the general idea of what the class does
This important principle is called abstraction
When you drive a car, you don't have to know how the engine works
All you have to know is that stepping on the gas pedal makes the car move
And the further you press the pedal the faster it goes
When an object is properly encapsulated its clients cannot directly access or modify its fields
Or know about its internal workings
Only the programmer who writes or maintains the class needs to know its internal details
Remember the Scanner objects we used to get input into a class?
We did not need to know how they worked in order to use them
Trying to learn the inner details of this class would take a lot of of time
And would not help us to use a Scanner object better

Changing Fields Directly Is A Bad Idea

The code for PointDriver.java contains the following
```
p.x = 7; 
p.y = 2; 
```
At the time, I said this was a bad idea
Why?

Consider the following class

public class Time1 {
    int hours;
    int minutes;
    int seconds;

    public Time1 (){
        this.hours   = 0;
        this.minutes = 0;
        this.seconds = 0;
    }

    public String toString(){
        return hours + ":" + minutes + ":" + seconds;
    }
}

And this driver

public class Time1Driver {
    public static void main (String[] args){
        Time1 t = new Time1();
        t.hours   = 30;
        t.minutes = 90;
        t.seconds = 100;
        System.out.println(t);
    }
}

$ java Time1Driver
30:90:100

Can you see the problem?
Hours should only be between 0 and 23
Assuming a 24 hour clock
And both minutes and seconds should range from 0 to 59

Data Hiding

To prevent errors like the one above, most object oriented languages practice data hiding
Data hiding means keeping the inner details of a class hidden from programmers writing client code
So we need to prevent users of our class from changing the field values
We can do this declaring the fields private
The format for creating a private field is
```
private DATA_TYPE FIELD_NAME;
```
A field marked private can only be changed by instance methods inside the class

So let's do this in a new version of Time1

public class Time2 {
    private int hours;
    private int minutes;
    private int seconds;

    public Time2(){
        this.hours   = 0;
        this.minutes = 0;
        this.seconds = 0;
    }

    public Time2(int hours, int minutes, int seconds){
        this.hours   = hours;
        this.minutes = minutes;
        this.seconds = seconds;
    }

    public String toString(){
        return hours + ":" + minutes + ":" + seconds;
    }
}

If we try to compile the following driver code

public class Time2Driver {
    public static void main (String[] args){
        Time2 t = new Time2();
        t.hours   = 30;
        t.minutes = 90;
        t.seconds = 100;
        System.out.println(t);
    }
}

we will get errors

$ javac Time2Driver.java 
Time2Driver.java:4: error: hours has private access in Time2
        t.hours   = 30;
         ^
Time2Driver.java:5: error: minutes has private access in Time2
        t.minutes = 90;
         ^
Time2Driver.java:6: error: seconds has private access in Time2
        t.seconds = 100;
         ^
3 errors

So let's write a new driver

public class Time2Driver2 {
    public static void main (String[] args){
        Time2 t = new Time2(30, 90, 100);
        System.out.println(t);
    }
}

$ java Time2Driver2
30:90:100

So it is not enough to merely make the fields private
We have to make sure the the constructor does not accept invalid field values

Data Validation in Classes

We need to have the constructor check its arguments

Like this

    public Time3(int hours, int minutes, int seconds){
        if (hours < 0 || hours > 23){
            System.out.println("Hours must be between 0 and 23");
        } else if ( minutes < 0 || minutes > 59){
            System.out.println("Minutes must be between 0 and 59");   
        } else if ( seconds < 0 || seconds > 59){
            System.out.println("seconds must be between 0 and 59");   
        } else {
            this.hours   = hours;
            this.minutes = minutes;
            this.seconds = seconds;
        }
    }

Here is the driver

public class Time3Driver {
    public static void main (String[] args){
        Time3 t = new Time3(30, 90, 100);
        System.out.println(t);
    }
}

But when we run it we get

$ java Time3Driver
Hours must be between 0 and 23
0:0:0

Why?
The constructor did not use the values we gave it
But it did create an object
And since it did not set the fields, they kept their default values of 0

Throwing an Exception

Java lets methods do more than catch an exception
They can also create an exception object
And throw it
These two operations are usually written on single line with the following format
```
throw new EXCEPTION_TYPE()
```
The type of exception thrown depends upon the nature of the runtime error
When you do this, the header must have a throws clause

Constructor Throwing Exception

A constructor can throw and exception like any other method

Our Time constructor should throw a IllegalArgumentException

	public Time4(int hours, int minutes, int seconds)
        throws IllegalArgumentException {
        if (hours < 0 || hours > 23){
            throw new IllegalArgumentException ("Hours must be between 0 and 23");
        } else if ( minutes < 0 || minutes > 59){
            throw new IllegalArgumentException ("Minutes must be between 0 and 59");
        } else if ( seconds < 0 || seconds >s 59){
            throw new IllegalArgumentException ("Minutes must be between 0 and 59");
        } else {
            this.hours   = hours;
            this.minutes = minutes;
            this.seconds = seconds;
        }
    }

Now we we run the driver we get an exception

public class Time4Driver {
    public static void main (String[] args){
        try {
          Time4 t = new Time4(30, 90, 100);
          System.out.println(t);
        } catch (Exception e){
          System.out.println(e);
        }
}

$ java Time4Driver
Hours must be between 0 and 23
0:0:0

Refactoring the Time Constructor

The new constructor is ugly
It has a lot of redundant code
We need to move the testing into a new method
And also create a method to create an exception object with the appropriate error message

Here is the new constructor and its helper methods

public Time5(int hours, int minutes, int seconds)
        throws IllegalArgumentException {
        if (entry_invalid(hours, 23)){
            throw exception_create("Hours", 23);
        } else if (entry_invalid(minutes, 59)){
            throw exception_create("Minutes", 59);
        } else if (entry_invalid(seconds, 59)){
            throw exception_create("Seconds", 59);
        } else {
            this.hours   = hours;
            this.minutes = minutes;
            this.seconds = seconds;
        }
    }

    public boolean entry_invalid (int value, int max) {
            return value < 0 ||  value > max;
    }

    public IllegalArgumentException exception_create(String label, int max){
        String err_msg = label + " must be between 0 and " + max;
        return new IllegalArgumentException(err_msg);
    }

When we run the driver we get the same results as before

public class Time5Driver {
    public static void main (String[] args){
        try {
          Time5 t = new Time5(30, 90, 100);
          System.out.println(t);
        } catch (Exception e){
          System.out.println(e);
        }
    }
}

$ java Time5Driver
java.lang.IllegalArgumentException: Hours must be between 0 and 23

Hiding Methods

You can hide methods as well as fields
You do this by making them private using the following format
```
private RETURN_TYPE METHOD_NAME(PARAMETER)
```

So the latest version of our Time class will have helper methods that look like this

 	private boolean entry_invalid (int value, int max) {
            return value < 0 ||  value > max;
    }

    private IllegalArgumentException exception_create(String label, int max){
        String err_msg = label + " must be between 0 and " + max;
        return new IllegalArgumentException(err_msg);
    }

Why bother?
No programmer of client code would ever have to use these methods
But people sometimes do strange and stupid things
If programmers have no need for these methods don't make them available

Time Accessors

Since we have made the fields private, there is no way client code can get their values
So we need to create accessors

Here they are

public int get_hours(){
        return hours;
    }

    public int get_minutes(){
        return minutes;
    }

    public int get_seconds(){
        return seconds;
    }

Running the driver

public class Time7Driver {
    public static void main (String[] args){
        try {
          Time7 t = new Time7(9, 30, 0);
          System.out.println(t);
          System.out.println("Hours: " + t.get_hours());
          System.out.println("Minutes: " + t.get_minutes());
          System.out.println("Seconds: " + t.get_seconds());
        } catch (Exception e){
          System.out.println(e);
        }
    }
}

$ java Time7Driver 
9:30:0
Hours: 9
Minutes: 30
Seconds: 0

Time Mutators

We also need to create mutators

Here they are

public void set_hours(int hours){
        this.hours = hours;
    }

    public void set_minutes(int minutes){
        this.minutes = minutes;
    }

    public void set_seconds(int seconds){
        this.seconds = seconds;
    }

And the driver

public class Time8Driver {
    public static void main (String[] args){
        try {
          Time8 t = new Time8(9, 30, 0);
          System.out.println(t);
          t.set_hours(10);
          t.set_minutes(15);
          t.set_seconds(30);
          System.out.println(t);
        } catch (Exception e){
          System.out.println(e);
        }
    }
}

$ java Time8Driver
9:30:0
10:15:30

We now have a completely enclosed class
You can see the full code for Time here

Changing Internal Implementations

We have to be careful when making changes to a class that is already in use
We must make sure that nothing we do will break existing code written for the class
Encapsulation makes this possible
Because all we have to do is make sure we do not change the method signatures of any public class
Let's change Time so it only has one field, total_seconds
We replace the the hours minutes and seconds field with a single field
```
private int total_seconds;
```
In order to do this we will need 4 helper methods
- hours_minutes_seconds_to_total_seconds
- total_seconds_to_hours
- total_seconds_to_minutes
There are 60 seconds make a minute
3600 seconds (60 * 60) make an hour

To convert hours, minutes and seconds to total seconds we have

	private int hours_minutes_seconds_to_total_seconds(int hours, int minutes, int seconds){
        return hours * 3600 + minutes * 60 + seconds;
    }

To convert total seconds to hours we simple divide by the number of second in an hour
Since both quantities are integers, the result of division will also be an integer

So we can write

	private int total_seconds_to_hours(){
        return this.total_seconds / 3600;
    }

To get minutes from total seconds we first subtract the seconds that constitute the hours
Then divide the remainder by 60

This gives us

	private int total_seconds_to_minutes(){
        int total = this.total_seconds;
        total -= total_seconds_to_hours() * 3600;
        return total / 60;
    }

Now we can change the constructors

The constructor with no parameters is simple

	public Time9(){
        this.total_seconds = 0;
    }

The other constructor replaces three assignment statements with a c

public Time9(int hours, int minutes, int seconds)
        throws IllegalArgumentException {
        if (entry_invalid(hours, 23)){
            throw exception_create("Hours", 23);
        } else if (entry_invalid(minutes, 59)){
            throw exception_create("Minutes", 59);
        } else if (entry_invalid(seconds, 59)){
            throw exception_create("Seconds", 59);
        } else {
            this.total_seconds = hours_minutes_seconds_to_total_seconds(hours, minutes, seconds);
        }
    }

The getters simply make calls to the appropriate conversion method

	public int get_hours(){
        return total_seconds_to_hours();
    }

    public int get_minutes(){
        return total_seconds_to_minutes();
    }
    public int get_seconds(){
        return total_seconds_to_seconds();
    }

And toSting simply uses these getters

public String toString(){
        //return hours + ":" + minutes + ":" + seconds;
        return get_hours() + ":" + get_minutes() + ":" + get_seconds();
    }

The setters are a little more complicated
We need to call two conversion methods and hours_minutes_seconds_to_total_seconds

The driver shows that everything works

public class Time9Driver {
    public static void main (String[] args){
        try {
          Time9 t = new Time9(9, 30, 15);
          System.out.println(t);
          System.out.println(t.get_hours());;
          System.out.println(t.get_minutes());;
          System.out.println(t.get_seconds());;
          t.set_hours(10);
          t.set_minutes(5);
          t.set_seconds(45);
          System.out.println(t);
        } catch (Exception e){
          System.out.println(e);
        }
    }
}

$ java Time9Driver
9:30:15
9
30
15
10:5:45

You can see the entire class here