java assignment statement

What Is an Assignment Statement in Java?

Java programs store data values in variables. When a programmer creates a variable in a Java application, he declares the type and name of the variable, then assigns a value to it. The value of a variable can be altered at subsequent points in execution using further assignment operations. The assignment statement in Java involves using the assignment operator to set the value of a variable. The exact syntax depends on the type of variable receiving a value.

Advertisement

In Java, variables are strongly typed. This means that when you declare a variable in a Java program, you must declare its type, followed by its name. The following sample Java code demonstrates declaring two variables, one of primitive-type integer and one of an object type for a class within the application: int num; ApplicationHelper myHelp;

Video of the Day

Once a program contains a variable declaration, the kind of value assigned to the variable must be suited to the type declared. These variable declarations could be followed by assignment statements on subsequent lines. However, the assignment operation could also take place on the same line as the declaration.

Assignment in Java is the process of giving a value to a primitive-type variable or giving an object reference to an object-type variable. The equals sign acts as assignment operator in Java, followed by the value to assign. The following sample Java code demonstrates assigning a value to a primitive-type integer variable, which has already been declared: num = 5;

The assignment operation could alternatively appear within the same line of code as the declaration of the variable, as follows: int num = 5;

The value of the variable can be altered again in subsequent processing as in this example: num++;

This code increments the variable value, adding a value of one to it.

Instantiation

When the assignment statement appears with object references, the assignment operation may also involve object instantiation. When Java code creates a new object instance of a Java class in an application, the "new" keyword causes the constructor method of the class to execute, instantiating the object. The following sample code demonstrates instantiating an object variable: myHelp = new ApplicationHelper();

This could also appear within the same line as the variable declaration as follows: ApplicationHelper myHelp = new ApplicationHelper();

When this line of code executes, the class constructor method executes, returning an instance of the class, a reference to which is stored by the variable.

Referencing

Once a variable has been declared and assigned a value, a Java program can refer to the variable in subsequent processing. For primitive-type variables, the variable name refers to a stored value. For object types, the variable refers to the location of the object instance in memory. This means that two object variables can point to the same instance, as in the following sample code: ApplicationHelper myHelp = new ApplicationHelper(); ApplicationHelper sameHelp = myHelp;

This syntax appears commonly when programs pass object references as parameters to class methods.

• Oracle: The Java Tutorials - Variables
• Oracle: The Java Tutorials - Assignment, Arithmetic, and Unary Operators
• Oracle: The Java Tutorials - Primitive Data Types
• Oracle: The Java Tutorials - Creating Objects
• Oracle: The Java Tutorials - What Is an Object?
• Oracle: The Java Tutorials - Summary of Variables
• Java Language Specification; Types, Values, and Variables; 2000
• Oracle: The Java Tutorials - Understanding Instance and Class Members

Report an Issue

Screenshot loading...

1.7 Java | Assignment Statements & Expressions

An assignment statement designates a value for a variable. An assignment statement can be used as an expression in Java.

After a variable is declared, you can assign a value to it by using an assignment statement . In Java, the equal sign = is used as the assignment operator . The syntax for assignment statements is as follows:

An expression represents a computation involving values, variables, and operators that, when taking them together, evaluates to a value. For example, consider the following code:

You can use a variable in an expression. A variable can also be used on both sides of the =  operator. For example:

In the above assignment statement, the result of x + 1  is assigned to the variable x . Let’s say that x is 1 before the statement is executed, and so becomes 2 after the statement execution.

To assign a value to a variable, you must place the variable name to the left of the assignment operator. Thus the following statement is wrong:

Note that the math equation  x = 2 * x + 1  ≠ the Java expression x = 2 * x + 1

Which is equivalent to:

And this statement

is equivalent to:

Note: The data type of a variable on the left must be compatible with the data type of a value on the right. For example, int x = 1.0 would be illegal, because the data type of x is int (integer) and does not accept the double value 1.0 without Type Casting .

◄◄◄BACK | NEXT►►►

What's Your Opinion? Cancel reply

Enhance your Brain

Subscribe to Receive Free Bio Hacking, Nootropic, and Health Information

HTML for Simple Website Customization My Personal Web Customization Personal Insights

DISCLAIMER | Sitemap | ◘

HTML for Simple Website Customization My Personal Web Customization Personal Insights SEO Checklist Publishing Checklist My Tools

Top Posts & Pages

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot

• Explore Our Geeks Community
• Java Tutorial

Overview of Java

• Introduction to Java
• The complete History of Java Programming Language
• C++ vs Java vs Python
• How to Download and Install Java for 64 bit machine?
• Setting up the environment in Java
• How to Download and Install Eclipse on Windows?
• JDK in Java
• How JVM Works - JVM Architecture?
• Differences between JDK, JRE and JVM
• Just In Time Compiler
• Difference between JIT and JVM in Java
• Difference between Byte Code and Machine Code
• How is Java platform independent?

Basics of Java

• Java Basic Syntax
• Java Hello World Program
• Java Data Types
• Primitive data type vs. Object data type in Java with Examples
• Java Identifiers

Operators in Java

• Java Variables
• Scope of Variables In Java

Wrapper Classes in Java

Input/output in java.

• How to Take Input From User in Java?
• Scanner Class in Java
• Java.io.BufferedReader Class in Java
• Difference Between Scanner and BufferedReader Class in Java
• Ways to read input from console in Java
• System.out.println in Java
• Difference between print() and println() in Java
• Formatted output in Java
• Fast I/O in Java in Competitive Programming

Flow Control in Java

• Decision Making in Java (if, if-else, switch, break, continue, jump)
• Java if statement with Examples
• Java if-else
• Java if-else-if ladder with Examples
• Loops in Java
• For Loop in Java
• Java while loop with Examples
• Java do-while loop with Examples
• For-each loop in Java
• Continue Statement in Java
• Break statement in Java
• Usage of Break keyword in Java
• return keyword in Java
• Java Arithmetic Operators with Examples
• Java Unary Operator with Examples

Java Assignment Operators with Examples

• Java Relational Operators with Examples
• Java Logical Operators with Examples
• Java Ternary Operator with Examples
• Bitwise Operators in Java
• Strings in Java
• String class in Java
• Java.lang.String class in Java | Set 2
• Why Java Strings are Immutable?
• StringBuffer class in Java
• StringBuilder Class in Java with Examples
• String vs StringBuilder vs StringBuffer in Java
• StringTokenizer Class in Java
• StringTokenizer Methods in Java with Examples | Set 2
• StringJoiner Class in Java
• Arrays in Java
• Arrays class in Java
• Multidimensional Arrays in Java
• Different Ways To Declare And Initialize 2-D Array in Java
• Jagged Array in Java
• Final Arrays in Java
• Reflection Array Class in Java
• util.Arrays vs reflect.Array in Java with Examples

OOPS in Java

• Object Oriented Programming (OOPs) Concept in Java
• Why Java is not a purely Object-Oriented Language?
• Classes and Objects in Java
• Naming Conventions in Java
• Java Methods

Access Modifiers in Java

• Java Constructors
• Four Main Object Oriented Programming Concepts of Java

Inheritance in Java

Abstraction in java, encapsulation in java, polymorphism in java, interfaces in java.

• 'this' reference in Java
• Inheritance and Constructors in Java
• Java and Multiple Inheritance
• Interfaces and Inheritance in Java
• Association, Composition and Aggregation in Java
• Comparison of Inheritance in C++ and Java
• abstract keyword in java
• Abstract Class in Java
• Difference between Abstract Class and Interface in Java
• Control Abstraction in Java with Examples
• Difference Between Data Hiding and Abstraction in Java
• Difference between Abstraction and Encapsulation in Java with Examples
• Difference between Inheritance and Polymorphism
• Dynamic Method Dispatch or Runtime Polymorphism in Java
• Difference between Compile-time and Run-time Polymorphism in Java

Constructors in Java

• Copy Constructor in Java
• Constructor Overloading in Java
• Constructor Chaining In Java with Examples
• Private Constructors and Singleton Classes in Java

Methods in Java

• Static methods vs Instance methods in Java
• Abstract Method in Java with Examples
• Overriding in Java
• Method Overloading in Java
• Difference Between Method Overloading and Method Overriding in Java
• Differences between Interface and Class in Java
• Functional Interfaces in Java
• Nested Interface in Java
• Marker interface in Java
• Comparator Interface in Java with Examples
• Need of Wrapper Classes in Java
• Different Ways to Create the Instances of Wrapper Classes in Java
• Character Class in Java
• Java.Lang.Byte class in Java
• Java.Lang.Short class in Java
• Java.lang.Integer class in Java
• Java.Lang.Long class in Java
• Java.Lang.Float class in Java
• Java.Lang.Double Class in Java
• Java.lang.Boolean Class in Java
• Autoboxing and Unboxing in Java
• Type conversion in Java with Examples

Keywords in Java

• List of all Java Keywords
• Important Keywords in Java
• Super Keyword in Java
• final Keyword in Java
• static Keyword in Java
• enum in Java
• transient keyword in Java
• volatile Keyword in Java
• final, finally and finalize in Java
• Public vs Protected vs Package vs Private Access Modifier in Java
• Access and Non Access Modifiers in Java

Memory Allocation in Java

• Java Memory Management
• How are Java objects stored in memory?
• Stack vs Heap Memory Allocation
• How many types of memory areas are allocated by JVM?
• Garbage Collection in Java
• Types of JVM Garbage Collectors in Java with implementation details
• Memory leaks in Java
• Java Virtual Machine (JVM) Stack Area

