core_java11_fundamentals/lesson3.md

Lesson 3: Fundamental Programming Structures in Java

3.1 Write a simple Java program

public class FirstSample
{
    public static void main(Sting[] args)
    {
        System.out.println("We will not use 'Hello, World!'")S
    }
}

• Java is case sensitive: Main is not main

• Keywords public, static, etc.

• Braces {} are used for blocks

• Statements end in semicolons ;

• Everything is inside a class. (i.e. everything is class). Creating second class is similar.

• By convention, class names are CamelCase

• Source file must be called FirstSample.java

• System.out.println(<str>);

  • System.out. is an object
  • println is an method of System.out

• General structure: object.method(parameters)

• Parentheses needed even if there are no parameters: System.out.println();

Comment in Java

• Single line: //
• Multiple line: /* new line */
• Documentation comments: /** documentation lines */
• comments does not nest

3.2 Work with numeric data type

Data Type

Integer

Four Integer types

Type	byte number	description
int	4	-2,147,483,648 to 2,147,483,648
short	2	-32,768 to 32,768
long	8
byte	1

When writing number, there are Number Literals

• Long: 400000000L
• Hex: 0xCAFE
• Binary: 0b1111_0100 use _ to s

Floating type

Two Floating types:

Type	byte number	Description
float	4
double	8

Floating Literal:

• float literals: 0.5F
• Only use float if a library requires it
• Special values Double.POSITIVE_INFINITY, Double.DEGATIVE_INFINITY, Double.NaN

char Type

• Originally used to describe Unicode char with UTF-8 encoding. But now unicode has grow to UTF-16. So, every unicode char requires 1 or 2 char:
  • e.g. "U+1D546"
• Avoid char unless you know what it is
• Char literal enclosed in single quotes. e.g. 'A'
• Special unicode. e.g. \n, or \u2122 (for trade mark symble)

Bool Type

• 2 values: false, true.
• No conversion btw int and boolean

Totally Java has 8 primitive types:

• int, long, short, byte
• double, float
• char
• boolean

Variable

• Java is strongly typed language. Every variable must be declared with type (like C, C++): int VacationDays
• Initialization is optional: int vacationDays = 12;
• Declaration can happen everywhere, recommanded to be declare along first use
• Can assign new value with = operator
• Constant declared with final: final int vacationDays = 12;

Math Operations & Functions

• Arithmetic: +, -, *, /
• Integer division and modulus: / and %
• Using function from Math class:
  • Math.sqrt(x) for square root
  • Math.pow(a,b) a power of b
  • Math.floorMod(a,b) like a%b
  • Trig and log functions: Math.sin()

Conversion between types are possible, as long as they don't loss information. Otherwise explicit convert use casts e.g.:

double x = 9.997;
int nx = (int) x;
int rx = (int) Math.round(x)

More Operations

• Combining assignment with operators: n+=4
  • -=, *=, /=, %=
• Increment, decrement: n++, n--
• Relational operators: ==, !=, <, <=, >, >=
• Boolean operators: &&, ||, !
• Bitwise operators: &, |, ^, >>, >>>, <<
• Conditional operator: x<y ? x:y, if true, then x; if false, then y

Enumerated (枚举) Types

• A type with restricted set of values. e.g. enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE}
• Can declare variable of this type: Size z = Size.MEDIUM
• Variable of type s can only hold size values or null; So much safer for coding

Java 9 New Feature: JShell Tips

• Shift+Tab, V fills in variable declaration
• Shift+Tab, I fills in import declaration

Java 10 New Feature: Local Type Interference

• Can use var instead of type for local variable: var counter = 0;
• Still strongly types: counter = 0.5; will lead to error as can't assign a double to int
• Useful for unwieldy (complicated) type names: var traces = Thread.getAllStackTraces(); // a Map<Thread,StackTraceElement[]>

3.3 Work with Strings and API documentation

String Manipulation

