COSC 123 - Computer Creativity
Lab 7: Classes, Inheritance, and Polymorphism

In this lab, we will practice with classes and inheritance in Java. The tutorials in the lab will be presented by the TA step-by-step. However, you are free to work at your own pace on the lab. The lab assignment questions will not be presented by the TA.

Tutorial #1

This tutorial will demonstrate how to create a class with instance variables and methods.

Step #1: Creating a Person Class

Create a new project called Lab7 and a new class inside the project called Person. This class should be public and it should not have a main method. Create a second class called TestPerson that has a main method.

Step #2: Adding Instance Variables

Add to the Person class the instance variables firstName, lastName, and birthYear. All instance variables should be private.

Step #3: Constructors

A constructor is a special method that builds an object when new is called. If you do not create a constructor, Java automatically creates a constructor for you with no parameters which is called the default constructor. We will create the default constructor and our own constructor that takes in the values of the instance variables as parameters. The code is below. Eclipse will build a constructor for you. Select Source from the menu then Generate Constructor Using Fields...

Just click OK in the window that prompts for the fields to build a constructor for. Repeat the process again, but this time uncheck all fields to produce a default constructor.

The result should look like this. For now, ignore the super() call. The this. means change the instance variables of this object.

Step #4: Adding Getter/Setter Methods

Since instance variables are private, we need methods to get or set the values of these variables. These are called getter/setter methods. These have a standard naming convention. For the variable firstName, the get method would be String getFirstName() and the set method would be void setFirstName(String fname). Notice that the get method has no parameters but returns a string (the first name), and the set method returns nothing but takes as a paramteter a string that represents what the first name should be set to. You could type these methods yourself, but Eclipse makes it easier for you. Under Source menu select Generate Getters and Setters.... Make sure all fields are checked (you want to generate get/set methods for all your instance variables), then click OK.

The code results for two of the instance variables:

Step #5: Adding Other Methods

You can create as many methods as you want in your class. We will add two more methods: int getAge() will calculate the user's age based on the current date (may be imprecise as only storing year) and String getFullName() which will return their full name. One special method is toString(). This method is used by Java whenever it has to convert your object into a string (like when it needs to print it). By defining this method, it is easier to see what objects contain rather than calling lots of get methods. The code is below. You will need to import java.util.Calendar and java.util.GregorianCalendar.

Step #6: Creating Object Instances

In the main method of the TestPerson class, we will create two new Person object instances. One uses the default constructor while the other uses the customer constructor with values "Joe", "Smith", 1990. The default constructor creates an "empty" object. We can use the set methods to set the first name, last name, and year to "Fred", "Walter", 1980 respectively. Finally, we use some of the getter methods to retrieve the data and show how toString() can print out an entire object however we decide to format it. The final code files are: Person.java and TestPerson.java.

Output:

Fred was born in: 1980
Info about Joe: First name: Joe Last name: Smith Year: 1990

Tutorial #2

In this tutorial, we will learn how we can use inheritance to define similar objects.

Step #1: Two New Classes

In your Lab7 project, create two new classes (no main methods) called Student and Instructor. The Student class should have instance variables major and gpa. The Instructor class should have instance variables salary and department. Create the appropriate getter/setter methods.

Step #2: Inheritance

Inheritance is a method for extending existing classes. A new class inherits properties and methods from an existing class. In our example, the two new classes Student and Instructor can inherit from the existing class Person. This is beneficial as we can use the existing instance variables and methods in the class that we inherit from. To denote inheritance, we say class Student extends Person. Person is called the superclass, and Student and Instructor are called subclasses.

Step #3: Constructors

Create a default and overloaded constructor for both Student and Instructor. In this case, Eclipse will not automatically generate an overloaded constructor that has all fields of the subclass and all fields of the superclass. You will have to manually edit.

Step #4: Polymorphism

Polymorphism is when a method that is defined in both a superclass and subclass is dynamically selected based on the object type. Let's define a toString method for both new subclasses. Then, create a new class with a main method called TestInheritance.java with code as below. Note that the object reference is of type Person. When the toString method is called, the system calls the correct toString method based on the type of object not the type of the object reference. The final code files are: Person.java, Instructor.java, Student.java, TestPerson.java, TestInheritance.java.

toString method for Student:

toString method for Instructor:

main method in TestInheritance.java:

Output:

Printing student: First name: Amy Last name: Winters Year: 1990 Major: Computer Science GPA: 4.0
Printing instructor: First name: Steve Last name: Smith Year: 1960 Salary: 70000.0 Department: Unit 4

Asteroids Game Project