Classes of Java

• Understanding Classes and Objects in Java
• Singleton Method Design Pattern in Java
• Object Class in Java
• Inner Class in Java
• Throwable Class in Java with Examples

Packages in Java

• Packages In Java
• How to Create a Package in Java?
• Java.util Package in Java
• Java.lang package in Java
• Java.io Package in Java
• Java Collection Tutorial

Exception Handling in Java

• Exceptions in Java
• Types of Exception in Java with Examples
• Checked vs Unchecked Exceptions in Java
• Java Try Catch Block
• Flow control in try catch finally in Java
• throw and throws in Java
• User-defined Custom Exception in Java
• Chained Exceptions in Java
• Null Pointer Exception In Java
• Exception Handling with Method Overriding in Java
• Multithreading in Java
• Lifecycle and States of a Thread in Java
• Java Thread Priority in Multithreading
• Main thread in Java
• Java.lang.Thread Class in Java
• Runnable interface in Java
• Naming a thread and fetching name of current thread in Java
• What does start() function do in multithreading in Java?
• Difference between Thread.start() and Thread.run() in Java
• Thread.sleep() Method in Java With Examples
• Synchronization in Java
• Importance of Thread Synchronization in Java
• Method and Block Synchronization in Java
• Lock framework vs Thread synchronization in Java
• Difference Between Atomic, Volatile and Synchronized in Java
• Deadlock in Java Multithreading
• Deadlock Prevention And Avoidance
• Difference Between Lock and Monitor in Java Concurrency
• Reentrant Lock in Java

File Handling in Java

• Java.io.File Class in Java
• Java Program to Create a New File
• Different ways of Reading a text file in Java
• Java Program to Write into a File
• Delete a File Using Java
• File Permissions in Java
• FileWriter Class in Java
• Java.io.FileDescriptor in Java
• Java.io.RandomAccessFile Class Method | Set 1
• Regular Expressions in Java
• How to write Regular Expressions?
• Matcher pattern() method in Java with Examples
• Pattern pattern() method in Java with Examples
• Quantifiers in Java
• java.lang.Character class methods | Set 1
• Java IO : Input-output in Java with Examples
• Java.io.Reader class in Java
• Java.io.Writer Class in Java
• Java.io.FileInputStream Class in Java
• FileOutputStream in Java
• Java.io.BufferedOutputStream class in Java
• Java Networking
• TCP/IP Model
• User Datagram Protocol (UDP)
• Differences between IPv4 and IPv6
• Difference between Connection-oriented and Connection-less Services
• Socket Programming in Java
• java.net.ServerSocket Class in Java
• URL Class in Java with Examples

Operators constitute the basic building block of any programming language. Java too provides many types of operators which can be used according to the need to perform various calculations and functions, be it logical, arithmetic, relational, etc. They are classified based on the functionality they provide.

Types of Operators: 

• Arithmetic Operators
• Unary Operators
• Assignment Operator
• Relational Operators
• Logical Operators
• Ternary Operator
• Bitwise Operators
• Shift Operators

This article explains all that one needs to know regarding Assignment Operators. 

Assignment Operators

These operators are used to assign values to a variable. The left side operand of the assignment operator is a variable, and the right side operand of the assignment operator is a value. The value on the right side must be of the same data type of the operand on the left side. Otherwise, the compiler will raise an error. This means that the assignment operators have right to left associativity, i.e., the value given on the right-hand side of the operator is assigned to the variable on the left. Therefore, the right-hand side value must be declared before using it or should be a constant. The general format of the assignment operator is, 

Types of Assignment Operators in Java

The Assignment Operator is generally of two types. They are:

1. Simple Assignment Operator: The Simple Assignment Operator is used with the “=” sign where the left side consists of the operand and the right side consists of a value. The value of the right side must be of the same data type that has been defined on the left side.

2. Compound Assignment Operator: The Compound Operator is used where +,-,*, and / is used along with the = operator.

Let’s look at each of the assignment operators and how they operate: 

1. (=) operator: 

This is the most straightforward assignment operator, which is used to assign the value on the right to the variable on the left. This is the basic definition of an assignment operator and how it functions. 

Syntax:  

Example:  

2. (+=) operator: 

This operator is a compound of ‘+’ and ‘=’ operators. It operates by adding the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. 

Note: The compound assignment operator in Java performs implicit type casting. Let’s consider a scenario where x is an int variable with a value of 5. int x = 5; If you want to add the double value 4.5 to the integer variable x and print its value, there are two methods to achieve this: Method 1: x = x + 4.5 Method 2: x += 4.5 As per the previous example, you might think both of them are equal. But in reality, Method 1 will throw a runtime error stating the “i ncompatible types: possible lossy conversion from double to int “, Method 2 will run without any error and prints 9 as output.

Reason for the Above Calculation

Method 1 will result in a runtime error stating “incompatible types: possible lossy conversion from double to int.” The reason is that the addition of an int and a double results in a double value. Assigning this double value back to the int variable x requires an explicit type casting because it may result in a loss of precision. Without the explicit cast, the compiler throws an error. Method 2 will run without any error and print the value 9 as output. The compound assignment operator += performs an implicit type conversion, also known as an automatic narrowing primitive conversion from double to int . It is equivalent to x = (int) (x + 4.5) , where the result of the addition is explicitly cast to an int . The fractional part of the double value is truncated, and the resulting int value is assigned back to x . It is advisable to use Method 2 ( x += 4.5 ) to avoid runtime errors and to obtain the desired output.

Same automatic narrowing primitive conversion is applicable for other compound assignment operators as well, including -= , *= , /= , and %= .

3. (-=) operator: 

This operator is a compound of ‘-‘ and ‘=’ operators. It operates by subtracting the variable’s value on the right from the current value of the variable on the left and then assigning the result to the operand on the left. 

4. (*=) operator:

 This operator is a compound of ‘*’ and ‘=’ operators. It operates by multiplying the current value of the variable on the left to the value on the right and then assigning the result to the operand on the left. 

5. (/=) operator: 

This operator is a compound of ‘/’ and ‘=’ operators. It operates by dividing the current value of the variable on the left by the value on the right and then assigning the quotient to the operand on the left. 

6. (%=) operator: 

This operator is a compound of ‘%’ and ‘=’ operators. It operates by dividing the current value of the variable on the left by the value on the right and then assigning the remainder to the operand on the left. 

Please Login to comment...

• nishkarshgandhi
• chakka_saikiran
• Java-Operators

Please write us at contrib[email protected] to report any issue with the above content

Improve your Coding Skills with Practice

• Table of Contents
• Course Home
• Assignments
• Peer Instruction (Instructor)
• Peer Instruction (Student)
• Change Course
• Instructor's Page
• Progress Page
• Edit Profile
• Change Password
• Scratch ActiveCode
• Scratch Activecode
• Instructors Guide
• About Runestone
• Report A Problem
• 1.1 Preface
• 1.2 Why Programming? Why Java?
• 1.3 Variables and Data Types
• 1.4 Expressions and Assignment Statements
• 1.5 Compound Assignment Operators
• 1.6 Casting and Ranges of Variables
• 1.7 Java Development Environments (optional)
• 1.8 Unit 1 Summary
• 1.9 Unit 1 Mixed Up Code Practice
• 1.10 Unit 1 Coding Practice
• 1.11 Multiple Choice Exercises
• 1.12 Lesson Workspace
• 1.3. Variables and Data Types" data-toggle="tooltip">
• 1.5. Compound Assignment Operators' data-toggle="tooltip" >

1.4. Expressions and Assignment Statements ¶

In this lesson, you will learn about assignment statements and expressions that contain math operators and variables.

1.4.1. Assignment Statements ¶

Remember that a variable holds a value that can change or vary. Assignment statements initialize or change the value stored in a variable using the assignment operator = . An assignment statement always has a single variable on the left hand side of the = sign. The value of the expression on the right hand side of the = sign (which can contain math operators and other variables) is copied into the memory location of the variable on the left hand side.

Figure 1: Assignment Statement (variable = expression) ¶

Instead of saying equals for the = operator in an assignment statement, say “gets” or “is assigned” to remember that the variable on the left hand side gets or is assigned the value on the right. In the figure above, score is assigned the value of 10 times points (which is another variable) plus 5.

The following video by Dr. Colleen Lewis shows how variables can change values in memory using assignment statements.

As we saw in the video, we can set one variable to a copy of the value of another variable like y = x;. This won’t change the value of the variable that you are copying from.

Click on the Show CodeLens button to step through the code and see how the values of the variables change.

The program is supposed to figure out the total money value given the number of dimes, quarters and nickels. There is an error in the calculation of the total. Fix the error to compute the correct amount.

Calculate and print the total pay given the weekly salary and the number of weeks worked. Use string concatenation with the totalPay variable to produce the output Total Pay = $3000 . Don’t hardcode the number 3000 in your print statement.

Assume you have a package with a given height 3 inches and width 5 inches. If the package is rotated 90 degrees, you should swap the values for the height and width. The code below makes an attempt to swap the values stored in two variables h and w, which represent height and width. Variable h should end up with w’s initial value of 5 and w should get h’s initial value of 3. Unfortunately this code has an error and does not work. Use the CodeLens to step through the code to understand why it fails to swap the values in h and w.

1-4-7: Explain in your own words why the ErrorSwap program code does not swap the values stored in h and w.

Swapping two variables requires a third variable. Before assigning h = w , you need to store the original value of h in the temporary variable. In the mixed up programs below, drag the blocks to the right to put them in the right order.

