IT 114: Introduction to Java

IT 114: Introduction to Java
Class 33

Topics

Review

Writing To a File

New Material

Reusing Classes
Inheritance
An Example of Inheritance
The Video Class
Checking the Constructor Arguments
Checking the title Field
Checking the length Field
Checking the format Field
Honesty and Trust
Fairness

Announcements

We will continue working on the Section class at a future date.

Today we will start discussing inheritance.

You will need to know this for the homework assignment.

Homework 11

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

You will find the assignment here.

This will be the last homework assignment.

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

Review

Writing To a File

There are many ways of writing to a file in Java
But we will use a FileWriter object

You create such an object using the following format

FileWriter VARIABLE_NAME = new FileWriter(FILENAME;)

The FileWriter class is contained in the import java.io package
And it can throw an IOException which is found in the same package

So we need to import both classes

import java.io.FileWriter;
import java.io.IOException;

We write to the file using the write method of the FileWriter object
And when we are done writing we much use its close method

Here is an example

import java.io.FileWriter;
import java.io.IOException;

public class WriteToFile {
    public static void main (String[] args){
        String filename = args[0];
        try {
            FileWriter output = new FileWriter(filename);
            output.write("Line 1 \n");
            output.write("Line 2 \n");
            output.write("Line 3 \n");
            output.close();
        } catch (IOException e) {
            System.out.println("Could not create a FileWriter object for " + filename);
        }

    }
}

Notice that we had to add the newline character at the end of each line we wrote
Otherwise all the output would appear on the same line

New Material

Reusing Classes

Why create a class?
If you want to do something once and never do it again, classes are not worth the effort
You only create a class if it holds data that you want to use again and again
The effort that was needed to create the Student and Section classes was well spent
Because they can be used semester after semester
But there is another advantage to using classes
You can use one class as the basis for another class that does something similar
This feature is called inheritance

Inheritance

Inheritance lets you create new classes using the fields and methods of another class
Say you were a biologist studying the evolution of life
Biologists divide all living things into separate categories that are sometimes called kingdoms
There are five kingdoms
- Eubacteria - Normal bacteria
- Archaebacteria - Very old bacteria
- Protists - Various microscopic organisms
- Fungi - Fungi and yeasts
- Plants
- Animals
You will a nice summary of the different kingdoms here
Let's say you needed to write a Java program to catalog various organisms
We would probably first create class called Organism ...
which would contain the two parts of the scientific name
- Genus name
- Species name
You might also want to have fields for
- A picture
- The scientific paper that first described it
- The museum that holds the first specimen
Using inheritance you could then create subclasses for the different kingdoms
Contain information relevant for only that kind of organism
For example you might want to have a field called "soil" for plants
This is important information for plants
But not for animals

Principles of Inheritance

The first question we have to ask about inheritance is when we should use it
Inheritance only works when there is an "is a" relationship between two things
An animal is certainly an organism
So we could create create an Animal class based on an Organism class
Whenever we use one class as the basis of another class we call the original class the superclass
Or that base class
The class which inherits from another class is called the subclass
Or the derived class
A subclass inherits all the attributes and methods of its superclass

An Example of Inheritance

We need an example to demonstrate how inheritance works
Most of you are not biologists
So we need another example
Let's say you wanted to write a program for a friend who had many DVDs
Of different types
He wanted a program which would catalog the collection
But he wanted to store different information for each type in the collection
Some were movies
Others contained season of television shows like Mythbusters
In addition there were recording of lectures from the company called The Great Courses
Your friend wanted to store the actors and directors for movies
But not for a TV series
For them he would want to record the name of each episode

The Video Class

Let's start out by creating the Video superclass
Our first task is decide what fields are needed
Here is the list
- Collection number
- Title
- Length
- Format
The collection number is unique for each video starting with 1
The length is the running time in minutes
It must be an integer
The format can either be 'DVD' or 'Blue Ray'
None of these attributes will change once the are entered
So we won't need setters
Only getters
We will also need a constructor
And a toSting method

Here is the class


public class Video1 {
    private int collection_no;
    private String title;
    private int length;
    private String format;

    public Video1(int collection_no, String title, int length, String format){
        this.collection_no = collection_no;
        this.title = title;
        this.length = length;
        this.format = format;
    }

