Variables

Variables are convenient handles for accessing memory. We don't need to mess with memory addresses:

Figure 68. Variables: Handles to memory

Declaring a variable requires a type name like double and an identifier:

// Variable declaration:
//     Variable's type is double
//     Variable's name is «pi» (identifier)

double pi;

{type name} {variable name} ;

We may assign values to variables or build expressions like pi * 2.0 * 2.0 :

Figure 70. Declare, assign and use

double pi;      // Variable declaration

pi = 3.1415926; // Assigning value to variable

// Print a circle's area of radius 2.0

System.out.println(pi * 2.0 * 2.0);

Figure 71. Combining declaration and initialization

Separate declaration and initialization

double pi;      // Declaration of variable pi

pi = 3.1415926; // Value assignment

Combined declaration and initialization

double pi = 3.1415926;

Figure 72. Compound declarations

Separate declarations	Equivalent compound declaration
`int a; int b = 22; int c;`	`int a, b = 22, c;`

exercise No. 10

The sum of two values

We consider:

int i = 45,
    j = 10;

Extend this snippet by adding a suitable System.out.println(...) statement to produce the following output:

45 + 10 = 55

When changing just the values of i and j your program shall still produce a correct output. Your complete code will thus resemble:

int i = <your first value>,
    j = <your second value>;

System.out.println(...)

This exercise is surprisingly tricky. A naive approach might read:

int i = 45,
    j = 10;

System.out.println(i + " + " + j + " = " + i + j);

This unfortunately generates an erroneous outcome:

45 + 10 = 4510

The “+” operator acts from left to right doing string concatenation rather than usual arithmetics: Both int values 45 and 10 are being transformed into strings "45" and "10" respectively. These are subsequently being concatenated into "4510" rather than being summed up into 55.

Overcoming this problem we require an additional pair of braces for partly overriding the evaluation precedence:

Code	int i = 45, j = 10; System.out.println(i + " + " + j + " = " + (i + j));
Result	45 + 10 = 55

Figure 73. Identifier in Java™:

Variable names.
Class names
Method names, e.g.:

public static void main(String [] args)

Figure 74. Identifier name examples:

Identifier rules	Legal	Illegal
Start with a letter, “`_`” or “`$`” May be followed by letters, digits, “`_`” or “`$`” Must not match a reserved keyword or literal	`$test` `_$` `count` `blue`	`2sad` `switch` `true`

Figure 75. Java™ keywords.

Reserved keywords

abstract  char      else     if          long       return        this      while
assert    class     enum     goto        native     short         throw     _ (underscore)
boolean   const     extends  implements  new        static        throws  
break     continue  final    import      package    strictfp       transient  
byte      default   finally  instanceof  private    super         try  
case      do        float    int         protected  switch        void  
catch     double    for      interface   public     synchronized  volatile

Reserved boolean and null literal values

true   false   null

Contextual keywords

exports  non-sealed opens    provides  requires  to          uses  when  yield
module   open       permits  record    sealed    transitive  var   with

Figure 76. Variable naming conventions

Start with a small letter like africa rather than Africa.

Use “camel case” e.g. myFirstCode.

Do not start with _ or $.

exercise No. 11

Legal variable names

Which of the following names are legal variable names? If so, would you actually use them in your code?

Complete the following table and explain your decision with respect to the “Language Fundamentals” / “variables” section of [Kurniawan] .

Identifier	Legal? (yes / no)	Explanation / remark
`for`
`sum_of_data`
`sumOfData`
`first-name`
`ABC`
`42isThesolution`
`println`
`B4`
`AnnualSalary`
`"hello"`
`_average`
`ανδρος`
`$sum`

Tip

You may want to prepare a simple Java™ program testing the above names.

Consider:

int 42isThesolution = 6; // Syntax error on token "42", delete this token

Unfortunately this message does not explain the underlying cause: It does not hint towards an illegal identifier name.

One indication of a sound compiler implementation is its ability to provide meaningful, self explanatory error messages:

