Core Java. Lecture #2

Demo

Language keywords [JLS17, 3.9]

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

Null and Boolean Literals

             null       true        false

Restricted Keywords & Identifiers

(Java 9)
open     module      requires    transitive    exports
opens    to          uses        provides      with

(Java 10)
var

(Java 14)
yield    record

(Java 15)
sealed   non-sealed  permits

Comments

/**
 * This is the first sample program in Core Java Chapter 3
 * @version 1.01 1997-03-22
 * @author Gary Cornell
 */
public class FirstSample
{
  public static void main(String[] args)
  {
  /*multiline
  comment*/
  System
    .out //single-line comment
    .println("We will not use 'Hello, World!'");
  }
}

Types

Integer types

Varieties of integer literals

Floating point types

Literals for floating-point types

Be careful with floating point!

Numeric types compatibility

Explicit type casting

double x = 9.997F; //float to double converted implicitly
int nx = (int) x; //9
nx = (int) Math.round(x); //10

char type

char literals

String literals

String s = "Hello, world!";

//Before Java 13
String txt =
      "Some\n" +
      "  Nested\n" +
      "    Text\n" +
      "  Is\n" +
      "Here\n";

Some
  Nested
    Text
  Is
Here

Text Blocks (Java 13+)

    String txt = """
      Some
        Nested
          Text
        Is
      Here
      """;

//The maximum number of spaces ahead has been removed:
Some
  Nested
    Text
  Is
Here

Escape sequences

boolean type

Variables declaration and scope

// declaration
double salary;
int vacationDays;
long earthPopulation;
boolean done;

// not very welcomed
int i, j;

// technically possible, but . . .
int суммаНДФЛ;

Variables initialization

int vacationDays;
System.out.println(vacationDays); //COMPILATION ERROR
  // variable not initialized

int vacationDays;
vacationDays = 12;

int vacationDays = 12;

final keyword (constants)

final int a;
...
a = 42; // initialization

...
a = 43; // compilation error:
  // variable a might already have been initialized

Variable scope

int n;
. . .
{
  int k;
  int n; // Error--can't redefine n in inner block
  . . .
} // k is only defined up to here

Type inference when defining variables (Java 10+)

var i = 1; // i is of int type

Type inference

//BEFORE JAVA 10
URL codefx = new URL("http://codefx.org");
URLConnection connection = codefx.openConnection();
Reader reader = new BufferedReader(
    new InputStreamReader(connection.getInputStream()));

//AFTER JAVA 10
var codefx = new URL("http://codefx.org");
var connection = codefx.openConnection();
var reader = new BufferedReader(
    new InputStreamReader(connection.getInputStream()));

Arithmetic operators

Shifts

Don’t overdo it with shifts!!

Don’t overdo it with shifts!!

Bitwise operators

Comparison operators

Boolean operators

x != 0 && 1 / x > x + y // no division by 0

Assignment operator

int x;
System.out.println(x = 42); //prints 42

while ((n = readValue()) != null)
  ... //do something with n

Pre/post increment/decrement, assignment with change

Ternary operator

x < y ? x : y

Operators in descending order of priority

Operators in descending order of priority (continued)

//Conjunction operator has higher priority than disjunction, that's why
a || b && c
// is equivalent to
a || (b && c)

Operators in descending order of priority (continued)

//Since += associates right to left, the expression
a += b += c
//means
a += (b += c)
//That is, the value of b += c
// (which is the value of b after the addition)
//is added to a.

What about the comma operator?

if statement

if (yourSales >= target) performance = "Satisfactory";

if + block

if (yourSales >= target) { performance = "Satisfactory"; bonus = 100; }

if + block + else

if (yourSales >= target) { performance = "Satisfactory"; bonus = 100 + 0.01 * (yourSales - target); } else { performance = "Unsatisfactory"; bonus = 0; }

else is grouped with the nearest if

/* Better add curly braces!!*/ if (x <= 0) if (x == 0) sign = 0; else sign = -1;

else if chains

if (sales >= 2 * target) { performance = "Excellent"; bonus = 1000; } else if (sales>=1.5*target) { performance = "Fine"; bonus = 500; } else if (sales >= target) { performance = "Satisfactory"; bonus = 100; } else { fireThisPerson(); }

switch

switch (choice) { case 1: . . . break; case 2: . . . break; default: . . . break; }

