IT 114: Introduction to Java

IT 114: Introduction to Java
Class 38

Topics

New Material

An Application for Managing Classes
The Course Class
Validating Course Field Values
The Semester Class
Validating Semester Field Values
Adding a Course
Storing the List of Courses
Restoring the List of Courses

New Material

An Application for Managing Classes

Several classes ago we created three Java classes that an instructor at UMB could use to manage their coursework
- Student
- Section
- Grade
Today we are going to use these and other Java classes to create the Java application CourseWork
Coursework will be a static class that will use the classes listed above and other classes that we will create
CourseWork has a main method and will serve as the driver for this application
The application will consist of CourseWork and the classes it uses

The Course Class

CourseWork will have to create sections at the start of each semester

The last version of Section had the following constructor

    public Section(String class_id, String class_name, String section_no)

But if you think about it, both class_id and class_name are attributes of the same thing
A course like IT 114
Whenever you have a distinct thing, you really should create a Java class for it
So let's create the class Course
This class will have three attributes
- department (IT)
- catalog_no (114)
- name (Introduction to Java)

Here is the first version of Course

public class Course {
    private String department;
    private String catalog_no;
    private String name;

    public Course (String department, String catalog_no, String name) {
        this.department = department;
        this.catalog_no = catalog_no;
        this.name       = name;
    }

    public String toString() {
        return department + " " + catalog_no + ": " + name;
    }

    public String department(){
        return department;
    }

    public String catalog_no(){
        return catalog_no;
    }

    public String name(){
        return name;
    }    
}

Now we test it

public class CourseTest1 {
    public static void main (String[] args){
        Course1 course = new Course1("IT", "114", "Introduction to Java");
        System.out.println(course);
        System.out.println("Department:     " + course.department());
        System.out.println("Catalog number: " + course.catalog_no());
        System.out.println("Course name:    " + course.name());
    }
}

$ java CourseTest1
IT 114: Introduction to Java
Department:     IT
Catalog number: 114
Course name:    Introduction to Java

So far, so good, but we really should test that the field values are reasonable

Validating Course Field Values

To do this we need a validation method for each attribute value
Though this application might eventually be used by other departments
At this point in time we will limit it to IT
And to courses taught by the CS department

First we check department

    private boolean department_good(String value) throws IllegalArgumentException{
        boolean value_good = value.equals("IT");
        if (! value_good ){
            throw new IllegalArgumentException("Department must be IT");
        } else {
            return value_good;
        }
    }

Then catalog_no

    private boolean catalog_no_good(String catalog_no) throws IllegalArgumentException{
        switch (catalog_no) {
            case "114":
            case "116":
            case "117":
            case "244":
            case "246":
            case "285":
            case "341":
            case "442":
            case "443":
            case "444":
            case "485":
                return true;
            default:
                throw new IllegalArgumentException(catalog_no + " is not valid");
        }
    }

And finally name

    private final int MIN_NAME_LEN = 10;
    private final int MAX_NAME_LEN = 100;
    ...
	private boolean name_good(String name){
        if (name.length() >= MIN_NAME_LEN && name.length() <= MAX_NAME_LEN) {
            return true;
        } else {
            throw new IllegalArgumentException("name must be between " + MIN_NAME_LEN +
                                                " and " + MAX_NAME_LEN + " characters long");
        }
    }

Of course we need to update the constructor to use these methods

    public Course (String department, String catalog_no, String name) 
        throws IllegalArgumentException{
            if (department_good(department) && catalog_no_good(catalog_no) &&
                 name_good(name)){
            this.department = department;
            this.catalog_no = catalog_no;
            this.name       = name;
        }   
    }

Now we test

public class CourseTest2 {
    public static void main (String[] args){
        try {
            Course course1 = new Course("XXX", "114", "Introduction to Java");
            System.out.println(course1);
        } catch (Exception e1 ){
            System.out.println(e1);
            try {
                Course course2 = new Course("IT", "XXXXX", "Introduction to Java");
                System.out.println(course2);
            } catch (Exception e2) {
                System.out.println(e2);
                try {
                    Course course3 = new Course("IT", "114", "");
                    System.out.println(course3);
                } catch (Exception e3){
                    System.out.println(e3);
                }
            }
        }
        Course course = new Course("IT", "114", "Introduction to Java");
        System.out.println(course);
    }
}