The following has the correct code that uses a third variable named “temp” to swap the values in h and w.

The code is mixed up and contains one extra block which is not needed in a correct solution. Drag the needed blocks from the left into the correct order on the right, then check your solution. You will be told if any of the blocks are in the wrong order or if you need to remove one or more blocks.

After three incorrect attempts you will be able to use the Help Me button to make the problem easier.

Fix the code below to perform a correct swap of h and w. You need to add a new variable named temp to use for the swap.

1.4.2. Incrementing the value of a variable ¶

If you use a variable to keep score you would probably increment it (add one to the current value) whenever score should go up. You can do this by setting the variable to the current value of the variable plus one (score = score + 1) as shown below. The formula looks a little crazy in math class, but it makes sense in coding because the variable on the left is set to the value of the arithmetic expression on the right. So, the score variable is set to the previous value of score + 1.

Click on the Show CodeLens button to step through the code and see how the score value changes.

1-4-11: What is the value of b after the following code executes?

• It sets the value for the variable on the left to the value from evaluating the right side. What is 5 * 2?
• Correct. 5 * 2 is 10.

1-4-12: What are the values of x, y, and z after the following code executes?

• x = 0, y = 1, z = 2
• These are the initial values in the variable, but the values are changed.
• x = 1, y = 2, z = 3
• x changes to y's initial value, y's value is doubled, and z is set to 3
• x = 2, y = 2, z = 3
• Remember that the equal sign doesn't mean that the two sides are equal. It sets the value for the variable on the left to the value from evaluating the right side.
• x = 1, y = 0, z = 3

1.4.3. Operators ¶

Java uses the standard mathematical operators for addition ( + ), subtraction ( - ), multiplication ( * ), and division ( / ). Arithmetic expressions can be of type int or double. An arithmetic operation that uses two int values will evaluate to an int value. An arithmetic operation that uses at least one double value will evaluate to a double value. (You may have noticed that + was also used to put text together in the input program above – more on this when we talk about strings.)

Java uses the operator == to test if the value on the left is equal to the value on the right and != to test if two items are not equal. Don’t get one equal sign = confused with two equal signs == ! They mean different things in Java. One equal sign is used to assign a value to a variable. Two equal signs are used to test a variable to see if it is a certain value and that returns true or false as you’ll see below. Use == and != only with int values and not doubles because double values are an approximation and 3.3333 will not equal 3.3334 even though they are very close.

Run the code below to see all the operators in action. Do all of those operators do what you expected? What about 2 / 3 ? Isn’t surprising that it prints 0 ? See the note below.

When Java sees you doing integer division (or any operation with integers) it assumes you want an integer result so it throws away anything after the decimal point in the answer, essentially rounding down the answer to a whole number. If you need a double answer, you should make at least one of the values in the expression a double like 2.0.

With division, another thing to watch out for is dividing by 0. An attempt to divide an integer by zero will result in an ArithmeticException error message. Try it in one of the active code windows above.

Operators can be used to create compound expressions with more than one operator. You can either use a literal value which is a fixed value like 2, or variables in them. When compound expressions are evaluated, operator precedence rules are used, so that *, /, and % are done before + and -. However, anything in parentheses is done first. It doesn’t hurt to put in extra parentheses if you are unsure as to what will be done first.

In the example below, try to guess what it will print out and then run it to see if you are right. Remember to consider operator precedence .

1-4-15: Consider the following code segment. Be careful about integer division.

What is printed when the code segment is executed?

• 0.666666666666667
• Don't forget that division and multiplication will be done first due to operator precedence.
• Yes, this is equivalent to (5 + ((a/b)*c) - 1).
• Don't forget that division and multiplication will be done first due to operator precedence, and that an int/int gives an int result where it is rounded down to the nearest int.

1-4-16: Consider the following code segment.

What is the value of the expression?

• Dividing an integer by an integer results in an integer
• Correct. Dividing an integer by an integer results in an integer
• The value 5.5 will be rounded down to 5

1-4-17: Consider the following code segment.

• Correct. Dividing a double by an integer results in a double
• Dividing a double by an integer results in a double

1-4-18: Consider the following code segment.

• Correct. Dividing an integer by an double results in a double
• Dividing an integer by an double results in a double

1.4.4. The Modulo Operator ¶

The percent sign operator ( % ) is the mod (modulo) or remainder operator. The mod operator ( x % y ) returns the remainder after you divide x (first number) by y (second number) so 5 % 2 will return 1 since 2 goes into 5 two times with a remainder of 1. Remember long division when you had to specify how many times one number went into another evenly and the remainder? That remainder is what is returned by the modulo operator.

Figure 2: Long division showing the whole number result and the remainder ¶

In the example below, try to guess what it will print out and then run it to see if you are right.

The result of x % y when x is smaller than y is always x . The value y can’t go into x at all (goes in 0 times), since x is smaller than y , so the result is just x . So if you see 2 % 3 the result is 2 .

1-4-21: What is the result of 158 % 10?

• This would be the result of 158 divided by 10. modulo gives you the remainder.
• modulo gives you the remainder after the division.
• When you divide 158 by 10 you get a remainder of 8.

1-4-22: What is the result of 3 % 8?

• 8 goes into 3 no times so the remainder is 3. The remainder of a smaller number divided by a larger number is always the smaller number!
• This would be the remainder if the question was 8 % 3 but here we are asking for the reminder after we divide 3 by 8.
• What is the remainder after you divide 3 by 8?

1.4.5. FlowCharting ¶

Assume you have 16 pieces of pizza and 5 people. If everyone gets the same number of slices, how many slices does each person get? Are there any leftover pieces?

In industry, a flowchart is used to describe a process through symbols and text. A flowchart usually does not show variable declarations, but it can show assignment statements (drawn as rectangle) and output statements (drawn as rhomboid).

The flowchart in figure 3 shows a process to compute the fair distribution of pizza slices among a number of people. The process relies on integer division to determine slices per person, and the mod operator to determine remaining slices.

Figure 3: Example Flow Chart ¶

A flowchart shows pseudo-code, which is like Java but not exactly the same. Syntactic details like semi-colons are omitted, and input and output is described in abstract terms.

Complete the program based on the process shown in the Figure 3 flowchart. Note the first line of code declares all 4 variables as type int. Add assignment statements and print statements to compute and print the slices per person and leftover slices. Use System.out.println for output.

1.4.6. Storing User Input in Variables ¶

Variables are a powerful abstraction in programming because the same algorithm can be used with different input values saved in variables.

Figure 4: Program input and output ¶

A Java program can ask the user to type in one or more values. The Java class Scanner is used to read from the keyboard input stream, which is referenced by System.in . Normally the keyboard input is typed into a console window, but since this is running in a browser you will type in a small textbox window displayed below the code. The code below shows an example of prompting the user to enter a name and then printing a greeting. The code String name = scan.nextLine() gets the string value you enter as program input and then stores the value in a variable.

Run the program a few times, typing in a different name. The code works for any name: behold, the power of variables!

Run this program to read in a name from the input stream. You can type a different name in the input window shown below the code.

Try stepping through the code with the CodeLens tool to see how the name variable is assigned to the value read by the scanner. You will have to click “Hide CodeLens” and then “Show in CodeLens” to enter a different name for input.

The Scanner class has several useful methods for reading user input. A token is a sequence of characters separated by white space.

Run this program to read in an integer from the input stream. You can type a different integer value in the input window shown below the code.

A rhomboid (slanted rectangle) is used in a flowchart to depict data flowing into and out of a program. The previous flowchart in Figure 3 used a rhomboid to indicate program output. A rhomboid is also used to denote reading a value from the input stream.

Figure 5: Flow Chart Reading User Input ¶

Figure 5 contains an updated version of the pizza calculator process. The first two steps have been altered to initialize the pizzaSlices and numPeople variables by reading two values from the input stream. In Java this will be done using a Scanner object and reading from System.in.

Complete the program based on the process shown in the Figure 5 flowchart. The program should scan two integer values to initialize pizzaSlices and numPeople. Run the program a few times to experiment with different values for input. What happens if you enter 0 for the number of people? The program will bomb due to division by zero! We will see how to prevent this in a later lesson.

The program below reads two integer values from the input stream and attempts to print the sum. Unfortunately there is a problem with the last line of code that prints the sum.

Run the program and look at the result. When the input is 5 and 7 , the output is Sum is 57 . Both of the + operators in the print statement are performing string concatenation. While the first + operator should perform string concatenation, the second + operator should perform addition. You can force the second + operator to perform addition by putting the arithmetic expression in parentheses ( num1 + num2 ) .

More information on using the Scanner class can be found here https://www.w3schools.com/java/java_user_input.asp

1.4.7. Programming Challenge : Dog Years ¶

In this programming challenge, you will calculate your age, and your pet’s age from your birthdates, and your pet’s age in dog years. In the code below, type in the current year, the year you were born, the year your dog or cat was born (if you don’t have one, make one up!) in the variables below. Then write formulas in assignment statements to calculate how old you are, how old your dog or cat is, and how old they are in dog years which is 7 times a human year. Finally, print it all out.

Calculate your age and your pet’s age from the birthdates, and then your pet’s age in dog years. If you want an extra challenge, try reading the values using a Scanner.

1.4.8. Summary ¶

Arithmetic expressions include expressions of type int and double.

The arithmetic operators consist of +, -, * , /, and % (modulo for the remainder in division).

An arithmetic operation that uses two int values will evaluate to an int value. With integer division, any decimal part in the result will be thrown away, essentially rounding down the answer to a whole number.