    public String toString(){
        return "#" + collection_no + ": " + title + ", " + length 
            + " minutes, " + format;
    }

    public int collection_no(){
        return collection_no;
    }

    public String title(){
        return title;
    }

    public int length(){
        return length;
    }

    public String format(){
        return format;
    }

}

And the driver

public class Video1Driver {
    public static void main (String[] args){
        Video1 v = new Video1(1, "Forbidden Planet", 98, "DVD");
        System.out.println("Collection number: " + v.collection_no());
        System.out.println("Title: " + v.title());
        System.out.println("Length" + v.length());
        System.out.println("Format:" + v.format());
        System.out.println(v);
    }
}

$ java Video1Driver
Collection number: 1
Title: Forbidden Planet
Length98
Format:DVD
#1: Forbidden Planet, 98 minutes, DVD

Checking the Constructor Arguments

Now we need to add some methods to make sure the arguments to the constructor are valid
These will be private methods since only the constructor will be using them
In general we should check each argument, but collection_no is special
The application we are writing should keep track of the last collection number used
And assign the next one in order to each new entry
But this is best done outside the Video class
We need to check title for length
To check length that it falls within a reasonable range
And format for the values "DVD" and "Blue-ray"

Checking the title Field

title is a string so we will only be checking its length
We need a minimum and maximum, are the values chosen are judgement call
There are movies whose titles are one letter, but they are not the things most people watch
Two letter titles are more common so let's chose 2 as the minimum

According to IMDb the longest movie title ever was

Night of the Day of the Dawn of the Son of the Bride of the Return of the Revenge of the Terror of the Attack of the Evil, Mutant, Hellbound, Flesh-Eating Subhumanoid Zombified Living Dead, Part 3

Which is 196 characters long
Just to be safe lets set the maximum length at 250
That should catch a title generated by a cat sitting on the keyboard

Here is the validation method title_good

    private boolean title_good(String title) throws IllegalArgumentException {
        if (title.length() < MIN_TITLE_LENGTH || title.length() > MAX_TITLE_LENGTH){
            throw new IllegalArgumentException("Title must be between " +
                MIN_TITLE_LENGTH + " and " + MAX_TITLE_LENGTH + " characters long");
        } else {
            return true;
        }
    }

It throws an IllegalArgumentException exception if title does not have the right length
But return true if it does

It used the constants MIN_TITLE_LENGTH and MAX_TITLE_LENGTH which are defined at the top of the class

public class Video2 {
    final int MIN_TITLE_LENGTH = 2;
    final int MAX_TITLE_LENGTH = 250;
 ...
 }

That way they will be easy to find if we ever want to change them

Now we have to modify the constructor

    public Video2(int collection_no, String title, int length, String format)
        throws IllegalArgumentException {
        if (title_good(title)){
            this.collection_no = collection_no;
            this.title = title;
            this.length = length;
            this.format = format;
        }
    }

And create a new driver

public class Video2Driver {
    public static void main (String[] args){
        try {
            Video2 v1 = new Video2(1, "I", 98, "DVD");
            System.out.println(v1);
        } catch (Exception e) {
            System.out.println(e);
        }
        Video2 v2 = new Video2(1, "Forbidden Planet", 98, "DVD");
        System.out.println(v2);
    }
}
$ java Video2Driver
java.lang.IllegalArgumentException: Name must be between 2 and 250 characters long
#1: Forbidden Planet, 98 minutes, DVD

Checking the length Field

Now we need to check length
Again we need to choose values for the maximum and minimum

The following values seem reasonable

    final int MIN_LENGTH      = 15;
    final int MAX_LENGTH      = 1000;

Using these we can write length_good

    private boolean length_good(int length) throws IllegalArgumentException {
        if (length < MIN_LENGTH || length > MAX_LENGTH){
            throw new IllegalArgumentException("Length must be between " +
                MIN_LENGTH + " and " + MAX_LENGTH + " characters long");
        } else {
            return true;
        }
    }

And we add a call to this in the constructor

    public Video3(int collection_no, String title, int length, String format)
        throws IllegalArgumentException {
        if (title_good(title) && length_good(length)){
            this.collection_no = collection_no;
            this.title = title;
            this.length = length;
            this.format = format;
        }
    }

Now we test this with a driver

