• Language Fundamentals
  • ➟ Integer, ASCII and Unicode

5. Hotel key cards

• Language Fundamentals
  • ➟ Primitive types

6. Literal samples
7. Literals of type int
8. Integer overflow
9. Strange sum result
10. Correcting the error

• Language Fundamentals
  • ➟ Variables

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);

int a;
int b = 22;
int c;

being equivalent to either of:

int a, b = 22, c;  

int a,
    b = 22,  
    c;

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

Modifier final prohibits changes:

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

Variable names are case sensitive:

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

Resulting output:

32:44

11. Legal variable names

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

12. Benefits of final

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

«C» programming language miracles:

#include <stdio.h>

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

Velocity=-302

The cause of the failure was a software error in the inertial reference system.

Specifically, a 64 bit floating point number relating to the horizontal velocity of the rocket with respect to the platform was converted to a 16 bit signed integer.

The number was larger than 32,767, the largest integer possible in a 16 bit signed integer, and thus the conversion failed.

Related video explanation

13. «C» vs. Java.
14. Assignment and type safety
15. Inventing tinyint.
16. An int's minimum and maximum value

//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'

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

• Language Fundamentals
  • ➟ Literals

System.out.println("35 as Binary (Base 2):       " + Integer.toString(35, 2));
System.out.println("35 as Ternary (Base 3):      " + Integer.toString(35, 3));
System.out.println("35 as Octal (Base 8):        " + Integer.toString(35, 8));
System.out.println("35 as Hexadecimal (Base 16): " + Integer.toString(35, 16));

results in:

35 as Binary (Base 2):       100011
35 as Ternary (Base 3):      1022
35 as Octal (Base 8):        43
35 as Hexadecimal (Base 16): 23

17. Pretty may not be pretty
18. Strange output

System.out.println(1000000000);    // o.K.
System.out.println(2147483647);    // o.K.: Largest int value 2^31 - 1

System.out.println(10000000000L);  // o.K.: Using type long
System.out.println(10000000000 );  // Compile time error: Integer number
                                   // larger than 2147483647 or 
                                   // 2^31 - 1, Integer.System.out.println("i carrying double: " + i))

System.out.println("Hello");     // A String literal

System.out.println(33452);       // An int literal

System.out.println(34.0223);     // A double (floating point) literal

System.out.println(2147483648L); // A long literal

System.out.println("Value 1: " + 29);
System.out.println("Value 2: " + 0b11101);
System.out.println("Value 3: " + 0x1D);
System.out.println("Value 4: " + 035);

Value 1: 29
Value 2: 29
Value 3: 29
Value 4: 29

19. Poor mans ASCII table
20. Integer value hexadecimal representation
21. Binary literals
22. Testing the limits (Difficult)
23. Why using braces in System.out.println(...) ?
24. Composing strings of literals and variables
25. Escaping double quotes
26. Supplementary string exercises

int year = MMXIV; // Roman numerals representation

System.out.println("Olympic winter games: " + year);

Could this happen?

Olympic winter games: 2014

• Language Fundamentals
  • ➟ Arithmetic limitations

byte count = 91;   // o.K.

int i = 91;

byte count2 = i;   // Compile error: Incompatible types
                   // Required: byte Found: int

byte points = 130; // Compile error: Incompatible types
                   // Required: byte Found: int

final int i = 91;

byte count = i;   //  o.K.

float float2Power31 = Integer.MAX_VALUE + 1f; // 2^31

float floatDoubleMAX_VALUE = 2 * float2Power31 * float2Power31 - 1f; // 2^63 - 1

System.out.format( "   Float value: %f\n", floatDoubleMAX_VALUE);
System.out.println("Expected value: "   +  Long.MAX_VALUE);

Result:

   Float value:  9223372036854776000.000000
Expected value: -9223372036854775807
------------------------------------------
    Difference:                  193

• Language Fundamentals
  • ➟ Conversions

byte   b = 42;  // Narrowing: constant int literal to byte
short  s = b;   // Widening
int    i = s;   // Widening
long   l = i;   // Widening
float  f = l;   // Widening
double d = f;   // Widening

double d = 14.23;
float  f  = (float) d;  // Narrowing
long   l  = (long)  f;  // Narrowing
int    i  = (int)   l;  // Narrowing
short  s  = (short) i;  // Narrowing
byte   b  = (byte)  s;  // Narrowing

27. int and char
28. float vs. double
29. int to char narrowing problems
30. Get a byte from 139
31. Ariane, I miss you!
32. Reducing long to int (difficult)

• Language Fundamentals
  • ➟ Operators and expressions
    • ➟ Arithmetic and logical operators

33. Calculating a circle's area
34. Dividing values
35. Strange things with operator ++
36. Adding values
37. Representational float and double miracles

try {
    int sum = Math.addExact(2147480000, 2147480000);
    System.out.println("sum = " + sum);
} catch (ArithmeticException ex) {
    System.err.println("Problem: " + ex.getMessage());
}

Problem: integer overflow

double f = 34.3 / 0;
System.out.println("Value: " + f);

Value: Infinity

Watch out: “Silent” error!

38. Expressions involving infinity

Get a division's remainder:

// Fair distribution of nuggets
// among gold diggers
int nuggets = 11,
    diggers = 3;

System.out.println("Nuggets per digger: " + nuggets / diggers);
System.out.println("Remaining nuggets: " + nuggets % diggers);

Nuggets per digger: 3
Remaining nuggets: 2

byte a = 1, b = 2;

byte sum = a + b; // Error: Incompatible types. ❶
                  // Required: byte
                  // Found: int

39. int to short assignment
40. int to short assignment using final
41. Calculating a circle's area avoiding accidental redefinition
42. Turning weeks into seconds
43. Turning seconds into weeks
44. Using predefined Java™ standard library constants
45. Converting temperature values
46. Time unit conversion
47. Interest calculation
48. Summing short and char

Boolean “and” of two operands:

boolean examSuccess = true,
        registered = false;

boolean examPassed = examSuccess & registered;

System.out.println("Exam passed:" + examPassed);

Exam passed:false

49. Operator & vs. &&

• Language Fundamentals
  • ➟ Operators and expressions
    • ➟ Assignment operators

Increment variable by right hand value:

int a = 4;

a = a + 2;

System.out.println("Value:" + a);

int a = 4;

a += 2;

System.out.println("Value:" + a);

Value:6

50. Strange addition

Logical and operation:

boolean examSuccess = true,
        registered = false;

examSuccess = examSuccess & registered;

System.out.println(
  "Exam success:" + examSuccess);

boolean examSuccess = true,
        registered = false;

examSuccess &= registered;

System.out.println(
  "Exam success:" + examSuccess);

Exam success:false

51. Understanding +=

• Language Fundamentals
  • ➟ Operators and expressions
    • ➟ Unary operators

52. Three ways expressing the same

53. Guessing results
54. Cleaning up the mess

• Language Fundamentals
  • ➟ Comments

int strength = a /* fixed value */ + b /* age */ + c /* courage */;

being run-time equivalent to:

int strength = a + b + c;

/**
 * Describing rectangles. ❶
 */
public class Rectangle {

  /**
   * Setting a rectangle's width.
   *
   * @param width The rectangle's new width. ❷
   *          ▲
   *          ┗━━━━━━━━━━━━━━━━━┓
   */                           ▼
  public void setWidth(double width) {
      // Implementation yet missing
  }
  ...
}