An arithmetic operation that uses at least one double value will evaluate to a double value.

Operators can be used to construct compound expressions.

During evaluation, operands are associated with operators according to operator precedence to determine how they are grouped. (*, /, % have precedence over + and -, unless parentheses are used to group those.)

An attempt to divide an integer by zero will result in an ArithmeticException to occur.

The assignment operator (=) allows a program to initialize or change the value stored in a variable. The value of the expression on the right is stored in the variable on the left.

During execution, expressions are evaluated to produce a single value.

The value of an expression has a type based on the evaluation of the expression.

• Java HyperText
• Style Guide
• 0. Create project
• 1. Show line numbers
• 2. Import preferences for automatic formatting
• 3. Reset layout
• 4. Syntax help
• 5. Open 2 files
• 6. ToDO comments
• 7. JUnit testing
• 8. Assert statement
• 9. Generating javadoc
• 10. Red square: terminating programs
• 11. Remove/add imports
• 12. Use UTF-8 character encoding
• 1. API documentation
• 3. Using Strings
• Introduction
• 1. Assignment statement
• 2. New-expression
• 3. Method calls
• 2. Try-statement
• 1. Output of thrown exceptions
• 2. Throwable objects
• 3. Try-stmt/propagation
• 4. Throw-statement
• 5. Throws-clause
• Abstract classes interfaces
• Iterator & Iterable
• Program correctness
• 1. Introduction
• 2. Developing loops
• 3. Finding an invariant
• Stepwise refinement
• Intro to recursion
• Recursion on linked lists
• Recursion on trees
• Backtracking
• Shortest path

1. How to execute the assignment statement

1. explaining how to execute the assignment statement.

2. Homework assignment HW1

The first question is easy ---you can copy from the first video or its transcript on the pdf file. Questions 2 and 3 ask about the if-statement and if-else statement. These are the same as in just about any programming language, except for the syntax, of course. So use your knowledge of these statements in whatever programming language you know.

1. Write the algorithm for executing the Java assignment statement <variable>= <expression>; 2. Write the algorithm for executing the Java if-statement               if (<boolean-expression>) <statement 1> 3. Write the algorithm for executing the Java if-else-statement               if (<boolean-expression>) <statement 1> else <statement 2> 4. Tell us in a few words what you thought of the videos on presenting algorithms in English and executing the assignment statement, their message, and the homework.

Java Assignment Operators

Java programming tutorial index.

The Java Assignment Operators are used when you want to assign a value to the expression. The assignment operator denoted by the single equal sign = .

In a Java assignment statement, any expression can be on the right side and the left side must be a variable name. For example, this does not mean that "a" is equal to "b", instead, it means assigning the value of 'b' to 'a'. It is as follows:

Java also has the facility of chain assignment operators, where we can specify a single value for multiple variables.

Java SE > Java SE Specifications > Java Language Specification

Chapter 16. Definite Assignment

Table of Contents

Every local variable declared by a statement ( §14.4.2 , §14.14.1 , §14.14.2 , §14.20.3 ) and every blank final field ( §4.12.4 , §8.3.1.2 ) must have a definitely assigned value when any access of its value occurs.

An access to its value consists of the simple name of the variable (or, for a field, the simple name of the field qualified by this ) occurring anywhere in an expression except as the left-hand operand of the simple assignment operator = ( §15.26.1 ).

For every access of a local variable or blank final field x , x must be definitely assigned before the access, or a compile-time error occurs.

Similarly, every blank final variable must be assigned at most once; it must be definitely unassigned when an assignment to it occurs.

Such an assignment is defined to occur if and only if either the simple name of the variable (or, for a field, its simple name qualified by this ) occurs on the left hand side of an assignment operator.

For every assignment to a blank final variable, the variable must be definitely unassigned before the assignment, or a compile-time error occurs.

The remainder of this chapter is devoted to a precise explanation of the words "definitely assigned before" and "definitely unassigned before".

The idea behind definite assignment is that an assignment to the local variable or blank final field must occur on every possible execution path to the access. Similarly, the idea behind definite unassignment is that no other assignment to the blank final variable is permitted to occur on any possible execution path to an assignment.

The analysis takes into account the structure of statements and expressions; it also provides a special treatment of the expression operators && , || , ! , and ? : , and of boolean-valued constant expressions.

Except for the special treatment of the conditional boolean operators && , || , and ? : and of boolean-valued constant expressions, the values of expressions are not taken into account in the flow analysis.

Example 16-1. Definite Assignment Considers Structure of Statements and Expressions

A Java compiler recognizes that k is definitely assigned before its access (as an argument of a method invocation) in the code:

because the access occurs only if the value of the expression:

is true , and the value can be true only if the assignment to k is executed (more properly, evaluated).

Similarly, a Java compiler will recognize that in the code:

the variable k is definitely assigned by the while statement because the condition expression true never has the value false , so only the break statement can cause the while statement to complete normally, and k is definitely assigned before the break statement.

On the other hand, the code:

must be rejected by a Java compiler, because in this case the while statement is not guaranteed to execute its body as far as the rules of definite assignment are concerned.

Example 16-2. Definite Assignment Does Not Consider Values of Expressions

A Java compiler must produce a compile-time error for the code:

even though the value of n is known at compile time, and in principle it can be known at compile time that the assignment to k will always be executed (more properly, evaluated). A Java compiler must operate according to the rules laid out in this section. The rules recognize only constant expressions; in this example, the expression n > 2 is not a constant expression as defined in §15.29 .

As another example, a Java compiler will accept the code:

as far as definite assignment of k is concerned, because the rules outlined in this section allow it to tell that k is assigned no matter whether the flag is true or false . But the rules do not accept the variation:

and so compiling this program must cause a compile-time error to occur.

Example 16-3. Definite Unassignment

A Java compiler will accept the code:

as far as definite unassignment of k is concerned, because the rules outlined in this section allow it to tell that k is assigned at most once (indeed, exactly once) no matter whether the flag is true or false . But the rules do not accept the variation:

In order to precisely specify all the cases of definite assignment, the rules in this section define several technical terms:

whether a variable is definitely assigned before a statement or expression

whether a variable is definitely unassigned before a statement or expression

whether a variable is definitely assigned after a statement or expression

whether a variable is definitely unassigned after a statement or expression

For boolean-valued expressions, the last two are refined into four cases:

whether a variable is definitely assigned after the expression when true

whether a variable is definitely unassigned after the expression when true

whether a variable is definitely assigned after the expression when false

whether a variable is definitely unassigned after the expression when false

Here, when true and when false refer to the value of the expression.

For example, the local variable k is definitely assigned a value after evaluation of the expression:

when the expression is true but not when the expression is false (because if a is false, then the assignment to k is not necessarily executed (more properly, evaluated)).

The phrase " V is definitely assigned after X " (where V is a local variable and X is a statement or expression) means " V is definitely assigned after X if X completes normally". If X completes abruptly, the assignment need not have occurred, and the rules stated here take this into account.

A peculiar consequence of this definition is that " V is definitely assigned after break; " is always true! Because a break statement never completes normally, it is vacuously true that V has been assigned a value if the break statement completes normally.

The statement " V is definitely unassigned after X " (where V is a variable and X is a statement or expression) means " V is definitely unassigned after X if X completes normally".

An even more peculiar consequence of this definition is that " V is definitely unassigned after break; " is always true! Because a break statement never completes normally, it is vacuously true that V has not been assigned a value if the break statement completes normally. (For that matter, it is also vacuously true that the moon is made of green cheese if the break statement completes normally.)

In all, there are four possibilities for a variable V after a statement or expression has been executed:

V is definitely assigned and is not definitely unassigned.

(The flow analysis rules prove that an assignment to V has occurred.)

V is definitely unassigned and is not definitely assigned.

(The flow analysis rules prove that an assignment to V has not occurred.)

V is not definitely assigned and is not definitely unassigned.

(The rules cannot prove whether or not an assignment to V has occurred.)

V is definitely assigned and is definitely unassigned.

(It is impossible for the statement or expression to complete normally.)

To shorten the rules, the customary abbreviation "iff" is used to mean "if and only if". We also use an abbreviation convention: if a rule contains one or more occurrences of "[un]assigned" then it stands for two rules, one with every occurrence of "[un]assigned" replaced by "definitely assigned" and one with every occurrence of "[un]assigned" replaced by "definitely unassigned".

For example:

V is [un]assigned after an empty statement iff it is [un]assigned before the empty statement.

should be understood to stand for two rules:

V is definitely assigned after an empty statement iff it is definitely assigned before the empty statement.

V is definitely unassigned after an empty statement iff it is definitely unassigned before the empty statement.

Throughout the rest of this chapter, we will, unless explicitly stated otherwise, write V to represent a local variable or blank final field which is in scope ( §6.3 ). Likewise, we will use a , b , c , and e to represent expressions, and S and T to represent statements. We will use the phrase " a is V " to mean that a is either the simple name of the variable V , or V 's simple name qualified by this (ignoring parentheses). We will use the phrase " a is not V " to mean the negation of " a is V ".

The definite unassignment analysis of loop statements raises a special problem. Consider the statement while ( e ) S . In order to determine whether V is definitely unassigned within some subexpression of e , we need to determine whether V is definitely unassigned before e . One might argue, by analogy with the rule for definite assignment ( §16.2.10 ), that V is definitely unassigned before e iff it is definitely unassigned before the while statement. However, such a rule is inadequate for our purposes. If e evaluates to true , the statement S will be executed. Later, if V is assigned by S , then in the following iteration(s) V will have already been assigned when e is evaluated. Under the rule suggested above, it would be possible to assign V multiple times, which is exactly what we have sought to avoid by introducing these rules.

