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 [Link] 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 [Link]

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