switch-case peculiarities:

Switch Expressions

int numLetters = switch(day) {
  case MONDAY, FRIDAY, SUNDAY -> 6;
  case TUESDAY -> 7;
  case SATURDAY -> 8;
  default -> 9;
}

Switch in Java 14+: no Fallthrough

int numLetters = switch(day) {
 case MONDAY, FRIDAY, SUNDAY -> 6;
 case TUESDAY -> 7;
 case THURSDAY, SATURDAY -> 8;
 default -> 9;
}

switch(day) {
 case MONDAY, FRIDAY, SUNDAY ->
  numLetters = 6;
 case TUESDAY -> {
  logger.info("Tuesday");
  numLetters = 7;
 }
 case THURSDAY, SATURDAY ->
  numLetters = 8;
  //Need not be exhaustive:
  //no WEDNESDAY
}

Switch in Java 14+: with Fallthrough

int numLetters = switch(day) {
  case MONDAY, FRIDAY, SUNDAY:
    yield 6;
  case TUESDAY:
    logger.info("Tuesday");
    yield 7;
  case THURSDAY:
    logger.info("Thursday");
  case SATURDAY:
    yield 8;
  default:
    yield 9;
}

switch(day) {
  case MONDAY, FRIDAY, SUNDAY:
    numLetters = 6;
    break;
  case TUESDAY:
    logger.info("Tuesday");
    numLetters = 7;
    break;
  case THURSDAY:
    logger.info("Thursday");
  case SATURDAY:
    numLetters = 8;
    break;
  default:
    numLetters = 9;
}

Arrays

Declaring and initializing an array

Arrays are passed by reference

int[] luckyNumbers = smallPrimes;
luckyNumbers[5] = 12; // now smallPrimes[5] is also 12

luckyNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);
//now luckyNumbers is a separate array
//and it became twice as long

Arrays are covariant

 String[] a = new String[1];
 // Compiles. after all, a string is an object,
 // and so why not think of an array of strings as an array of objects?
 Object[] b = a;
 // runtime ArrayStoreException
 b[0] = 5;

"Multidimensional" arrays

int[][] magicSquare = { {16, 3, 2, 13}, {5, 10, 11, 8}, {9, 6, 7, 12}, {4, 15, 14, 1} }; /* magicSquare[1][2] == ?? */

Triangular matrices

double[][] odds = new double[ROWNUM][]; for (int n = 0; n < ROWNUM; n++) odds[n] = new int[n + 1]; for (int n = 0; n < ROWNUM; n++) for (int k = 0; k <= n; k++){ /* compute lotteryOdds*/ . . . odds[n][k] = lotteryOdds; }

while loop: same as in C

while (balance < goal) { balance += payment; double interest = balance * interestRate / 100; balance += interest; years++; } System.out.println( years + " years.");

Same, but not the same!

final boolean flag = false;
. . .
while (flag) {
   . . . //won't compile, unreachable code
}

do while: loop with postcondition

do { balance += payment; double interest = balance * interestRate / 100; balance += interest; years++; // print current balance // ask if ready to retire and get input } while (input.equals("N"));

for loops

for (int i = 1; i <= 10; i++)
  System.out.println(i);

for (int i = 1; i <= 10; i++, j++)
  System.out.println(i);

Scope of the cycle variable

for (int i = 1; i <= 10; i++)
{
. . .
}
// i no longer defined here

int i;
for (i = 1; i <= 10; i++)
{
. . .
}
// i is still defined here

Using break and continue

while (years <= 100) {
  balance += payment;
  double interest = balance * interestRate / 100;
  balance += interest;
  if (balance >= goal) break;
  years++;
}

Scanner in = new Scanner(System.in);
while (sum < goal) {
  System.out.print("Enter a number: ");
  n = in.nextInt();
  if (n < 0) continue;
  sum += n; not executed if n < 0
}

We don’t have goto, but there are labels for break and continue!

Scanner in = new Scanner(System.in);
int n;
// label is here!
read_data: while (. . .) {
  . . .
  for (. . .) {
    System.out.print("Enter a number >= 0: ");
    n = in.nextInt();
    if (n < 0)
      break read_data;
      // break out of read_data loop
    . . .
   }
}
if (n < 0) {
  // deal with bad situation
} else {
  // carry out normal processing
}