A revised rule would be: " V is definitely unassigned before e iff it is definitely unassigned before the while statement and definitely unassigned after S ". However, when we formulate the rule for S , we find: " V is definitely unassigned before S iff it is definitely unassigned after e when true". This leads to a circularity. In effect, V is definitely unassigned before the loop condition e only if it is unassigned after the loop as a whole!

We break this vicious circle using a hypothetical analysis of the loop condition and body. For example, if we assume that V is definitely unassigned before e (regardless of whether V really is definitely unassigned before e ), and can then prove that V was definitely unassigned after e then we know that e does not assign V . This is stated more formally as:

Assuming V is definitely unassigned before e , V is definitely unassigned after e .

Variations on the above analysis are used to define well founded definite unassignment rules for all loop statements in the Java programming language.

16.1. Definite Assignment and Expressions

16.1.1. boolean constant expressions.

V is [un]assigned after any constant expression ( §15.29 ) whose value is true when false.

V is [un]assigned after any constant expression whose value is false when true.

V is [un]assigned after any constant expression whose value is true when true iff V is [un]assigned before the constant expression.

V is [un]assigned after any constant expression whose value is false when false iff V is [un]assigned before the constant expression.

V is [un]assigned after a boolean-valued constant expression e iff V is [un]assigned after e when true and V is [un]assigned after e when false.

This is equivalent to saying that V is [un]assigned after e iff V is [un]assigned before e .

Because a constant expression whose value is true never has the value false , and a constant expression whose value is false never has the value true , the first two rules are vacuously satisfied. They are helpful in analyzing expressions involving the operators && ( §16.1.2 ), || ( §16.1.3 ), ! ( §16.1.4 ), and ? : ( §16.1.5 ).

16.1.2. Conditional-And Operator &&

V is [un]assigned after a && b ( §15.23 ) when true iff V is [un]assigned after b when true.

V is [un]assigned after a && b when false iff V is [un]assigned after a when false and V is [un]assigned after b when false.

V is [un]assigned before a iff V is [un]assigned before a && b .

V is [un]assigned before b iff V is [un]assigned after a when true.

V is [un]assigned after a && b iff V is [un]assigned after a && b when true and V is [un]assigned after a && b when false.

16.1.3. Conditional-Or Operator ||

V is [un]assigned after a || b ( §15.24 ) when true iff V is [un]assigned after a when true and V is [un]assigned after b when true.

V is [un]assigned after a || b when false iff V is [un]assigned after b when false.

V is [un]assigned before a iff V is [un]assigned before a || b .

V is [un]assigned before b iff V is [un]assigned after a when false.

V is [un]assigned after a || b iff V is [un]assigned after a || b when true and V is [un]assigned after a || b when false.

16.1.4. Logical Complement Operator !

V is [un]assigned after ! a ( §15.15.6 ) when true iff V is [un]assigned after a when false.

V is [un]assigned after ! a when false iff V is [un]assigned after a when true.

V is [un]assigned before a iff V is [un]assigned before ! a .

V is [un]assigned after ! a iff V is [un]assigned after ! a when true and V is [un]assigned after ! a when false.

This is equivalent to saying that V is [un]assigned after ! a iff V is [un]assigned after a .

16.1.5. Conditional Operator ? :

Suppose that b and c are boolean-valued expressions.

V is [un]assigned after a ? b : c ( §15.25 ) when true iff V is [un]assigned after b when true and V is [un]assigned after c when true.

V is [un]assigned after a ? b : c when false iff V is [un]assigned after b when false and V is [un]assigned after c when false.

V is [un]assigned before a iff V is [un]assigned before a ? b : c .

V is [un]assigned before c iff V is [un]assigned after a when false.

V is [un]assigned after a ? b : c iff V is [un]assigned after a ? b : c when true and V is [un]assigned after a ? b : c when false.

Suppose that b and c are expressions that are not boolean-valued.

V is [un]assigned after a ? b : c iff V is [un]assigned after b and V is [un]assigned after c .

16.1.6.  switch Expressions

Suppose that a switch expression ( §15.28 ) has result expressions e 1 , ..., e n , all of which are boolean-valued.

The following rules apply only if the switch block of the switch expression consists of switch labeled statement groups ( §14.11.1 ):

V is definitely assigned after a switch expression when true iff for every yield statement with expression e ( §14.21 ) in the switch block that may exit the switch expression, V is definitely assigned after e when true.

V is definitely assigned after a switch expression when false iff for every yield statement with expression e in the switch block that may exit the switch expression, V is definitely assigned after e when false.

V is definitely unassigned after a switch expression when true iff for every yield statement with expression e in the switch block that may exit the switch expression, V is definitely unassigned before the yield statement and V is definitely unassigned after e when true.

V is definitely unassigned after a switch expression when false iff for every yield statement with expression e in the switch block that may exit the switch expression, V is definitely unassigned before the yield statement and V is definitely unassigned after e when false.

V is [un]assigned before the selector expression iff V is [un]assigned before the switch expression.

V is [un]assigned before the first statement of the first switch labeled statement group in the switch block iff V is [un]assigned after the selector expression.

V is [un]assigned before the first statement of any switch labeled statement group other than the first iff V is [un]assigned after the selector expression and V is [un]assigned after the preceding statement.

The following rules apply only if the switch block of the switch expression consists of switch rules ( §14.11.1 ):

V is definitely assigned after a switch expression when true iff for every switch rule, one of the following is true:

It introduces a switch rule expression e and V is definitely assigned after e when true.

It introduces a switch rule block B and for every yield statement with expression e contained in B that may exit the switch expression, V is definitely assigned after e when true.

It introduces a switch rule throw statement.

V is definitely assigned after a switch expression when false iff for every switch rule, one of the following is true:

It introduces a switch rule expression e and V is definitely assigned after e when false.

It introduces a switch rule block B and for every yield statement with expression e contained in B that may exit the switch expression, V is definitely assigned after e when false.

V is definitely unassigned after a switch expression when true iff for every switch rule, one of the following is true:

It introduces a switch rule expression e and V is definitely unassigned after e when true.

It introduces a switch rule block B and for every yield statement with expression e contained in B that may exit the switch expression, V is definitely unassigned before the yield statement and V is definitely unassigned after e when true.

V is definitely unassigned after a switch expression when false iff for every switch rule, one of the following is true:

It introduces a switch rule expression e and V is definitely unassigned after e when false.

It introduces a switch rule block B and for every yield statement with expression e contained in B that may exit the switch expression, V is definitely unassigned before the yield statement and V is definitely unassigned after e when false.

V is [un]assigned before any switch rule expression or switch rule statement in the switch block iff V is [un]assigned after the selector expression.

Suppose that a switch expression has result expressions e 1 , ..., e n , not all of which are boolean-valued.

V is [un]assigned after a switch expression iff all of the following are true:

V is [un]assigned before every yield statement that may exit the switch expression.

For each switch rule in the switch block, V is [un]assigned after the switch rule expression, switch rule block, or switch rule throw statement introduced by the switch rule.

V is [un]assigned before the selector expression of a switch expression iff V is [un]assigned before the switch expression.

V is [un]assigned before the switch rule expression, switch rule block, or switch rule throw statement introduced by a switch rule in the switch block iff V is [un]assigned after the selector expression of the switch expression.

V is [un]assigned before the first block statement of a switch labeled statement group in the switch block iff both of the following are true:

V is [un]assigned after the selector expression of the switch expression.

If the switch labeled statement group is not the first in the switch block, V is [un]assigned after the last block statement of the preceding switch labeled statement group.

V is [un]assigned before a block statement that is not the first of a switch labeled statement group in the switch block iff V is [un]assigned after the preceding block statement.

16.1.7. Other Expressions of Type boolean

Suppose that e is an expression of type boolean and is not a boolean constant expression, logical complement expression ! a , conditional-and expression a && b , conditional-or expression a || b , or conditional expression a ? b : c .

V is [un]assigned after e when true iff V is [un]assigned after e .

V is [un]assigned after e when false iff V is [un]assigned after e .

16.1.8. Assignment Expressions

Consider an assignment expression a = b , a += b , a -= b , a *= b , a /= b , a %= b , a <<= b , a >>= b , a >>>= b , a &= b , a |= b , or a ^= b ( §15.26 ).

V is definitely assigned after the assignment expression iff either:

a is V , or

V is definitely assigned after b .

V is definitely unassigned after the assignment expression iff a is not V and V is definitely unassigned after b .

V is [un]assigned before a iff V is [un]assigned before the assignment expression.

V is [un]assigned before b iff V is [un]assigned after a .

Note that if a is V and V is not definitely assigned before a compound assignment such as a &= b , then a compile-time error will necessarily occur. The first rule for definite assignment stated above includes the disjunct " a is V " even for compound assignment expressions, not just simple assignments, so that V will be considered to have been definitely assigned at later points in the code. Including the disjunct " a is V " does not affect the binary decision as to whether a program is acceptable or will result in a compile-time error, but it affects how many different points in the code may be regarded as erroneous, and so in practice it can improve the quality of error reporting. A similar remark applies to the inclusion of the conjunct " a is not V " in the first rule for definite unassignment stated above.

16.1.9. Operators ++ and --

V is definitely assigned after ++ a ( §15.15.1 ), -- a ( §15.15.2 ), a ++ ( §15.14.2 ), or a -- ( §15.14.3 ) iff either a is V or V is definitely assigned after the operand expression.

