IT 114: Introduction to Java

IT 114: Introduction to Java
Class 32

Topics

Review

Thinking about Objects
Designing a Class

New Material

Writing To a File
Getting Current Date
Creating an Attendance Sheet
Writing the Attendance File
The Name of the Attendance File
Last Two Helper Methods
The Grade Class
Checking the Grade
Finishing the Grade Class
Assigning a Grade

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

Thinking about Objects

There are two ways to think about objects
- How they appear in RAM
- How they represent some thing
In RAM an object is a section of memory holding many values
And methods that work on these values
But an object also represents one particular thing
Like an individual student
The object holds particular information about a particular student or car
The method let us see the characteristics of the thing they represent
And do the things one does on that object
Like change the major of a student
Or sell a car
There are two parts to solving any problem
- Deciding what to do
- Deciding how to do it
In working on both parts, it is useful to think abstractly
Objects help us do just that

Designing a Class

A heuristic is a way of solving a problem
It may not be perfect, but it gives us practical approach to the work ahead
In other words it is rule of thumb for tackling the job
Here is a list of heuristics for designing a class
1. Each method should have a coherent set of things it has to do
2. No one method should do too large a share of the overall work
3. Dependencies between methods should be minimized
4. The main method should be a summary of the application does
5. Data should be kept at the lowest level possible
What do these mean?
A method is coherent if all the things it does are closely related
So a method that gives a student a grade should not deal with the student's gender
The second guideline means that a method should do one thing and do it well
The third point has to do with making the program robust
The more a class depends on other classes, the greater the chance that it will eventually break
Software is always changing
This can cause bugs in other classes that depend on them
The 4th point deals with the main method
Class names and method names should always be simple and straightforward
The names should tell a reader what the class or method does
If they are, someone should be able to read it and understand what is going on
The fifth item refers to keeping data as close as possible to where it is used

New Material

Writing To a File

One of the methods in the Section class will print a file that will be used to take attendance
So we need to know how to write strings to a file
There are many ways of doing this 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);
        }

    }
}

$ java WriteToFile test.txt

$ cat test.txt 
Line 1 
Line 2 
Line 3

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

Getting Current Date

Another thing we need to do in order to create an attendance file is to learn the current
We can do this using a LocalDateTime object
Which is found in the java.time package

Here is an example

import java.time.LocalDateTime;

public class CurrentDate {
    public static void main (String[] args){
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
    }
}

When we run this we get
```
$ java CurrentDate
2020-04-10T12:40:58.990
```
which has both the date and the time
You can use a DateTimeFormatter object to present the information in any number of formats
But that is too much trouble for what we need to do

Creating an Attendance Sheet

An attendance sheet is a text file whose name will have the format
```
MM-DD_attendance_CLASS_ID_SECTION_NUMBER.txt
```
So the filename for the May 4th meeting of IT 114-1 will be
```
05-04_attendance_it114_1.txt
```
The first line of the line will be a header containing the date course ID and section number
This will be followed by a line of dashes
After this will be a line for each student
It will consist of "__ " followed by the students name
And the phonetic field it it exists
This means we need the following methods
- attendance_file_write - writes the lines of the attendance file
- attendance_filename - creates the filename
- header - creates the header
- student_line - creates a line for each student
Only the first of these methods will be public

Writing the Attendance File

attendance_file_write will do the following
1. Call attendance_filename_create to get the filename
2. Create a FileWriter object for that file
3. Print the output of header_create
4. Loop through the Studentobjects in students printing an entry for each
5. Close the FileWriter object
In order to have a working version of attendance_file_write we will have to write "dummy" versions of the three helper functions

Here is the method

    public void attendance_file_write(){
        String filename = attendance_filename();
        try {
            FileWriter output = new FileWriter(filename);
            output.write(header());
            for (int i = 0; i < students.size(); i++){
                output.write(student_line(students.get(i)));
            }
            output.close();
        } catch (IOException e) {
            System.out.println("Could not create FileWriter on " + filename);
        }
    }