Identifier	Legal? (yes / no)	Explanation / remark
`for`	no	“for” is a Java keyword.
`sum_of_data`	yes	-
`sumOfData`	yes	-
`first-name`	no	Operators like “-” or “+” must not appear in variable names.
`ABC`	yes	Discouraged by «Best practices» if non-constant (`final`): Non-constant variables should start with lowercase letters.
`42isThesolution`	no	Identifiers must not start with a number.
`println`	yes	`println` is a method's name but is no Java™ keyword.
`B4`	yes	See «ABC» above.
`AnnualSalary`	yes	See «ABC» above.
`"hello"`	no	String delimiters must not be part of an identifier.
`_average`	yes	Discouraged by «Best practices»: Identifier starting with «_» should be reserved for system code.
`ανδρος`	yes	Perfectly legal Greek Unicode characters.
`$sum`	yes	Discouraged by «Best practices»: Identifier starting with «$» should be reserved for system code.

Figure 77. Constant variables

Modifier final prohibits changes:

final double PI = 3.1415926;
...
PI = 1.0; // Compile time error: Constant cannot be modified

Note

final variables by convention are being capitalized

Figure 78. Case sensitivity

Variable names are case sensitive:

int count = 32;
int Count = 44;
System.out.println(count + ":" + Count);

Resulting output:

32:44

Figure 79. Define before use

Correct:

double f;
f = -4.55;

Wrong:

f = -4.55;
double f;

Figure 80. Type safety

int i = 2;
int j = i;   // o.K.: Assigning int to int
long l = i;  // o.K.: Widening conversion

i = l;       // Wrong: Narrowing

boolean b = true;
i = b;       // Error: int and boolean are incompatible types
i = 4.3345   // Error: Cannot assign double to int
i = "Hello"; // Even worse: Assigning a String to an int

Figure 81. Compile time analysis

`byte b127 = 127; // o.K., static check byte b128 = 128; // Wrong: Exceeding 127`	Performing static range check
`int a = 120; byte b120 = a; // Error Incompatible types // Required: byte // Found:int`	No static check on `int` variable's value

exercise No. 12

Benefits of `final`

We reconsider our code from Figure 81, “Compile time analysis ”:

int a = 120;

byte b120 = a; // Error Incompatible types
               // Required: byte
               // Found:int

Adding the final modifier solves the issue:

final int a = 120;

byte b120 = a;  // o.K.

Why does adding a final modifier solve the fatal compile time error issue?

Tip

Read Static program analysis.

Modifying variable a to become final assures its initially assigned value will never change. Thus from a Data-flow analysis point of view these two snippets are equivalent:

final int a = 120;

byte b120 = a;

byte b120 = 120;

The final modifier enables the compiler to perform a compile time range check assuring the value of 120 to be within the interval [-128, 127] at all times.

Figure 82. Type inference (JDK™ 10)

var count = 30; // o.K., type can be inferred from int literal
        
var index;      // Wrong: No way to infer type here.
index = 3;

Figure 83. Forcing conversions by cast

long l = 4345;

int i = (int) l; // Casting long to int
System.out.println("i carrying long: " + i);

double d = 44.2323;
i = (int) d; // Casting double to int
System.out.println("i carrying double: " + i);

i carrying long: 4345
i carrying double: 44

Figure 84. Watch out!

long l = 3000000000000000L;
int i = (int) l;
System.out.println("i carrying long:" + i);

double d = 44300000000000.0;
i = (int) d;
System.out.println("i carrying double:" + i);

i carrying long:-296517632
i carrying double:2147483647

Figure 85. Casting long to int

‹›

Figure 86. Casting double to short

double measurement = 65234.5435;

/* A cast forcing double to short conversion */
short velocity = (short) measurement;
System.out.println("Velocity = " + velocity);

Uups:

Velocity = -302

Figure 87. «C» programming language “liberal” assignment policy:

#include <stdio.h>