$ java CourseTest2
java.lang.IllegalArgumentException: Department must be IT
java.lang.IllegalArgumentException: XXXXX is not valid
java.lang.IllegalArgumentException: name must be between 10 and 100 characters long
IT 114: Introduction to Java

The Semester Class

If our Application is to be useful it must work for more than one semester
So a Section object should also store the the semester in which the section was offered
This will allow us to do things like see all students for a given semester
To do this we need a Semester class
This class will have two fields
- season (Fall, Spring, Summer)
- year

Here is the first version

public class Semester {
    
    private String season;
    private int    year;

    public Semester(String season, int year){
        this.season = season;
        this.year   = year;
    }

    public String toString(){
        return season + " " +  Integer.toString(year);
    }

    public int year(){
        return year;
    }

    public String season(){
        return season;
    }
}

Which we test

public class SemesterTest1 {
    public static void main (String[] args){
        Semester s = new Semester("Spring", 2020);
        System.out.println(s);
        System.out.println("Season: " + s.season());
        System.out.println("Year:   " + s.year());
    }
}

$ java SemesterTest1
Spring 2020
Season: Spring
Year:   2020

Validating Semester Field Values

Now let's create methods to validate the values given to the Semester constructor

season can can only have three values

    private boolean season_good(String season) throws IllegalArgumentException{
        switch (season) {
            case "Fall":
            case "Spring":
            case "Summer":
                return true;
            default:
                throw new IllegalArgumentException(season + " is not a valid season");
        }
    }

And year must lie within a range

    private final int YEAR_MIN = 2020;
    private final int YEAR_MAX = 2050;
    ...
    private boolean year_good(int year) throws IllegalArgumentException {
        if (year >= YEAR_MIN && year <= YEAR_MAX){
            return true;
        } else {
            throw new IllegalArgumentException("year must be between " + YEAR_MIN + " and " + YEAR_MAX);    
        }
    }

We modify the constructor

    public Semester(String season, int year) throws IllegalArgumentException{
        if (season_good(season) && year_good(year)) {
            this.season = season;
            this.year   = year;            
        }   
    }

And test the changes

public class SemesterTest2 {
    public static void main (String[] args){
        try {
            Semester s1 = new Semester("XXXX", 2020);
            System.out.println(s1);
        } catch (Exception e1) {
            System.out.println(e1);
            try {
               Semester s2 = new Semester("Spring", 2000); 
               System.out.println(s2);
            } catch (Exception e2) {
                System.out.println(e2);
            }
        }
        Semester s = new Semester("Spring", 2020);
        System.out.println(s);
    }
}

$ java SemesterTest2
java.lang.IllegalArgumentException: XXXX is not a valid season
java.lang.IllegalArgumentException: year must be between 2020 and 2050
Spring 2020

Adding a Course

CourseWork will have a list of Course objects
One for every course the instructor teaches

It will keep these in an ArrayList

    private static ArrayList<Course> courses = new ArrayList<>();

The main method of CourseWork contains a while loop that interacts with the user

    public static void main (String[] args) throws FileNotFoundException{
        Scanner console = new Scanner(System.in);
        boolean done = false;
        while (! done) {
            menu();
            String choice = console.nextLine();
            choice        = choice.trim();
            if (choice.equals("1")){
                add_course(console);
            } else if (choice.equals("q")) {
                done = true;
            } else {
                System.out.println(choice + " is not a valid entry");
            }
        }
    }

The private method menu prints a list of actions

    private static void menu(){
        String menu = "";
        menu += "1 : Add Course\n";
        menu += "q : Quit\n";
        menu += "? ";
        System.out.print(menu);
    }

add_course will not add the course itself
Why?
Because creating that would mean creating a Course object
And that is a job for the Course class
Instead it will call an add_course method in Course to create the object

And then store it in the courses list

private static void add_course(Scanner console) throws FileNotFoundException {
        Course c = Course.add_course(console);
        System.out.println(c); //debug
        courses.add(c);
    }

The add_course method in Course gets a Scanner object and uses this to get the values it needs with the help of get_field_value