And here are the dummy helper methods

    private String attendance_filename(){
        return "attendance.txt";
    }

    private String header(){
        return "-------------------------------";
    }

    private String student_line(Student s){
        return "";
    }

Now to test with the driver

import java.util.ArrayList;

public class Section4Driver {
    public static void main (String[] args){
        Section4 section = new Section4("IT 114", "Introduction to Java", "1");
        section.add_students("it114-1_student.txt");
        ArrayList students = section.get_students();
        section.attendance_file_write();
    }
}

$ java Section4Driver

$ cat attendance.txt 
-------------------------------

The Name of the Attendance File

We need 4 pieces of information to construct the attendance filename
- Month number
- Day number
- Class ID
- Section number
The first two we can get from a LocalDateTime object
Unfortunately we have to do some work to get them since the result of calling the now method on such an object is something like this
```
2020-04-10T16:23:10.186
```
Two applications of the split method will give us what we need

But the statement

LocalDateTime today = LocalDateTime.now();

does not return a string

It returns a LocalDateTime object
So we have to use the objects toString method to get a string
Then we split that string on "T"
And only keep the first part
This we split on "_" to get values for year, month and day

Here is the attendance_filename method

// create a string of the form MM-DD_attendance_CLASS_ID_SECTION_NUMBER.txt
    private String attendance_filename(){
        // get a string with date and time data
        LocalDateTime today = LocalDateTime.now();
        String today_string = today.toString();
        // get month and day strings
        String [] fields    = today_string.split("T");
        String yr_mnth_day  = fields[0];
        fields              =  yr_mnth_day.split("-");
        String month_no     =  fields[1];
        String day_no       =  fields[2];
        // get class ID in the correct format
        String class_id = this.class_id; // make a local copy we can manipulate
        class_id        = class_id.toLowerCase();
        class_id        = class_id.replace(" ", "");
        String filename = month_no + "_" + day_no + "_attendance_" + class_id + "-" +
            this.section_no + ".txt";
        return filename;
    }

Which we test

import java.util.ArrayList;

public class Section5Driver {
    public static void main (String[] args){
        Section5 section = new Section5("IT 114", "Introduction to Java", "1");
        section.add_students("it114-1_student.txt");
        ArrayList students = section.get_students();
        section.attendance_file_write();
    }
}

$ java Section5Driver

$ cat 04_10_attendance_it114-1.txt 
-------------------------------

Last Two Helper Methods

Only two helper methods remain
- header
- student_line

The first is very simple

    private String header(){
        return this.class_id + "-" + this.section_no + " Attendance\n" +
            "-------------------------------\n";
    }

The second requires more work

Because what appears on the line depends on whether the phonetic field has a value

    private String student_line(Student s){
        String line = "__  " + s.full_name();
        String phonetic = s.get_phonetic();
        if ( phonetic.length() > 0) {
            line += " (" + phonetic + ")";
        }
        System.out.println(line);
        return line + "\n";
    }

Here is the driver and the test results

import java.util.ArrayList;

public class Section6Driver {
    public static void main (String[] args){
        Section6 section = new Section6("IT 114", "Introduction to Java", "1");
        section.add_students("it114-1_student.txt");
        ArrayList<Student> students = section.get_students();
        // add preferred and phonetic fields for Dimetrio
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            String name = s.full_name();
            if (name.contains("Dimetrio")) {
                s.set_prefered("Bill");
                s.set_phonetic("di MEET tree oh");
            }
        }
        section.attendance_file_write();
    }
}

$ java Section6Driver
__  Bill Dimetrio (di MEET tree oh)
__  Andrew Smith
__  Joan Sanders

The Grade Class

Now we need to add the ability to assign grades to Section
When we first created the Section we created the ArrayList field grades
And declared it would contain values of type String
The was done so we could get on with the job of creating the Section class
But we really need another class of objects to hold the grade information for each
It will have three fields
- student_id
- class_id
- grade

Our first version of this class will just have a constructor and toString

public class Grade1 {
    private String student_id;
    private String class_id;
    private String grade;

    public Grade1(String student_id, String class_id, String grade){
        this.student_id = student_id;
        this.class_id   = class_id;
        this.grade      = grade;
    }

