diff --git a/lesson3.md b/lesson3.md new file mode 100644 index 0000000..99b9c40 --- /dev/null +++ b/lesson3.md @@ -0,0 +1,394 @@ +# 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();` + * `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` + +## 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) +