{"id":2080,"date":"2020-03-06T18:09:41","date_gmt":"2020-03-06T18:09:41","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=2080"},"modified":"2020-03-10T13:07:41","modified_gmt":"2020-03-10T13:07:41","slug":"java-variables-and-data-types","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/java-variables-and-data-types\/","title":{"rendered":"Java Variables and Data Types"},"content":{"rendered":"

Variable is a name associated with a piece of memory that stores data and whose associated value may be changed\u00a0 To declare a variable you need to write the Java <\/a>variable type with giving it a name.\u00a0<\/span><\/p>\n

For example, let’s declare two variables. One is named\u00a0 <\/span>personName<\/span><\/i> and has type String, other is named <\/span>personAge<\/span><\/i> and is of type int.<\/span><\/p>\n

String personName;
\n<\/span><\/i>int personAge;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/i><\/p>\n

Now that we\u2019ve declared a variable, we can give it a value. This is called <\/span>initializing<\/b> a variable. To initialize a variable, you just type the variable name followed by an equal sign, followed by the desired value:<\/span><\/p>\n

personName = “Denis”;
\n<\/span><\/i>personAge = 30;<\/span><\/i><\/p>\n

Since you often want to initialize a variable right away, you can do so in the same statement as the declaration. For example, here we merge the previous declarations and initializations into more concise code:<\/span><\/p>\n

String personName = “Denis”;
\n<\/span><\/i>int personAge = 30;<\/span><\/i><\/p>\n

In the picture below you can find basic terms that developers use for variables:<\/span><\/p>\n

\"Java<\/p>\n

You can also declare and initialize multiple variables in the same statement. How many\u00a0<\/span>variables do you think are declared and initialized in the following two lines?<\/span><\/p>\n

String str1, str2;
\n<\/span><\/i>String str3 = “yes”, str4 = “no”;<\/span><\/i><\/p>\n

We declared 4 String variables were declared: str1, str2, str3, and str4. You can declare many variables in the same declaration in case they have the same type. You can also initialize any\u00a0<\/span>or all of those values inline. In the previous example, we have two initialized variables: str3\u00a0<\/span>and str4. The other two variables remain declared but not initialized.<\/span><\/p>\n

Pay attention to tricky things! This is where it gets tricky.\u00a0<\/span><\/p>\n

Let’s try one more example, how many variables do you think are declared and initialized in this code?<\/span><\/p>\n

int i1, i2, i3 = 0;<\/span><\/i><\/p>\n

As you should expect, 3 variables were declared: i1, i2, and i3. If you look with the attention you will understand that only one of those values i3 was initialized. The other two are declared but not initialized.<\/span><\/p>\n

That\u2019s the trick. Each snippet separated by a comma is a little declaration of its own. The\u00a0<\/span>initialization of i3 only applies to i3. It doesn\u2019t have anything to do with i1 or i2 despite\u00a0<\/span>being in the same statement.<\/span><\/p>\n

Look at this line:<\/span><\/p>\n

int num, String value; \/\/ DOES NOT COMPILE<\/span><\/i><\/p>\n

This code doesn\u2019t compile because it tries to declare multiple variables of different types\u00a0<\/span>in the same statement. The shortcut to declare multiple variables in the same statement only\u00a0<\/span>works when they share a type.<\/span><\/p>\n

To make sure you understand this, see if you can figure out which of the following are\u00a0<\/span>legal declarations:<\/span><\/p>\n

boolean b1, b2;
\n<\/span><\/i>String s1 = “1”, s2;
\n<\/span><\/i>double d1, double d2;
\n<\/span><\/i>int i1; int i2;
\n<\/span><\/i>int i3; i4;<\/span><\/i><\/p>\n

The first statement declares two variables without initializing them. The\u00a0<\/span>second statement declares two variables and initializes only one of them.\u00a0<\/span>Look at the third statement. It is not legal. Java does not allow you to declare two different types\u00a0<\/span>in the same statement. Variables d1 and d2 are the same types. They are both of type double. Although that\u2019s true, it still isn\u2019t allowed. If you want to declare multiple\u00a0<\/span>variables in the same statement, they must share the same type declaration and not repeat<\/span><\/p>\n

    \n
  1. double d1, d2; would have been legal.<\/span><\/li>\n<\/ol>\n

    The fourth statement is legal. Although int does appear twice, each one is in a separate\u00a0<\/span>statement. A semicolon (;) separates statements in Java. It just so happens there are two\u00a0<\/span>completely different statements on the same line. The fifth statement is not legal. Again,\u00a0<\/span>we have two completely different statements on the same line. The second one is not a\u00a0<\/span>valid declaration because it omits the type. When you see an oddly placed semicolon on the\u00a0<\/span>exam, pretend the code is on separate lines and think about whether the code compiles that\u00a0<\/span>way. In this case, we have the following:<\/span><\/p>\n

    int i1;
    \n<\/span><\/i>int i2;
    \n<\/span><\/i>int i3;
    \n<\/span><\/i>i4;\/\/ DOES NOT COMPILE<\/span><\/i><\/p>\n

    Looking at the last line on its own, you can easily see that the declaration is invalid.\u00a0<\/span>And yes, the exam really does cram multiple statements onto the same line partly to\u00a0<\/span>try to trick you and partly to fit more code on the screen. In the real world, please limit\u00a0<\/span>yourself to one declaration per statement and line. Your teammates will thank you for the\u00a0<\/span>readable code.<\/span><\/p>\n


    \nIdentifiers<\/b><\/p>\n

    Java has rules about identifier names. The same rules for identifiers apply to variables, methods, classes, and fields.<\/span><\/p>\n

    The rules are:<\/span><\/p>\n