public class Video3Driver {
    public static void main (String[] args){
        try {
            Video3 v1 = new Video3(1, "Forbidden Planet", 2000, "DVD");
            System.out.println(v1);
        } catch (Exception e) {
            System.out.println(e);
        }
        Video3 v2 = new Video3(1, "Forbidden Planet", 98, "DVD");
        System.out.println(v2);
    }
}

$ java Video3Driver
java.lang.IllegalArgumentException: Length must be between 15 and 1000 characters long
#1: Forbidden Planet, 98 minutes, DVD

Checking the format Field

There are two ways a value for format can be invalid
- The value could be the empty string
- The string supplied could be an incorrect value
The first case is easily dealt with by looking at the length of the string
The second required a little more effort
Once again we will use a constant
But here the constant is an Array of strings

Which we initialize with a string literal

    final String [] FORMATS   = {"DVD", "Blu-ray"};

To use this constant we need to compare each the value supplied by the user to each legal value
We can do this with a for loop
If the value is OK we return true

If not we throw an exception

   private boolean length_good(int length) throws IllegalArgumentException {
        if (length < MIN_LENGTH || length > MAX_LENGTH){
            throw new IllegalArgumentException("Length must be between " +
                MIN_LENGTH + " and " + MAX_LENGTH + " characters long");
        } else {
            return true;
        }
    }

    private boolean format_good(String format) throws IllegalArgumentException {
        if (format.length() == 0) {
            throw new IllegalArgumentException("You must specify a format");
        } else {
            for (int i = 0; i < FORMATS.length; i++){
                if (format.equals(FORMATS[i])) {
                    return true;
                }
            }
            throw new IllegalArgumentException( format + " is not a valid format");
        }
    }

We insert a call to this method into the constructor

public Video4(int collection_no, String title, int length, String format)
        throws IllegalArgumentException {
        if (title_good(title) && length_good(length) && format_good(format)){
            this.collection_no = collection_no;
            this.title = title;
            this.length = length;
            this.format = format;
        }
    }

The driver shows the code works

public class Video4Driver {
    public static void main (String[] args){
        try {
            Video4 v1 = new Video4(1, "Forbidden Planet", 98, "");
            System.out.println(v1);
        } catch (Exception e1) {
            System.out.println(e1);
            try {
                Video4 v2 = new Video4(1, "Forbidden Planet", 98, "XXX");
                System.out.println(v2);
            } catch (Exception e2) {
                System.out.println(e2);
            }
        }
        Video4 v3 = new Video4(1, "Forbidden Planet", 98, "DVD");
        System.out.println(v3);
    }
}

$ java Video4Driver
java.lang.IllegalArgumentException: You must specify a format
java.lang.IllegalArgumentException: XXX is not a valid format
#1: Forbidden Planet, 98 minutes, DVD

You can see the code for the class here

Honesty and Trust

The third of the ACM ethical principles is
```
Be honest and trustworthy
```
Professionals depend upon their reputation
Would you go to an accountant who had been accused of embezlement?
Or a doctor who was addicted to drugs?
IT professionals often have access to confidential data
And trade secrets
A company would be stupid to hire you if they could not trust you
Men could learn the address and phone number of attractive women
Dishonest employees could sell confidential information to competitors
Integrity is especially important for people working in security

Fairness

The fourth ACM ethical principle is

Be fair and take action not to discriminate

Technical knowledge gives us the power to help people
We have a moral obligation use this ability fairly
To do this, we must distinguish between two things
- Prejudice
- Unconscious Bias
Prejudice is "preconceived opinion that is not based on reason or actual experience"
In other words, coming to a conclusion about something before examining the evidence
Prejudice toward minorities is illegal in this country and many others
Most large companies have policies against this
This is done for both legal and practical reasons
Companies do not want to violate the law
And they don't want to alienate potential customers
Prejudice does occur in professional life
But unconscious bias is more prevalent
It is also harder to recognize
Prejudice is conscious
Unconscious bias is not
Unconscious biases are formed through life experiences
And the cultural context in which we live
The brain has two decision making systems, one slow and the other fast
The slow system allows us to think about problems and come to a well thought out decision
But some dangers come quickly
This is why we have a faster decision system as this video explains
This system is fast but not very smart or accurate
But you can train yourself to learn when this fast system kicks in
You can learn to stop it from making a biased decision