IT 114: Introduction to Java

IT 114: Introduction to Java
Class 34

Topics

Review

Reusing Classes
Inheritance
Honesty and Trust
Fairness

New Material

Creating Superclasses
The Movie Subclass
Creating Subclass Constructor
Calling a Superclass Constructor
Using Superclass Methods
Movie Accessor Methods
Mutator and Accessor for actor Field
A General Method for Checking String Values
Checking Movie Values
The Instructional Class

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

Reusing Classes

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

Principles of Inheritance

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

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 embezzlement?
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

New Material

Creating Superclasses

In practice, you almost never create an object of the superclass
The superclass is just a place to store attributes and methods the subclasses will use
The superclass contains methods and fields that are shared by all subclasses
You can count on having certain methods and attributes in each subclass you create

The Movie Subclass

The first subclass we will create will be for movies
Every movie entry will have the four attributes of the Video class
- collection_no
- title
- length
- format
But it will also have the following additional attributes
- director
- studio
- actors
The fields director and studio will be set by the constructor
But actors can have many entries
So we'll make it an ArrayList of strings
The constructor will create the object
But adding individual actors will be left to a mutator method we will define later

Here are the fields for Movie

    private String director;
    private String studio;
    private ArrayList actors;

Creating Subclass Constructor

When we declare a subclass, we need to tell the Java interpreter what class we are using as a base class

We do that using the following format

public class SUBCLASS_NAME extends SUPERCLASS_NAME

The Movieconstructor will have 6 parameters
Four from Video
- collection_no
- title
- length
- format
And two for it's own fields
- director
- studio

So you might think that you could write

import java.util.ArrayList;

public class Movie1 extends Video {
    private String director;
    private String studio;
    private ArrayList<String> actors;

    public Movie1 (int collection_no, String title, int length, 
        String format, String director, String studio){
        this.collection_no = collection_no;
        this.title         = title;
        this.length        = length;
        this.format        = format;
        this.director      = director;
        this.studio        = studio;
        this.actors        = new ArrayList<>();
    }
}

But you would be wrong