It then creates the Course object and returns it

    public static Course add_course(Scanner console) throws FileNotFoundException{
        String department = get_field_value(console, "Department");
        String course_no  = get_field_value(console, "Catalog number");
        String name       = get_field_value(console, "Name");
        Course course     = new Course(department, course_no, name);
        return course;
    }

    private static String get_field_value(Scanner console, String field_name)
        throws FileNotFoundException {
        System.out.print(field_name + ": ");
        String field_value = console.nextLine();
        return field_value.trim();
    }

Now we can run CourseWork to add a Course

$ java CourseWork
1 : Add Course
q : Quit
? 1
Department: IT
Catalog number: 114
Name: Introduction to Java
IT 114: Introduction to Java
1 : Add Course
q : Quit
? q

Storing the List of Courses

Of course we will lose the list of course when we quit CourseWork
So we need to store the values in a file on disk

First we need a couple of constants for this effort

    private static final String store_filename = "coursework_store.txt";
    private static final String separator      = "-------------------------------------\n";
    private static final String end_of_file    = "=====================================";

We also need to create the method store_state

Which will be called inside the while loop when the user quits

            } else if (choice.equals("q")) {
                store_state();
                done = true;

store_state will create the string stored in this file
But it will not create the text for each Course entry

That will be the job of method called store_string inside Course

    public String store_string(){
        String store_text = "course\n";
        store_text += department + "\n";
        store_text += catalog_no + "\n";
        store_text += name + "\n";
        return store_text;
    }

store_state will loop through the Course entries in the courses list
Inside the loop it will call the store_string method on each object to create the text to be stored
Then adding the string separator to mark the end of an entry for a particular object
When exiting the loop it adds the string end_of_file

And writes this to the file to disk

    private static void store_state() throws IOException{
        String store_text = "";
        for (int i = 0; i < courses.size(); i++){
            Course c = courses.get(i);
            store_text += c.store_string();
            store_text += separator;
        }
        store_text += end_of_file;    
        FileWriter output = new FileWriter(store_filename);
        output.write(store_text);
        output.close();
    }

Now we can call CourseWork to test this feature

$ java CourseWork
1 : Add Course
q : Quit
? 1
Department: IT
Catalog number: 114
Name: Introduction to Java
IT 114: Introduction to Java
1 : Add Course
q : Quit
? 1
Department: IT
Catalog number: 244
Name: Introduction to Linux/Unix
IT 244: Introduction to Linux/Unix
1 : Add Course
q : Quit
? q	

$ cat coursework_store.txt 
course
IT
114
Introduction to Java
-------------------------------------
course
IT
244
Introduction to Linux/Unix
-------------------------------------
=====================================

Restoring the List of Courses

We will follow a similar approach when restoring the entries in courses
We create the restore_state method in CourseWork
Which first checks to see whether a storage file exist
If it does it creates a Scanner object on it
And loops through the file using a while loop
It will know when to stop when it reaches the string end_of_file

Within the loop it looks for the string "course" and when it finds it calls the restored_course method in Course

    private static void restore_state() throws FileNotFoundException{
        File store_file = new File(store_filename);
        if (store_file.exists()) {
            Scanner input = new Scanner(store_file);
            String line   = input.nextLine();
            while ( ! line.equals(end_of_file)){
                if (line.equals("course")){
                    Course c = Course.restored_course(input);
                    System.out.println(c); // debug
                    courses.add(c);
                }
                line   = input.nextLine();
            }
        }
    }

Here is the code for restored_course

    public static Course restored_course(Scanner input) {
        String department = input.nextLine();
        String catalog_no = input.nextLine();
        String name       = input.nextLine(); 
        input.nextLine(); // skip over the entry_separator
        Course course     = new Course(department, catalog_no, name);
        return course;
    }

Notice that we put a print statement in this method for debugging
But we have marked it with a debug comment so we can delete it later
Now all we have to do is put a call to restore_state in the main method in CourseWork

Just before the while loop

public static void main (String[] args) throws FileNotFoundException, IOException{
        restore_state();
        Scanner console = new Scanner(System.in);
        boolean done = false;
        while (! done) {
        ....

And now we can test this using CourseWork $ java CourseWork IT 114: Introduction to Java IT 244: Introduction to Linux/Unix 1 : Add Course q : Quit ?
You can see the current version of Course here
And the current version of CourseWork here