Archive for category: Java

Nested looping refers to a loop inside another loop. Many applications require to loop over a repeated task. Nested looping is a solution to aid such repetitive tasks. As an example, consider printing ten lines on the terminal, where each line contains twenty asterisks, as shown below.

********************
********************
********************
********************
********************
********************
********************
********************
********************
********************

Printing one line of twenty asterisks can be performed using a loop. We can write ten lines of asterisks by running another loop over it ten times.

The Code used in the Video Lecture

In the video, we wrote a code using nested loops that prints the output of ten lines, where each line contains twenty asterisks. The java program is below. Please save the program in a file named Nested.java.

class Nested{
    public static void main(String[] args){
        int i;
        int j;
        for (i=1; i<=10;i=i+1){
            for (j=1;j<=20;j=j+1){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

The Video Lecture

The YouTube Video lecture is embedded below.

Exercise

Write a program using nested for loop to print the following pattern of asterisks on the terminal.

**********
*********
********
*******
******
*****
****
***
**
*

Transcription of the Audio of the Video

Hi,
This is Dr. Shahriar Hossain. How are you today? I hope that you are enjoying Java programming. In this video, I am going to explain nested loops. Nested looping refers to looping over another loop. Many applications rely on multiple levels of nesting. For simplicity, today we will learn how to use one for-loop inside another.

In this video, we will go over one problem. At the end of the video, we will provide an exercise. We will solve the exercise in the next video.

The problem

The problem we are going to solve is as follows: Print 10 lines, where each line contains 20 asterisks. The sample output is provided below.

[Show the sample output.]

********************
********************
********************
********************
********************
********************
********************
********************
********************
********************

[End of — Show the sample output.]

Analyzing the problem

Let us talk about the problem. Print 10 lines, where each line contains 20 asterisks, or stars, or multiplication symbols.

Let us think about the solution. Notice that we need to draw a line of 20 asterisks.

If we can draw one line that has 20 asterisks, we can repeat the process 10 times.

[Show the hand-written code]

Whatever code we will write should have this structure [as shown on screen.] The first thing is, we will try to print one line that contains 20 asterisks. That is, at first, we will solve this subproblem – print 20 asterisks in one line.

Printing one line of asterisks

Let us write our code in the main method in a class named Nested. Obviously, the name of the file is Nested.java.

Printing 20 asterisks can be done by typing writing System.out.println(“********************”);

Hard coding the asterisks will not make your code easy to change. That is, if someone wants to print fifty asterisks in one line, then you have to change the System.out.println with fifty asterisks.

Printing one line of asterisks using a for-loop

Anyway, we are going to use a loop that iterates over a System.out.print statement 20 times.

I am writing the structure of the for loop. As you can see, this for loop is designed to iterate 20 times. The value of the variable j will vary from 1 to 20 in this loop. Inside the for loop I use a System.out.print statement, which prints just one asterisk. Notice that this is a System.out.print statement not a System.out.println statement. That is, each asterisk will be printed one after another one, without any line.

Let us save the file, compile it, and run the generated class file. Twenty asterisks are printed on the terminal. Notice that my command line, which states “My computer” starts right after the last asterisk. I actually want to print all these 20 asterisks in a line. Nothing else should be here.

A new line

What we have to do is, we have to put a new line right after the last asterisk is printed.

Let us put a newline after the for loop ends. That is, after all the asterisks are printed, this System.out.println statement will print a new line. As a result, the text, “My Computer”, which is the prefix of my command prompt will move to the next line. Please notice again, System.out.println without any content in the parentheses simply prints a new line.

Let us save the file, compile it, and run the generated class file. All the 20 asterisks are now printed in one line. We have printed one line of twenty stars. That means we are done with this part. [Show the hand-written pseudocode.] We have to now implement this part, which is repetition of what we have done so far 10 times.

Repeating the previous loop

Now that we have the code to print just one line, we can repeat this part that prints one line of 20 stars, 10 times. If we repeat this part of the code 10 times, we should have the desired output, which is 10 lines, where each line has 20 asterisks.

To repeat this part 10 times, we need another for loop. To control that other for loop, we will need a variable. Let the variable be “i”. We write a for-loop, in which the variable “i” varies between 1 and 10. The code that prints 20 asterisks in a line is inside the outer for loop that iterates 10 times.

Running the program

Now save the java file, compile it, and run the generated class file.

Notice that all the 10 lines are printed. Each line contains 20 asterisks. Therefore, we have solved the problem. [Show the original problem]

Today, we have discussed the nested loops – one loop inside another one.

Nested looping can be more complex than what we have explained so far.

Exercise

We are providing an exercise now.

Print 10 lines, where the first line, contains 10 asterisks, the 2^nd line contains 9 asterisks, the 3^rd line contains 8 asterisks, the 4^th line contains 7 asterisks, so and so forth. The sample output is provided below.

**********
*********
********
*******
******
*****
****
***
**
*

We are giving this problem as an exercise. Please try to solve it before watching the next video.

Concluding remarks

It is fine if you cannot solve it at this point. We generally give exercises that are harder than what we have covered so far. That is what makes learners skilled. We will definitely provide the solution of the exercise and explain some relevant items in the next video.

If you have not yet subscribed to our website Computing4All.com and to this YouTube channel, please do so to confirm that you receive notifications on our new articles and videos. Wish you a wonderful day, evening, or night, whatever is upcoming. Thank you!

Repetition of segments of codes is an essential part of programming. Repeating the execution of a code segment, a programmer can reduce the size of the code as well as solve problems that require iterations of similar computations for an arbitrary number of times. Java provides three syntaxes for repetition: for loop, while loop, and do-while loop. This article covers Java for loop.

Java for loop

Java for loop is is a powerful syntax to repeat segments of code. It provides integral mechanisms to use variables to control a looping. The “for” syntax itself has three parts: initialization, condition, and change (modification of variables.) These parts are seperated by two semicolons. The basic for-structure is provided below.

for (initialization; condition; change){
// Write the code you need to repeat.
// This is the scope of the for loop.
}

The first part, initialization, is executed only once. It executes before anything else regarding the for-loop has been executed.

The second part, condition, executes each time the execution attempts to go insde the scope of a for-loop. The execution goes inside the loop if the condition results in true, otherwise it terminates the loop.

The third part, change, executes at the end of each iteration. Generally, increment or decrement operations on variables are applied in this part.

All the three parts are optional. Java for loop is a powerful syntax because a programmer can use it quite flexibly and creatively. In fact, knowing just “for loop” from the looping control statments is good enough. A programmer can skip while loop and do-while loop pretty easily, if she/he learns the for-loop well. (If you are reading this page for a coursework, I must tell you NOT TO SKIP while loop and do-while loop.)

The video lecture on Java for loop

The following video provides great details on how to use Java for loops. It is a great introductory material. The last part of the video contains a tracing of the program to visually explain how a Java for loop works.

The code used in the video lecture

Here is the code we used in the video lecture. Save the code in a file named MyCode.java.

class MyCode{
   public static void main(String[] args){
     int i;
     for (i=0; i<5; i=i+1){
       System.out.println("Hello Java!!!");
       System.out.println(i);      
     }
   }
 }

Exercise on Java for loop

Use Java for loop in solving all the problems below.

1. Write a program to print your name twenty times.
2. Write a program that sums up all the integers between 1 and 100 (including 1 and 100.) Report the final summation on the terminal.
3. Write a program that prints all the odd numbers between 0 and 50 on the terminal.

Comment

Please feel free to send us your code in solving the exercises above. Write your questions in the “Comments” section below. We will be happy to help you in problem-solving.

Transcription of the Audio of the Video

Hi, this is Dr. Shahriar Hossain. Have you ever thought about how can we repeat segments of our code for a certain number of times? Like most standard programming languages, Java has three different syntaxes  for repeating a segment of code. These syntaxes are called the “for loop”, the “while loop”, and the “do-while loop.”

Today, we are going to learn the “for loop.”

Sample problem

To explain a sample problem, let us write a program. The problem is to print “Hello Java!!!” five times. Based on topics we have discussed so far in this lecture series, we would write five System.out.println statements to print “Hello Java!!!” five times. If we have to write “Hello Java!!!” one hundred times, we have to write one hundred System.out.println statements. We might even have situations, where we have to repeat the same statement a thousand times. It is not quite practical to repeat statements so many times in the same program. To solve this issue, all languages provide looping.

Java for loop

Java’s “for” control statement has three parts. The first part is initialization. This part is executed once before entering the scope of the for loop. The second part is condition check. As long as this condition check is true, the execution will go inside the scope of the for loop. The third part is something that is automatically executed after each iteration of the scope.

All these three parts are separated by two semicolons, within the parentheses. Now notice that if you initialize a variable in the first part, and increase the variable in the last part, then you can put a condition in the second part to allow the execution to go inside certain number of times. For example, consider that you have a variable named “i”. You initialize the variable “i” to 0. Then you, say in the third part, i=i+1. The third part executes automatically after the execution of the segment scoped by the for loop. Therefore, at the end of each iteration i will automatically be incremented by 1.

You are starting the loop with i=0. After executing the code inside the scope of the for loop, the value of i will become 1 because i=i+1 will execute. In the next iteration, I will remain 1; then at the end of the iteration, i will become 2. This will continue for ever, unless you put a condition in the second part of the three parts of the for loop.

Terminating the loop

You can tell when to terminate the loop. In this example, you can tell “when to stop” based on the value of the variable i. Again, the second part should hold a condition; that is, it should result in a Boolean value. Before executing the scope, the program will check the second part if it is true. If it is not true, then the program will not go inside the loop.

If you type i<5, then it means as long as the value of “i” remains smaller than 5, the execution should go inside the scope of the for loop.

Summary of the three parts

Again, the first part is the initialization and executed only once. The third part is executed after every iteration. The second part is checked for “true” every time the execution attempts to go inside the scope of the for loop.

Since, we have i=0 in the first part, i<5 in the second part, and i=i+1 in the third part, this particular for loop will go inside the scope five times. We will discuss more on this soon in this video.

Let us use a Java for loop in our code

For now, let us change our code with five System.out.println statements so that our code contains only one System.out.println statement, but we repeat that statement five times using a for loop.

I am declaring an integer variable named “i”. I will use this integer variable to control the for loop.

Based on the discussion so far, all we have to do is, write a for loop, in which the first part will contain the initialization. I am putting i=0. In the second part I am putting i<5. In the third part I am writing i=i+1; Notice that, starting from 0, there are five integer numbers that are smaller than 5. Therefore, the loop will execute five times.

Let us save the file, compile, and run it. The program prints “Hello Java!!!” five times.

Values of “i” in each iteration

To check the value of the variable “i” during each of the five iterations, we can write another System.out.println statement, just to print the value of “i”. Save the file, compile, and run it.

Notice that after printing each of the “Hello Java!!!” phrases, we have a number printed in the next line which corresponds to the value of “i” in that particular iteration.

Let us trace the execution of the program.

Tracing the program

I am using a software to trace the program. You are already familiar with manual tracing from the previous video. In this video, I am doing tracing using a software named Netbeans to trace the execution of the code I have written. You do not have to use Netbeans at this point; I am using Netbeans because it gives a good visual illustration of what I am teaching today.

The light green highlight shows where the execution is right now.

I am going to track two items during this tracing. One is the value of the variable “i”  and the other is the Boolean value of “i<5”. I have the output-terminal too.

i=0

Now, the program is in a state where it has created memory space for the variable “i”. The execution is currently in the line where we have the syntax “for”. It has not yet executed the initialization i=0. The first thing the computer will do is execute, the initialization i=0. Then it will check if i<5. Because the variable “i” is zero after the initialization, 0<5 will be true. The execution will go inside the scope of the for loop. Notice that we have two System.out.println statements inside the scope of the for loop. The execution point is now on the first System.out.prinln statement.

At this point, the variable “i” is zero, as you can see here. Also notice that i<5 is true. This is the reason the “for” control statement has allowed the execution to go inside the scope of the for loop. If we execute the current line, which is System.out.println (“Hello Java !!!”), then “Hello Java !!!”  will be printed on the terminal. Our execution point has moved to the next line. Notice that “Hello Java !!!” has been printed on the terminal.

Again, the current value of the variable “i” is 0. Therefore, if we execute the current highlighted line, 0 will be printed on the terminal and here it is. 0 is printed on the terminal.

i=1

After 0 is printed on the terminal, the “for” control statement has executed the scope for the current iteration just once. Now, the third part of the for statement will execute. The third part is i=i+1. Again, the third part is executed at the end of each iteration. Once the variable “i” is incremented by 1, “i” becomes 1 because 0+1 is 1. At this point we are in the second iteration of the scope of the for loop. Notice that i<5 is a true statement because the variable “I” is 1, and 1 is smaller than 5 is a true statement. This is the reason why the execution was able to enter the scope with 1 as the value of i. We print “Hello Java!!!” for the second time on the terminal. Then we print the value of the variable “i”, which is 1 at this point.

i=2

Once the content of the variable “i” is printed on the terminal, i=i+1 will be executed and I will become 2. Since 2<5 is a true statement, the execution will go inside the scope. The first System.out.println will be executed. The execution will now go to the second System.out.println statement. Since the value of “i” is 2, the program will print 2. After printing 2, the third part of the for loop will be executed.

i=3

Therefore, the value of the variable “i” will become 3. Since 3<5 is a true statement, the execution will go inside the scope of the for loop. “Hello Java!!!” will be printed for the fourth time. The value of the variable “i”, which is 3 will be printed.

i=4

The value of the variable “i” will now become 4. Now, 4<5. Therefore, the execution will go inside the scope of the for loop. “Hello Java !!!” will be printed for the fifth time. In the next System.out.println statement 4 will be printed because the variable “i” now contains 4.

Our example loop terminates when i==5

At this point, the third part of the for syntax, which is i=i+1, will be executed. The variable “i” will become 5. Now 5<5 is a false statement. Therefore, the execution will not go inside the for loop anymore. Once the second part of the for loop becomes false, looping is terminated. The execution will jump what we have after the for loop. In our case, it is the closing curly bracket of the main method. Notice that, at this point the variable “i” is 5, and therefore the condition i<5 is false. This is the reason the for loop terminated.

By this time, we have printed “Hello Java!!!” five times on the terminal.

Now, won’t you be able to print “Hello Java!!!” ten times, on the terminal. Or say, print your name on the terminal fifty times, using a for loop? I’m sure you will.

Concluding remarks regarding Java for loops

Now that we can repeat code segments, we can write complicated codes. We can sum up all integers between 0 to 100. Or, we can find if a number is a prime number or not. Note that, you can write arbitrary number of lines inside the scope of the for loop. Those lines may contain anything including if-else if statements, or oven other for loops. More on this in the upcoming videos. If you have not already subscribed to our website Computing4All.com or to this YouTube channel, please do so to receive notifications on our new posts.

Thank you for watching the video. Hope to see you soon in in our video lecture series.

There are several control statements in Java, among which if-else if-else and switch statements are used for selection operations. The video lecture below explains if-else if-else statements. Programmers use if-else if-else statements for decision making in the code. That is, if-else if-else statements help in executing a part of the code based on certain conditions.

Prerequisites

Please make sure to go over the previous lecture on Boolean Variables and Relational Operators, if you haven’t already done so. The last lecture will give a good idea on Conditions, which is the basis for the current video.

The Video: if-else if-else statements in Java

The video explains if-else if-else statements in Java. It uses a simple example to explain the concept. Overall, the video will help beginners to start practicing if-else if-else statements.

The Program Used in the Video

The program demonstrated in the video is provided below. Please save the code in a file named ConditionTest.java if you want to use the code directly. We suggest that you type the code while you watch the video. When you type the code, you practically develope an understanding regarding the syntax you type.

import java.util.Scanner;
class ConditionTest{
    public static void main(String[] args){
        int x;
        int y;
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the 1st number");
        x=scan.nextInt();
        System.out.println("Enter the 2nd number");
        y=scan.nextInt();        
        if (x>y){
            System.out.println("x is greater");
        }else if (x<y){
            System.out.println("x is smaller");
        }else{
            System.out.println("Equal numbers");
        }
    }
}

Exercise to practice if-else if-else statements

Write a program that asks the user for a GPA on a scale of 0.0 to 4.0. If the user enters a number larger than 4.0 or less than 0.0, the program must output “Invalid GPA.” If the user enters a valid number, the program should display the corresponding letter grade based on the table below.

Please do not hesitate to send us your code via the comments section below. We will be happy to provide you feedback.

Comment

Please subscribe to Computing4All.com and to our YouTube channel to stay in touch.

Transcription of the Audio of the Video

From the previous video, you are familiar with comparisons and Boolean variables, we are now moving to what we can do with the comparisons. Practically, we can use comparisons for decision making in the program. That is, a part of our code will be executed if certain conditions are met; otherwise, another part of the code will be executed.

Starting of the code

I am starting my code where I will show how we can use if-else statements. The name of the class is ConditionTest; Of course the file name is ConditionTest.java. I have already written the main method, inside which I will write my code.

I am declaring two integer variables, x and y.

the variable scan is my Scanner object, using which I will get input from the user. I have written my code to get input for the first number x, and the second number y.

The first if statement

At this point, what I will do is, I will print a message if x and y have a certain relationship. The statement is written using “if” then in parentheses state the comparison. Within the parentheses, you must have a Boolean value. Notice that the comparison x>y results in a boolean value, either true or false.

Again, at first write if, then within parentheses provide the condition or comparison that results in a Boolean value. After the parentheses provide the scope of the code that should be executed if the condition in the parentheses results in “true”. You define the scope using a left curly bracket and a right curly bracket.

Anything you write inside the curly brackets will be executed, only if the condition you have provided within the “if” statement results in true. Inside the scope of the if statement I have written, I am writing a System.out.println statement. If x is greater than y, then the System.out.println will print “x is greater than y.”

Save, compile, and run

Let us save the file, compile it and run it. If the user enters a larger number for x than y, then the program should print “x is greater than y”, otherwise the program will print nothing after the user enters the numbers.

The user enters 10 for x and 5 for y. The program immediately prints “x is greater” because the first number the user provided is greater than the second number.

Let us run the code again. The user now provides 10 as the first number and 20 as the second number. Now, the program compares x>y, which results in the comparison 10>20, which in turn results in false. Since the if statement results in false, the System.out.println is not executed. The program just ends without printing anything.

Change the code to include another scope

Now, if we want the program to print something when x is not greater than y, then we can create another scope, which will be executed if the if statement results in false. What we write is, “else” and then we create another scope using left and right curly brackets.  You can print anything inside these curly brackets. Anything you print via a System.out.println statement will be printed on the terminal when x is NOT greater than y. Let us just print “x is not greater.”

Save, compile, and run the code

Let us save the file, compile it, and then run it.

Now, notice that for the first number 10, and the second number 20, the program outputs ” x is not greater.”

Earlier, the program was not printing anything for 10 and 20.

Running the program again with 20 and 10. Now the program is saying “x is greater.” That is if the first number if greater than the second number, the program says “x is greater”, otherwise the program says “x is not greater.”

What happens if you have two equal numbers

Now, what will happen if the user provides two equal numbers, say 10 and 10? Based on the code we have, the program will say that x is not greater. Notice that in the code, the if statement will result in false because x is not greater than y. Therefore, the first System.out.println will not be executed. The execution will go to the else part and execute the System.out.println of the scope of the else, which is “x is not greater.”

What if we want to say something different when x and y have the same value? Practically, we have to include a scope which will be executed when x is equal to y.

In the code, currently, we have if x is greater than y, then do something, otherwise, do another thing. The otherwise part executes only when x is smaller than or equal to y.

We will separate the smaller than part and the equal part. In the else part, we will include another if statement, with a condition x is smaller than y. When x is smaller than y, we want the program to print “x is smaller”.

Save this code, compile, and run the program. When the user puts 10 as the first number and 20 as the second number, the program outputs, “x is smaller.” It is the correct outcome.

When the user enters 20 as the first number and 10 is the second number, the program prints “x is greater.” This is a correct outcome too.

Now notice that when the user enters 10 as the first number and 10 as the second number, the program does not print anything. That is, when the user provides two equal numbers, the program does not go to any of the if scopes.

“The equal to” situation

We would like to see output for “the equal” situation too.

Notice that the first if statement handles the situation with x is greater than y. The second if statement, that is with else,handles the “x is smaller than y” situation. The only situation left is the “x is equal to y” situation. Therefore, we can simply add an “else” to handle the scope of “x is equal to y.” Inside the scope of “else”, we write “equal numbers,” within System.out.println.

We have now written a program that takes two numbers, x and y, from the user and gives an idea of which number is larger, or smaller, or if they are equal.

Let us save the file, compile the code, and run the program. Notice that for equal numbers, the program now outputs “Equal numbers.”

The general structure of if-else if-else statements

[Show the following on screen]

        if (condition 1) {
            ------------
        } else if (condition 2) {
            ------------
        } else if (condition 3) {
            ------------
        } 
            ------------
            ------------
        } else if (condition n) {
            ------------
        } else {
            ------------
        }

[End of — Show the following on screen]

Here is the general structure of “if then else” statements. The first “if” statement is straightforward. If more “if” statements are required in a sequence, they must be preceded by an “else”. You can write as many else if conditions as you need. You may end the if-then-else sequence with just an “else”. The last “else” will cover all situations that are not covered by all the if and else if statements you have in the sequence.

This overall sequence is called if-then-else statements. One thing I should mention is that, each scope under an “if” statement or an “else if” statement or an “else” statement may have many lines of code depending the problem the programmer is trying to solve. In our example, we just had a System.out.println statement within each scope.

Once a condition of the sequence is satisfied, the corresponding scope is executed. Nothing else will execute. The purpose of if-then-else sequence is to execute only one scope.

Conclusion

Please practice what we have discussed today. For exercises, please visit the link provided in the description. Subscribe to this YouTube channel and to our website Computing4All.com. We do not assume that you know anything about programming. Our video lectures, so far, are prepared for beginners regardless of background. Please start from the beginning of this lecture series if you are entirely a new learner.

Thank you very much for watching the video.

Arithmetic operators play a significant role in mathematical operations when using a programming language to solve a problem. The Java programming language has five basic arithmetic operators — addition (+), subtraction (-), multiplication (*), division, and the remainder (%). Programmers apply each of these operators on two operands (that is, on two numbers).

The Video: Arithmetic Operators in Java

In the following YouTube video, we explain the use of arithmetic operators in Java using three examples. Each of the three examples involves the implementation of a mathematical expression.

Programs Used in the Video

In this section, we provide the codes of the three programs we wrote in the video.

Program 1: Implementing a Mathematical Expression

In the first program, we implement an arithmetic expression containing two variables. The arithmetic expression is:

{(a+b)(2a+3b)}+3a

The video explains, how curly braces and square brackets of mathematical expressions should be handled in Java. It also explains how to handle implicit operators (for example, multiplication symbols that are not present in the equation above.)

The following program codes the arithmetic expression above. Save the code in a file named Prog.java.

import java.util.Scanner;

class Prog{
  public static void main(String[] args){
    double a;
    double b;
    double res;
    Scanner sc = new Scanner(System.in);
    
    System.out.println("Enter the 1st number:");
    a=sc.nextDouble();
    System.out.println("Enter the 2nd number:");
    b=sc.nextDouble();
    res = ((a+b)*(2*a+3*b))+3*a;
    System.out.println(res);
    
  }
}

Program 2: Compute the Area of a Circle

In geometry, computing the area of a circle given a radius, r requires evaluating the following expression: πr².

We wrote the following program in the video to calculate the area of a circle. Please save the code in a file named CircleArea.java.

import java.util.Scanner;

class CircleArea{
  public static void main(String[] args){
    double area;
    double r;
    Scanner scan = new Scanner (System.in);
    System.out.println("What is the radious?");
    r=scan.nextDouble();
    area = 3.14159 * r * r;
    System.out.println("The area is: "+area);    
  }
}

Program 3: Compute an Arithmetic Expression

Just like the first program, we implement a mathematical expression in the third program. The expression in the third program is slightly more complex than the one in the first program.

We implemented the following arithmetic expression in the third program.

We wrote the following program in the video to code the equation above. Save the program in a file named ProgExt.java.

import java.util.Scanner;
class ProgExt{
  public static void main(String[] args){
    double x;
    double y;
    double result;
    
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter value of x: ");
    x=sc.nextDouble();
    System.out.println("Enter value of y: ");
    y=sc.nextDouble();
    result = (5*x)/(4*y)+(3*y-2)/(2*x);
    System.out.println("The result is: "+result);
  }
}

Exercise

Write a program to evaluate each of the following arithmetic expressions.

For each of the arithmetic expressions above, using paper and pencil, come up with results for some given values of x and y. For the same x and y, check if your program gives the same result. If the results are different, then you know that either you did it wrong on paper or something is wrong with your code. Please find the issues and fix them. Such fixing of problems is commonly called debugging in the practice of programming.

Additional Resource

The Arithmetic Operators section of the official Java documentation page is a useful reference for the topic we discussed in the video.

Comment

We will cover conditional statements in a future video. Conditional statements help execute different parts of a program under different conditions. To stay in touch, please subscribe to Computing4All.com. Enjoy!

Transcription of the Audio of the Video

Hi, I am Dr. Shahriar Hossain. Today, I am going to explain some items regarding numeric or arithmetic operators in Java. In the previous videos of this lecture series, that Dr. Monika Akbar and I taught, we discussed numeric data types like integers, double, and byte.

We also discussed simple arithmetic operations like addition, subtraction, multiplication, and division. We will describe more on how to use arithmetic operations using Java in this lecture.

The Arithmetic Operators in Java

Java or most standard programming languages have five numeric or arithmetic operators – addition (+), subtraction (-), multiplication (*), division (/), and the remainder (%).

We already worked on addition, subtraction, multiplication, and division in another video. They are basic arithmetic operations and I am sure everyone who is watching this video is familiar with them.

What is the Remainder Operator

What is not common is the remainder operation, which is represented by the percentage symbol (%). In Java, the percentage symbol does not have anything to do with the percentage. After you divide a number by a divisor, you get a quotient and then you have a remainder. The percent symbol or operator in Java will give you the remainder.

For example, 14 remainder 4 is 2, because 4 times three is 12 and then you will have 2 remainder to reach 14. The remainder is computed by the remainder operator.

Anyway, the remainder operations is not hugely common in day-to-day software development. You might need to use the remainder operation if you are working on projects that require implementation of mathematical equations.  

Let us talk about how to perform numeric or arithmetic operations in Java.

Evaluating an Arithmetic Expression

You may recall from middle school, how we did simplification of mathematical expressions. We used square brackets, curly braces, and parentheses in arithmetic expressions. The use of curly braces and square brackets is restricted in Java. In arithmetic statements (in Java), we can only use parenthesis.

Use Parentheses Instead of Curly or Square Braces in Java Arithmetic Expressions

For example, in an expression like this one, {(a+b)(2a+3b)}+3a, we have to replace the opening and ending curly braces with opening and ending parenthesis. Also, we cannot skip any operator when we write arithmetic statements.

Multiplication Symbol has to be Explicit in Java Arithmetic Expressions

On paper, in this expression, ((a+b)(2a+3b))+3a, we did not provide the multiplication symbols. When using Java, we must explicitly put the multiplication symbols.

Another item, I should mention is that whatever arithmetic statement you write, the result should be kept in a variable, to be able to use it later.  For example, if you have a double variable named res, then you can write:

res=((a+b)*(2*a+3*b))+3*a;

Remember from the previous video lectures that the right side of the equals symbol is executed first. The equals symbol is called the assignment operator.

Variables are Replaced by their Contents when Executed

Of course, in place of variables like “a” and “b” Java will put the values in those variables before computing the arithmetic expression you have written in the right side of the assignment operator. After the right side of the assignment is operated, the computed value goes to the variable you have placed in the left side, which is “res”. In this case.

Coding Program 1

Let me quickly code the program.

[Write the code in fast forward mode using equation res=((a+b)*(2*a+3*b))+3*a. Initialize, a to 1.0, and b to 2.0.]

Notice that, I initialized “a” to 1.0 and “b” to 2.0. For these values, I am doing the calculation on paper first. The simplified value is 27. The same way, I did it on paper, the Java Virtual Machine will do it for me using the computer’s processor.

Running the Program

That is if I run the program I have written, the computer will evaluate the arithmetic expression we have written in the right side of the assignment operator of the “res” variable. If I compile and run the program I will be able to check if the program prints 27, as expected.

After compiling and running the program, we see that 27 is printed on the terminal. This demonstrate that whatever we did on paper is actually replicated here using the program. You have written a program that can compute the expression.

Changing the Code to Get User Input

In an ideal case, we will not hard code the initial values like what we did here in our code. We know how to change the code to ask the user for the values of the variables we have.

I will now change the code. I will use a Scanner object that I will use to get the user input for “a” and “b”. After I do that, my code will ask the user for each of the two numbers. The program will take the first number and put it in a. It will take the second number and put it in b.

Let us, save the file, compile it, and run the program. The program is asking for the first number. The user enters 1. It is asking for the second number. The user enters 2. The computer states that the calculated value is 27.

We can run the program again and find the calculated value for any two numbers.

You can write a program to compute the area of a circle, or a rectangle, or a trapezoid, or practically anything as long as you have the arithmetic expression for the problem you are trying solve.

Coding Program 2: Area of a Circle

Let us go over another program. We are writing a program that is able to compute the area of a circle.

Remember from geometry that the area of a circle is πr².

Pi (π) is constant. That means the value of pi never changes. The value is quite long, but in this program, we will keep only a few digits after the decimal point. We will use π= 3.14159.

Notice that the only variable you have here for the mathematical expression is “r”, which is the radius of the circle. Therefore, we will ask the user to provide the radius. After the user provides the radius, all we have to do is compute π times radius squared.

The radius is stored in the variable “r”. Therefore, we can write “r times r” for radius square. My arithmetic expression becomes, 3.14159*r*r.

We will put the computed value of this expression in a variable named area. Therefore we will print the area.

Let us save the file, compile it, and run the code. The user enters a radius of 2.0. The program computes the area and then prints the area of the circle on the terminal.

The user can run the program again and again to get the areas of circles of different radii.

The Third Program

I will go over one more program now. Suppose, you have this expression

[show on paper 5x/4y+(3y-2)/2x].

How can we code this.

The expression in Java code will be:

(5*x)/(4*y)+(3*y-2)/(2*x)

Notice that there are two variables x and y. Therefore we will ask the user for two numbers, x and y. These two numbers will be kept in two variables named x and y. We will make x and y double numbers. We will keep another variable named “result”, which will hold the computed result.

Coding Program 3

Let us do the coding in fast forward mode. Please pause the video if you are coding it. I will provide the code in the website Computing4All.com too. However, I recommend that you type it yourself. I feel that when you type it yourself, you build a foundational understanding of the program.

Let us save the file, compile it, and run it.

The program asks for the first number and the second number. The program computes the expression for the two given numbers, and prints the computed value.

Conclusion

We will provide exercises regarding today’s video on our website Computing4All.com. As I said before one cannot learn to ride a bike or to swim by watching videos or by reading books. Similar to that, one cannot become skilled in programming just by watching videos or just by reading books. Please practice, practice, and practice to make sure that you develop a strong programming skill over time.

I am writing this article in support of the video we made on the topic — Getting User Input in Java. The video helps new learners by providing explanations on how to develop a simple calculator program. The user of the program types on the keyboard to enter two numbers. The program captures the two numbers the user provides and then it applies addition, subtraction, multiplication, and division operations on the numbers.

Why a Programmer Needs to Know About User Input

A programmer needs to know about user input due to the tremendous need for user input in many modern day software pieces. Consider the calculator program you have on your phone or laptop. It requires your input to apply mathematical operations. Consider editor software like MS Word. We type on the keyboard, and MS Word saves what we type. MS Word helps us format what we want to print.
Consider the Google Maps App on your smartphone. You write a destination address, and the software provides you directions to the destination. That is, the program reads the address you provide.

Therefore, getting input from the user is quite common in computer programs.

The Video: Getting Input from the User, for a Calculator Program, Using Java

Getting input from the user is an essential part of programming. It can be intimidating for beginners. With some practice, writing Java code to get input from user becomes quite mundane over time.

The Final Program Used in the Video

In the video, we only covered how to get user input of double data type using a Java Scanner object. The programmer can use nextInt() instead of the nextDouble() method to get an integer from the user. The program that we came up with, for double numbers, in the video is provided below. Save the program in a file named MyProg.java.

import java.util.Scanner;

class MyProg{
    public static void main(String[] args){
        double num1;
        double num2;
        double res;
        
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter the first number:");
        num1= scan.nextDouble();
        System.out.println("Enter the second number:");
        num2= scan.nextDouble();

        res=num1+num2;
        System.out.println("Summation: "+res);
        res=num1-num2;
        System.out.println("Subtraction: "+res);
        res=num1*num2;
        System.out.println("Multiplication: "+res);
        res=num1/num2;
        System.out.println("Division: "+res);
    }
}

Exercise

Write a program that does the following items.

The program asks the user for three double numbers and displays (a) the result of the summation of the three numbers the user provided and (b) the result of multiplication of the three numbers.

Comment

You will see more of user input in our future videos. To stay in touch, please subscribe to Computing4All.com. Enjoy!

Transcription of the Audio of the Video

Hi,
I am Dr. Shahriar Hossain. I am here today to help you practice more on variables. We will build a Calculator program today using Java.

From the last video lecture, you know how to add two numbers and how to subtract one number from another. In the exercise, which I provided on Computing4All.com, I asked for multiplication and division as well. I will extend the concept that I described in the previous class. I will write the code of the last lesson and also do the exercise, which is the inclusion of multiplication and division. That should be good enough for a quite primitive calculator.

One item is that in our code, we are hard-coding the numbers so far. That is, every time we change the numerical values of the variables, we need to compile the code to generate the class file because of the change. In an ideal program, the program should ask the user for two numbers, and then the program should do whatever mathematical operations it is supposed to do.

I will now share my screen with you so that you can see how I write the program. I will keep explaining on the way.

The starting of the code

Suppose, the name of the Java file I am working on is MyProg.java. Therefore, the class name has to be MyProg. The scope of the class is within a set of curly braces. I will now write the Main Method. I am writing the Main Method public static void main and the parameters. The Main Method has a scope too, within a set of curly braces. We will write the instructions inside the curly braces.

Please note that we are building a calculator program. Therefore, we need two numbers held in two variables. These two variables will be the operands of addition, subtraction, multiplication, and division. We are not working on any sophisticated calculator program today. The calculator we will build will only have the ability to add, subtract, multiply, and divide.

Declaring the variables

Let us declare two Double variables. We already know how to declare two Double variables from the last lecture. The names of the two variables that will become our operands are num1 and num2. I declare the first one by stating “double num1;”, and the second one by “double num2;”. I should mention again that we have to put a semicolon at the end of each instruction. The line public static void main is not an instruction. It is defining where is the starting of the program is. Therefore, public static void main does not have a semicolon at the end. Over time, we will see that there are statements in Java for which we do not put semicolons.

An Instruction is a unit task. In general, each instruction inside the main method must have a semicolon at the end.

Anyway, I declare another double variable named res, in which I will put results of the mathematical operations addition, subtraction, multiplication, and division.

Now we will put some values inside num1 and num2. Let us write instructions to put 25 inside num1 and 12 inside num2.

So far, we declared all the variables and initiated num1 and num2 with operands. I will first add the two numbers in num1 and num2 and put them in the “res” variable.

The assignment operator

Note from the previous lecture that, in a line, with the assignment operator, the computer executes the right side of the assignment operator first. Whatever the value of the right side is, the computer copies the value to the variable in the left side. The left side cannot have anything other than one variable.

Summation

When executed, res should contain the summation result. Let us print the summation result on the terminal, as we did in the previous video lecture. If we run and compile the program, we should see the value of res, which is the addition of num1 and num2, on the terminal.

To be exact, the output will be “Summation: 37”

Subtraction

Now, we would like to do the subtraction. Notice that after printing the summation result, we can reuse the “res” variable for any other operation. We will subtract. So, we write “res=num1-num2;”

We write a System.out.println instruction to print the subtraction result.

Multiplication and division

Similar to addition and subtraction, let us write the code for multiplication and division. Each of the mathematical tasks includes one line of instruction to do the mathematical operation and one line to display the result.

After you have written the code for all four operations, compile and run the program. We can see that results of all the operations — addition, subtraction, multiplication, and division — are correctly printed on the terminal.

Hard-coding is not a good idea, in this case

While I like the code so far, notice that for a pair of new numbers in num1 and num2, we have to recompile the code and run again, which is not a good idea for software development. The user does now know how to compile or change the code. Therefore, we need to modify the program in such a way that the program asks the user for two numbers, and then the program outputs the results of the mathematical operations carried over the two numbers that the user provided.

Assigning values directly in the code like the ones we have done here, is called hard-coding. Instead of hard-coding the numbers we will change the code so that the program asks for input to the person who will run the program.

Getting user input in Java may not look straightforward

Getting input from the user is not entirely straightforward. I will introduce a few new items regarding getting information from the user. The items might not make much sense at this point because we are still not familiar with methods, classes, and objects. We will be using the new items to get input from the user. Much later, when we learn advanced topics, we will understand the inner functionality.

Java Scanner

Anyway, to enable your code to get inputs from the user, you need to use the Scanner class, which we are not familiar with at all. At the beginning of the code, even before the first line, now we have to write “import java.util.Scanner;”. For now, the explanation that might make sense is the following — this particular class “Scanner” has the functionality written in it that allows a program to get user inputs. Through this line, your program is telling the Java Virtual Machine to import that functionality of scanning numbers from users.

Now, instead of hard-coding the numbers to num1 and num2, we will ask the user to enter two numbers by typing on the keyboard. Our program will assign the two numbers that the user provided to num1 and num2.

Before the assignments, we will have to create a scanner object. To create a scanner object named “scan”, I am writing this line. We have not discussed objects yet. Therefore, it will be hard for you to understand this line at this point. For now, you will have to trust the following explanation: this line creates a scanner object named “scan” that is capable of capturing the input the user will type on the keyboard.

Getting user input in Java: The nextDouble() method

Previously we assigned 25 to num1 and 12 to num2. These two lines must change because we are not hardcoding anymore. Instead, we will tell the computer to copy the number that the object “scan” captures to the variable num1. In the right side of the assignment operator of num1, we write scan.nextDouble();

That is, the object “scan” will wait for the next double number entered by the user. Once the user types a double number and hits the enter button, the “scan” object will send it to the num1 variable. If the user does not type a number and does not hit the enter button on the keyboard, then the program will remain waited at that point.

Now let us do the same for num2. In the right side of the assignment of num2, we will write scan.nextDouble();

In this line, the program will wait for the second number to be entered by the user.

Now, the program is ready. Save the MyProg.java, and compile it.

User input on terminal

Now let us run the program. Notice that the program is not displaying anything. Instead, it is waiting, which looks like the program is stuck. Actually, it is waiting in the line “num1=scan.nextDouble();” It is waiting for the user to type a number and hit enter. Now, as the user, I am typing 22.4, and then I press the enter button.

Notice that the program is again waiting. It is because now the execution is in the line “num2=scan.nextDouble();” The computer is waiting at “scan.nextDouble()” for the user to enter another number, which the computer will put in variable num2.

Therefore, as the user, I am typing 2.0 and then I will hit the enter button. As soon as I will hit the enter button the scan.nextDouble() will capture the value 2.0. Then the assignment operator will send 2.0 to num2.

Once num1 and num2 are ready, the computer will execute the rest of the lines in a jiffy. That is, the summation, subtraction, multiplication, and division results will be printed as soon as the num2 variable receives a value from the user. Now, I will hit enter, and the program will print all the results.

The user can run the program again and again. Each time the program will wait twice for two variables, num1 and num2.

Prompting for user input

One thing that I would like to include in the program is a message on the terminal before the program starts waiting for num1. I would like to add System.out.println and then write “Enter the first number: ” inside the parentheses inside quotations.

Similarly, before the scanner waits for the second input from the user, I would like to print on the terminal “Enter the second number: ” using a System.out.println method.

Save MyProg.java and compile it. Run the program. Now notice that the program prints “Enter the first number: ” before it starts to wait for the first input. Now I enter 20.2. The program now received the first input. Before it started to wait for the second input, it printed “Enter the second number: “. Now I enter 2.0. The program prints all the results.

Notice that this version of the program is more user-friendly since the program is communicating with the user by providing guidelines like, Enter the First number, or Enter the second number.

Conclusion

If you have any question, or if you are struggling to compile and run any of the programs we discussed so far, please do not hesitate to contact us via Computing4All.com or by leaving a comment in the comments section.

Thank you for watching the video. We will be coming back soon with another video in this video lecture series. To stay in touch, please subscribe to Computing4All.com and to our YouTube channel.