core_java11_fundamentals/lesson3.md

# Lesson 3: Fundamental Programming Structures in Java

## 3.1 Write a simple Java program

```java
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.:

```java
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

```Java
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

```java
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: 

```java
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

```java
Scanner in = new Scanner(System.in);
```

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

```java
int age = in.nextInt();
```

* Need to add import statement:

```java
import java.util*
```

### Terminal output (formatted)

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

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

Just for formatting string (not output)

```java
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

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

* Writing to a file using PrintWriter constructor

```java
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

```java
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](Core_JAVA_Volume1/corejava/v1ch03/Retirement/Retirement.java)
* Do while statement: do before check condition. e.g. [Retirement2.java](Core_JAVA_Volume1/corejava/v1ch03/Retirement2/Retirement2.javas)
* For loop: e.g. [LotteryOdds.java](Core_JAVA_Volume1/corejava/v1ch03/LotteryOdds/LotteryOdds.java)
* Switch statement
* `break` statement; 
* `continue` statement will skip remaining and jump to next iteration


Used to breaks out of a loop

```java
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`

```java
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`
```java
BigInteger a = BigInteger.valueOf(100000000);
```
* Use methods such as `add` and `multiply` to combine big numbers. You cannot use math operator on object
```java
BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));
```

e.g. as shown in [BigIntegerTest.java](Core_JAVA_Volume1/corejava/v1ch03/BigIntegerTest/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]`

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

* Or use `for each` loop, e.g.

```java
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](Core_JAVA_Volume1/corejava/v1ch03/LotteryDrawing/LotteryDrawing.java)

### Multidimensional Arrays

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

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

* Without initializer:

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

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

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

e.g. as shown in [CompoundInteres](Core_JAVA_Volume1/corejava/v1ch03/CompoundInterest/CompoundInterest.java)

**Ragged array** (each row does not has same number of elements) as shown in [LotteryArray.java](Core_JAVA_Volume1/corejava/v1ch03/LotteryArray/LotteryArray.java)