V is definitely unassigned after ++ a , -- a , a ++ , or a -- iff a is not V and V is definitely unassigned after the operand expression.

V is [un]assigned before a iff V is [un]assigned before ++ a , -- a , a ++ , or a -- .

16.1.10. Other Expressions

If an expression is not a boolean constant expression, and is not a preincrement expression ++ a , predecrement expression -- a , postincrement expression a ++ , postdecrement expression a -- , logical complement expression ! a , conditional-and expression a && b , conditional-or expression a || b , conditional expression a ? b : c , assignment expression, or lambda expression, then the following rules apply:

If the expression has no subexpressions, V is [un]assigned after the expression iff V is [un]assigned before the expression.

This case applies to literals, names, this (both qualified and unqualified), unqualified class instance creation expressions with no arguments, array creation expressions with initializers that contain no expressions, superclass field access expressions, unqualified and type-qualified method invocation expressions with no arguments, superclass method invocation expressions with no arguments, and superclass and type-qualified method reference expressions.

If the expression has subexpressions, V is [un]assigned after the expression iff V is [un]assigned after its rightmost immediate subexpression.

There is a piece of subtle reasoning behind the assertion that a variable V can be known to be definitely unassigned after a method invocation expression. Taken by itself, at face value and without qualification, such an assertion is not always true, because an invoked method can perform assignments. But it must be remembered that, for the purposes of the Java programming language, the concept of definite unassignment is applied only to blank final variables. If V is a blank final local variable, then only the method to which its declaration belongs can perform assignments to V . If V is a blank final field, then only a constructor or an initializer for the class containing the declaration for V can perform assignments to V ; no method can perform assignments to V . Finally, explicit constructor invocations ( §8.8.7.1 ) are handled specially ( §16.9 ); although they are syntactically similar to expression statements containing method invocations, they are not expression statements and therefore the rules of this section do not apply to explicit constructor invocations.

If an expression is a lambda expression, then the following rules apply:

V is [un]assigned after the expression iff V is [un]assigned before the expression.

V is definitely assigned before the expression or block that is the lambda body ( §15.27.2 ) iff V is definitely assigned before the lambda expression.

No rule allows V to be definitely unassigned before a lambda body. This is by design: a variable that was definitely unassigned before the lambda body may end up being assigned to later on, so we cannot conclude that the variable will be unassigned when the body is executed.

For any immediate subexpression y of an expression x , where x is not a lambda expression, V is [un]assigned before y iff one of the following is true:

y is the leftmost immediate subexpression of x and V is [un]assigned before x .

y is the right-hand operand of a binary operator and V is [un]assigned after the left-hand operand.

x is an array access, y is the subexpression within the brackets, and V is [un]assigned after the subexpression before the brackets.

x is a primary method invocation expression, y is the first argument expression in the method invocation expression, and V is [un]assigned after the primary expression that computes the target object.

x is a method invocation expression or a class instance creation expression; y is an argument expression, but not the first; and V is [un]assigned after the argument expression to the left of y .

x is a qualified class instance creation expression, y is the first argument expression in the class instance creation expression, and V is [un]assigned after the primary expression that computes the qualifying object.

x is an array creation expression; y is a dimension expression, but not the first; and V is [un]assigned after the dimension expression to the left of y .

x is an array creation expression initialized via an array initializer; y is the array initializer in x ; and V is [un]assigned after the dimension expression to the left of y .

16.2. Definite Assignment and Statements

16.2.1. empty statements.

V is [un]assigned after an empty statement ( §14.6 ) iff it is [un]assigned before the empty statement.

16.2.2. Blocks

A blank final member field V is definitely assigned (and moreover is not definitely unassigned) before the block ( §14.2 ) that is the body of any method in the scope of V and before the declaration of any class declared within the scope of V .

A local variable V is definitely unassigned (and moreover is not definitely assigned) before the block that is the body of the constructor, method, instance initializer or static initializer that declares V .

Let C be a class declared within the scope of V . Then V is definitely assigned before the block that is the body of any constructor, method, instance initializer, or static initializer declared in C iff V is definitely assigned before the declaration of C .

Note that there are no rules that would allow us to conclude that V is definitely unassigned before the block that is the body of any constructor, method, instance initializer, or static initializer declared in C . We can informally conclude that V is not definitely unassigned before the block that is the body of any constructor, method, instance initializer, or static initializer declared in C , but there is no need for such a rule to be stated explicitly.

V is [un]assigned after an empty block iff V is [un]assigned before the empty block.

V is [un]assigned after a non-empty block iff V is [un]assigned after the last statement in the block.

V is [un]assigned before the first statement of the block iff V is [un]assigned before the block.

V is [un]assigned before any other statement S of the block iff V is [un]assigned after the statement immediately preceding S in the block.

We say that V is definitely unassigned everywhere in a block B iff:

V is definitely unassigned before B .

V is definitely assigned after e in every assignment expression V = e , V += e , V -= e , V *= e , V /= e , V %= e , V <<= e , V >>= e , V >>>= e , V &= e , V |= e , or V ^= e that occurs in B .

V is definitely assigned before every expression ++ V , -- V , V ++ , or V -- that occurs in B .

These conditions are counterintuitive and require some explanation. Consider a simple assignment V = e . If V is definitely assigned after e , then either:

The assignment occurs in dead code, and V is vacuously definitely assigned. In this case, the assignment will not actually take place, and we can assume that V is not being assigned by the assignment expression. Or:

V was already assigned by an earlier expression prior to e . In this case the current assignment will cause a compile-time error.

So, we can conclude that if the conditions are met by a program that causes no compile time error, then any assignments to V in B will not actually take place at run time.

16.2.3. Local Class and Interface Declarations

V is [un]assigned after a local class or interface declaration ( §14.3 ) iff V is [un]assigned before the local class or interface declaration.

16.2.4. Local Variable Declaration Statements

V is [un]assigned after a local variable declaration statement ( §14.4.2 ) that contains no variable initializers iff V is [un]assigned before the local variable declaration statement.

V is definitely assigned after a local variable declaration statement that contains at least one variable initializer iff either V is definitely assigned after the last variable initializer in the local variable declaration statement or the last variable initializer in the declaration is in the declarator that declares V .

V is definitely unassigned after a local variable declaration statement that contains at least one variable initializer iff V is definitely unassigned after the last variable initializer in the local variable declaration statement and the last variable initializer in the declaration is not in the declarator that declares V .

V is [un]assigned before the first variable initializer in a local variable declaration statement iff V is [un]assigned before the local variable declaration statement.

V is definitely assigned before any variable initializer e other than the first one in the local variable declaration statement iff either V is definitely assigned after the variable initializer to the left of e or the initializer expression to the left of e is in the declarator that declares V .

V is definitely unassigned before any variable initializer e other than the first one in the local variable declaration statement iff V is definitely unassigned after the variable initializer to the left of e and the initializer expression to the left of e is not in the declarator that declares V .

16.2.5. Labeled Statements

V is [un]assigned after a labeled statement L : S (where L is a label) ( §14.7 ) iff V is [un]assigned after S and V is [un]assigned before every break statement that may exit the labeled statement L : S .

V is [un]assigned before S iff V is [un]assigned before L : S .

16.2.6. Expression Statements

V is [un]assigned after an expression statement e ; ( §14.8 ) iff it is [un]assigned after e .

V is [un]assigned before e iff it is [un]assigned before e ; .

16.2.7.  if Statements

The following rules apply to a statement if ( e ) S ( §14.9.1 ):

V is [un]assigned after if ( e ) S iff V is [un]assigned after S and V is [un]assigned after e when false.

V is [un]assigned before e iff V is [un]assigned before if ( e ) S .

V is [un]assigned before S iff V is [un]assigned after e when true.

The following rules apply to a statement if (e) S else T ( §14.9.2 ):

V is [un]assigned after if ( e ) S else T iff V is [un]assigned after S and V is [un]assigned after T .

V is [un]assigned before e iff V is [un]assigned before if ( e ) S else T .

V is [un]assigned before T iff V is [un]assigned after e when false.

16.2.8.  assert Statements

The following rules apply both to a statement assert e 1 and to a statement assert e 1 : e 2 ( §14.10 ):

V is [un]assigned before e 1 iff V is [un]assigned before the assert statement.

V is definitely assigned after the assert statement iff V is definitely assigned before the assert statement.

V is definitely unassigned after the assert statement iff V is definitely unassigned before the assert statement and V is definitely unassigned after e 1 when true.

The following rule applies to a statement assert e 1 : e 2 :

V is [un]assigned before e 2 iff V is [un]assigned after e 1 when false.

16.2.9.  switch Statements

V is [un]assigned after a switch statement ( §14.11 ) iff all of the following are true:

V is [un]assigned before every break statement ( §14.15 ) that may exit the switch statement.

For each switch rule ( §14.11.1 ) in the switch block, V is [un]assigned after the switch rule expression, switch rule block, or switch rule throw statement introduced by the switch rule.

If there is a switch labeled statement group in the switch block, then V is [un]assigned after the last block statement of the last switch labeled statement group.

If there is no default label in the switch block, or if the switch block ends with a switch label followed by the } separator, then V is [un]assigned after the selector expression.

V is [un]assigned before the selector expression of a switch statement iff V is [un]assigned before the switch statement.

V is [un]assigned before the switch rule expression, switch rule block, or switch rule throw statement introduced by a switch rule in the switch block iff V is [un]assigned after the selector expression of the switch statement.