• String = a sequence of Unicode characters.
• Enclosed in double quotes: `"Java\u2122"
• It's instance of String class

Substring

• Use substring method to extract substrings
  • Position start at zero: 0,1,2,3...
  • Last position is excluded: exclude 3rd char
  • Position are code units

String gretting = "Hello"
String s = greeting.substring(0,3); // return "Hel"

String Concatenation

• Concatenation (+) joins strings
• If one operand is not a string (e.g. int), it's cast to string characters

String expletive = "Expletive";
String PG13 = "deleted";
String message = expletive + PG13;

More about Strings

• String are immutable: greeting.substring(0,3) or greeting + "!" does not change greeting. As the object itself is not changed, it only return a new object
• Can be reassigned: greeting = greeting.substring(0,3)
• String comparison: "Hello".equals(greeting) or "Hello".equalsIgnoreCase(greeting)
  • Don't use ==: because == check whether it point to a same memory
• Empty string "" has length 0
• null indicates no string at all.

Code Points and Code Units

• s.length() = number of code units (not Unicode characters)
• s.charAt(i) = ith code unit
• Slice string to get ith code point:

int index = s.offsetByCodePoints(0,i);
int cp = s.codePointAt(index);

• To get all code points: int[] codePoints = str.codePoints().toArray();

String API

• There are many useful String methods
• trim yield a new string
• toLowerCase
• etc.

3.4 Write programs that read input & produce output

Terminal input

• Read console input from a Scanner
  • System.in by itself used as system console, but cannot read in

Scanner in = new Scanner(System.in);

• Scanner object has methods nextLine, next, nextInt, nextDouble to read input:

int age = in.nextInt();

• Need to add import statement:

import java.util*

Terminal output (formatted)

• Use printf for formatted printing:
  • f for floating-point, d for integer, s for string, etc.

System.out.printf("Price:%8.2f", 10000.0/3.0); // Print Price: 3333.33

Just for formatting string (not output)

String message = String.format("Hello, %s. Next year, you'll be %d", name, age);

Read/Write File

Same as terminal input/output. Just use object to deal with file

• Read from a file

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

• Writing to a file using PrintWriter constructor

Printwriter out = new PrintWriter("myfile.txt", "UTF-8");
out println(...);

• Require packages import java.io, java.nio.path
• Need to tag main, for compilation error catching

public static void main(String[] args)
{
  Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");
}

3.5 Use the control flow constructs of the Java

• If statement.
• While statement: check condition first. e.g. Retirement.java
• Do while statement: do before check condition. e.g. Retirement2.java
• For loop: e.g. LotteryOdds.java
• Switch statement
• break statement;
• continue statement will skip remaining and jump to next iteration

Used to breaks out of a loop

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

We can always replace break by placing remainder insider if

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

3.6 Work with big numbers when arbitrary precision is required

• If precision of int or double not enough, use BigInteger or BigDecimal
• Turn an int into a BigInteger

BigInteger a = BigInteger.valueOf(100000000);

• Use methods such as add and multiply to combine big numbers. You cannot use math operator on object

BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));

e.g. as shown in BigIntegerTest.java

3.7 Use arrays to store multiple elements of same type

Creating/Initialize Array

• Type of array of object: type[]. e.g. int[]
• Array variable declaration: int[] a;
• new operator need to create object: int[] a = new int[100];
• Array indexes are from 0 to a.length-1
• Use [] bracket to access elements: a[i]

for (int i = 0; i < a.length; i++)
{
  System.out.println(a[i]);
}

• Or use for each loop, e.g.

for (int element : a)
{
  System.out.println(element);
}

• Declare & Initialize array: int[] smallPrimes = {2,3,5,7};
• Anonymous arrays: new int[] {17,19,23,29}

Copy Arrays

• Copying array like int[] array1 = array2; will not trully copy, it only copied reference. Hence both array variables are pointing toward same memory. Changing in one will result change in another
• True copy via Arrays.copyOf(array, length) method

e.g. as shown in LotteryDrawing.java

Multidimensional Arrays

• int[][] is an array of arrays or a 2-d dimensional array:

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

• Without initializer:

int[][] magicSquare = new int[ROWS][COLUMS];

• Access element: magicSquare[1][2]
• Use loop to traverse elements

for (int[] row : magicSquare)
  for (int element : row)
    // do something

e.g. as shown in CompoundInteres

Ragged array (each row does not has same number of elements) as shown in LotteryArray.java