Welcome back to CS 124!
Next we’ll continue discussing conditionals. Last time we introduced simple conditional expressions and statements, and blocks. This lesson continues on those topics, introducing a few new wrinkles. We’ll show how you can combine conditional expressions and statements, and discuss how blocks introduce scope to our variables. So let’s get started!
Previously we discussed how you can use conditional operators (<
, >
, <=
, >=
, ==
, and !=
) to create conditional expressions.
For example, to test whether the value stored in the variable speed
is less than 70, we’d use the conditional expression speed < 70
.
Conditional expressions evaluate to boolean
values:
So… great! But what if we want to determine if speed is both less than 80 and greater than 70? Here’s how we would do this:
The example above introduces some new syntax, so let’s look at it carefully.
The example above introduces compound conditional expressions.
They are created from combining multiple individual conditional expressions using two new operators: and (&&
) and or (||
).
Both and (&&
) and or (||
) combine two conditional expressions, one on either side of the operator:
&&
) evaluates to true if both the conditional expression on the right and the left are true
.||
) evaluates to true if either the conditional expression on the right or the left is true
.Let’s look at how they work by example:
By combining simple conditional expressions using &&
and ||
, we can express arbitrary decision-making logic.
For example, if we want to determine if the value of a variable was both greater than 10, less than or equal to 20, and not equal to both 14 and 15:
We’re typically going to keep our compound conditional expressions as simple as possible. But when evaluating a compound conditional expression, Java follows a few rules:
Some of this may seem complicated or confusing! But don’t worry—99% of the conditional expressions you’ll find in real programs are extremely simple. If you find yourself writing something fairly complex in CS 124, please ask for help. There may be a simpler way!
So we can combine multiple conditional expressions together using &&
and ||
to create more complex decision-making logic.
We can also create compound conditional statements to put our conditional expressions to use.
Here’s an example.
Let’s go through it slowly and carefully.
Our code is starting to look more complicated.
But if you break it down line by line, it’s still just made up of the same simple building blocks.
Here’s how Java evaluates an if
statement:
if
branch where the conditional expressions evaluates to true
, it enters that branch and executes itelse
statement (just else
, not if else
), it always enters that blockComputer programs can also make more complex decisions based on multiple pieces of data.
To illustrate this, let's complete the short snippet of code below. You should assume that three variables are
already declared and have their values set: x
and y
, both int
values, and print
, a boolean. You should not
declare or modify their values.
You should write a snippet of code containing a conditional expression to accomplish the following goal. If the
value of x
is strictly greater than y
, you should print "Larger". Otherwise you should print "Smaller".
However, if print
is set to false you should not print anything, regardless of the values of x
and y
.
Last time we introduced the idea of a block of code. We needed blocks so that we could set off the code that should or should not be executed by a conditional statement. And we’ll be using them again later—both to indicate what part of a program should be repeated, and when we start to create reusable pieces of logic called functions.
But there is another important aspect of blocks that we need to discuss. Let’s introduce it using an example:
Try to run the code above. What happens? An error occurs! Why? Because variables are not available outside of the block in which they were declared!
The part of a program in which a variable is available is known as its scope. For the variables that we’ve been using so far, their scope is limited to the block in which they were declared. Note that they can be accessed in blocks declared inside their block, just not outside of their block. That’s hard to explain in words. So let’s talk it through.
At the University of Illinois, we'll say that you're currently a first-year student if you entered in the year 2022.
Given an already-declared int
variable named year
containing the year a student entered, print "First-Year" if
the year is 2022, and "Upper-Level" otherwise.
However, if an already-declared boolean
variable advancedStanding
is true
, then don't print anything at all.
(Because who knows at that point!)
Don't modify year
or advancedStanding
.
CS 124 is designed to give every student a chance to succeed. Below we explain one unusual aspect of the course. You can find more information on the syllabus.
CS 124 submissions are autograded.
With a tiny number of infrequent exceptions, all work submitted in CS 124 is automatically evaluated and feedback returned immediately. Submitted code is examined to determine whether it performs correctly, meets our style guidelines, and for other aspects of code quality. The tools and systems used to do this were developed specifically for CS 124, and provide higher quality and more comprehensive feedback than other similar courses. All code submitted in CS 124 can be submitted an unlimited number of times without penalty—until you reach a deadline (homework or project) or run out of time (on a quiz).
We have embraced autograding for several reasons. It’s not just because the course is large. Autograding provides you with immediate and actionable feedback on your work. Correcting small mistakes isn’t something you only do when learning to program. Correcting small mistakes is most of what programming actually is. We want you to get good at it. The more mistakes you make, the more you’re learning.
Autograding also frees staff time to provide direct student support. Grading code by hand is difficult, boring, time-consuming, and slow, and most humans are terrible at spotting mistakes that are trivial to uncover through automated testing. Put another way: Humans are bad at evaluating code, and computers are good at it. We want the humans in CS 124 doing what humans are good at—working with you one-on-one to support your success in the course. And our autograding tools are pushing the limits of what’s possible through automated analysis.
Need more practice? Head over to the practice page.