You are expected to spend 5-8 hours per week outside the classroom working on this course. Please don't come up short with this time commitment and fall behind!
Announcements
Exam Review Recommendations
Exam - When & Where
Tues Apr 16, 2024 at 4:30pm - 7:30pm in A211
Exam Instructions
This is a closed book exam all done on paper – no notes or other aids are allowed.
(bring pencils, erasers and a ruler)
The exam is out of 102 marks.
You have 3 hours to complete the exam.
The exam consists of 19 pages.
Recommended Review:
Be competent on solving the big fat mark programs listed in class18
Important: We are using an open source version of the JDK (Java Developer Kit) in order to have the JDK
bundled with JavaFX. If you download the JDK from Oracle (Java), you will not get
JavaFX. For ease of ensuring both the JDK and JavaFX is installed on your system and will
work when submitted, please follow these instructions.
Installing Liberica JDK and IntelliJ
Use these instructions so that you install BOTH IntelliJ and JavaFX as a bundle.
There's a scanner reading issue when you read an integer or double and then a string; its got to do with the newline character; here's a fix: scanner and the newline issue
The hierarchy of Exceptions in the Java programming language begins with the Throwable class – which comes from the Object class and is its direct subclass.
Lecture 11.1:Catching Exceptions (30:43 mins) (Sam explains what exceptions are and how to catch them.)
Lecture 11.2:Throwing Exceptions (10:43 mins) (This is the best way to handle unintended errors that might occur in your class.)
What we did in class today: ( Mon Mar 25 2024 )
We introduced the concept of catching unintended user input errors, as well as other errors using the Exception class.
Viewed powerpoint slides regarding throwing exceptions and provided 5 example test questions on exceptions. Also included how to make your own RuntimeException.
Practiced on an Exam Question involving both catching and throwing exceptions. (Division_Question)
Build the Vehicle project. Began by creating concrete classes, then added an abstract class called Vehicle. Also added an interface called, Rollable. Concluded by building a polymorphic array of vehicles.
Inspiration & Amazing Thinking
James Outman on being super-locked-in James is a 24 year-old professional baseball player who has just earned an outfield spot on opening day for the LA Dodgers. He speaks about how he admires how his teammates are super locked in when they practice.
Here's an example of determination and an amazing problem solving ability. Watch how Kato perseveres and comes up with a creative solution. Kato pulling Braden on a Snow Sled
In Java, an abstract class is a class that cannot be instantiated and is intended to be subclassed by other classes. The main purpose of an abstract class is to provide a common interface for its subclasses while encapsulating implementation details.
Advantages of Abstract Classes
Classes like Shape and GeometricObject are generic and don't really have a "look" to them.
Classes can't be instantiated with the "new" statement.
Abstract classes are in italics in UML diagrams
Some or all of the abstract class methods can also be marked as abstract. In this case, you don't require to supply an implementation.
Abstract classes can hold common code so that it doesn't need to be repeated in each subclass.
Simple Example 1
Abstract_Example_1b.zip (
code )
Abstract classes allow you to define a common interface for a set of subclasses, while hiding implementation details that are not relevant to the interface. This helps to reduce complexity and improve code maintainability.
This example demonstrates how abstract classes can be used as a base class for other classes to inherit from. By defining common behaviour in the abstract class, subclasses can avoid repeating the same code and focus on implementing their specific functionality.
In Java, an interface is a type that defines a contract for the behaviour of a class. An interface specifies a set of methods that a class must implement, but it does not provide any implementation itself. In other words, an interface defines what methods a class must have, but not how those methods should work.
Within the interface, you can declare any number of method signatures, but you cannot provide implementations for them.
Lecture 9.0:
Abstract Classes
(12:36 mins)
( In this video Sam explains abstract classes. )
Lecture 9.1:
Interfaces
(17:22 mins)
( In this video Sam explains interfaces. )
Lecture 9.2:
Polymorphism Explained
(20:12 mins)
( In this video Sam explains the concept of polymorphism. )
What we did in class today: ( Mon Mar 11 2024 )
We introduced the concept of abstract classes and interfaces. The classes we've been dealing with so far are called concrete classes. Next, we discussed Polymorphism, which comes from the Greek and means many forms.
Polymorphism
In Java, polymorphism refers to the ability of objects of different classes to be treated as if they are objects of the same class.
Polymorphism is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its parent class. The correct method to be called is determined at runtime based on the actual object that the method is called on.
Java inheritance is a mechanism that allows a new class to be based on an existing class, inheriting all of its properties and behaviours. The existing class is called the superclass, and the new class is called the subclass.
Inheritance in Java is achieved using the extends keyword, which specifies the superclass that the subclass is extending. The subclass inherits all of the public and protected properties and behaviours of the superclass, and can also define its own properties and behaviours.
Overloading ( In Java, method overloading refers to the capability of defining multiple methods in the same class or in a parent class with the same name but different parameter lists. That is, overloaded methods have the different method signatures.
Same Method Name: Overloaded methods have the same name within the class.
Different Parameter Lists: Overloaded methods must have different parameter lists, which can vary in terms of the number of parameters, their types, or their order.
Return Type: Overloaded methods can have the same or different return types.
Overriding ( In Java inheritance, overriding refers to the capability of a subclass to provide a specific implementation of a method that is already defined in its superclass. When a subclass provides its own implementation of a method that is already present in its superclass, it is said to be overriding that method. )
When overriding...
to find the right method to run, START looking in the current class of the object and if not found work your way up the hierarchy until you find the a method within some relative (e.g. superclass).
Example: see the toString() method(s) from the Animal example
Video 800:Java Inheritance Explained (6:11 mins) ( In this example a Vehicle superclass is built and three subclasses are created, a Car, Bicycle and Boat. )
Lecture 8.0:Java Inheritance (26:54 mins) ( Sam Scott starts off discussing inheritance is general terms and then explains Example 2 above, i.e. how to reduce code via inheritance )
we introduced the concept of Inheritance using Simple Example 1 about animals and Simple Example 2 about a father and son to demonstrate Java inheritance.
UML diagrams ( explained "is a" and "has a" relationships; also about arrow shapes ) Animal, Bird, Wug
Inheritance gives us a way to reduce repetitious code. Used the Before and After inheritance example to demonstrate.
SimonSays: reduced code within BeforeInheritance.zip
Terminology
Method Signature is the combination of a method's name and its parameter list.
Association represents a relationship between two classes where one class is related to another class in some way. It is a "has-a" relationship, where one class has a reference to another class as a member variable.
For example, consider a class Car and a class Engine. The Car class may have an instance variable of type Engine, representing the engine of the car. This is an association between the Car and Engine classes.
class Car {
private Engine engine;
// other members and methods
}
class Engine {
// engine-specific members and methods
}
Inheritance is a mechanism in Java that allows a class to inherit properties and behaviors (methods) from another class. It is an "is-a" relationship, where one class is derived from another class.
The derived class (subclass) inherits the members (variables and methods) of the base class (superclass). This allows code reuse and promotes the concept of hierarchical classification. In Java, inheritance is implemented using the extends keyword.
class Vehicle {
// vehicle-specific members and methods
}
class Car extends Vehicle {
// car-specific members and methods
}
We began by building two GUI apps. A pitch counter and a bank app. We discussed event driven handler routines and GUI component styling.
Assignment #3 - Robots
Recommended: the various classes that you are required to build are SO SIMILAR to the
circle.java
class. That is, each class will need a .draw(gc) routine, just like the circle class has. Also, feel free to use the circle.java and
rectangle.java classes if they help in building your robots.
The following additional files are also required; but they need renaming as follows:
App.java.txt ( GraphicsTemplate with main pgm )
Head.java.txt
Player.java.txt
Team.java.txt
Wheel.java.txt
Important: when you upload to canvas, you should see 6 files as mentionned above. TurnItIn needs to scan the *.txt files. Your Submitted Files should look like this.
Note: if you use the circle and/or the rectangle class, don't include them the *.java.txt list above.
We began reviewing what an array of objects looks like in memory. Next we repeated a simon-says of the BankAccount exercise from a previous class. The BankAccount problem illustrates:
a static class variable, i.e. nextId
overloaded constructors, (always write the most complicated constructor first, then use this( ) to call the complicated constructor while making the additional overloaded constructors.
we added some getters and setters with IntelliJ's generate tool
Next, we saw a demo of the A2-VendingMachine.
We practiced making UML's with draw.io using the Pet project as an example.
Finally, we used draw.io to make a UML for the RemoteToyHelicopter.
Lecture 3.1:
Objects and Instance Variables (40:00 mins) ( Sam explains what a class is and how it contains properties. He explains what a reference address is and how it points to a class after the new keyword is executed. Sam discusses equality of objects and warns us not to confuse equality of references with equality of objects. At the end Sam, discusses free software to draw UML diagrams. ( https://umlet.com )
Lecture 3.2:
Instance Methods (24:51 mins) ( Sam explains that class methods describe the behaviour of what the
class can actually do. He uses a Circle class as an example, and writes .getArea(), .getRadius( ), .setRadius( ) and .draw( ) which draws the circle on a canvas. Sam also explains more about references which point to objects.
What we did in class: Mon Jan 22, 2024
We began by defining the term class and object. We defined the term UML and discussed how it is useful in the design process.
Next, we created a histogram of 500 dice throws using the Die class.
We watched a video on Neural Pathways, to emphasize how practice and reps affect our learning.The obstacle system was explained and the first obstacle program was given out in class. (i.e. OB3). The problem needs to be submitted back to the instructor in one week.
The A2-VendingMachine today is a good example of the model and view concept. The next A2 assignment was assigned.
The model, i.e. VendingMachine.java, MUST NEVER communicate with the user, i.e. use System.out.print( ). All output comes from the view, i.e. Breakroom.java
All displays of money, must be formatted to look like money. i.e. use System.out.printf("%.2f", moneyAmount);
Hand in Requirements:
Your submission must include 4 files.
A2.zip ( the full IntelliJ project )
VendingMachine_UML.png
Two additional files are also required; but they need renaming as follows:
Breakroom.java.txt ( contains your main method )
VendingMachine.java.txt
Important: when you upload to canvas, you should see 4 files as mentionned above. TurnItIn needs to scan the *.txt files. Your Submitted Files should look like this.
UML stands for Unified Modeling Language, and it is a standardized modeling language used in the field of software engineering to visualize, specify, construct, and document the artifacts of a software system. UML provides a set of graphical notations and a framework for modeling object-oriented systems.
Method Overloadingexampleanother example Method overloading in Java refers to the ability to define multiple methods in the same class with the same name but different parameters. In other words, two or more methods in the same class can have the same name as long as they have a different number or type of parameters.
Middle number of 3 -- determines the middle number of 3 -- ( uses method overloading )
(
code
)
( zip )
Video 40:User-defined Methods (10 mins) Demonstrates how to create a method which is called from the main program. The method also contains 2 arguments and 2 parameters.
What we did in class: Tue Jan 16 & Thurs Jan 18, 2024
We began by discussing static methods. Next, we defined the term overloading and gave a few examples of overloaded methods.
Selecting the middle number of 3 also illustrated overloading.
Next, we discussed breaking up hard problems to solve into several smaller easier problems. We used an array ROTATE example to illustrate the point.
We concluded by watching a word guessing game video. In W8 we produce our own word guessing game.
Scanner's Secret Issue ( wrt to consuming the newline character left in the buffer )
When using Scanner in Java to read input, you may encounter issues with newline characters being left in the input buffer, especially when switching between reading different types of data (e.g., reading an int followed by a double).
In such cases, you can use input.nextLine() to consume the newline character and move to the next line.
Here's an example: Scanner's Secret Problem ( if you run this program you'll see the issue. To fix the issue, uncomment the scanner.nextLine(). )
JavaFX Graphics - with Circle( )
This program uses pre-built classes and illustrates how to ...
ask the user a question in a graphics program.
insist the user's response is in a given range.
generate random integers.
use an already built Circle( ) class in your graphics program.
Reading a Dictionary of 173K works called,
words.txt ( code ) (
zip )
Identifying words ending in ...ING
Write a Java program to visit every word in the dictionary and display the words which end in ing. Save the ing words in a file called, INGwords.txt. Also, display the total number of words found that end in ing.
Recall, the string method
.containsThis program requires the words.txt dictionary file.
( code )
( zip )
Picking Random 5-Letter Word
Write a Java program which displays a random 5-letter word from the dictionary.
This program requires the
words.txt dictionary file.
( code )
( zip )
Writing to a File
This program creates and writes one line to a new text file.
( code )
Video 30:if statements with AND ( && ) and OR ( || )(12:28 mins)
We began by reaching back to class 2 and introduced Java Arrays, using the Array flash card powerpoint file. This is a stack of flashcards which you should review over-and-over until you become strong in arrays.
The Scanner class has a weird issue regarding reading ints and doubles. We discussed this issue and saw an example which illustrates what happens if you don't clear the buffer after reading an int or double and then read a String.
We began by discussing the syntax of DO WHILE. The DO WHILE loop is a good choice for validating input data. We did a Simon Says example where we used a Circle() class and a DO WHILE to generate random circles on the canvas. We then used a Rectangle() class to do the same thing. This example might help with A1-Arkanoid.
Next, we discussed the SYNTAX of various control structures, like IF, WHILE, DO WHILE, and FOR.
Below are flash cards with a lot of repetition to help you build and consolidate your understanding of Java arrays. Practice using the POWERPOINT file, running through these slides until you're knowledge of arrays is strong.
Video 21:String Functions (17:02 mins) This video begins discussing special characters, e.g. \n, \", \\, and + Next various string methods are demonstrated, e.g. toUpperCase(), toLowerCase(), .length(), contains(), charAt(), indexOf(), substring()
What we did in class: Tue Jan 9, or Thur Jan 11, 2023
We began by discussing string methods as well as common methods used with numbers. Block level scope was discussed. We fixed two programs that had scope error issues.
Next, we discussed casting and where and when it is commonly used.
It was emphasized that a good understanding of Arrays are essential to this course. The Array Flashcards should be mastered.
We outlined the importance of good documentation and the minimum standards required for documentation when submitting your program. Packages are a good way to organize like-minded java files.
Today's worksheet centers on mastering format strings found in printf and String.format( )
There's a scanner reading issue when you read an integer and then a string; its got to do with the newline character; here's a fix: scanner and the newline issue
JavaFX Graphics
IMPORTANT: when doing graphics, always start off with the graphics template: FXGraphicsTemplate.java
Lecture 1.3:
JavaFX Graphics (27:48 mins) ( Sam explains how to draw onto the graphics canvas. He explains how to start with a special graphics template file. Next, he draws rectangles, circles and arcs. Sam explains about changing colour with Color.web( ) method. Additional methods are discussed: setLineWidth( ), fillText( ), setFont( ), fillArc( ) )
What we did in class: Mon Jan 8 2023
We began by discussing what the JVM is and how to install it on your system at home.
Next we reviewed data types, primitives versus objects. A special discussion took place about comparing variables by contrasting == and .equals().
We empathized that the term "class" means "blueprint" and "object" means "an instance of an class".
Next, we discussed displaying output via, .print( ), .println( ) and .printf( ). We demonstrated how to accept user input using the Scanner class. A awkward adjustment was introduced regarding Scanner when reading integers followed by strings. We used the TipCalculator to demonstrate Scanner and the adjustment.
Next, we ran our first JavaFX program called, the Happyface. We looked at simple drawing tools and then discussed starting templates. Next, we ran a program which imports images as well as a program which demonstrates animation with a ball rolling across the canvas.
The expectations i.e. protocol, regarding worksheet submissions was discussed. The first two worksheets were assigned.
Java Final Exam Flash Cards ( pptx )