V is [un]assigned after the selector expression of the switch statement.

16.2.10.  while Statements

V is [un]assigned after while ( e ) S ( §14.12 ) iff V is [un]assigned after e when false and V is [un]assigned before every break statement for which the while statement is the break target.

V is definitely assigned before e iff V is definitely assigned before the while statement.

V is definitely unassigned before e iff all of the following are true:

V is definitely unassigned before the while statement.

Assuming V is definitely unassigned before e , V is definitely unassigned after S .

Assuming V is definitely unassigned before e , V is definitely unassigned before every continue statement for which the while statement is the continue target.

16.2.11.  do Statements

V is [un]assigned after do S while ( e ); ( §14.13 ) iff V is [un]assigned after e when false and V is [un]assigned before every break statement for which the do statement is the break target.

V is definitely assigned before S iff V is definitely assigned before the do statement.

V is definitely unassigned before S iff all of the following are true:

V is definitely unassigned before the do statement.

Assuming V is definitely unassigned before S , V is definitely unassigned after e when true.

V is [un]assigned before e iff V is [un]assigned after S and V is [un]assigned before every continue statement for which the do statement is the continue target.

16.2.12.  for Statements

The rules herein cover the basic for statement ( §14.14.1 ). Since the enhanced for statement ( §14.14.2 ) is defined by translation to a basic for statement, no special rules need to be provided for it.

V is [un]assigned after a for statement iff both of the following are true:

Either a condition expression is not present or V is [un]assigned after the condition expression when false.

V is [un]assigned before every break statement for which the for statement is the break target.

V is [un]assigned before the initialization part of the for statement iff V is [un]assigned before the for statement.

V is definitely assigned before the condition part of the for statement iff V is definitely assigned after the initialization part of the for statement.

V is definitely unassigned before the condition part of the for statement iff both of the following are true:

V is definitely unassigned after the initialization part of the for statement.

Assuming V is definitely unassigned before the condition part of the for statement, V is definitely unassigned after the incrementation part of the for statement.

V is [un]assigned before the contained statement iff either of the following is true:

A condition expression is present and V is [un]assigned after the condition expression when true.

No condition expression is present and V is [un]assigned before the condition part of the for statement.

V is [un]assigned before the incrementation part of the for statement iff V is [un]assigned after the contained statement and V is [un]assigned before every continue statement for which the for statement is the continue target.

16.2.12.1. Initialization Part of for Statement

If the initialization part of the for statement is a local variable declaration statement, the rules of §16.2.4 apply.

Otherwise, if the initialization part is empty, then V is [un]assigned after the initialization part iff V is [un]assigned before the initialization part.

Otherwise, three rules apply:

V is [un]assigned after the initialization part iff V is [un]assigned after the last expression statement in the initialization part.

V is [un]assigned before the first expression statement in the initialization part iff V is [un]assigned before the initialization part.

V is [un]assigned before an expression statement S other than the first in the initialization part iff V is [un]assigned after the expression statement immediately preceding S .

16.2.12.2. Incrementation Part of for Statement

If the incrementation part of the for statement is empty, then V is [un]assigned after the incrementation part iff V is [un]assigned before the incrementation part.

V is [un]assigned after the incrementation part iff V is [un]assigned after the last expression statement in the incrementation part.

V is [un]assigned before the first expression statement in the incrementation part iff V is [un]assigned before the incrementation part.

V is [un]assigned before an expression statement S other than the first in the incrementation part iff V is [un]assigned after the expression statement immediately preceding S .

16.2.13.  break , yield , continue , return , and throw Statements

By convention, we say that V is [un]assigned after any break , yield , continue , return , or throw statement ( §14.15 , §14.21 , §14.16 , §14.17 , §14.18 ).

The notion that a variable is "[un]assigned after" a statement or expression really means "is [un]assigned after the statement or expression completes normally". Because a break , yield , continue , return , or throw statement never completes normally, it vacuously satisfies this notion.

In a yield statement with expression e , or a return statement with expression e , or a throw statement with expression e , V is [un]assigned before e iff V is [un]assigned before the yield , return , or throw statement.

16.2.14.  synchronized Statements

V is [un]assigned after synchronized ( e ) S ( §14.19 ) iff V is [un]assigned after S .

V is [un]assigned before e iff V is [un]assigned before the statement synchronized ( e ) S .

V is [un]assigned before S iff V is [un]assigned after e .

16.2.15.  try Statements

The rules herein cover the try - catch and try - catch - finally statements ( §14.20.1 , §14.20.2 ). Since the try -with-resources statement ( §14.20.3 ) is defined by translation to a try - catch - finally statement, no special rules need to be provided for it.

These rules apply to every try statement ( §14.20 ), whether or not it has a finally block:

V is [un]assigned before the try block iff V is [un]assigned before the try statement.

V is definitely assigned before a catch block iff V is definitely assigned before the try block.

V is definitely unassigned before a catch block iff all of the following are true:

V is definitely unassigned after the try block.

V is definitely unassigned before every return statement that belongs to the try block.

V is definitely unassigned after e in every statement of the form throw e that belongs to the try block.

V is definitely unassigned after every assert statement that occurs in the try block.

V is definitely unassigned before every break statement that belongs to the try block and whose break target contains (or is) the try statement.

V is definitely unassigned before every continue statement that belongs to the try block and whose continue target contains the try statement.

If a try statement does not have a finally block, then this rule also applies:

V is [un]assigned after the try statement iff V is [un]assigned after the try block and V is [un]assigned after every catch block in the try statement.

If a try statement does have a finally block, then these rules also apply:

V is definitely assigned after the try statement iff at least one of the following is true:

V is definitely assigned after the try block and V is definitely assigned after every catch block in the try statement.

V is definitely assigned after the finally block.

V is definitely unassigned after the try statement iff V is definitely unassigned after the finally block.

V is definitely assigned before the finally block iff V is definitely assigned before the try statement.

V is definitely unassigned before the finally block iff all of the following are true:

V is definitely unassigned after every catch block of the try statement.

16.3. Definite Assignment and Parameters

A formal parameter V of a method or constructor ( §8.4.1 , §8.8.1 ) is definitely assigned (and moreover is not definitely unassigned) before the body of the method or constructor.

An exception parameter V of a catch clause ( §14.20 ) is definitely assigned (and moreover is not definitely unassigned) before the body of the catch clause.

16.4. Definite Assignment and Array Initializers

V is [un]assigned after an empty array initializer ( §10.6 ) iff V is [un]assigned before the empty array initializer.

V is [un]assigned after a non-empty array initializer iff V is [un]assigned after the last variable initializer in the array initializer.

V is [un]assigned before the first variable initializer of the array initializer iff V is [un]assigned before the array initializer.

V is [un]assigned before any other variable initializer e of the array initializer iff V is [un]assigned after the variable initializer to the left of e in the array initializer.

16.5. Definite Assignment and Enum Constants

The rules determining when a variable is definitely assigned or definitely unassigned before an enum constant ( §8.9.1 ) are given in §16.8 .

This is because an enum constant is essentially a static final field ( §8.3.1.1 , §8.3.1.2 ) that is initialized with a class instance creation expression ( §15.9 ).

V is definitely assigned before the declaration of a class body of an enum constant with no arguments that is declared within the scope of V iff V is definitely assigned before the enum constant.

V is definitely assigned before the declaration of a class body of an enum constant with arguments that is declared within the scope of V iff V is definitely assigned after the last argument expression of the enum constant

The definite assignment/unassignment status of any construct within the class body of an enum constant is governed by the usual rules for classes.

V is [un]assigned before the first argument to an enum constant iff it is [un]assigned before the enum constant.

V is [un]assigned before y (an argument of an enum constant, but not the first) iff V is [un]assigned after the argument to the left of y .

16.6. Definite Assignment and Anonymous Classes

V is definitely assigned before an anonymous class declaration ( §15.9.5 ) that is declared within the scope of V iff V is definitely assigned after the class instance creation expression that declares the anonymous class.

It should be clear that if an anonymous class is implicitly defined by an enum constant, the rules of §16.5 apply.

16.7. Definite Assignment and Member Classes and Interfaces

Let C be a class, and let V be a blank final field of C . Then:

V is definitely assigned (and moreover, not definitely unassigned) before the declaration of any member class or interface ( §8.5 , §9.5 ) of C .

Let C be a class declared within the scope of V . Then:

V is definitely assigned before the declaration of a member class or interface of C iff V is definitely assigned before the declaration of C .

16.8. Definite Assignment and Static Initializers

V is definitely assigned before an enum constant ( §8.9.1 ) or static variable initializer ( §8.3.2 ) of C iff V is definitely assigned before the declaration of C .

Note that there are no rules that would allow us to conclude that V is definitely unassigned before a static variable initializer or enum constant. We can informally conclude that V is not definitely unassigned before any static variable initializer of C , but there is no need for such a rule to be stated explicitly.

Let C be a class, and let V be a blank static final member field of C , declared in C . Then:

V is definitely unassigned (and moreover is not definitely assigned) before the leftmost enum constant, static initializer ( §8.7 ), or static variable initializer of C .

V is [un]assigned before an enum constant, static initializer, or static variable initializer of C other than the leftmost iff V is [un]assigned after the preceding enum constant, static initializer, or static variable initializer of C .

Let C be a class, and let V be a blank static final member field of C , declared in a superclass of C . Then:

V is definitely assigned (and moreover is not definitely unassigned) before every enum constant of C .

V is definitely assigned (and moreover is not definitely unassigned) before the block that is the body of a static initializer of C .

