Jan 30, 2020 -- Notes

IT 313 -- Jan 30, 2020

Review Exercises

Name four possible input sources for a Scanner object.
Ans: Keyboard, from a file, from the web, from a String. See the InputOutput Example.

Create an ArrayList collection that contains three Person objects. See the person module in the Classes Example. Ans:

public static void main(String[ ] args) {
    ArrayList<Person> col =
        new ArrayList< >(500);
    Person p1 = new Person("Alice", 'F', 21);
    Person p2 = new Person("Barry", 'M', 25);
    Person p3 = new Person("Chloe", 'F', 19);
    col.add(p1);
    col.add(p2);
    col.add(p3);
    System.out.println(col);
}

Modify Exercise 2 to populate the collection with person data read from an input file.
Ans: Here are the contents of the input file persons.txt:

Alice,F,21
Barry,M,25
Chloe,F,19
Danielle,F,27

Here is the main method. It was modified to use a try/catch block (see the Catching Exceptions section below). We used the IntelliJ shortcut Alt-Insert to write the try/catch block:

 public static void main(String[ ] args) {

    File f = new File("persons2.txt");
    Scanner s = null;
    try {
        s = new Scanner(f);
    } 
    catch (FileNotFoundException e) {
        System.out.println("File not found.");
        System.exit(1);
    }

    ArrayList<Person> col = new ArrayList< >(50);
    while(s.hasNextLine( )) {
        String line = s.nextLine( );
        String[ ] fields = line.split(",");
        String name = fields[0].strip( );
        char gender = fields[1].strip( ).charAt(0);
        int age = Integer.parseInt(fields[2].strip( ));
        Person p = new Person(name, gender, age);
        col.add(p);
    }
    s.close( );
    System.out.println(col);
}

Project 4

Look at the Project 4 Description.

Use the String object chars and String array codes to translate an input string into Morse code:

String chars = " ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
String[ ] codes = {"   ", ".-", "-...", "-.-.", "-..", 
    ".", "..-.", "--.", "....", "..", ".---", "-.-", 
    ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", 
    "...", "-", "..-", "...-", ".--", "-..-", "-.--", 
    "--..", ".----", "..---", "...--", "....-", ".....", 
    "-....", "--...", "---..", "----.", "-----"};

Write a method named toMorseCode to perform the translation.
Ans: Here are the source code files.

Wrapper Classes

Problem: create an ArrayList collection with capacity 500 that contains int values. Add these values to the collection:
```
32  19  63  86
```
An ArrayList collection can only contain class objects, it cannot contain primitive types.

To create the ArrayList collection, instead of

ArrayList<int> col = new ArrayList<int>(500);

use

ArrayList<Integer> col = new ArrayList<Integer>(500);

where Integer is the wrapper class for an int value.

We can also use this modern shortcut declaration and instantiation:
```
ArrayList<Integer> col = new ArrayList< >(500);
```
A wrapper class object is an object that contains a primitive type.
Here are some primitive types and their corresponding wrapper classes:

Primitive Type Wrapper Class

int Integer

double Double

char Character

boolean Boolean
Look at the IntegerTest class in the InstanceMethods Example project.
When a primitive value is added to an ArrayList collection, it is automatically converted to a wrapper class object. This process is called boxing:
The programmer writes this:
```
col.add(5);
```
which the compiler converts to this:
```
col.add(new Integer(5));
```

Primitive Type	Wrapper Class
int	Integer
double	Double
char	Character
boolean	Boolean

Catching Exceptions

If your program contains code that might cause an exception, place that code in a try block, then place code that responds to the exception in a catch block. This prevents the program from crashing due to a thrown exception.

For example:

try {
    int x = 3 / 0;
    System.out.println("Quotient == " + x);
}
catch(ArithmeticException e) {
    System.out.println("Division by zero.");
}

One way of determine which catch blocks are needed is to observe the name of the exception when an exception is thrown. Then write a catch block for that exception.

Packages

