Hi! My name is Mosh and I'm gonna be your
instructor in this Java course. In this
course, you're gonna learn everything you
need to get started programming in Java.
We'll start off by installing all the
necessary tools to build Java
applications then you're gonna learn
about the basics of Java you'll learn
how Java code gets executed you'll learn
how to build simple algorithms and
throughout this course I'm gonna share
with you lots of tips and shortcuts from
my years of experience I'll teach you
how to write good code like a
professional developer so we'll end up
watching this course you will have a
solid foundation in Java and be ready to
learn about advanced Java features I've
designed this course for anyone who
wants to learn Java if you're a beginner
don't worry I'll make Java super simple
and hold your hands through this entire
course you're not too old or too young
you'll write your first Java program in
minutes
my name is mosh I'm a software engineer
with two decades of experience and I've
taught over 3 million people how to code
and how to become professional software
engineers I have a coding school at code
with mass comm where you can find plenty
of courses that help you take her coding
skills to the next level I hope you'll
stick around and learn this beautiful
and powerful programming language and
now award from this video sponsor as
someone who runs an online business I
cannot stress enough the importance of
staying safe online which is why I was
so excited when dashlane reached out to
me if you don't know - Lane is the
password manager and VPN recommended by
Apple and Google and it's a fantastic
safeguard for keeping your information
secure it's completely free to use for
your first device so head over to - Ling
comm / marché - give it a go if you want
to upgrade to the premium to get VPN or
dark web monitoring you can use the
promo code mosh to get 10% off sign up
for - 9 today and keep yourself safe
online now back to the course
in this java tutorial we're going to
download and install the necessary tools
to build java applications so open up
your browser and search for jdk download
jdk is short for Java development kit
and it's basically a software
development environment for building
Java applications it has a compiler it
has a bunch of code that we can reuse it
has a Java Runtime environment at a
bunch of other stuff so over here you
can see this page on Oracle com Java se
which is short for Java standard edition
click on this now over here click on
this icon now on this page we can see
Java development kit for various
platforms like Linux Mac OS and Windows
here I'm on a Mac so I'm gonna download
this dmg file over here now before we do
this first we need to accept the license
agreement all right now let's download
the dmg let me open this we're gonna say
this package let's double click this and
here we see this installation wizard
it's super easy just click continue and
install you have to enter your
computer's password and then alright
done beautiful so we can move this to
trash now the next piece of software we
need is a code editor there are so many
cool editors for building Java
applications the popular ones are
NetBeans Eclipse and IntelliJ in this
Java course I'm gonna use IntelliJ but
if you have a favorite editor feel free
to use that to take this course that's
perfectly fine so let's search for
IntelliJ download all right you can see
download IntelliJ IDEA click on this
link over here download the community
edition which is absolutely free and
it's more than enough for this course so
download all right now let's drag and
drop this onto the Applications folder
beautiful alright we've installed all
the necessary tools to build Java
applications so next we're gonna look at
the anatomy of a Java program
in this java tutorial we're gonna look
at the anatomy of java programs the
smallest building block in java programs
are functions
if function is a block of code that
performs a task as a metaphor think of
the buttons on the remote control of
your TV each button performs a task
functions in programming languages are
exactly the same for example we can have
a function for sending emails to people
we can have a function for converting
someone's weight in pounds to kilograms
we can have a function for validating
users input and so on now let's see how
we can code a function in Java we start
by specifying the return type of that
function some functions return a value
like a number at day time and so on
other functions don't return anything so
the return type of this functions is
void void is a reserved keyword in Java
and that's why I've coded that in blue
here now after the return type we have
the name of our function so here we
should give our function a proper
descriptive name like send email this
name clearly identifies the purpose of
this function okay now after the name we
have a pair of parentheses and inside
these parentheses we add the parameters
for this function we use these
parameters to pass values to our
function for example our send email
function should have parameters like who
is the receiver what is the subject of
this email what is the content of this
email and so on now in this tutorial
we're not gonna worry about parameters
we'll look at them in the future
now after the parentheses we had a pair
of curly braces and inside these braces
we write the actual Java code now one
thing I want you to pay attention to
here is that in Java we put the left
brace on the same line where we define
our function in other programming
languages like C sharp it's more
conventional to put the left brace on a
new line but we don't do that in Java so
we put the left brace on the same line
where we define our function now every
Java program should have at least one
function and that function is called
main so main is the entry point to our
programs whenever we execute a Java
program the main function gets called
and the code inside this
function gets executed okay now these
functions don't exist on their own they
should always belong to a class so a
class is a container for one or more
related functions basically we use these
classes to organize our code just like
how products are organized in a
supermarket in a supermarket we have
various sections like vegetables fruits
cleaning products and so on each section
contains related products by the same
token a class in java contains related
functions now every Java program should
have at least one class that contains
the main function can you guess the name
of that class its main so this is how we
define a class in Java we start with a
class keyword then we give our class a
proper descriptive name and then we add
a pair of curly braces now the functions
that we define in between these curly
braces belong to this class and more
accurately we refer to them as methods
so a method is a function that is part
of a class in some programming languages
like Python we can have a function that
exists outside of a class so we call it
a function but when a function belongs
to a class we refer to it as a method of
that class okay now in Java all these
classes and methods should have an
access modifier an access modifier is a
special keyword that determines if other
classes and methods in this program can
access these classes and methods we have
various access modifiers like public
private and so on now most of the time
we use the public access modifier so we
put that in front of our class and
Method declarations so this is the basic
structure of a Java program at a minimum
we have a main class and inside this
main class we have the main method now
you might be curious why we have a
capital m in the name of this class
because in Java we use different
conventions for naming our classes and
our methods to name our classes we use
the Pascal naming convention and that
basically means the first letter of
every word should be uppercase in
contrast to name our methods we use the
camel naming convention and that means
the first letter of every word should be
operate
case except the first wart so that is
why we have a capital m in the name of
this class alright now that you
understand the anatomy of a Java program
let's create a new Java project and see
all these building blocks in action in
this Java tutorial you're gonna learn
how to write and execute your first Java
program so let's open IntelliJ IDEA here
on the home screen let's create a new
project alright on the left side select
java and make sure project sdk is not
black so earlier we downloaded jdk or
Java development kit version 12 that is
why JDK version 12 is selected here if
you don't see that make sure to select
it from this drop-down list alright now
let's click on next on this page select
create project from template so we're
gonna create a command line application
which is an application that we can run
from the command line it doesn't have a
graphical user interface or a GUI
now I know command line application is
not as exciting as an application with a
graphical user interface like a mobile
app or a desktop app but trust me
building an application with a graphical
user interface is very complicated so
for now we're just gonna build command
line applications to learn Java properly
once you learn Java properly then you
can learn about building desktop or
mobile applications with Java all right
now let's click on next on this page we
have to give our project a name let's
call it hello world now over here you
can see the location of this project so
it's inside the idea projects folder now
right below that you can see the base
package which is set to comm that code
with Marsh on my machine and your
mission is probably gonna be comm dot
package what is this well here we talked
about classes and methods I told you
that a class is a container for related
methods so we use classes to organize
our code by the same token we have a
concept called package and we use a
package to group related classes so as
our applications grow we're gonna end up
with hundreds or even thousands of
classes so we should properly organize
this class
us into packages now by convention the
base package for a Java project is the
domain name of your company in Reverse
so my website is code with mass comm
that is why I'm gonna set the base
package for this project to come that
code with Marsh now it doesn't mean that
you should have an actual domain
registered on an Internet this is just a
way to create a namespace for our
classes so now every class that we
create in this project will belong to
this package we're gonna talk about
packages in more detail in the future so
for now just type a base package for
your project it can become that your
name or whatever it doesn't really
matter all right now let's go forward
alright here's our first Java project
now this code editor might look a little
bit intimidating at first but trust me
it's really easy and you're gonna learn
about it throughout this course on the
left side we have the project panel
where we can see all the folders and
files in a project for example on the
top we have the hello word project
inside this project we have the source
folder where we have the source code of
a project now in this folder we have
another folder that is calm that code
with Marsh that is the name of our base
package and in this package we have this
class main so you can see this main file
opened on the right side here now look
at the name of this file its main the
Java so all Java files should have the
Java extension okay now let's collapse
the project panel by clicking on this
icon that is better so see what we have
here on top of this file we have the
package statement and this is used to
specify what package this class belongs
to so the main class that we have here
belongs to this package now this package
statement is terminated by semicolon so
in Java wherever we have a statement we
should terminate that statement with a
semicolon this is exactly like c-sharp
or C++ now below this package statement
we have our main class exactly like what
you saw in the previous tutorial so we
have public class main with a pair of
curly braces inside this class we have
our main method so it's a public method
which may
it's accessible from other parts of this
program it's static we haven't talked
about static metals yet we'll talk about
them in the future for now just remember
that the main method in your program
should always be static the return top
of this method is void which means this
method is not gonna return a value and
here in parentheses we have one
parameter for this function we can use
these parameters to pass values to our
program again we'll look at this in the
future now right after this parameters
as you can see the left brace and this
is where we write the code in this
method now by default we have this line
prefix with two slashes this indicates a
comment we use these comments to explain
our code to other people so these
comments don't get executed now let's
remove this comment and write a bit of
code to print something on the terminal
so here we're gonna use the system class
in Java so capital S system here in this
tooltip you can see the system class is
defined in this package Java dot Lang or
language also look at this icon on the
left side this indicates a class now
inside this class we have various
members we can use the dot operator to
see the members defined in the system
class now the member that we're gonna
access is out look at the icon of this
member it's F which is short for field
you're gonna talk about fields in the
future when we talk about classes and
object-oriented programming now what is
interesting here is the type of this
field and you can see that on the right
side that is print string so print
string is another class that is defined
in Java so once again we use the dot
operator to look at the methods or
members defined in the print stream
class the method we're gonna use is
print Ln which is short for line look at
the icon for this method so M indicates
a method now you press ENTER and
IntelliJ automatically adds these
parentheses as well as a semicolon so
now with the code on line six we're
calling or executing the print line
method earlier I told you that inside
this parenthesis we can pass values to
our methods here we want to print the
hello word
on the terminal so let's type double
quotes and inside these quotes right
hello world so hello word is textual
data in Java whenever we deal with
textual data we should always surround
them with double quotes now we say we
have his string so a string is a
sequence of characters all right so
we're done with our first program now to
execute this we can click on this icon
on the toolbar look at the shortcut on
Mac it's ctrl + R I always prefer to use
shortcuts because they're faster so ctrl
+ R now IntelliJ is building our
application and we can see the result in
this little terminal window so here's
our hello work message so that was our
first Java program next I'm going to
explain how Java code gets executed
under the hood
hey Marsh here I just wanted to let you
know that you really don't have to
memorize anything in this course I've
put together a comprehensive cheat sheet
with summary notes that you can download
below this video so I've done my best to
create the best possible Java course and
I would really appreciate it if you
support me by liking and sharing this
video on the social networks that you
use often also be sure to subscribe and
enable the notifications so next time I
upload a video you'll get notified thank
you so much and let's continue watching
all right now let's see what exactly
happens under the hood the moment we run
a Java program in IntelliJ
there are basically two steps involved
here compilation and execution in the
compilation step IntelliJ uses the Java
compiler to compile our code into a
different format called Java bytecode
this Java compiler comes with the Java
development kit that we downloaded at
the beginning of the course let me show
you so here we can right click on this
main the Java and in this context menu
we have an item called open in terminal
it's down below unfortunately it's not
visible in my recording window it's
called open in terminal on Mac and
probably open in command prompt on
Windows so let's open that we get this
terminal window or command prompt on
windows here we're currently inside of
this folder code with Maj that is where
we have our main the Java file now we
can invoke the Java compiler like this
Java C and pass the name or Java file as
an argument so main the Java if you're
on Mac or Linux make sure to spell this
with a capital M because these operating
systems are case-sensitive so enter now
let's look at the content of this folder
on Mac or Linux we can type LS on
windows we type dir so let's take a look
in this folder now we have a new file
main class this is the bytecode
representation of this Java file now let
me use IntelliJ to run our Java program
this class file gets stored somewhere
else let me show you so back to the
project panel here in our project we
have this source folder where we
our source code and we have this out
folder where we have the result of the
compilation so inside this folder we
have production inside this we have
hello world the same name as our project
inside hello world we have comm which is
the name of our top level package inside
this package we have a sub package that
is code with Marsh and here we have our
main dat class file so this was the
compilation step now this Java bytecode
that we have in this file is platform
independent and that means it can run on
Windows Mac Linux or any operating
systems that has a Java runtime
environment if you go to java.com slash
download we can download java or more
accurately java runtime environment for
various operating systems this Java
Runtime environment has a software
component called Java Virtual Machine or
JVM this JVM takes our Java bytecode and
translates it to the native code for the
underlying operating system so if you're
on Windows machine this Java Virtual
Machine converts or Java bytecode into
the native code that windows can
understand this architecture is the
reason why Java applications are
portable or platform independent we can
write a Java program on a Windows
machine and execute it on Linux Mac or
any other operating systems that have a
Java runtime environment
c-sharp and python also have the same
architecture that's why they are
platform independent as well now let me
show you how to invoke this java virtual
machine to run a Java program so back to
this terminal window let me expand this
currently we are inside of this folder
code with Marsh and in this folder we
have this class file now let's go one
level up so CD dot dot and one more time
so now we are inside the source folder
we can invoke Java Virtual Machine like
this they type Java and then we type the
full pass to our main class file what do
I mean by that well earlier we defined
this package comm that code with Marsh
and this class the main class is part of
this package so the full path
this class is calm dot code with Marsh
dot main make sure to use a capital M
here because this is case sensitive now
when we press ENTER Java will look at
this folder calm inside this folder it
will look at this other folder code with
Marsh and then it will find main that
class in that folder it will load the
bytecode and convert it to the native
code for the operating system we are
using so take a look so it executed our
program hello world beautiful let me run
a program using IntelliJ all these steps
are hidden from us we don't see the
compilation or execution steps
so you have seen Java in action now let
me tell you five interesting facts about
Java Java was developed by James Gosling
in 1995 at Sun Microsystems which was
later acquired by Oracle in 2010 it was
originally called oke after an oak tree
that stood outside Gosling's office
later it was renamed to green and was
finally renamed to Java inspired by Java
coffee that's why its logo looks like
this we have four editions of Java for
building different kinds of applications
we have Java standard edition this is
the core Java platform which is what
we're using in this course it contains
all of the libraries that every Java
developer must learn
we have Java Enterprise Edition which is
used for building very large-scale and
distributed systems it's built on top of
java standard edition and provides
additional libraries for building fault
tolerant distributed multi-tiered
software we have java micro Edition
which is a subset of Java standard
edition designed for mobile devices so
it has libraries specific to mobile
devices and finally we have Java card
which is used in smart cards the latest
version of Java is Java standard edition
12 which was released just a few months
ago in March 2019 Java has close to 9
million developers worldwide currently
about 3 billion mobile phones run Java
as well as 120 million TV sets and every
blu-ray player according to indeed.com
the average salary of a Java developer
is just over $100,000 per year in the US
so as we can see Java is everywhere
which means more opportunities for you
to get hired as a professional
programmer now let me give you a quick
overview of how I've structured this
course so you can get the most out of it
this course is the first part of my
complete four-part Java series each part
is about three to four hours long so it
can easily complete it in a day or two
in the first part which is what you're
watching you're gonna learn the
fundamentals of programming with Java in
the next section you'll learn about the
type system in Java you will learn how
to work with various types such as
purrs strings boolean's and arrays by
the end of this section you will build a
mortgage calculator as your first Java
project will be improving this
calculator bit by bit routers course
next you will learn about control flow
statements that are used to build
algorithms we'll be talking about
various types of conditional statements
and loops later in this section we'll
add data validation to our mortgage
calculator to force the user to enter
valid values at this point you'll be
able to build basic algorithms and
that's great
but being a good programmer requires
knowing how to write good code code that
is clean and expressive that's what
separates an outstanding programmer from
an average programmer so in the
following section we'll talk about clean
coding I will show you various
techniques that professional programmers
use to make their code clean and
maintainable and finally in the last
section you will learn how to find and
fix errors in your java programs as well
as how to package them for deployment so
others can use them so the materials in
the first part will give you a solid
foundation on how to start programming
in Java in the second part we'll talk
about object oriented programming which
is a style of programming use in most if
not all Java applications whether you
want to use Java to build web mobile or
desktop applications you need to
understand object-oriented programming
well because otherwise you're going to
constantly hit obstacles in the third
part we're going to talk about core Java
API is or application programming
interfaces you'll learn about many of
the useful classes in the standard Java
library and finally in the last part
we'll be looking at the advanced
features in Java such as streams threads
database programming and so on so I hope
you're gonna join me on this journey and
master Java the most popular programming
language behind millions of apps and
websites
you
intersection we're gonna look at the
fundamentals of programming in Java
you're gonna learn about variables and
constants primitive and reference types
you're gonna learn about casting or type
conversion you will learn how to work
with numbers strings and arrays and how
to read input from the user
once you learn all this I'm gonna give
you a project you're gonna build a
mortgage calculator on your own so make
sure to pay great attention to all the
materials you're gonna learn because
you're gonna use most of them in this
project are you ready now let's jump in
and get started in this tutorial we're
gonna talk about variables in Java we
use variables to temporarily store data
in computer's memory here is an example
imagine in this program you want to
store someone's age in the memory so we
declare a variable like this ant age
equals 30 so int or integer is the type
of this variable so in this variable we
can only store integers which are whole
numbers like 1 2 3 4 numbers that don't
have a decimal point now in Java we have
several different types I'm gonna talk
about them in the next tutorial so first
we specify the type of our variable then
we give it a name or a label this is
also called an identifier because we use
it to identify our variable this equal
sign is called the assignment operator
and 30 is the initial value that we are
assigning to this variable so we say on
line 6 we're initializing this variable
which means we're giving it an initial
value you always have to initialize our
variables before reading them so with
this line we're storing number 30
somewhere in computer's memory and we're
assigning this label to that memory
location now on line 7 instead of
printing hello world we can print the
value of the age variable take a look so
I'm gonna run this program using ctrl +
R there you go now we see 30 on the
terminal beautiful we can also change
the value of our variable so after we
initialize it per house we can change it
to 35 now when we run this program again
we see it 35 beautiful we can also
initialize multiple variables on the
same line but this is something that I
don't recommend because it makes your
code ugly and hard to read here is an
example we can declare another variable
like temperature and set it to 20 so
using a comma we can declare multiple
variables on the same line now even
though this is technically possible it's
not something that I recommend so it's
always better to declare one variable on
each line like this we can also copy the
value of one variable into another here
is an example let me delete these
variables and declare a new variable
called my age we set it to 30 and then
we declare another variable like her age
and we set it to my age so now when we
print her age we're gonna see 30 take a
look
so on line seven recapping the value of
this variable into this other variable
now one thing I want you to pay
attention to here is the convention I
have used for naming our variables as I
told you before this is called the
camelcase notation so we should
capitalize the first letter of every
word except the first word so in this
case the first word my it's all in
lowercase but the second word starts
with a capital letter so this is all
about declaring and initializing
variables in the next tutorial we're
going to talk about various types in
Java in this tutorial we're going to
talk about various types in Java
basically we have two categories of
types we have primitive types for
storing simple values and non primitive
types or reference types for storing
complex objects so in the category of
primitive types we have white which
takes one byte of memory and in one bite
we can store values from 128 to 127 now
the more bytes we have the larger
numbers we can store so next we have
short which takes two bytes and with
this we can store values up to 32,000
next we have integer which we have seen
before integers take four bytes of
memory and allow us to store values up
to two billion then we have long which
takes eight bytes and with this we can
store even larger numbers now all these
types are for storing whole numbers that
don't have a decimal point if you want
to store a number that has a decimal
point you have to use float or double
float takes four bytes double takes
eight bytes so obviously we double we
can store larger numbers next we have
char for storing a single character like
ABC and this chart I've take two bytes
so they support international letters
and finally we have boolean for storing
boolean values which can be true or
false just like yes or no in English now
let's take a look at a few examples
earlier we use an integer for storing
someone's age but as you learned
integers take four bytes and allow us to
store values up to two billion we don't
need four bytes of memory to store
someone's age all we need is one byte
because with one bite we can store
values up to 127 so I'm gonna change
this to byte that is better now let's
look at another example let's say we
want to store the number of times a
YouTube video has been watched so we
define an integer called views count
note that I'm always using meaningful
names for my variables because these
names help us understand what this code
does I've seen some people use variable
names like V or V 1 or n nobody knows
what these variables do so as a best
practice always use meaningful and
descriptive names for your variables so
views count we set this to a large
number like 1 2 3 4 5 6 7 8 9 now in
Java whenever you deal with a large
number like this you can use an
underscore to separate every three
digits just like how we use a comma in
our documents to make our numbers more
readable we can use an underscore in
Java so with integers we can store
values up to two billion but let's say
the number of times this video has been
watched is three billion so I had a
three here now we have a red on the line
that indicates an error
let me hover our mouse over it we see
this tooltip integer number too large so
we need to change the type of this
variable to long however the error is
still there what's going on here the
reason we're getting this error is that
by default Java sees these numbers as
integers so even though we have defined
the type of this variable as long Java
compiler sees this value as an integer
and he thinks this value is too large
for an integer to solve this problem we
need to add an L as a suffix or this
number we can use an uppercase or a
lowercase L but as you can see a
lowercase L kind of looks like a 1 so
it's better to use a capital L so these
are examples of whole numbers now let's
declare a variable for storing a number
with a decimal point so double price we
set this to 1099 obviously the double
variable is too large for storing the
price of a product so we can change this
to float that is better but you have a
compilation error here take a look
incompatible types required float but
found double the reason we're seeing
this error is that by default Java sees
these numbers with a decimal point as
double so even though we set the type of
this variable to float Java sees this
number as a double so just like how we
added a suffix to this number to
represent it as a long we need to add a
suffix here to represent this number as
a float and that suffix is F once again
we can use an upper case or lower case F
so these are examples of numbers now
let's store a character so char we call
it letter and we set it to a note that
we should always surround single
characters with single quotes and
multiple characters or strings with
double quotes
okay so char represents only one
character string represents a series of
characters and finally let's see an
example of a boolean so we define a
boolean variable called is eligible is
this person eligible for loan or not we
said this to true or false these are the
boolean values now note that all these
words coded in orange are reserved
keywords in Java
just like public static void class
package these are all reserved keywords
so we cannot use these reserved keywords
the name our variables classes and
methods in the last tutorial you learned
that we use primitive types to store
simple values like numbers boolean
values or single characters in contrast
use reference types to store complex
objects like data objects or mail
messages these are complex objects now
in Java we have eight primitive types
that you have seen before all the other
types are reference types let me show
you an example so here in this program
first I'm gonna declare a primitive type
let's say white age equals 30 now
declaring and initializing a reference
type is slightly different from
primitive type let me show you
so let's type date now here in this
tooltip box which is called intellisense
we can see various classes that have
date in their name so IntelliJ is
helping us complete our code by
suggesting these class names now here we
have a date class in this package Java
the util so this package contains a lot
of utility classes that are useful in a
lot of programs you also have a date
class in a different package Java SQL or
sequel which is used for programming
databases so this is the benefit of
packages we can have the same class but
in different packages they don't
conflict so packages create a namespace
for our classes okay now in this case if
we select the first date class and press
enter or tab IntelliJ automatically adds
this line for us import Java that you
till the date so because currently we
are in this package in order to use a
class from a different package we need
to import it so here we're importing the
date class in this package will talk
about packages in more detail in the
future so back to our date variable
let's give this variable a name collect
now now we set this here we need to use
the new operator to allocate memory for
this variable and this is one of the
differences between the primitive and
reference types when declaring primitive
types we don't need to allocate memory
memory is allocated and released by Java
Runtime environment but when dealing
with reference types we should always
allocate memory now we don't have to
release this memory Java Runtime
environment will automatically take care
of that so we use the new operator and
then repeat the name of our class in
this case date and then we add
parentheses followed by a semicolon in
this example this variable we have
defined here is an instance of the date
class so this class is defined template
or blueprints for creating new objects
new instances as another example we can
have a class called human and we can
have objects like John Bob Mary and so
on so an object is an instance of a
class now this object or this class
have members that we can access using
the dot operator so we can type now dot
and these are all the members defined in
this class or in this object for example
we have a method called get time and
this returns the time component of this
object this is another difference
between primitive types and reference
types these primitive types don't have
members so if you type age dot we don't
see anything these items you see here
are not members of age their code
snippets which allow us to quickly
generate code for example we can select
for I and this automatically generates
this block of code for us we'll talk
about this in the future so this age
variable is a primitive type it's not an
object it doesn't have any members and
that's why when we use the dot operator
we don't see anything here now let's
delete this line and instead print the
value of this data object so once again
we can type system this is a class so we
can use the dot operator to access its
members here we have out which is a
field and the type of this field is
print string which is another class in
Java so once again we can use a dot
operator and call the print line
function now let me show you a very cool
shortcut instead of typing all this we
can use one of these code snippets so we
type s oh you see and press tab and this
generates this piece of code for us all
right now let's pass our data object
here note that I have not surrounded
this variable with double quotes because
this is a string and if you run this
program we'll see now on the terminal
there you go
we don't want this you want the value of
our data object not a label so let's
remove the quotes I run the program
again so here's the current date I'm on
my machine I've learned a little bit
about the differences between the
primitive and reference types so you
know that we use primitive types for
storing simple values and reference
types for storing complex objects but
there's a very important difference
between these two categories of types in
terms of memory management and that's
what we're going to talk about in this
tutorial
so I'm going to declare a primitive
variable X and set it to 1 and then I'm
going to declare another variable like Y
and set it to X so in this example we
have two different variables x and y and
these two variables are at different
memory locations so they're completely
independent of each other in other words
if I change the value of X Y is not
going to get affected let me show you so
I'm gonna update X to 2 and then print Y
so syu t tab y let's take a look
so run as you can see Y is not affected
because x and y are completely
independent of each other however when
we use a reference time this behavior is
different
let's take a look so I'm gonna delete
all the code here in Java we have a
point class that is defined in this
package Java that awt so we press ENTER
and now we have this import statement on
the top beautiful let's declare a
variable like point 1 and set it to new
point here we can pass the initial
values for x and y so I'm gonna pass 1
and 1 so intelligent automatically adds
these labels x and y now just like
before I'm gonna declare another
variable point 2 and set it to point 1
and this is where things get interesting
when Java Runtime environment executes
line 8 first it's going to allocate some
memory to store this point object let's
see if the address of that memory
location is 100 then it's going to
allocate a separate part of the memory
and it's going to attach this label to
that memory location point 1 in that
memory location it's going to store the
address of our point object so this is
the critical difference between
primitive and reference types when we
declare a primitive variable like a byte
the value that we assigned to that
variable will be stored in that memory
location but when we use a reference
type like this point class our variable
is going to hold the ax
of that point object in memory not the
actual pointer object now look at line 9
here we're copying the value that we
have in this variable into this other
variable so that value as you learn is
not the point object is the address or
the reference to the point object in
memory that is why we refer to these
tiles as reference types because they
don't store the actual values they store
a reference to an object somewhere in
the memory so in this example point one
and point two are referencing the exact
same point object in memory we only have
one point object so these two variables
are not independent of each other
they're referencing the same object and
that means if I update this point object
through either of these variables the
changes will be visible to the other
variable I'm gonna show you so using the
first variable point one we're going to
update the value of x so we use the dot
operator and here we can see the members
of this object X on Y are both fields
which are variables that exist inside of
a class so we said X just like a regular
variable to a different value let's say
two now because point one and point two
are referencing the exact same object if
we print point two we're going to see
the change that we just made
take a look so S or ut tab let's print
point to run the program there you go
so the change was visible so remember
this reference types are copied by the
references whereas primitive types are
copied by their value and these values
are completely independent of each other
in this tutorial we're gonna look at
strings in Java so earlier in the course
we printed the hello world message on a
terminal this hello word that we have
here is a string or more accurately it's
a string literal
that means a string value now let's
extract this from here and store it in a
string variable so cut just before this
line we type string now look this string
class is defined in Java that Lang
package what is interesting is that we
don't have an import statement to import
this package or import this class
because this package is automatically
imported so we can use any classes that
are defined in this package now let's
declare a variable called message and
because this is a reference type we
should instantiate this variable using
the new operator so Neal string and here
in parenthesis we type our message hello
world however here we have this little
warning take a look new string is
redundant because in Java there is a
shorter way to initialize string
variables let me show you so instead of
using the new operator we simply set
this to our string literal now on the
surface this looks like a primitive type
because we are not using the new
operator but this is just a shorthand to
initialize a string variable strings are
reference types in Java but because we
use them often there is a short way to
create them
so now let's pass message to the print
line method and run our program you get
the exact same result as before
beautiful now let's look at a few
interesting things that you can do with
strings we can concatenate or joining a
string with another one using the plus
operator so here we can combine this
with another string with two exclamation
marks and here's the result now because
string is a class it has members that we
can access using the dot operator so we
can type message dot and these are all
the methods or functions do
find in the string class for example we
have this method here ends with and with
this we can check to see if our string
ends with a character or sequence of
characters for example here we can pass
their string to see if our message ends
with two exclamation marks
now instead of printing the message
let's print this expression here so
let's run the program we get true so
this method that we have called here
returns a boolean value which can be
true or false we also have another
method starts with let's take a look now
in this case we get false because our
message doesn't start with two
exclamation marks another useful method
is length so we can call that to get the
length of a string which is the number
of characters so message dot length take
a look
so in this string we have 13 characters
and this is useful in situations where
you want to check the length of the
input by the user for example you might
have a sign-up form with a username
field you can check the length of
someone's username and give them an
error if the username is longer than
let's say 20 characters pretty useful we
also have another method that is index
of and this returns the index of the
first occurrence of the character or the
string that we pass here for example if
you pass H the index of H is 0 so let's
run the program there you go we get 0 if
you pass e we get 1 because the index of
the first II in this message is 1 now
what if you pass a character or a string
that doesn't exist in this message let's
say Skye we get negative 1 so with this
method we can check to see if a string
contains certain characters or words or
sentences and so on another useful
method is replace and with this we can
replace one or more characters with
something else for example we can
replace any exclamation marks with
let's say a store so this replace metal
has two parameters one is target the
other is replacement and here we're
passing two values for these parameters
here's the first value here is the
second value and we have separated these
values using a comma now in programming
terms we refer to this values as
arguments a lot of programmers don't
know the difference between parameters
and arguments parameters are the holes
that we define in our methods arguments
are the actual values that we pass to
these methods so in this case target and
replacement or parameters but
exclamation mark and asterisk are
arguments now let's run this program and
see what happens so our explanation
marks are replaced with stars now what
is important here is that this method
does not modify our original string it
returns a new string so if we print our
original string right after SRU T tab
message you can see the original string
is not changed because in Java strings
are immutable
we cannot mutate them we cannot change
them so any methods that modify a string
will always return a new string object
okay we also have another useful method
to lowercase
let's take a look
so to lowercase converts all characters
to lowercase and once again you can see
that the original string is not affected
because this method returns a new string
okay we also have two uppercase and
another useful method is trim trim and
with this we can get rid of extra white
spaces that can be at the beginning or
the end of a string sometimes our users
type unnecessary spaces in form fields
so using the trim method we can get rid
of these white spaces let me show you so
I'm gonna add a couple of spaces before
and after our message now when we trim
it these white spaces are gonna get
removed take a look so here's the
original string you can see two white
spaces at the beginning and here's our
string after trimming so these are some
useful methods in the string class but
this glass has more methods than we
don't have time to cover in this lecture
but as we go through the course you're
gonna learn more about the string class
and other useful classes in Java third
times will include special characters in
our strings like a tab or a new line or
a backslash or double quotes so in this
tutorial I'm gonna show you how to
include these special characters in your
strings so here we have the string hello
Marsh let's say we want to surround
Marsh with double quotes now here's the
problem if we add a double quote here
Java compiler thinks this is the
termination of our string so it doesn't
stand what we have after that's why we
have a compilation error the fixes
problem we need to prefix this double
code with a backslash
so using this backslash we have escaped
the double quote now one more time let's
add backslash double code here now let's
run the program and see what we get so
we get hello Marsh in double quote
beautiful so double quote is one of
those special characters that you need
to be aware of another special character
is backslash let's say we want to store
the pass to a directory on a Windows
machine so that will look like this C
Drive
backslash windows backslash whatever now
if you want to store this in a string we
need to escape each backslash let me
show you so C Drive backslash now we
have a problem
Java compiler thinks we're escaping the
double code here so it thinks our string
is not terminated with another double
code but that's not what we want you
want to add a backslash here so we need
to prefix our backslash with another
backslash now we type windows one more
time something let's run the program so
even though we have two backslashes in
our code we actually see one backslash
in a terminal window in other escape
sequences backslash N and we use that to
add a new line to our strings so let's
change this to backslash N and run the
program to see what happens now our
string is broken down onto multiple
lines by the first line we have C Drive
then we have Windows so wherever we had
a backslash n Java will insert a new
line we can also add a tab in our
strings
so if you add backslash T here there
will be a tab which means C Drive and
windows let's take a look so C Drive
here we have a tab and then windows now
in Java we have a few more escape
sequences but quite honestly they're
hardly used so remember these four
escape sequences that we cover in this
tutorial
in this tutorial we're going to talk
about arrays in Java we use arrays to
store a list of items like a list of
numbers or a list of people or a list of
messages let me show you so here we have
an integer variable you want to convert
this to an integer array so right after
int we add square brackets now we have a
compilation error because we're storing
a single number in this array so to fix
this we need to remove one because
arrays are reference types we need to
use the new operator here then we repeat
the type one more time enter a and here
in square brackets we specify the size
or the length of this array how many
items do we want to include in this
array let's say five also we should
change the name of this variable from
number two numbers because we're dealing
with a list of items so always pay
attention to the name of your variables
now you can access individual items in
this array using an index so we type
numbers square brackets to reference the
first element or first item we use zero
now we can set this to a value like 1
similarly we can set the second item to
2 now what if we use an invalid index
let's say 10 this array doesn't have 10
items so let's see what happens numbers
of 10 we said this to 3 when we run this
program we get an exception exceptions
are Javas way to report errors so in
this case an exception was raised and
our program crashed we'll talk about
exceptions in detail later in the course
so now let's remove the last line and
treinta sorry
so sou t tab numbers let's see what we
get
we get this weird string in sort of the
items in our array here's the reason
by default when we print an array Java
returns the string which is calculated
based on the address of this object in
memory so if you have another array and
we print that we're gonna see something
different because each object is gonna
be in a different memory space okay now
how can we see the actual items in this
array well we have a class in Java
called arrays let me show you
arrays so this class is defined in Java
that util package let's press ENTER now
this is important on the top beautiful
so we can use the dot operator to access
the members of this class here we have a
method called two string now as you see
it this method is implemented multiple
times so in the first implementation
this method gets a float array in the
second implementation it takes an
integer array and so on so for all
primitive types as well as reference
types this method is implemented
multiple times this is what we call
method overloading now we can call this
method and pass our integer array and
this will return the string
representation of this array so we can
cut this from here and pass it to our
print method like this now let's run the
program one more time and here's our
array beautiful so the first two items
are initialized the others are set to 0
by default because here we're dealing
with an integer array if you had a
boolean array all items why default get
initialized to false if you have a
string array all items get initialized
to an empty string
okay now this syntax for creating and
initializing an array is a little bit
tedious and it's an older syntax there
is a newer way to initialize an array if
we know the items ahead of time like in
this case so I'm going to remove these
two lines I'm also gonna remove the new
operator here we use curly braces and
inside these braces we add all the items
in this array let's say 2 3 5 1 & 4 now
we have 5 items so the length of this
array is gonna be 5 we can read that
using the lengths
so if we type numbers dot look here we
have is filled look at the icon it's an
F so this is a field which is like a
variable in a class and the type of this
field is an integer so this returns the
number of items in this array let's get
that and printed using our print method
like this take a look so we get five now
in Java arrays have a fixed size so once
we create them we cannot add or remove
additional items to them they have a
fixed length if you want to be able to
add or remove additional items from an
array you should use one of the
collection classes that we'll talk about
later in the course for now all I want
you to remember is that arrays have a
fixed length now currently our array is
not sorted these numbers are in some
kind of random order we can easily sort
this array using the sort method of the
arrays class let me show you so I'm
gonna remove this line and call arrays
dot sort once again you can see this
method is overloaded because it's
implemented with different parameter
types so we call this method and pass
our numbers array
now when we run this program we can see
our array is sorted beautiful
so yeah I've learned that we use arrays
to store a list of objects in Java we
can also create multi-dimensional arrays
for example we can create a
two-dimensional array to store a matrix
or we can create a three-dimensional
array to store data for cube these are
useful in scientific computations let me
show you so here we have a single
dimensional array to convert this to a
two-dimensional array we need to add
another pair of square brackets now we
have a compilation error because we need
to repeat these brackets on the other
side so let's say we want to create a 2
by 3 matrix so 2 rows and 3 columns we
add in other brackets here and change
these lengths to 2 and 3 so now we have
2 rows and 3 columns now to access
individual items in this array we need
to supply two indexes first the index of
the row so we can go to the first row
and then the first column and initialize
that to 1 now let us print this so and
so you t-tap once again we use our
arrays class dot to string and pass this
object
take a look once again we get this weird
string because here we're dealing with a
multi-dimensional array to solve this
problem we need to use another method in
this class called deep to string use
this for printing multi-dimensional
arrays take a look now we have this
matrix which has two rows and in each
row we have three columns we can also
create a three dimensional array all we
have to do is to add another pair of
brackets and specify the length of that
dimension pretty easy now what about the
curly brace syntax let me show you so
let's revert this back to a two
dimensional array we're gonna get rid of
the new operator and use curly braces
now let's say in this matrix we're gonna
have two rows and three columns so each
row is an array itself because it's a
list of items right
so we add another array here let's say 1
2 3 then comma now we add the second row
which is another array in this row we're
gonna have 3 numbers 4 5 & 6
now let's remove this line we don't need
it anymore and print this array so
here's the end result you have learned a
lot about variables ya learned that when
declaring them we need to initialize
them and we can always change their
value later on throughout the lifetime
of our programs however there are times
that we don't want the value of a
variable to change for example let's
declare a variable called pi and set it
to 3.14 now here we need to add an F to
represent this as a float because by
default Java compiler sees this number
as a decimal okay now you know that we
use pi to calculate the area of a circle
what if before we calculate the area of
a circle I come here and type pi equals
1 then all our calculations are gonna
get messed up we don't want this to
happen that's when we use constants so
if we type final here Java compiler will
treat this as a constant so once we
initialize this we cannot change its
value later on you can see here we have
a compilation error and it says cannot
assign a value to final variable pi so
pi is a final variable or a constant now
by convention we use all capital letters
to name constants so this should be PI
beautiful now I tell you a little side
story in one of my early courses that I
created years ago that was c-sharp
basics for beginners there I used the
same example to teach the concept of
constants but I pronounce this word as P
instead of Pi and believe it or not to
this day people make fun of me for
saying P instead of Pi but that's how we
learned this back in Iran we pronounce
it as P and I think Greek people also
say P but anyway I just thought to share
this video to change the mood now you're
done with constants next we're gonna
talk about arithmetic
expressions
in this tutorial we're going to talk
about arithmetic expressions in Java so
in Java we have the same arithmetic
operators that we have in math we have
addition subtraction multiplication
division and modulus which is the
remainder of a division let's look at a
few examples so I'm gonna declare an
integer called result and here we can
type 10 plus 3 now when we print result
it's gonna be 13 pretty straightforward
there you go so this is addition we also
have subtraction multiplication division
is an interesting one let's take a look
so here the result is a whole number
because in Java the division of two
whole numbers is a whole number if you
want to get a floating-point number here
you need to convert these numbers to a
float or a double let me show you
so we prefix this number with
parentheses and in parentheses we type
double now we are casting or converting
this number to a double similarly we
should do that here and now we have a
compilation error because on the left
side we declared an integer but here the
result of this expression is a double
and by the way an expression is a piece
of code that produces a value so what we
have here is an expression because it
produces a value so to fix this problem
we need to change this to double now
when we run this program we get this
floating point number beautiful so these
are the arithmetic operators and these
numbers that we have here are called
operands we also have increment and
decrement operators let me show you so
I'm gonna declare a new variable int X
we set it to 1 now if you want to
increase the value of x by 1 we use the
increment operator now let's print this
on a terminal so we get 2 there you go
we can apply this operator as a postfix
or as a prefix and we get the same
result
take a look too however if we use this
on the right side of an assignment
operator we get different results let me
show you so I'm gonna declare another
variable Y we set it to X plus plus in
this case because we have applied the
increment operator as a postfix first
the value of x will get copied to Y so Y
would be 1 and then X will be
incremented by 1 so if you print x and y
x is gonna be 2 and Y is gonna be 1 take
a look so X is 2 and Y is 1 beautiful
however if you apply this as a prefix
first X will be incremented by 1 so it
will be 2 and then it will be copied to
Y so in this case both
X&Y will be to take a look so we get two
and two now what if you want to
increment X by more than one let's say
by two well there are two ways to do
this let's remove Y we don't really need
it anymore we can write x equals x plus
2 so first we add 2 to X the result will
be three and then three will be copied
into X the other way is to use the
Augmented or compound assignment
operator so we can write X plus equals
two what we have on line eight is
exactly identical to what we have on
line seven well as you can see it's
shorter so this is a better way to write
the same code now this is one of the
Augmented assignment operators we have
the Augmented assignment operator for
other arithmetic operators so we can
type X minus equals 2 and this would
reduce the value of x by 2 we also have
multiply and divide so these are the
Augmented or compound assignment
operators right now I've got a question
for you here we have declared this
variable X it goes to 10 plus 3 times 2
what do you think is the result of this
expression the result is 16 let's run
this program and find out so run there
you go we got 16 but why well this is a
very basic math concept that
unfortunately a lot of people don't know
in math the multiplication and division
operators have a higher priority so they
get applied first in this example this
expression 3 times 2 is evaluated first
the result is 6 and then 6 is added to
10 that's why we get 16 now if you want
to change the order of these operators
you can always use parentheses for
example if you want this expression to
be evaluated first we wrap it in
parentheses so like this now Java
compiler will first evaluate this
expression the result will be 13 and
then 13 is multiplied by 2 so we get 26
take a look
there you go so be aware of the order of
these operations parentheses always have
the highest priority then we have
multiplication and division and finally
we have addition and subtraction in this
tutorial we're going to talk about
casting and type conversion so I'm gonna
declare a short variable call X and set
it to 1 and then I'm gonna declare an
integer called Y and set it to X plus 2
in this example we're adding a short to
an integer what do you think the result
is gonna be well let's take a look
so sou t let's print Y we get 3 that is
what you were expecting but let me
explain what happens under the hood for
this expression to get executed because
we're dealing with two different types
of values one is a short the other is an
integer one of these values should be
converted to the other type so they are
equal now I got a question for you how
many bytes do we have in a short
variable we have 2 bytes how many bytes
do we have in an integer 4 bytes so any
values that we store in a short variable
can also be stored in an integer
variable right so when this piece of
code is gonna get executed this is
what's gonna happen first Java looks at
the value in this variable it's 1 right
it's going to allocate another variable
an anonymous variable somewhere in
memory we don't know where that is we
don't know the name of that variable it
doesn't have a name it's anonymous that
variable is gonna be an integer then
Java is gonna copy the value of x into
that memory space and then it will add
these two numbers together this is what
we call implicit casting let me type it
here implicit casting that means
automatic casting or automatic
conversion we don't have to worry about
it whenever we have a value and that
value can be converted to a data type
that is bigger casting or conversion
happens implicitly or automatically so
byte can be automatically converted to
short and this can be converted to int
and long okay
now what about floating-point numbers
let's look at an example I'm gonna
change this to a double one point one
now here we have a compilation error
because on the right side of the
assignment operator we have a
floating-point number a double on the
left side we have an integer so we need
to change this to double now when we
execute this code we're gonna get 3.1
let's verify this there you go now let's
see how casting happens here in this
case we're dealing with a double and an
integer an integer is less precise than
a double because in a double we can have
digits after the decimal point so in
this example Java is going to
automatically cast this integer to a
double so that will be two point zero
and then two point zero will be added to
one point one okay so back to this chain
here we're gonna have float and then
double so as a general rule of thumb
implicit casting happens whenever you're
not gonna lose data there is no chance
for data loss now what if you want Y to
be an integer so in this example we
don't care about the digits after the
decimal point you want to see three on
the terminal how should we do this this
is where we should explicitly cast the
result so we should cast X to an integer
like this parentheses int this is
explicit casting we convert X to an
integer so the result would be one
without a decimal point one will be
added to 2 and Y would be three take a
look there you go so this is all about
implicit and explicit casting now this
explicit casting can only happen between
compatible types so all these types are
compatible because they're all numbers
but we cannot cast a string to a number
in other words if X was a string like
this let's say 1
we cannot cast eggs to an integer
because they are not compatible so how
do we do this
well for all these primitive types you
have learned you have wrapper classes so
in Java we have a class which is a
reference type called integer this class
is defined in Java the Lang package and
in this class we have a method called
parse int so this method takes a string
and returns an integer so integer is the
wrapper class for the int primitive type
we also have short and in this class we
have parse short so it takes a string
and returns a short similarly we have
float and double and obviously the name
of these metas are different so here we
have parse float so back to this example
let's say we get X as a string and we
want to convert it to an integer this is
how we do it
integer dot parse int we pass X here and
then add it to take a look so we get 3
you might be curious why this matters
why should we parse or convert a string
to a number to add it to something else
well pretty much in most frameworks for
building user interfaces whether you're
building a desktop or a mobile
application or web application we always
receive input from the user as a string
so if you have a form with a bunch of
text boxes or drop-down lists almost
always we get values as a strings so
that's why we need to convert these
strings to their numeric representation
ok now what if X is a floating-point
number here what will happen when we try
to parse this as an integer
let's take a look once again we get an
exception which is how Java reports
errors to our programs we're going to
talk about exceptions in detail in the
future
so if the user enters one point one we
cannot use this method instead we should
use float or double let's say double
because that's easier double parse
double so we parse this number as a
double add two to it and then store the
result
in a double and then we will get 3.1
beautiful next we're gonna look at the
math class for performing mathematical
operations in this tutorial we're going
to look at the math class for performing
mathematical operations so in Java we
have this math class that is defined in
Java that Lang package so it's always
there we don't need to explicitly import
it now this class has a number of useful
methods the first method I'm gonna show
you is the round method and with this we
can round a floating-point number to a
whole number so as you can see this
method is overloaded which means it's
implemented twice in the first
implementation it takes a float and
returns an int and a second
implementation it takes a double and
returns a log so let's pass 1.1 as a
float to this method and store the
result in an integer like this now we
print the result and we get one
beautiful another useful method is seal
or sealing which returns the smallest
integer that is greater than or equal to
this number so the ceiling of 1.1 is 2
now here we have a compilation error
because this method returns a double but
we're storing the result in an integer
so here we need to explicitly cast this
to an integer and now you can see the
ceiling of this number is 2 we have
another useful method that is floor so
the floor of a number is the largest
integer that is smaller or equal to this
number in this case it's gonna be 1
let's take a look there you go another
useful method is max which returns the
greater of two values and once again
this method is overloaded so in the
first implementation we get two integers
we have other implementations for longs
floats and doubles so let's pass two
integers here one and two this will
return the greater number which is 2
there you go similar to this we have min
is pretty straightforward in
the useful method is random for
generating a random value between 0 and
1 once again we get a compilation error
because this method returns a double so
let's change that to double now every
time we run this program we get a
different number and this number is a
floating-point number between 0 to 1 now
what if you want a number between 0 to
let's say 100 instead of 0 to 1 well we
simply multiply this by 100 take a look
so every time we run this we get a
different number between 0 to 100 now if
we don't want these digits after the
decimal point we can either round this
number or cast it to an integer let me
show you so we can call math that round
and pass the result of this expression
so I'm gonna cut this add parenthesis to
call the round method and then paste
that expression now let's run this code
so every time we get a double we still
have the fraction here so we can change
the type to an INT now we have a
compilation error because the round
method returns a long but here we have
declared an integer this is one of those
cases where implicit casting cannot
happen because we have a value that is
represented in 8 bytes of memory and you
want to store that in a variable that
has only 4 bytes of memory so implicit
casting doesn't work but we can use
explicit casting because we know the
result of this expression is a number
between 0 to 100 so we can definitely
store it in an integer so let's add int
here now let's run this again there you
go now what if we don't use the round
method here let's see what happens so
I'm gonna remove the call to the round
method and simply I apply this casting
over here let's see what we get now
every time we run this program we get 0
do you know why because here we're
applying this casting to the result of
this method call not this entire
expression as you saw earlier every time
we call the random method it generates a
number between 0
to one so when we cast that number to an
integer we'll lose the fraction we
always get zero and zero times 100 is
zero to solve this problem we need to
wrap this entire expression in
parenthesis so we add parentheses around
this and now let me run this we get an
integer between 0 and 100 quite often
when we worked with numbers we need to
format them as currency values for
example we might have a number like this
imagine this is the price of a product
to display this to the user you want to
add a dollar sign here and separate
every three digits with a comma or if
you might have a number like 0.1 and we
want to represent this as a percentage
value so instead of 0.1 you want to
display 10% so in this tutorial I'm
gonna show you how to format numbers in
Java we have this class number format
that is defined in Java the text package
in this package we have a lot of classes
for handling text dates numbers and so
on so let's press ENTER here it's
important on the top beautiful now I
want to declare a variable so let's give
this variable a name currency now we
need to instantiate this new number
format however we get a compilation
error here let's take a look number
format is abstract it cannot be
instantiated so in Java we have this
concept of abstract classes so some
classes are abstract and they're
basically like a half-baked cake we
cannot use the new operator to create an
instance of them we're going to talk
about abstract classes and why they
exist later in the course for now
remember that we cannot create an
instance of the number format class
because it's abstract so there is
another way let me show you this class
has a bunch of methods that start with
get so we have get currency instance and
when we call this method this will
create an instance of the number format
class and return it so instead of using
the new operator we're gonna use this
method here this is what we call a
factory method because it's like a
factory it creates new are
jects now look at the return type of
this method it's a number format object
okay so we call this method now we get
the return value and store it in a
variable of type number format called
currency okay let me say improperly zoom
out so you can see all the code there
you go so on the right side of the
assignment operator we're calling the
get currency instance method we get the
result which is a number from an object
and store it in this variable okay now
I'm gonna zoom in so you can see clear a
name
alright that's better now this object
has a method for formatting values once
again you can see this method is
overloaded we have multiple
implementations we can give it a long or
a double or whatever so I'm gonna call
this method and pass a value like one
two three four five six seven point
eight nine one so we have three digits
after decimal and a few other digits
here now this method will return a
string representation of this number
formatted as a currency so let's get
that and store it in a string variable
like result and then we're gonna print
result on a terminal see what we get
so we get this dollar sign every three
digits are separated using a comma and
we only have two digits after the
decimal point so this class is very
handy in formatting numbers as
currencies we have another method for
formatting a number as a percent and
that is get percent instance right now
it returns an instance of the number
format class specialized for formatting
numbers as a percent so we need to
rename this variable from currency to
percent now we don't want to manually
change this because there are multiple
references to this variable this other
reference was not updated so let me show
you the proper way to rename objects in
intellij if you right click here you can
see this refactor menu and here we have
rename now look at this shortcut on the
right side unfortunately it's not
visible in my recording window but on
Mac is Shift + F
I always use shortcuts because they're
faster so let's press shift and f6 now
we get this red box and below this we
can see a few suggestions for a better
name we can choose one of these or pick
our own name I'm gonna change this to
percent and note that as I'm typing this
the other reference gets updated
automatically so this is very helpful
now let's press Enter
okay we're done with renaming now let's
pass a different value here so let's say
we have a number like 0.1 we want to
format this as a percent let's run the
program there you go you get 10%
beautiful now let me show you a cool
technique in this program we don't
really need this percent object because
we have used it in a single place it
would make sense to have this as a
separate variable if you have multiple
references to it so what can we do here
we can completely get rid of this object
so let's delete this piece of code we're
basically calling this method of the
number format class as you know this
method returns a number format object so
right after calling this method and
before the semicolon we can use the dot
operator to access the methods or
members of the number format object so
here we call the format method straight
away and pass our value this is what we
call method chaining we're chaining
multiple methods together so here's one
method and here's another method now
this returns a string so we can store it
in this result variable let me cut this
expression from here and put it over
here now we have double semicolons I'm
going to delete one of them
all right beautiful in this tutorial I'm
gonna show you how to read input from
the user in Java we have this scanner
class that is defined in Java did util
package let's import this and create a
scanner object so new scanner now here
inside this parenthesis we need to
specify where we're gonna read data from
we're gonna read it from the terminal
window are we gonna read it from a file
or what to work with the terminal window
we type system dot in this is one of the
fields in the system class a fill as I
told you before is like a variable that
we define in a class so we have system
that in we also have system that out
which we used to print something on the
terminal right now let's use system that
in and terminate this statement with a
semicolon now this object has a bunch of
methods for reading data and all these
methods start with next so we have next
byte for reading a byte we have next
line for reading a line we have next
boolean for ending a boolean and so on
so let's call the next byte method and
see what we get
this returns a byte value so we can
store it in a byte variable let's say
someone's age and then we print it on a
terminal saying you are plus h so here
we're concatenating a string with a byte
and in this scenario we're gonna have
implicit casting or implicit type
conversion so Java will automatically
convert this byte variable here tray
string so they can be added together
okay now let's run this program and see
what happens so here in the terminal
window we can type 20 enter and it says
your 20 beautiful but this is pretty
boring let's add a label here and ask
the user to type something for example
before reading data we're gonna call the
print line method and say age : now
let's run the program so we get this
label here however whatever we type will
appear on the next line this is because
the print line method adds a new
line after this label the Soviets issue
recall the print method now let's run
the program one more time we get this
popup box because our program hasn't
finished execution so we need to tell
IntelliJ that you want to stop and rerun
this program all right now whatever we
type appears right in front of this
label beautiful ENTER we are 20 now what
if we type a floating-point number like
20 point 1 we get an exception because
this method can only parse white values
if you want to get a floating-point
number we need to call next float or
next double what if you want to read our
string we don't have next string we have
next and next line let's look at the
differences so first I'm going to call
the next method here we have a
compilation issue because this method
returns a string I'm gonna change this
to a string let me collapse this that's
better
we should also rename this variable so
what was the shortcut Shift + f6 now
let's train just a name enter beautiful
and one last time we should also update
the label name run the program so I'm
gonna type my name here Marsh it says
your Amash pretty under for one more
time this time I'm gonna type my
full-name maha Madani but we don't get
the last name here's the reason these
wars that we have here these are called
tokens every time we call the next
method it reads one token so here we
have a space we have two tokens and we
need to call the next method two times
to get the full name the first time we
call it it returns Marsh the second time
we call it it returns Hamid ani then we
need to combine this suit together this
is not ideal so that's when we use the
next line method with this method we get
the in turn line that the user enters no
matter how many spaces or tabs are there
take a look so Marsh
comma Donny and we get the full name now
what if I type a few spaces before my
name let's see what happens
so those spaces also appear here and
this looks a little bit odd this is
where we use the trim method remember we
trim we can get rid of all these white
spaces before or after a string so this
next line method returns a string that
we are storing in this variable right
now just before storing the result in
this variable here we can use the dot
operator to access the members of this
string object so we call the trim method
and then store the result in this
variable once again we're chaining
multiple methods here let's run the
program so a few spaces Maharani and you
get this beautiful output
right now it's time for a project I want
you to use what you have learned in a
section and build a mortgage calculator
like this so when you run this program
we get a few questions the first
question is the principal or the amount
of loan we want to get let's say
$100,000 the second question is the
annual interest rate let's say three
point nine two percent and the third
question is period in years let's say
you want to get a loan for thirty years
so this program calculates our monthly
payments and displays it as a currency
this is a great exercise for you to
practice all the materials you learn in
this section now before you get started
I want to give you a few hints here is a
formula for calculating the mortgage or
the monthly payments I found this page
on wikiHow comm is called calculate
mortgage payments so let's see how this
works mortgage equals P or principal or
the amount we're gonna loan multiplied
by R which is our monthly interest rate
this is very important so this number
that we get here is our annual interest
rate we need to divide this by 12 also
take into account that this number is
represented as a percent to calculate
the actual interest rate you need to
divide this number by 100 so in this
example the interest rate is zero point
zero three nine two so whatever the user
enters divided by 100 and then divided
by twelve to get to the monthly interest
rate now we have this monthly interest
rate we need to multiply this by this
expression here we need to add 1 to this
interest rate and raise it to the power
of n where n is the number of payments
so we need to multiply this number by 12
or 12 months to calculate the number of
payments now to raise this number to the
power of n you need to use the power
method of the math class so this math
class has this power or power method
that takes two arguments or two values a
and B so go ahead and spend ten to
fifteen minutes on this exercise when
you're done come back see my solution
all right let's see what I've done here
and by the way don't worry if your coat
is different from mine
we all think and coat differently so
it's perfectly fine if your code is
different
just look at my coat see what I've done
here and see if there are ways you can
improve your coat
that's what matters okay so here in our
main method first I've declared two
final variables or constants
the first one is months in year which
I've set to 12 and the second one is
percent which I've set to 100 the reason
I declared this constant is that I
didn't want to have magic numbers in
this code so over here where we
calculate the monthly interest we get
the annual interest divided by percent
and then months in here this code is
very self-explanatory someone else
reading this code we'll have no problem
understanding what's going on here in
contrast if you had a magic number here
like divided by 12 and then for whatever
someone else reading this code would
wonder what is this for doing here what
is 12 it's quite obvious to you that 12
is the number of months in a year but
trust me sometimes other people cannot
see this straight away so as a best
practice avoid magic numbers in your
code always use constants or final
variables to describe them
so let's revert this back all right so
after declaring this constant I've
created this scanner object here we ask
the first question
principle and we read the answer as an
integer
I thought integer is a good datatype for
storing the principle because short is
not enough with short we can store a
maximum of $32,000 that's not enough
what if someone wants to find us
$1,000,000 so int is good and it allows
us to store a value up to two billion
next we ask the second question annual
interest rate we read this as a float
here I could use double but the interest
rate is a small number so float is
sufficient for that we don't really need
double so we get the annual interest and
then based on that we calculate the
monthly interest also see how I have
named my variables all variables have a
proper meaningful names there are no
magic words here like MI as it short for
monthly interest
or m1 or m2 do not use magic names for
your variables always use meaningful and
descriptive names alright next we get
the period we read this as a byte
because the maximum number we want to
support is 30 so one byte is sufficient
to store the number 30 or anything
smaller now based on the number of years
we calculate the number of payments note
the camel notation here I've capitalized
the first letter of every word except
the first word so we get the Earth's and
x months in here
again the code is very self-explanatory
once we collect all this data then we
calculate the mortgage so we get a
principal multiplied by this expression
and then divide it by this other
expression let's have a quick look here
now this looks a little bit complicated
so if you're not download my source code
look below this video I'm attached it
for you to download and finally after we
calculate the mortgage we use the number
format class to format this value as a
currency so we get a result store it in
this string mortgage format it and print
it over here now here we can also avoid
declaring this variable and simply add
this expression over here but it decided
to do this to increase the readability
of this code otherwise this line would
be so long but that's just my personal
preference you don't have to follow this
alright so this was my implementation of
the mortgage calculator
however this program has a number of
problems the first problem is input
validation so if we run this and enter a
non numeric value like XYZ our program
crashes or as another example if we
enter a negative value here our program
is not gonna behave properly so that's
where conditional statements come to the
rescue in the next section we're going
to talk about conditional statements you
will learn how to use these statements
to validate the values entered by the
user so that brings us to the end of
this section I hope you learn a lot and
thank you for watching
so in this section you'll learn all
about variables and constants you learn
about primitive and reference types you
learn that primitive types store simple
values but reference types hold
references to complex objects that's why
we call them reference types you also
learn about casting and type conversion
you learn about two types of casting
implicit and explicit you learn how to
work with numbers strings and arrays and
finally you learned how to read input
from the terminal I hope you learned a
lot I've been enjoying the course so far
in the next section we're going to look
at conditional statements for
controlling the flow of our programs so
I'll see you in the next section
hey Marcia I just want to make a quick
announcement this course you've been
watching is actually the beginning of my
complete Java series in this course we
only talk about the basics but in my
complete series we go way beyond that so
if you're serious about Java if you're
looking for a job as a Java developer I
highly encourage you to enroll in my
complete Java series it's exactly the
same structure the same quality but it
has way more content plus you will get a
certificate of completion that you can
add to your resume so if you're
interested I put the link down below you
can get the course with a discount and
if you're not happy for any reasons you
can ask for a refund within the first 30
days so I hope to see you in the course
in this section we're going to look at
control flow or controlling the flow of
execution of our programs you're gonna
start off by talking about comparison
operators for comparing values then I'm
gonna talk about logical operators like
the logical and logical or and logical
not we use these operators for
implementing real world rules and then
we're gonna talk about three different
types of control flow statements we're
going to talk about conditional
statements for making decisions in our
programs then we're going to talk about
loops for executing code repeatedly and
finally we're going to revisit our
mortgage calculator and add error
handling to it
so if a user enters an invalid value we
keep asking them to try again all right
now let's jump in and get started we're
gonna start this section by talking
about comparison operators we use these
operators to compare primitive values
for example our x on y equal or not so
I'm gonna declare two integers x and y
now let's compare this to see if they're
equal or not
so first I'm gonna add this print line
statement now to compare these variables
we type x equals y so here we have two
equal signs and this is the Equality
operator don't confuse this with a
single equal sign that we use for
assignment that is the operator used
over here okay so two equal signs
repairs
the Equality operator now when we run
this program we get true because these
values are equal this expression that we
have here is called a boolean expression
so earlier I told you that an expression
is a piece of code that produces a value
this piece of code produces a boolean
value true or false that's why we refer
to it as a boolean expression we also
have the inequality operator so when we
run this program we're gonna see false
let's take a look we get false because
these two variables are equal so the
expression X is not equal to Y returns
false we also have greater than greater
than or equal to less than and less than
or equal to so if I change Y to 2 this
expression is gonna evaluate to true
because X is less than or equal to Y
take a look there you go
next we're going to talk about logical
operators in the last tutorial you learn
that a boolean expression produces a
boolean value now there are times we
want to combine multiple boolean
expressions let me show you so I'm going
to declare an integer called temperature
and set it to 22 next we declare a
boolean variable is warm now we want to
check to see if temperature is greater
than 20 and less than 30 so we write a
boolean expression like this temperature
greater than 20 here we need to use the
end operator so these two ampersands
represent the logical and operator in
Java
after this we add our second condition
temperature less than 30 now if both
these conditions are true the result of
this boolean expression is going to be
true
otherwise if at least one of these is
false the result would be false let's
take a look so I'm gonna print is warm
on a terminal
the result is true but if you change the
temperature to let's say 12 the result
is gonna be false and this is how this
works Java will evaluate this expression
from left to right first it looks at the
first condition the first condition is
false because temperature is not greater
than 20 so because this expression is
false it doesn't matter what we have
after the and operator Java will ignore
the other expressions because the and
operator will return true if both
conditions are true okay now let's look
at another operator that is the or
operator so I'm going to delete all this
code and start with a new example let's
declare a boolean has high income we set
it to true and another boolean has good
credit we set this to true as well so
let's say we're building an application
for processing loans we want to see if a
new applicant is eligible for a loan or
not
so we declare another boolean is
eligible and by the way look at the
names I have used for these variables
they're very meaningful and descriptive
so here's the rule an applicant is
eligible if they have high income or
good credit if one of these conditions
is true they are eligible so we write
has high income or so these two vertical
bars represent the or operator so if
they have high income or good credit
then they are eligible so with the or
operator if at least one condition is
true the result will be true in this
example when Java evaluates this
expression it starts from the left side
this boolean variable is true so it
doesn't matter what we have after Java
will not evaluate the rest of this
expression it simply returns true
however if this variable was false Java
would continue evaluating this
expression hoping that the next boolean
value or the next boolean expression is
true so this is the or operator and
finally we have the not operator that we
use to reverse a value let me show you
how that works
so
let's declare another boolean variable
has criminal record we set this to false
so here's the rule we want to implement
in order for someone to be eligible for
a loan they should either have high
income or good credit and they should
not have any criminal records so let's
see how we can implement this rule we
have implemented the first part they
should either have high income or good
credit now we want to make sure they
don't have any criminal records so we
need to combine the result of this
expression with this boolean value using
the and operator so first we wrap this
expression in parentheses then we apply
the end operator and here we add has
criminal record now you want to make
sure they don't have criminal record and
this is where we use the not operator so
the not operator will reverse the value
of this boolean variable or expression
in this case this variable is set to
false so when we apply the not operator
to it the result would be true so if the
first condition is true and the second
condition is true then that person is
eligible for a new loan so as you can
see these logical operators are very
useful in implementing real word rules
next we're going to talk about if
statements in this tutorial we're going
to look at if statements in Java if
statements are extremely important
because they allow us to build programs
that can make decisions based on certain
conditions here's an example in this
file we have a bunch of conditions if
temperature is greater than 30 perhaps
you want to display two messages to the
user it's a hot day drink plenty of
water otherwise if it's between 20 and
30 you want to print it's a nice day and
otherwise we want to print it's a cold
day so let's see how we can implement
these rules in a Java program back to
our main file we start by declaring a
variable temperature we set it to 32 now
we use an if statement followed by a
pair of parentheses inside this
parenthesis we type
an expression or a boolean value so
let's say temp is greater than 30 now if
this condition is true the statement
that we had after this if statement will
be executed so let's print it's a hot
day let's run the program we get this
message because temperature is greater
than 30 now what if you want to print
another message like drink plenty of
water here we should add curly braces to
define a code block so if this condition
is true all the code that we have inside
of this block would be executed let's
add another message here drink water
okay so this was our first condition now
let's add a second condition so after
the right brace we type LS if once again
we add our parentheses and inside these
parentheses we type a boolean expression
if 10 is greater than 20 and it's less
than or equal to 30
you want to print a different message
like beautiful day now here I haven't
added the braces because we have a
single statement so braces are only
required if we have multiple statements
now this is a little bit controversial
some people believe we should always add
braces whether we have a single
statement or not other people like
myself believe this creates unnecessary
noise in the code in this tutorial I'm
gonna add the braces first and then
remove them so you can see the
difference so let's add a pair of curly
braces here and finally our last
condition so if none of these two
conditions are true let me print a
different message so here we simply type
LS we don't have any more conditions so
let's add a code block and print cold
day now let me define a few terms here
we have an if statement and this
statement has three clauses or three
sections here's the first Clause here's
the second Clause and here's the third
Clause pay attention to how a formatted
this if statement so first we have the
if Clause the else if
and else clauses are placed after these
right braces so we have some kind of
hierarchy here here we have a parent
followed by two children now let's get
rid of these unnecessary braces and
reformat our code to see the difference
so I'm gonna remove the braces for the
else clause and also one more time here
that's better now we can simplify this
boolean expression basically we don't
need this piece of code here here's the
reason if the first condition is not
true what does it mean that means the
temperature is less than or equal to 30
so this expression here is unnecessary
let's delete this and simplify our code
that's better now look at how this code
is formatted on the top we have if the
else if Clause is a little bit indented
but the else Clause is not indented it's
at the same level as the if Clause and
this looks a little bit ugly the code is
not symmetrical so if you want to get
rid of the curly braces a better way to
format this code is like this so instead
of adding the else if or else classes
after curly braces we add them on a new
line now all these clauses are at the
same level the code is easier to read in
this tutorial I'm gonna show you a very
cool technique for simplifying if
statements so let's start by declaring a
variable called income and set it to
120,000 now here we can use an
underscore in between these three digits
to make our code more readable now let's
say we want to declare a boolean
variable called has high income if the
income is more than $100,000 you want to
set this to true otherwise we want to
set this to false so here we can write
an if statement like this if income is
greater than $100,000 we want to set has
high income to true however we get a
compilation error here
let's take a look declaration not
allowed here
so we cannot declare a variable here we
can only declare variables inside code
blocks like this code block over here so
to declare this variable we need to add
curly braces to define a new code block
now we have a different problem this
variable that we have defined is scoped
to this code block so it's only
available here we cannot access it
outside of this block let me show you so
if we print has high income you can see
we have a compilation error cannot
resolve symbol has high income because
this variable is not available outside
of the block in which it's declared so
to solve this problem we can declare
this variable after setup this block
boolean has high income and then we can
simply set it to true in this block now
we don't need these braces anymore so
let's simplify the code we add an else
clause otherwise we said has high income
to false let's remove this print method
we don't need it anymore so this is one
way to implement this scenario but this
code looks very amateurish a
professional programmer doesn't write
code like this let's improve it step by
step one way to improve this is to give
this boolean variable an initial value
for example we can set it to false
initially and then we implement this
condition so if the income is more than
$100,000 then we set this variable to
true with this we no longer need is else
Clause
so that was one improvement but it's
still not ideal in situations like this
we can completely get rid of this if
statement here let me show you instead
of hard-coding false here we type our
expression income is greater than
$100,000 so here we have a boolean
expression if this boolean expression
evaluates to true this boolean variable
is going to be true otherwise it's going
to be false so this is the simplest the
most elegant and the most professional
way to implement this scenario now one
more improvement before we finish this
tutorial I
personally prefer to wrap this
expression in parentheses even though
technically we don't need parentheses
here but these parentheses make our code
more clear more readable let me show you
so I'm gonna wrap this inside these
parentheses now it's very clear we're
obviously on the right side of this
assignment operator we have a boolean
expression in this tutorial we're gonna
look at the ternary operator in Java so
we're gonna continue with the example
from the last tutorial we had this
income variable imagine this is the
income or customers now depending on
their income
you want to put these customers in
different classes if their income is
more than $100,000 you want to put them
in the first class otherwise we want to
put them in the economy class so here's
one way to implement the scenario we
declare this string variable class name
note that we cannot call this class
because class is a reserved keyword so
class name now we write our first
condition if income is greater than
$100,000 we said class name to first
otherwise we set it to economy
now as you learn in the last tutorial
this code looks very amateurish a
professional programmer doesn't write
code like this so one way to simplify
this is to give this variable an initial
value so we assume they are in the
economy class and then we check this
condition if this condition is true we
put them in the first class so with this
we can get rid of this else clause that
is better now in the last tutorial I
showed you how to simplify this even
further but the technique you learned
there cannot be used here in other words
we cannot add income greater than
$100,000 here because here we have a
boolean expression but on the left side
we have declared a string variable so we
want to set this to a different string
depending on the result of this
expression and this is where we use the
ternary operator so we start with our
condition then we type a question mark
if this condition is true we add this
value here otherwise we add the other
value so this question mark and colon is
the ternary operator in Java it has
three pieces first we have a condition
if this condition is true this value
will be returned and assigned to our
class named variable otherwise this
other value will be returned now we can
completely get rid of this if statement
so put the ternary operator in your tool
box it's very helpful next we're going
to look at switch statements in Java in
this tutorial we're going to look at
switch statements in Java we use three
statements to execute different parts of
code depending on the value of an
expression kind of similar to if
statements let me show you so let's say
we're gonna write a program and check
the role of the current user and then
we're gonna print different messages or
give them different features depending
on their row so let's declare a string
variable called role and here we set
this to admin now to check the role of
the user we can write an if statement
like this if role equals admin then
perhaps
we want to print you are an admin now
you might be wondering why we have this
condition here it's obvious that this
condition is always true because we have
set roll to admin but this is just for
demonstration in a real program we are
not gonna hard code this admin here so
we're gonna read the role of the current
user from somewhere else
we don't know what it is at the time of
writing code okay so here we have one
condition
let's write another condition else if
role equals moderator perhaps we want to
display a different message so you are a
moderator and finally if the role is
none of these values you want to print
you are a guest so this is one way to
implement this scenario using an if
statement we can also implement this
using a switch statement and sometimes
that looks a little bit cleaner let me
show you so we start with a switch
statement then we add parentheses and
inside this parenthesis we add our
variable in this case row next we define
a block of code and in this block we add
one or more case clauses so we have a
case for an admin we add a colon here
now what do we want to do here if the
role is admin you want to print you are
an admin so I'm gonna copy this line
from here and then paste it over here
now after this line we need to add a
break statement to jump out of this
switch block okay then we add another
case Clause so case moderator once again
you got a colon and here we're gonna
print this other message so we paste it
here and then we're gonna break
now optionally we can have a default
clause here so if none of these previous
cases apply the code that we write in
this section will be executed so here we
want to print you are a guest
now here we don't need to use a break
statement because we're at the end of
the switch block so will automatically
jump out of this block in contrast if we
didn't use this break statement here
Java will continue executing these other
lines here so if the role is admin first
it will execute this line and then it
will jump to this case block it will
execute this other line and then after
it executes this break statement it will
jump out of this switch block okay so
this is how we use a switch statement
now compare this with wave statement
some people prefer to use if statements
others prefer to use a switch statement
now one more thing before we finish this
tutorial here we're comparing the value
of role with strings but we could also
use integers other than the long type so
if roll was a byte short or an integer
our cases would look like this case one
case two and so on now here we have a
compilation error because roll is a
string let's change this to an integer
and we can initialize this to one so as
you can see with sweet statements we can
execute different code depending on the
value of an expression
all right now it's time for an exercise
this exercise I'm gonna give you is a
popular interview question so I want you
to write a program that behaves like
this here we should enter a number if
this number is divisible by five we get
this so if you run the program again and
enter ten once again we get fit now if
this number is divisible by 3 we get
buzz if this number is divisible by both
five and three like fifteen or thirty or
whatever we get fizzbuzz and if this
number is not divisible by five or three
like two we get the same number printed
on the terminal so go ahead and spend
five to ten minutes on this exercise
you'll see my solution next
all right to read the number first we
need to use the scanner object so
scanner we import this and instantiate
it and as you know here we need to pass
system that in to read data from the
terminal now we print a message so we're
gonna use the print method instead of
print line here we add a label like
number and then we call scanner the next
int to read a number we store it in this
variable number okay so the first part
is done now we need to check to see if
this number is divisible by five or not
so we can write an if statement like
this if number here we use the modulus
operator which returns the remainder of
a division so we divide this by five and
if the remainder equals zero that means
this number is divisible by 5 so we
print fizz now
otherwise if this number is divisible by
3 we print buzz we need another
condition if this number is divisible by
5 and 3 so here we use the and operator
number divisible by 3 equals 0 in this
case we want to print fizz buzz
otherwise you want to print the same
number like this now this is not the
right solution as I will show you in a
second this program has a book but it's
a very common solution that I see
amongst my students so let's run this
program and see what is wrong here
all right here we enter five we get fizz
utiful what if you enter ten ten is also
divisible by 5 so we get fits so far so
good what about a number that is
divisible by 3 we get buzz good what if
we enter a number that is divisible by
both 5 & 3 like 15 we get physican why
is that here's the reason with this
implementation if we enter 15 this first
condition will evaluate to true so we
get fizz these other else clauses will
be ignored and that is why this line
will not be executed so in situations
like this you should have the most
specific conditions on the top and the
most generic ones on the bottom in this
case we want to move this condition to
the top so if the number is divisible by
5 & 3 we're gonna print fizzbuzz so this
is very specific otherwise if the number
is only divisible by 5 we print fizz
else if it's divisible by 3 we print
buzz and finally if none of his
conditions is true then we print the
same number now let's run the program
one more time so we enter 15 and we get
fizzbuzz beautiful so here's one way to
solve this problem now I've seen some
people argue that we have repeated this
expression twice number is divisible by
5 we have that here on line 12 as well
as line 14 in programming we have this
concept called dry which is short for
don't repeat yourself so some people
argue that here we have repeated this
expression and this is not a good
solution here is another way let me show
you so we're gonna get rid of this
second condition here instead we're
gonna add a code block over here so if
the number is divisible by 5 first we
check to see if the number is also
divisible by 3 if that's the case we
print fizzbuzz
otherwise we print just fizz
like this okay now we no longer need
these two lines because we already
implemented this concept here so first
we check to see if the number is
divisible by five if not we check to see
if it's divisible by three and otherwise
so here is another way to solve this
problem but in my opinion this approach
is kind of amateurish and ugly because
these nested if-else statements are
considered a bad practice now this is
not terribly bad but the more you nest
these L statements the more confusing
your code is going to be to other people
so I personally prefer the previous
solution even though we had a bit of
repetition in the code the more you
program the more you build software the
more you realize that there is no way to
build ideal software programming and
problem solving is all about trade-offs
every solution has certain strengths and
certain weaknesses this solution doesn't
have any repetition or duplication in
the code but it has a nested structure
and these nested structures make our
code hard to read and understand the
previous solution had a bit of
repetition but it had a flat structure
there is no nesting here and this code
is cleaner and easier to read there are
times that we want to repeat one or more
statements for example let's say we have
this hello world message here let's say
we want to print this five times on the
terminal we don't want to repeat this
code like this this looks very ugly
that's where we use loops in Java we
have a few different types of loops the
first one that I'm going to talk about
in this tutorial is for loops so let's
see how we can use a for loop here I'm
going to delete all this code you start
by typing the for keyword followed by
parentheses and inside these parentheses
we need to do three things first we need
to declare a loop or counter variable so
let's declare a variable called I and
initialize it to 0 quit often use
variable names like I J and K for loop
counters next we add a semicolon to
terminate the first statement then we
write a boolean expression that
determines how many times this loop is
gonna get executed so I
than five as long as I is less than five
this loop will be executed once again we
add a semicolon and finally we increment
I by one like this so this is the basic
structure for a for loop now here we can
repeat one or more statements using this
for loop so we can add our hello world
message here like here we have a single
statement so we don't need braces but if
you have multiple statements that we
want to repeat we need to define a code
block here now I'm gonna remove this
because you don't really need them so
let's run this code and see what we get
you get hello world printed five times
on the terminal beautiful now let me
explain how this code gets executed when
Java sees this for loop first it will
execute this statement so here we are
initializing I to zero then Java
evaluates this condition is this
condition true obviously it is because
zero is less than five so the control
moves to line seven this line gets
executed now at the end of this
iteration or at the end of this loop the
control moves here
so I is incremented by one now we are at
the beginning of the second iteration
once again this condition is evaluated
is one less than five obviously it is so
once again the body of this loop gets
executed now fast forward at the end of
the fifth iteration I will become five
five is not less than five so the loop
condition will be false and control
moves outside of this for loop now
here's one thing you need to remember if
you want to execute something five times
you can initialize your loop counter or
loop variable to zero and use the less
than operator here another way is to
initialize this to one and then use the
less than or equal to operator here now
to make this more interesting let's
print I over here so here we add a space
and then concatenate this string with I
take a look so we get hello ward one two
three four five in contrast if we
initialize I to zero and use the less
than operator
we will get hello word zero one two
three four we can also print these
numbers in reverse order so we
initialize I to five and execute this
loop as long as I is greater than zero
but here instead of incrementing I we
decrement it now we get hello world five
four three two one
so this is all about for loops next
we're gonna look at while loops in this
tutorial we're gonna talk about while
loops in Java while loops are very
similar to for loops in terms of their
functionality but they're different in
terms of syntax let me show you so we're
gonna continue with the example from the
last tutorial I'm gonna rewrite this
code using a while loop so first we
declare a loop variable and I initialize
it to zero
next we type while and here in
parentheses we type our loop condition
while I is greater than zero then we're
gonna execute the code inside this block
so I'm gonna copy this from here paste
it in this block and finally we need to
decrement I like this so at the end of
each iteration we decrement I just like
our for loops so as you can see we can
achieve the same thing using a for loop
or a while loop
however the implementation using the for
loop is a little bit lighter and cleaner
so in situations where you know ahead of
time how many times you want to execute
one or more statements it's better to
use a for loop while loops are better in
situations where we don't know exactly
how many times you want to repeat
something for example let's say we're
going to write a program and ask the
user to continuously enter something
until they type quit the moment they
type quit we're gonna terminate the
program in that situation we don't know
how many times the user is going to
enter something so let's write that
program using a while loop
I'm gonna delete everything from here
all right we're gonna start with our
while loop now what is our loop
condition here we don't have a counter
variable in this example instead we want
to check to see if the user entered quit
or not so here we can declare a string
called input and initialize it to an
empty string then we can write a while
loop like this while input does not
equal to quit now this code is not gonna
work because input is a string which is
a reference type and we cannot use
comparison operators between reference
types because these operators will
compare the address or a string objects
not their value so if you have two
strings quit and quit but stored in
different memory locations to have
different addresses so we can use the
inequality operator to compare their
value instead we need to use the equals
method of string objects so we want to
check to see if the input equals quit
now here we need to apply the not
operator so as long as the input does
not equal quit we're gonna continuously
ask the user to enter something so here
we can print a label like input and then
we can use a scanner object to read
something from the terminal so let's
create a scanner object and instantiate
it using system dot in I didn't call
scanner that next this will return a
string so we can store it in this input
variable now with this implementation in
every iteration we're going to create a
new scanner object so if the user enters
10 numbers we're gonna create 10 scanner
objects in memory this is unnecessary
and it's actually a bad practice because
it's going to pollute our memory so it's
better to create the scanner object
outside of a while loop and then simply
use it here also here we are assuming
that the user is typing everything in
lowercase so if they type quit in
uppercase or any combinations of
lowercase and uppercase characters this
logic is not gonna work the way we want
so over here right after reading
something from the terminal we're gonna
call the
to lowercase method of string objects to
convert it to lowercase now to make this
program more interesting let's echo back
whatever the user enters so we simply
print that on the terminal now let's run
this and see what happens
so I'm going to enter if your numbers
like 1 2 & 3 whatever we type gets a
code back but the moment we type quit
our program terminates so while loops
are useful in situations where we don't
know ahead of time how many times we
want to repeat something in Java we have
another type of loop called a do-while
loop it's very similar to a while loop
but it gets executed at least once let
me show you what I mean so I'm gonna
rewrite the same code using a do-while
loop we start with a do keyword then we
create a code block at the end of this
code block we type while followed by our
loop condition so not input dot equals
quit and then we terminate this using a
semicolon now inside the body of this
loop we'll simply copy all these lines
we have here
now compared these two types of loops
with while loops we check the condition
first so if the condition is false the
first time this loop will never get
executed in contrast with do-while loops
we check the condition last so do-while
loops always get executed at least once
even if the condition is false that is
the only difference the reality most of
the time we use while loops do-while
loops are rarely used but there are
certain cases for that so just be aware
of them but most of the time prefer to
use wire loops
we're gonna continue with the example
from the last tutorial this program we
have written has a tiny problem let me
show you so I'm gonna run this enter a
couple numbers these numbers get echo
back beautiful
if we type quit the program terminates
but the word quit also gets echoed back
this is a bit weird so let's look at a
couple ideas for solving this problem
back to our code one way to solve this
problem is to check the input before
printing it so here we can type an if
statement if the input does not equal
quit then we're print it so not equal
input dot equals quit if this condition
is true then we're going to print the
input let's take a look so one to quit
beautiful we solved the problem there is
another way to solve this problem as
well let me show you we can reverse this
condition so if the user types quit you
can immediately jump out of the loop
using the break statement so I'm gonna
remove the nut operator if the user
types quit we're gonna break out of the
loop otherwise we're gonna continue
execution and print this input on a
terminal so when Java sees the break
statement it will ignore everything else
after and it will terminate the loop
let's run the program
once again we enter a couple numbers
followed by quit beautiful so this is
the break statement we also have the
continuous statement that moves control
to the beginning of a loop let me show
you so let's imagine if the user types
pass we don't want to echo that but also
we don't want to terminate the loop you
want to ask the user to try one more
time so after we read the input we can
check to see if input equals pass this
is where we use the continuous statement
when Java sees this it would move
control to the beginning of the loop so
all these other statements are gonna get
ignored and what the user types is not
gonna get printed on the terminal let's
run the program and see this in action
so we type 1 2 pass it doesn't get
echoed back one more time and finally
quit so to recap the break statement
terminates a loop and the continue
statement moves control to the beginning
of a loop now one last thing before
finish this tutorial in this
implementation we don't really need this
loop condition because the moment user
types quit this break statement is gonna
kick in and terminate the loop so we can
simplify this code by using a true as
our loop condition so this is always
true and this loop is gonna get executed
forever until the user types quit this
is a very common technique that you see
amongst professional programmers just
remember if you're using this technique
make sure to have a break statement
otherwise you will end up with an
infinite loop that executes forever it
never terminates and that can be very
dangerous in terms of memory consumption
so if you're using while true make sure
you have a break statement in your loop
the last type of loop we want to look at
is the for each loop in Java we use for
each loops to iterate over arrays or
collections let me show you so I'm going
to start by declaring a string array
called fruit and we initialize this with
three items let's say Apple mango and
orange now let's say we want to iterate
over this array and print each item on a
terminal we can use any of the loops you
learn about earlier like a for loop or a
while loop but we can also use the for
each loop which is a bit easier let me
show you first I'm going to use the for
loop to iterate over this array so we
type for here we declare our loop
variable or loop counter into I we set
it to zero as long as I is less than
fruits that length we're going to
increment I by one after each iteration
and here we simply print fruits of I
let's run the program and see what we
get so we get each item on a new line
beautiful now there is another way to
write the same code using the for each
loop here we type for in parentheses
with declare and loop variable but the
type of this variable should be based on
the type of items in our array so here
we have a string array and that means
every item in this array is a string so
here we should declare a string variable
we call it fruit here we type a colon
and then the name of our array fruits
now in each iteration fruit will hold
the value of one item in this array so
here we don't have to declare a numeric
counter we don't have to write a boolean
expression like this we don't have to
increment our counter it's much easier
to iterate over an array now if we print
fruit we get the exact same result as
before take a look
so the first three items are from our
for loop and here's the result our for
each loop
so this is the for each loop however
this for each loop has a couple of
limitations one limitation is that it's
always forward only so we cannot iterate
over this array from the end to the
beginning in contrast we can easily do
this with a for loop so here we can
initialize I to fruits that length then
we change this operator to greater than
and replace this value with zero so as
long as I is greater than zero we're
going to decrement I the second
limitation of the for each loop is that
here we don't have access to the index
of each item all we have is this loop
variable which holds the value of each
item in this array in contrast in our
for loops we can access both the index
and the actual item so I represents the
index of each item and fruits of I
returns the item at the given index so
if you need the index then you'll have
to use the for loop otherwise it's much
easier to use the for each loop
all right now let's get back to our
mortgage calculator and implement some
basic error handling
so here I've changed this question by
adding this label that identifies the
range of values we can enter so the
minimum amount of loan we can get is
$1,000 and maximum is 1 million dollars
so if I enter 1 here I get this message
enter a number between one thousand and
one million and now we are asked this
question one more time if I keep
entering invalid values I get asked the
same question now let's enter a valid
value like 1 million dollars next we'll
have to enter the annual interest rate
now here we need to enter a value that
is greater than 0 and less than or equal
to 30 so if I enter 0 we get this
message enter a value greater than 0 and
less than or equal to 30
once again we're asked this question one
more time so let's enter a valid value
like 3.9 to here we need to enter a
value between 1 and 30 so if you enter 0
we get an error message and we're asked
the same question so let's enter 30 and
finally we get the result here's our
mortgage or monthly payments so go ahead
and spend five to ten minutes on
extending this mortgage calculator by
adding error-handling to it you'll see
my solution X
all right let me show you how I'm gonna
solve this problem step by step so for
each question we want to validate the
value that the user enters if the value
is invalid you want to keep asking the
same question so this is where we can
use an infinite loop let me show you so
here's our first question principal I'm
gonna wrap these two lines inside an
infinite loop while true
so we're gonna keep asking the same
question until the user enters a valid
value so here after we read the
principle we can write an if statement
like this if principle is greater than
or equal to 1000 and it is less than or
equal to 1 million and here we can use
an underscore to separate these digits
to make our code more readable so if the
user enters a valid value then we can
break out of this infinite loop
otherwise we're gonna print an error
message so enter a value between 1001
million like this ok now if you look on
the right side here you can see this red
bar this indicates an error and here in
this preview window you can see exactly
where we have an error it's down below
on line 30 where we calculate the
mortgage so if you click on this red bar
we jump over here principal is
highlighted in red so here we have a
compilation error cannot resolve symbol
principle here is the reason because
we've wrapped these few lines inside
this while loop and earlier I told you
that whenever you declare a variable
that variable scope to the Block in
which it's defined so this is where we
have declared the principal variable and
it's scoped to this block it's not
available outside of this block that's
why we get this compilation error so to
solve this problem we need to declare
this outside of this while loop we can
do it right here after radicular our
constants so let's say int principle and
we can initialize it to 0 now we remove
the declaration from here and the error
is gone now we need to repeat the same
pattern with other questions so real
quick here's our second question where
we read the annual interest once again
we add an infinite loop
now the moment we read the annual
interests invalidate the data so if
annual interest is greater than or equal
to let's say one and it is less than or
equal to 30 then we're gonna break out
of this infinite loop
now here we should also calculate the
monthly interest so the proper way to do
this is like this if the user enters a
valid value we add a code block here
first we calculate the monthly interest
and then break out of the loop otherwise
we print an error message enter a value
between 1 and 30 okay now if you look to
the right side again we have two
compilation errors monthly interest is
not resolved because we have declared it
inside of this block so let's move the
declaration to the top here we remove
the float keyword and declare monthly
interest over here
that's better and finally for the last
question one more time we're to wrap it
in this infinite loop
this is where we read the number of
years and right after this line we need
to do our data validation so if yours is
greater than or equal to one and it's
less than or equal to 30 here we add a
code block this is where we calculate
the number of payments and then we break
actually I forgot to type an S here
otherwise if the user enters an invalid
value will simply print an error message
enter a value between 1 and 30 now here
once again we have a compilation error
because number of payments cannot be
resolved so we remove the declaration
from here and we'll be to the top right
here number of payments so this is how
we add data validation to this program
the problem is that this code the code
inside the main method is now getting a
little bit too long and this hurt the
maintainability of our program someone
else reading this code they have to look
at all these statements to figure out
what's going on this is where we need to
break this code down into smaller easier
to read and easier to understand chunks
and that's what I'm gonna show you next
so in this section you'll learn how to
control the flow of execution of your
programs we started off by talking about
the comparison operators for comparing
primitive values then we talked about
the logical operators like and or and
not I showed you how we can use these
operators for implementing real word
rules and then we talked about three
types of control flow statements you
learn about conditional statements like
if and switch for making decisions in
our programs then you learn about loops
for executing code repeatedly we looked
at four types of loops for loops while
loops do-while loops and for each loops
and finally we looked at the break and
continue statements for breaking or
jumping to the beginning of a loop I
hope you learned a lot and been enjoying
the course so far
as Martin Fowler said any fool can write
code that a computer can understand good
programmers write code that humans can
understand I can't agree more if you
have seen any of my courses you probably
know that I've put a lot of emphasis on
writing clean code so I have dedicated
this entire section on clean coding
we're going to continue extending our
mortgage calculator and add new features
to it along the way you will see our
code starts to get messy and hard to
maintain so I will show you a few
techniques for changing the structure of
the code and make it clean and beautiful
are you ready let's jump in and get
started
hey guys maj here i want to congratulate
you on your determination for learning I
would really appreciate it if you
support me by liking and sharing this
video also subscribe to my channel and
enable notifications so next time I
upload a video you get notified now if
you want to learn more I would encourage
you to enroll in my ultimate Java series
as I told you earlier this YouTube
tutorial is the first two hours of this
series if you're serious about learning
Java and want to become a professional
job of developer I highly encourage you
to enroll in this series in case you're
interested I put the link down below in
the description box thank you on have a
fantastic day