void main(void) {
  double measurement = 65234.5435;

  /* assigning double to short, no cast required */
  short velocity = measurement;
  printf("Velocity = %d", velocity);
}

Uups:

Velocity = -302

Figure 88. Consequences

Development costs:

~$7 billion.

Rocket and cargo

~$500 million.

«C» vs. Java.

We reconsider the «C» code example from Figure 87, “«C» programming language “liberal” assignment policy: ”:

#include <stdio.h>

void main(void) {
  double measure = 65234.5435;
  short velocity = measure;
  printf("Velocity=%d\n", velocity);
}

Rewrite the same code in Java. Replace printf("Velocity=%d\n", velocity) by a System.out.println(...) statement. Answer the following two questions:

You will encounter a compile time error not being present in »C«. Try to overcome it.

Tip

Read Object Type Casting in Java.

After your correction the result will be -302 like in the »C« snippet. On contrary for a related double to int conversion the overflow behaviour is different:

Code	Output
double d = 3000000000.0; // Larger than Integer.MAX_VALUE int i = (int) d; System.out.println(i); // Result: Integer.MAX_VALUE	2147483647

This time we get an int's maximum value representing the closest possible value to 3000000000.0.

If the velocity = measure assignment was behaving accordingly we should see an outcome of Short.MAX_VALUE or 32767 rather than -302.

Explain this different behaviour.

Tip

Read 5.1.3. Narrowing Primitive Conversion.

Naively rewriting the »C« snippet in Java™ yields a compile time error:
```
double measure = 65234.5435;
short velocity = measure; // Error: Incompatible types. Required: short, Found: double
System.out.println(velocity);
```
Resolving this error requires a type cast:
```
double measure = 65234.5435;
short velocity = (short) measure; // Explicit double to short conversion, possible data loss
```
Note

This resolves the syntax error. However the overflow problem when converting a double 65234.5435 into a short of -302 still prevails.

The referenced specification reads:

A narrowing conversion of a floating-point number to an integral type T takes two steps:

In the first step, the floating-point number is converted either to a long, if T is long, or to an int, if T is byte, short, char, or int as follows:

...
In the second step:
- If T is int or long, the result of the conversion is the result of the first step.
  
  This is the behaviour for double to int.
- If T is byte, char, or short, the result of the conversion is the result of a narrowing conversion to type T (§5.1.3) of the result of the first step.
  
  This is the behaviour for double to short.

So behind the scenes the velocity = (short) measure assignment is being decomposed into two steps:

double → int conversion:

double measure = 65234.5435;
int velocityInt = (int) measure;

Since fractions are just cut off rather then being rounded this results in velocityInt carrying a value of 65234 .

int → short conversion:

Code

// Conversion loss when casting decimal 65234 four byte two complement
//  00000000_00000000_11111110_11010010 into two byte two complement
//                    11111110_11010010 or decimal -302

short velocity = (short) velocityInt;  

System.out.println("velocityInt = " + velocityInt + ", velocity = " + velocity);

Result

velocityInt = 65234, velocity = -302

exercise No. 14

Assignment and type safety

We consider:

int i = -21;
double d = i;

This snippet shows correct Java™ code. However Figure 80, “Type safety ” suggests we should not be allowed to assign an int to a double value due to type safety.

Even worse: Swapping types yields a compile time error:

double d = 2.4;
int i = d; // Error: Incompatible types

Questions to answer:

Explain on syntax level why is d = i is allowed but i = d causes an error? Hint: Read about widening and narrowing conventions.
Whats the ratio behind this design decision? Hint: What would happen for larger double values?

The first code snippet uses the widening conversion: When assigning d = i the Java™ compiler implicitly converts a four byte int into an eight byte double value.

In contrast there is no automated narrowing from double to int hence causing a compile time error.
Turning a double into an int is more cumbersome: The expression e.g. i = 3.5 could be evaluated by agreeing on a specific rounding prescription. But what about e.g. i = 3457357385783573478955345.45 ? A Java™ int's maximum value is $2^{31} - 1$ unable to accommodate the double value in question by far.