Java classes can be grouped into packages.
Package names are dot-separated sequences of identifiers, for example:
```
java.util  javax.swing   it313.smith

edu.depaul.it313.sjost
```
The usual inclusion order from largest to smallest is
Project ⊃ Module ⊃ Package ⊃ Class ∋ Method
A class is placed into a package by including a package statement at the top of a class file before the class declaration:
```
package it313.smith;
public class Main {
    ...
}
```
A package can be specified when creating a Java project with IntelliJ.
A class without the package statement at the top of the source code file is considered to be using the default package. Best practice is to specify a package when creating a Java project.
The import statement allows source code to omit package names when referring to classes. For example:
```
import java.util.Scanner;
```
allows a Scanner object to be created as
```
Scanner s = new Scanner(System.in);
```
Without the import statement, the Scanner object is created as
```
java.util.Scanner s = new java.util.Scanner(System.in);
```
Practice Problem: Create the Java package it313.sjost, and the class Greeter inside this package with the method makeGreeting (see the Greeter Example). Then create a Main class not in the package. The Main class should contain a main method that tests Greeter.makeGreeting.
Ans: In IntelliJ, you add a package to a src file by selecting File >> New >> Package. In addition to creating the folders it313 and sjost for the source code files in the package, a class file in the package has this line at the top:
```
package it313.sjost;
```
Here are the Greeter.java and Main.java files:
```
// ***************************************************************
// Source code file: Greeter.java
package it313.sjost;
public class Greeter {
        
    public static String makeGreeting(String name) {
        return String.format("Hello, %s, how are you?", name);
    }
}

// **************************************************************
// Source code file: Main.java
import it313.sjost.Greeter;
public class Main {
    public static void main(String[ ] args) {
        System.out.println(Greeter.makeGreeting("Larry"));
    }
}
```
Notice that the import statement in Main.java allows the Main class to use the Greeter class without qualification. Without the import statement, the Greeter.makeGreeting method is called like this:
```
System.out.println(it313.sjost.Greeter.makeGreeting("Larry"));
```

Review of Inheritance

Read this section to review the concepts of inheritance for Tuesday, Feb 4.
Consider this Employee Hierarchy UML diagram. Here is the short version of the UML diagram:
```
Person ← Employee ← Executive
```
An arrow in a UML diagram means "inherits from."

We know about private (can only use the object within the current class) and public (can use the object anywhere). In addition, we can use protected accessibility, which means that the item is accessible in the current class or in any derived class of the current class.
The is-a test is used to determine whether inheritance makes sense. For example, an Employee is a Person, so it makes sense to make Person the base class and Employee derived class.
Inheritance is the process of creating a derived class from a base class.
The derived class inherits all of the instance variables and methods from the base class.
The derived class can add additional instance variables and methods.
The derived class can also override (replace) methods in the base class with methods of the same name and signatuve that are more appropriate for the derived class.
A derived class object is a specialized version of a base class object with extra capabilities.
Look at the employeehierarchy Module in the Inheritance Example.
Practice Problems
1. Identify the base class and derived class in the following pairs of classes. Use the is-a test.
```
Employee   Manager

GraduateStudent   Student  

Person   Student  

Vehicle   Car      

Car   Minivan  

Truck   Pickup   
```
2. What are other terms for base class and derived class? Ans:
  
  Base Class Derived Class
  
  Parent Class Child Class
  
  Super Class Subclass
3. Identify the inheritance relationships between these classes. Use the is-a test.
```
Student   SeminarSpeaker   Professor   Person   TeachingAssistant
Course   Employee   Seminar   Secretary   Lecture   DepartmentChair
ComputerLab   Janitor   
```
Look at the SocialNetwork Example in the classes2 examples file.

JAR Files

A JAR (Java Archive) file contains compressed Java class files.
JAR files are a preferred format for distributing Java library software.
A command that creates a JAR file from Java class files:
```
java -jf person.jar person.class unit.class
```
Working with JAR Files in IntelliJ

Base Class	Derived Class
Parent Class	Child Class
Super Class	Subclass