Hi there! We need a group Java statements together in to blocks.
By blocks I mean a block of statements. There are rules though
on how Java works between the blocks. We're going to look at how we create
Java blocks,
how we put them together, and how we start to build these blocks into a full Java
application.
In this lesson we're going to answer what
is a Java statement. We'll look at how to group these statements into a Java
block.
With Java blocks we'll need to understand variable scope
as we nest the Java blocks. We'll also see firsthand why we need to use braces
to define blocks
even when it's not a hundred percent necessary. Let's start with
what is a Java statement. You can think of a statement
in Java similar to a simple sentence. I say simple because
each Java statement should do just one thing.
In Java you can also group statements and represent the collection of statements
as one statement. In Java, statements are read
in your program top-down and then left to right.
Each Java statement represents a command to execute.
With each statement you're basically telling Java "go do this".
Java has two categories of statements available.
Declarative statements and control statements.
Declarative statements do exactly what it sounds like, declare a fact.
I declare a variable of type int named "i"
to be equal to 42. We use declarative statements to assign values to variables.
We also use declarative statements to change the value of variables.
So later on we might say "i" is now 100.
That is also a declarative statement. Control statements help you control the flow the
Java application.
Java has control statements for making decisions, performing loops,
and branching to other sections of code.
A decision control statement would state, if something's "true"
run this block of code. A looping control statement says,
run this code over and over and over until I say stop.
Branching control statements tell Java
to jump over here and run this block of code. An example of running a block of
statements
is when we print things to the screen. Lots of things happen behind the
scenes, but we represent it with this one statement.
So what would we call a group of Java statements?
We call a collection of Java statements a Java block.
Now just like the toys, we connect these blocks with control statements to form a
Java program.
Blocks can then be assembled into larger blocks.
Blocks are usually defined by starting brace
and an ending brace. Let's take a look at the blocks.
A Java program is really a big block made of many little blocks.
The important takeaway here is your Java
application is one big block composed of smaller blocks.
Inside your Java program
you'll have smaller blocks of code. Often these are methods or classes.
We've seen this before. This is the main method which
is the start of every Java application. The main method
is a Java block. Its enclosed in the larger block
up the Java application. The larger block
is made from and encloses smaller blocks. We can keep creating blocks
inside blocks inside blocks to infinity...
It's blocks all the way down. In this case
an if-then control statement, something we're covering in the next lesson,
contains another Java block. At each level
you can see the braces that enclose the Java block.
Of course you don't need braces for every block.
otherwise every statement would need braces around it. Java already has a bad
reputation for having too many braces,
and that would just make it worse. You can have a block that does not have
braces
as this case shows. The if-then control statement can branch to block that is a
single statement.
This is bad form though, and you really don't want to do it.
Now some might argue this point, but spacing is optional and is inconsistent between
developers.
Look at what happens if someone thinks you're adding a statement to the orange
block.
Because of the spacing, they might miss that the orange block
is missing braces. From the indenting, it looks like the two statements are part
of the same block.
Here's what this code really looks like.
The expected behavior is
the second print statement is also not run,
but since is really part of the blue block, and not the orange block,
the second print statement will always be run.
Let's run this in code and see what happens. Here we have the code exactly
how we had it in the slide. We're going step through this program using the
NetBeans debugger.
I'll show you how to do that. First we're going to set a breakpoint
on line 12. What a breakpoint is,
is it tells our debugger stop here
when we start running our code. And then we can implement our code by one step at a
time. So we can actually see the flow of
our application. Now that we've set our breakpoint,
what we're expecting here from the indentation is
this program will run. It will print out byte
b = 42, and then since the block is false,
it shouldn't print out inside block and not inside block.
So we go to "Debug | Debug project".
And then it stops
on our breakpoint. So next we're going to hit this button,
"Step over expression".
We go, and it's the system print out "b = 42",
and prints it out. Then it should be done once it hits the "if (false)",
but it runs the not inside block statement.
That isn't the expected behavior from way it looks.
So our code had "byte b = 42",
and "not inside block". The moral of the story is
don't do this! It's crossing the streams bad.
You never know what's going to happen. Now let's take a look at scope.
In the blue block, we're declaring a variable b and printing it to the screen.
This works because both the declaration and the print
are in the same block. Now look what happens when we declare a variable
inside the orange block.
Here we're declaring a variable "k" and setting it equal to 24.
The declaration happens inside the orange block.
So what do you think happens when we try to print "k" in the blue scope?
Well let's go try. Okay we have the code exactly as we have it in slide.
First thing we're going to do is try to run it. And we hit
"Run | Build project" and we get a compilation error.
This code won't even compile. The error
is it cannot find the symbol on line 18.
Now if we look closely in our code, we would have seen the little
red mark underneath our "k", which would have told us
"Cannot find symbol, Symbol variable k". The reason is
k is not in scope here. The only place k
exists is inside the block of this if statement.
So what we've seen is, k is not visible in the enclosing scope.
You cannot see k in the blue block. It only exists in the orange block.
So what do you think will happen if we try to print b in the orange block?
Let's go try it! Okay we know that we can't print
k here, so let's go ahead and delete that out. Let's see if we can print
b inside the if block. So b is declared above,
outside of the if block. Okay, looks good so far.
And we were able to print b.
So in this case, b is visible. Variables can
be seen only in the block it's defined and in any in block
it encloses. So in this case b can be seen, or
is "in scope", in the blue and orange blocks
The k variable cannot be seen from the blue scope.
It's said to be "out of scope" from the view of the blue block.
Scope sometimes confused with the lifetime with the variable.
Sometimes this is true, but we're going to see in other lessons, the lifetime of the variable can
extend past the scope where the program
is currently running. Right now, just understand how scope works.
The last thing to note is empty blocks.
You've seen your statement can be a complete block
without braces. You can also have braces with no statements inside.
This defines an empty block. If you ever find yourself needing an empty block,
leave a comment inside the empty block noting you did that on purpose
and why. Usually there's no reason to have an empty block.
But you can do it and there's few instances where it might make sense like
in interfaces.
We'll cover that much later. Okay
In this lesson we've learned that a Java statement can either be
a declarative statement or control statement. Declarative statements declare
facts.
And control statements control the flow of your application. We've covered
a ton of declarative statements, so let's start looking at control statements in
the next lesson!
Hey! Thanks for watching the video. There is a quick quiz for this on DeegeU.com to
if you'd
like to gauge how much you learned. If you like the videos are seeing,
please let me know by liking the video and hitting the subscribe button
for the DeegeU channel on YouTube. I'd really appreciate that! If you have concerns or
questions please leave them in the comments below
or on DeegeU.com. There's a poll on the front page
of DeegeU.com so you can also let me know the topics covered
next. Thanks for watching, and see you next video!