    public String toString(){
        return student_id + ", " + class_id + ", " + grade;
    }
}

Here is the driver

public class Grade1Driver {
    public static void main (String[] args){
        Grade1 g = new Grade1("09999999", "IT 114", "A" );
        System.out.println(g);
    }
}

$ java Grade1Driver
09999999, IT 114, A

Checking the Grade

There are only a limited number of possible grades
So we need to create a method to check the grade value
This method will be used in the constructor

Here is the method

    private boolean grade_good(String grade)
        throws IllegalArgumentException{
        switch(grade) {
            case "A":
            case "A-":
            case "B+":
            case "B":
            case "B-":
            case "C+":
            case "C":
            case "C-":
            case "D+":
            case "D":
            case "D-":
            case "F":
                return true;
            default:
                throw new IllegalArgumentException(grade + " is not a legal grade");
        }
    }

The method throws a IllegalArgumentException if the grade is not valid
Here we are using a trick involving a switch statement
If several value have the same result, they can share a code block
This makes the function much more concise
The constructor will call this method

And pass along the IllegalArgumentException if the grade is invalid

    public Grade2(String student_id, String class_id, String grade)
        throws IllegalArgumentException{
        if (grade_good(grade)){
            this.student_id = student_id;
            this.class_id   = class_id;
            this.grade      = grade;

We test it with the driver

public class Grade2Driver {
    public static void main (String[] args){
        try {
            Grade2 g1 = new Grade2("08888888", "IT 114", "XX" );
            System.out.println(g1);
        } catch (Exception e) {
            System.out.println(e);
        }
        Grade2 g2 = new Grade2("09999999", "IT 114", "A-" );
        System.out.println(g2);
    }
}

$ java Grade2Driver
java.lang.IllegalArgumentException: XX is not a legal grade
09999999, IT 114, A-

Finishing the Grade Class

The last thing we need to do is add getters for student_id and grade

    public String get_student_id(){
        return student_id;
    }

    public String get_grade(){
        return grade;
    }

Which we test

public class Grade3Driver {
    public static void main (String[] args){
        Grade3 g = new Grade3("09999999", "IT 114", "A-" );
        System.out.println(g);
        System.out.println("Student ID: " + g.get_student_id());
        System.out.println("Grade: " + g.get_grade());
    }   
}

$ java Grade3Driver
09999999, IT 114, A-
Student ID: 09999999
Grade: A-

You can see the finished Grade class here

Assigning a Grade

To assign grades we have to
- Loop through all the students in the class
- Assign each one a grade
As before we will assign each task to two different methods
- grade_all_students
- grade_create
grade_all_students loops through all the students in a section
It prints the name of each student and obtains the student_id
Which it uses to call grade_create for a Grade object

It then adds the grade to grades

    public void grade_all_students(){
        for (int i =0; i < students.size(); i++){
            Student s = students.get(i);
            System.out.println(s.full_name());
            String student_id = s.get_student_id();
            Grade grade = grade_create(student_id);
            grades.add(grade);
        }
    }

grade_create prompts the user for a grade
Creates a Grade object

Which it returns to the calling method

    private Grade grade_create(String student_id){
        Scanner console = new Scanner(System.in);
        System.out.print("Grade: ");
        String grade_letter = console.next();
        Grade grade = new Grade(student_id, this.class_id, grade_letter);
        return grade;
    }

Running the driver proves it works

import java.util.ArrayList;

public class Section7Driver {
    public static void main (String[] args){
        Section7 section = new Section7("IT 114", "Introduction to Java", "1");
        section.add_students("it114-1_student.txt");
        ArrayList<Student> students = section.get_students();
        section.grade_all_students();
        ArrayList<Grade> grades = section.get_grades();
        for (int i = 0; i < grades.size(); i++){
            Grade grade = grades.get(i);
            System.out.println(grade);
        }
    }
}

$ java Section7Driver
William Dimetrio
Grade: A
Andrew Smith
Grade: B
Joan Sanders
Grade: C
07777777, IT 114, A
06666666, IT 114, B
05555555, IT 114, C