$ javac Movie1.java
./Movie1.java:9: error: constructor Video in class Video cannot be applied to given types;
        String format, String director, String studio){
                                                      ^
  required: int,String,int,String
  found: no arguments
  reason: actual and formal argument lists differ in length
./Movie1.java:10: error: collection_no has private access in Video
        this.collection_no = collection_no;
            ^
./Movie1.java:11: error: title has private access in Video
        this.title          = title;
            ^
./Movie1.java:12: error: length has private access in Video
        this.length        = length;
            ^
./Movie1.java:13: error: format has private access in Video
        this.format        = format;
            ^
5 errors
...

A subclass cannot set the fields in its base class
It has to call the base class constructor to do that

Calling a Superclass Constructor

You can call the constructor of a superclass using the following format
```
super(EXPRESSION, ...);
```

So we can rewrite our constructor

    public Movie2 (int collection_no, String title, int length, 
        String format, String director, String studio){
        super(collection_no, title, length, format);
        this.director      = director;
        this.studio        = studio;
        this.actors        = new ArrayList<>();
    }

And the driver shows it works

public class Movie2Driver {
    public static void main (String[] args){
        Movie2 m = new Movie2(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
        System.out.println(m);
    }
}

$ java Movie2Driver
#1: Forbidden Planet, 98 minutes, DVD

Notice that the toString method from Video works in Movie
But it does not show the fields inside Movie

Using Superclass Methods

We can override the toString method of the Movie class by writing our own
To do this properly, we need to access the toString method of the base class
To do this we have to use the keyword super and dot notation
super refers to the parent class
When we use it followed by parentheses, () it is the constructor of the superclass
We can use it with dot notation to class a method in the parent class
Or access a field

The new constructor will look like this

public String toString(){
        return super.toString() + ", " + director + ", " + studio;
    }

And here is the driver to test it

public class Movie3Driver {
    public static void main (String[] args){
        Movie3 m = new Movie3(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
        System.out.println(m);
    }
}

$ java Movie3Driver
#1: Forbidden Planet, 98 minutes, DVD, Fred McLeod Wilcox, MGM

Movie Accessor Methods

We need to write accessors for the three Movie fields
We will put off dealing with the studio field for now

Here is the code

	public String director(){
        return director;
    }

    public String studio(){
        return studio;
    }

And the driver

    public class Movie4Driver {
    public static void main (String[] args){
        Movie4 m = new Movie4(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
        System.out.println("Collection #: " + m.collection_no());
        System.out.println("Title: " +        m.title());
        System.out.println("Length: " +       m.length());
        System.out.println("Format: " +       m.format());
        System.out.println("Director: " +     m.director());
        System.out.println("Studio: " +       m.studio());
    }
}

$ java Movie4Driver
Collection #: 1
Title: Forbidden Planet
Length: 98
Format: DVD
Director: Fred McLeod Wilcox
Studio: MGM

Notice that the driver does not have to anything special to use the the getters from the Video class
As opposed to the Movie class

Mutator and Accessor for actor Field

Here is method to add actors to the actors ArrayList

public void add_actor(String actor){
        actors.add(actor);
    }

The getter method needs to construct a string from the actors

    public String actors(){
        String value = "";
        for (int i = 0; i < actors.size(); i++){
            value += actors.get(i) + " ";
        }
        return value;
    }

Here is the driver

public class Movie5Driver {
    public static void main (String[] args){
        Movie5 m = new Movie5(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
        m.add_actor("Walter Pidgeon");
        m.add_actor("Anne Francis");
        m.add_actor("Leslie Nielson");
        m.add_actor("Warren Stevens");
        System.out.println(m.actors());
    }
}

$ java Movie5Driver
Walter Pidgeon Anne Francis Leslie Nielson Warren Stevens

A General Method for Checking String Values

The Movie Constructor should check the length of strings it it receives for director and studio
And add_actor should do the same
We already did this in the Video class with title_good
Why will refactor this class so it can check the length of string in all subclasses
There are values used in title_good, that make it work for only the Video title field
- "Title" used in constructing the exception
- MIN_TITLE_LENGTH
- MAX_TITLE_LENGTH
We replace these with three new parameters
- field_name
- min
- max

Here is the new version

    public boolean name_good(String field_name, String value, int min, int max) 
        throws IllegalArgumentException {
        if (value.length() < min || value.length() > max){
            throw new IllegalArgumentException(field_name + " must be between " +
                min + " and " + max + " characters long");
        } else {
            return true;
        }
    }

We also have to change the Video Constructor

    public Video5(int collection_no, String name, int length, String format)
        throws IllegalArgumentException {
        if (name_good("name", name, MIN_NAME_LENGTH, MAX_NAME_LENGTH) && 
            length_good(length) && format_good(format)){
            this.collection_no = collection_no;
            this.name = name;
            this.length = length;
            this.format = format;
        }
    }

Here is the driver

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

$ java Video5Driver
java.lang.IllegalArgumentException: name must be between 2 and 250 characters long
#1: Forbidden Planet, 98 minutes, DVD

Checking Movie Values

We can now use the method created above to check the field values in Movie
We will need constants for the maximum and minimum string lengths

We will use these two for director and actors

    final int MIN_NAME_LENGTH = 10;
    final int MAX_NAME_LENGTH = 50;

We will need another set of constants for studio

    final int STUDIO_MIN_LENGTH = 3;
    final int STUDIO_MAX_LENGTH = 25;

Now we add two calls to Video5. in the constructor

	public Movie6 (int collection_no, String title, int length, String format, String director, String studio) {
        super(collection_no, title, length, format);  
        if (super.name_good("director", director, MIN_NAME_LENGTH, MAX_NAME_LENGTH ) &&
            super.name_good("studio", studio,STUDIO_MIN_LENGTH, STUDIO_MAX_LENGTH)) {  
            this.director = director;
            this.studio   = studio;
            this.actors   = new ArrayList<>();
        }
    }

And another call to add_actor

public void add_actor(String actor){
        if (super.name_good("actor", actor, MIN_NAME_LENGTH, MAX_NAME_LENGTH )) {
            actors.add(actor);
        }
    }

Here is the driver

public class Movie6Driver {
    public static void main (String[] args){
        try {
            Movie6 m1 = new Movie6(1, "Forbidden Planet", 98, "DVD", "", "MGM");
            System.out.println(m1);
        }   catch (Exception e1){
            System.out.println(e1);
            try {
                Movie6 m2 = new Movie6(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "");
                System.out.println(m2);
            } catch (Exception e2) {
                System.out.println(e2);
                try {
                    Movie6 m3 = new Movie6(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
                    m3.add_actor("X");
                    System.out.println(m3);
                    System.out.println(m3.actors());
                } catch (Exception e3) {
                    System.out.println(e3);
                    Movie6 m4 = new Movie6(1, "Forbidden Planet", 98, "DVD", "Fred McLeod Wilcox", "MGM");
                    m4.add_actor("Walter Pidgeon");
                    m4.add_actor("Anne Francis");
                    m4.add_actor("Leslie Nielson");
                    m4.add_actor("Warren Stevens");
                    System.out.println(m4.actors());
                }
            }
        }
    }
}

$ java Movie6Driver
java.lang.IllegalArgumentException: director must be between 10 and 50 characters long
java.lang.IllegalArgumentException: studio must be between 3 and 25 characters long
java.lang.IllegalArgumentException: actor must be between 10 and 50 characters long
Walter Pidgeon Anne Francis Leslie Nielson Warren Stevens

You can see the full code here

The Instructional Class

Let's create another subclass of Video
Videos from
I buy instructional videos from The Great Courses
Each set of videos is for a specific course ...
taught by a Professor in the field
Each individual DVD has 6 lectures ...
of 30 minutes each
Each course has several DVDs
Here is the list of attributes for this class
- __course_name
- __company
- __disc_number
- __instructor
- __lectures
The first 4 numbers will be set by the constructor ...
The names of the 6 lectures on the disc ...
will be stored in a the list __lecture_names