Conclusion: Java™ disallows double to int assignments unless using a so called cast (explicit type conversion):

Caveats using explicit casts:

double d = 2.6;
int i = (int) d; // Explicit cast double to int
System.out.println("Result: " + i);

Result: 2

Notice the result of 2 rather than 3 as you might have expected assuming common rounding convention rules. Rounding does not happen unless you explicitly use methods like e.g. Math.round().

double d = 3_000_000_000.;
int i = (int) d; // Explicit cast double to int
System.out.println("Result: " + i);

Result: 2147483647

This truncation of 3 billion to 2147483647 is due to the latter value being the largest possible int value to be represented in Java™.

Java™ provides meta information on types:

exercise No. 15

An `int`'s minimum and maximum value

In this exercise we look at an int's the largest and smallest (negative) possible value.

A Java™ int is internally being represented by 4 bytes. ${00000000_00000000_00000000_00000101}_{2}$ for example represents the decimal value 5.

Java™ implements negative values using Two's complement representation. We provide some values:

Table 1. 4 Byte Two's complement representation of int values.

Two complement representation	Decimal representation
`00000000_00000000_00000000_00000000`	0
`11111111_11111111_11111111_11111111`	-1

Use int literals in binary representation like e.g. 0B1100 in order to write an int's minimum and maximum possible value to standard output.

int minimum = 0B... , //TODO: provide values by
    maximum = 0B...;  // binary int literals

System.out.println("Minimum:" + minimum);
System.out.println("Maximum:" + maximum);

Tip

You may get some inspiration from Figure 57, “3 bit two-complement representation ” and Figure 59, “Signed 8 bit integer binary representation ”.

We insert Two's complement representations of minimum and maximum int values according to Table 1, “4 Byte Two's complement representation of int values.”.

int minimum = 0B10000000_00000000_00000000_00000000,
    maximum = 0B01111111_11111111_11111111_11111111;

System.out.println("Minimum int value:" + minimum);
System.out.println("Maximum int value:" + maximum);

BTW: The JDK™ does provide maximum value, minimum value and related information for char, byte, short and int primitive data types within their corresponding Character, Byte, Short and Integer classes. You may want to execute:

System.out.println("int minimum:" + Integer.MIN_VALUE);
System.out.println("int maximum:" + Integer.MAX_VALUE);

System.out.println("int byte count:" + Integer.BYTES);
System.out.println("int size:" + Integer.SIZE);

Figure 90. Dynamic typing in PERL

$test = 44;  # Assigning an int
print $test, "\n";

$test = "Jim"; # Assigning a string
print $test, "\n";

$cmp = 43.55; # A float

if ($test == $cmp) { # comparing string against float
   print "Equal\n";
} else {
   print "Different\n";
}

44
Jim
Different

Figure 91. Dynamic typing in PERL, part 2

$a = 2; # An integer
$b = 3; # Another integer

print '$a + $b = ', $a + $b, "\n";

$jim = "Jim";         # A string
print '$jim + $a = ' , $jim + $a, "\n";

$a + $b = 5
$jim + $a = 2

Figure 92. Using final

//Bad!
double pi = 3.141592653589793;
...
pi = -4; // Woops, accidential and erroneous redefinition

//Good
final double PI = 3.141592653589793;
...
PI = -4; // Compile time error:
         // Cannot assign a value to final variable 'pi'

Figure 93. Reference type examples

GpsPosition start = new GpsPosition(48.7758, 9.1829);
String name = "Simon";
LocalDate birtday = LocalDate.of(1990, Month.JULY, 5);

Prev	Up	Next
Primitive types	Home	Literals

Language Fundamentals

Variables

The sum of two values

Legal variable names

Tip

Note

Benefits of final

Tip

«C» vs. Java.

Tip

Tip

Note

Assignment and type safety

An int's minimum and maximum value

Tip

Benefits of `final`

An `int`'s minimum and maximum value