V is definitely assigned (and moreover is not definitely unassigned) before every static variable initializer of C .

16.9. Definite Assignment, Constructors, and Instance Initializers

V is definitely assigned before an instance variable initializer ( §8.3.2 ) of C iff V is definitely assigned before the declaration of C .

Note that there are no rules that would allow us to conclude that V is definitely unassigned before an instance variable initializer. We can informally conclude that V is not definitely unassigned before any instance variable initializer of C , but there is no need for such a rule to be stated explicitly.

Let C be a class, and let V be a blank final non- static member field of C , declared in C . Then:

V is definitely unassigned (and moreover is not definitely assigned) before the leftmost instance initializer ( §8.6 ) or instance variable initializer of C .

V is [un]assigned before an instance initializer or instance variable initializer of C other than the leftmost iff V is [un]assigned after the preceding instance initializer or instance variable initializer of C .

The following rules hold within the constructors ( §8.8.7 ) of class C :

V is definitely assigned (and moreover is not definitely unassigned) after an alternate constructor invocation ( §8.8.7.1 ).

V is definitely unassigned (and moreover is not definitely assigned) before an explicit or implicit superclass constructor invocation ( §8.8.7.1 ).

If C has no instance initializers or instance variable initializers, then V is not definitely assigned (and moreover is definitely unassigned) after an explicit or implicit superclass constructor invocation.

If C has at least one instance initializer or instance variable initializer then V is [un]assigned after an explicit or implicit superclass constructor invocation iff V is [un]assigned after the rightmost instance initializer or instance variable initializer of C .

Let C be a class, and let V be a blank final member field of C , declared in a superclass of C . Then:

V is definitely assigned (and moreover is not definitely unassigned) before the block that is the body of a constructor or instance initializer of C .

V is definitely assigned (and moreover is not definitely unassigned) before every instance variable initializer of C .

Java Tutorials

Java assignment statement.

In this tutorial, we will learn about Java Assignment Statement. We can assign or give value to a variable using the assignment statement.

The general syntax for assigning a value to a variable is as follows:

variable_name = value;

We can also assign value to a variable as part of the declaration. This is known as variable initialization. The syntax for the variable initialization is:

Datatype variable_name = value;

To assign a value of 72 to a variable named length :

// assign a value to the variable

length = 72;

For example, to initialize a variable width to 6.2:

//declare and initialize the variable

float width = 6.2;

Java Tutorial on this website:

https://www.testingdocs.com/java-tutorial/

For more information on Java, visit the official website :

https://www.oracle.com/java/

Related Posts

Java Tutorials /

Improving Java Performance with Multithreading

Download & Install Greenfoot on Windows

Java static code analysis, java testing tools, handle multiple exceptions in java.

CS101: Introduction to Computer Science I (2019.A.01)

Variables and Assignment Statements

Read this chapter, which covers variables and arithmetic operations and order precedence in Java.

28. Nested Parentheses

The last answer is correct. It is done like this:

Nested Parentheses

Sometimes in a complicated expression one set of parentheses is not enough. In that case use several nested sets to show what you want. The rule is:

The  innermost  set of parentheses is evaluated  first .

Start evaluating at the most deeply nested set of parentheses, and then work outward until there are no parentheses left. If there are several sets of parentheses at the same level, evaluate them left to right. For example:

(Ordinarily you would not do this in such detail.)

Question 28:

What is the value of this expression:

• Basics of Java
• ➤ Java Introduction
• ➤ History of Java
• ➤ Getting started with Java
• ➤ What is Path and Classpath
• ➤ Checking Java installation and Version
• ➤ Syntax in Java
• ➤ My First Java Program
• ➤ Basic terms in Java Program
• ➤ Runtime and Compile time
• ➤ What is Bytecode
• ➤ Features of Java
• ➤ What is JDK JRE and JVM
• ➤ Basic Program Examples
• Variables and Data Types
• ➤ What is Variable
• ➤ Types of Java Variables
• ➤ Naming conventions for Identifiers
• ➤ Data Type in Java
• ➤ Mathematical operators in Java
• ➤ Assignment operator in Java
• ➤ Arithmetic operators in Java
• ➤ Unary operators in Java
• ➤ Conditional and Relational Operators
• ➤ Bitwise and Bit Shift Operators
• ➤ Operator Precedence
• ➤ Overflow Underflow Widening Narrowing
• ➤ Variable and Data Type Programs
• Control flow Statements
• ➤ Java if and if else Statement
• ➤ else if and nested if else Statement
• ➤ Java for Loop
• ➤ Java while and do-while Loop
• ➤ Nested loops
• ➤ Java break Statement
• ➤ Java continue and return Statement
• ➤ Java switch Statement
• ➤ Control Flow Program Examples
• Array and String in Java
• ➤ Array in Java
• ➤ Multi-Dimensional Arrays
• ➤ for-each loop in java
• ➤ Java String
• ➤ Useful Methods of String Class
• ➤ StringBuffer and StringBuilder
• ➤ Array and String Program Examples
• Classes and Objects
• ➤ Classes in Java
• ➤ Objects in Java
• ➤ Methods in Java
• ➤ Constructors in Java
• ➤ static keyword in Java
• ➤ Call By Value
• ➤ Inner/nested classes in Java
• ➤ Wrapper Classes
• ➤ Enum in Java
• ➤ Initializer blocks
• ➤ Method Chaining and Recursion
• Packages and Interfaces
• ➤ What is package
• ➤ Sub packages in java
• ➤ built-in packages in java
• ➤ Import packages
• ➤ Access modifiers
• ➤ Interfaces in Java
• ➤ Key points about Interfaces
• ➤ New features in Interfaces
• ➤ Nested Interfaces
• ➤ Structure of Java Program
• OOPS Concepts
• ➤ What is OOPS
• ➤ Inheritance in Java
• ➤ Inheritance types in Java
• ➤ Abstraction in Java
• ➤ Encapsulation in Java
• ➤ Polymorphism in Java
• ➤ Runtime and Compile-time Polymorphism
• ➤ Method Overloading
• ➤ Method Overriding
• ➤ Overloading and Overriding Differences
• ➤ Overriding using Covariant Return Type
• ➤ this keyword in Java
• ➤ super keyword in Java
• ➤ final keyword in Java

Assignment Operator in Java with Example

Assignment operator is one of the simplest and most used operator in java programming language. As the name itself suggests, the assignment operator is used to assign value inside a variable. In java we can divide assignment operator in two types :

• Assignment operator or simple assignment operator
• Compound assignment operators

What is assignment operator in java

The = operator in java is known as assignment or simple assignment operator. It assigns the value on its right side to the operand(variable) on its left side. For example :

The left-hand side of an assignment operator must be a variable while the right side of it should be a value which can be in the form of a constant value, a variable name, an expression, a method call returning a compatible value or a combination of these.

The value at right side of assignment operator must be compatible with the data type of left side variable, otherwise compiler will throw compilation error. Following are incorrect assignment :

Another important thing about assignment operator is that, it is evaluated from right to left . If there is an expression at right side of assignment operator, it is evaluated first then the resulted value is assigned in left side variable.

Here in statement int x = a + b + c; the expression a + b + c is evaluated first, then the resulted value( 60 ) is assigned into x . Similarly in statement a = b = c , first the value of c which is 30 is assigned into b and then the value of b which is now 30 is assigned into a .

The variable at left side of an assignment operator can also be a non-primitive variable. For example if we have a class MyFirstProgram , we can assign object of MyFirstProgram class using = operator in MyFirstProgram type variable.

Is == an assignment operator ?

No , it's not an assignment operator, it's a relational operator used to compare two values.

Is assignment operator a binary operator

Yes , as it requires two operands.

Assignment operator program in Java

a = 2 b = 2 c = 4 d = 4 e = false

Java compound assignment operators

The assignment operator can be mixed or compound with other operators like addition, subtraction, multiplication etc. We call such assignment operators as compound assignment operator. For example :

Here the statement a += 10; is the short version of a = a + 10; the operator += is basically addition compound assignment operator. Similarly b *= 5; is short version of b = b * 5; the operator *= is multiplication compound assignment operator. The compound assignment can be in more complex form as well, like below :

List of all assignment operators in Java

The table below shows the list of all possible assignment(simple and compound) operators in java. Consider a is an integer variable for this table.

How many assignment operators are there in Java ?

Including simple and compound assignment we have total 12 assignment operators in java as given in above table.

What is shorthand operator in Java ?

Shorthand operators are nothing new they are just a shorter way to write something that is already available in java language. For example the code a += 5 is shorter way to write a = a + 5 , so += is a shorthand operator. In java all the compound assignment operator(given above) and the increment/decrement operators are basically shorthand operators.

Compound assignment operator program in Java

a = 20 b = 80 c = 30 s = 64 s2 = 110 b2 = 15

What is the difference between += and =+ in Java?

An expression a += 1 will result as a = a + 1 while the expression a =+ 1 will result as a = +1 . The correct compound statement is += , not =+ , so do not use the later one.

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

Javatpoint Services

JavaTpoint offers too many high quality services. Mail us on h [email protected] , to get more information about given services.

• Website Designing
• Website Development
• Java Development
• PHP Development
• Graphic Designing
• Digital Marketing
• On Page and Off Page SEO
• Content Development
• Corporate Training
• Classroom and Online Training

Training For College Campus

JavaTpoint offers college campus training on Core Java, Advance Java, .Net, Android, Hadoop, PHP, Web Technology and Python. Please mail your requirement at [email protected] . Duration: 1 week to 2 week