Starting in this lab, the labs are designed to construct the components of the simple game Asteroids. Each lab will build one part of each project.

Lab Question #1 - Asteroids Game (20 marks)

We will begin with creating four classes for use with our asteroids game:

GameObject Class

This is the superclass for all game objects. Instance variables:

• Two double variables locationX and locationY to track the location of the object.
• Two double variables speedX and speedY to track the speed of the object.
• Two double variables sizeX and sizeY to track the size of the object.
• Make sure to create getter/setter methods for all instance variables.

Methods:

• Create a constructor that initializes all instance variables. Also create a default constructor.
• String toString() - Writes out "Location: ([locationX,locationY]), Speed: ([speedX],[speedY]), Size: ([sizeX,sizeY])".

Ship Class

This class inherits from GameObject class and will represent our spaceship. New instance variables:

• Two double variables acclerationX and accelerationY to track the acceleration of the object.
• An integer variable storing the number of lives (numLives).
• Make sure to create getter/setter methods for all instance variables.

Methods:

• Create a constructor that initializes all instance variables (including those of the superclass). Also create a default constructor.
• String toString() - Writes out all the information from the superclass then also "Accleration: ([accerlationX,accelerationY]), Num.Lives: [numLives]".
• void accelerate(double accX, double accY) - Change acceleration for both horizational and vertical directions.

Asteroid Class

This class inherits from GameObject class and will represent the asteroids that we will shoot. New instance variables:

• An integer variable, type, that denotes the size/shape of the asteroid. The largest asteroids are type 3. A type 3 explodes into a type 2 (smaller) asteroid. A type 2 asteroid explodes into a type 1 asteroid.
• Make sure to create getter/setter methods for all instance variables.

Methods:

• Create a constructor that initializes all instance variables (including those of the superclass). Also create a default constructor.
• String toString() - Writes out the all the information from the superclass then also "Type: [type]".
• Asteroid explode() - Explodes the current asteroid into a new asteroid of the next smallest size. A type 1 asteroid explodes into nothing (return null). For now, the new asteroid after explosion has the same position and speed as the original asteroid. The sizeX and sizeY of the asteroid is 20*type.

Asteroids Class

This is the main class. It has no instance variables. It has no methods. In the main method we will create and print three objects:

• Create a GameObject using the default constructor and print it.
• Create a Ship object with the overloaded constructor with parameters: (100,200,5,5,30,30,1,1,3).
• Crate a Asteroid object with the overloaded constructor with parameters: (50,50,-5,-10,60,60,3).
• Create a GameObject object reference. Assign the Ship object to it and print it. Do the same with the Asteroid object. This is an example of polymorphism as the correct toString() method will be called automatically based on the object.
• Call explode method on asteroid created and print out the result.

An example output when running the main class is:

Game object: Location: (0.0,0.0) Speed: (0.0,0.0) Size: (0.0,0.0)
Ship: Location: (100.0,200.0) Speed: (5.0,5.0) Size: (30.0,30.0) Acceleration: (1.0,1.0) Num.Lives: 3
Asteroid: Location: (50.0,50.0) Speed: (-5.0,-10.0) Size: (60.0,60.0) Type: 3

Ship: Location: (100.0,200.0) Speed: (5.0,5.0) Size: (30.0,30.0) Acceleration: (1.0,1.0) Num.Lives: 3
Asteroid: Location: (50.0,50.0) Speed: (-5.0,-10.0) Size: (60.0,60.0) Type: 3

Exploding asteroid: Location: (50.0,50.0) Speed: (-5.0,-10.0) Size: (60.0,60.0) Type: 3
New asteroid: Location: (50.0,50.0) Speed: (-5.0,-10.0) Size: (40.0,40.0) Type: 2

Submission Instructions and Marking

For this lab assignment, each group should submit using Connect all the Java files for the questions. Please submit a zip containing all Java files.

Grading (20 Marks Total)

Question #1 (20 marks)

1. +1 - for creating Asteroids class
2. +4 - for main method in Asteroids class that creates and prints several objects
3. +2 - for creating GameObject class with instance variables and getter/setter methods
4. +1 - for GameObject default and overloaded constructor
5. +1 - for GameObject toString() method
6. +2 - for creating Ship class with instance variables and getter/setter methods
7. +1 - for Ship default and overloaded constructor
8. +1 - for Ship toString() method
9. +1 - for Ship accelerate method
10. +2 - for creating Asteroid class with instance variables and getter/setter methods
11. +1 - for Asteroid default and overloaded constructor
12. +1 - for Asteroid toString() method
13. +2 - for Asteroid explode() method