git-fork ( Git GUI Client )

 https://git-fork.com/

https://marcus116.blogspot.com/2019/09/git-git-client-fork.html

rapidAPI

 https://rapidapi.com/blog/access-global-weather-data-with-these-weather-apis/

https://docs.rapidapi.com/docs/php-1

curl不只是個別字母的意義，更有它自己的source code

 https://curl.se/

https://github.com/curl/curl

※curl的definition：

curl is a tool to transfer data from or to a server, using one of the supported protocols (DICT, FILE, FTP, FTPS, GOPHER, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET and TFTP). The command is designed to work without user interaction.

curl offers a busload of useful tricks like proxy support, user authentication, FTP upload, HTTP post, SSL connections, cookies, file transfer resume, Metalink, and more.

※curl 學習完成的指令：

1. get response:
   curl <site_url>
   same as
   curl -X GET  <site_url>
2. 下載指定圖片
   curl -o <customed_fileName> <image_url>
3. post
   curl -X POST -H "Content-Type: application/json" -d '{"name" : "Jack"}' "http://localhost:8080/post/"
4. put
5. delete
   這是執行delete方法的那個後端程式指定路徑中的function handler，如果handler裡沒有寫刪除檔案是不會刪除的！

https://blog.techbridge.cc/2019/02/01/linux-curl-command-tutorial/

※POST 的請求頭content-type：

HTTP 協議是以 ASCII 碼 傳輸，創建在 TCP/IP 協議之上的應用層規範。規範把 HTTP 請求分為三個部分：狀態行、請求頭、消息主體。

協議規定 POST 提交的數據必須放在消息主體（entity-body）中，但協議並沒有規定數據必須使用什麼編碼方式。Content-type 一般只存在於 Post 方法中，因為 Get 方法是不含 “body” 的，它的請求參數都會被編碼到 url 後面，所以在 Get 方法中加 Content-type 是無用的。

→所以POST取得傳入的資料用req.body.xxx
→所以GET取得傳入的資料用req.query.xxx

1. application/x-www-form-urlencoded
   最常見 POST 提交數據的方式，瀏覽器的原生 <form> 表單，如果沒有設置 enctype 屬性，就會以默認以此方式提交數據。
   Content-Type 被指定為 application/x-www-form-urlencoded；其次，提交的數據按照 key1=val1&key2=val2 的方式進行編碼，key 和 val 都進行了 URL 轉碼。大部分服務端語言都對這種方式有很好的支持。
2. multipart/form-data
   我們使用表單上傳文檔時，必須讓 form 的 enctyped 等於這個值。
   
3. application/json
   由於 JSON 規範的流行，越來越多人把它當作 header。
   可以方便的提交複雜的結構化數據，特別適合 RESTful 的接口。各大抓包工具如 Chrome 自帶的開發者工具、Firebug、Fiddler，都會以樹形結構展示 JSON 數據。但也有些服務端還沒有支持這種方式，例如 php 就無法通過 $_POST 對象從上面的請求中獲得內容。需要自己手動處理下：在請求頭中 Content-Type 為 application/json 時，從 php:// input 裡獲得原始輸入流，再 json-decode 成對象。
4. text/xml
   XML-RPC （XML Remote Procedure Call）協議簡單、功能夠用，各種語言的實現都有。它的使用也很廣泛，但已經逐漸被上面幾種方法取代。

總結：

Post 請求數據的時候有兩種，傳 json 的話就是 application/json，不傳 json 的話就是 application/x-www-form-urlencoded，傳文件的話用 multipart/form-data

reference: https://medium.com/@des75421/post-%E8%AB%8B%E6%B1%82%E9%A0%AD-content-type-82b93f9230f7

devicePixelRatio

 https://developer.mozilla.org/zh-CN/docs/Web/API/Window/devicePixelRatio

chrome extension 開發~~有趣

chrome extension api reference: https://developer.chrome.com/docs/extensions/reference/

這篇說明得很好:

https://medium.com/%E9%BA%A5%E5%85%8B%E7%9A%84%E5%8D%8A%E8%B7%AF%E5%87%BA%E5%AE%B6%E7%AD%86%E8%A8%98/%E7%AD%86%E8%A8%98-%E5%BE%9E%E9%9B%B6%E9%96%8B%E5%A7%8B%E8%A3%BD%E4%BD%9C-chrome-%E5%A5%97%E4%BB%B6%E5%88%B0%E4%B8%8A%E6%9E%B6%E5%95%86%E5%BA%97-4971ed79ac77   

注意: 在套件中每使用一個 API，就需要先在 manifest 檔案裡請求使用該 API 的權限

基本需要的檔案有以下幾個：

1. manifest.json

2. background.js

3. content.js

4. images/image16.png    ( 用於右鍵選單中的項目icon 或 瀏覽器右上的套件顯示，亦可設定不同圖片)

5. popup.html 點開瀏覽器右上的icon時跳出的彈出窗

上架流程： https://developer.chrome.com/docs/webstore/publish/ 
簡單的說：
1. 須建立一個開發者帳戶，
2. 需繳一次性費用5美金/可上架20個extension)
3. 套件在正式被發佈到商店前，可能需要經過一系列的審查(為加快審查速度，有較基本的兩點可注意 a. 程式碼是否有好的可讀性與功能性（Performance Evaluation）b. 套件請求的權限範圍是否已盡可能最小化)

下面這個好像是firefox才用的，興趣缺缺

https://developer.mozilla.org/zh-TW/docs/Mozilla/Add-ons/WebExtensions/Your_first_WebExtension

https://developer.mozilla.org/zh-TW/docs/Mozilla/Add-ons/WebExtensions/Your_second_WebExtension

ssr 生命週期時間

ssr: 

beforeCreate

watch immediate

created

client端:

beforeCreate, beforeCreate client

watch immediate, watch immediate client

created, created client

mounted, mounted client

在本身就是client端的mounted加上client沒有意義，它會根據程式寫的順序由上到下執行

※有空測他們和上面那些比較它們的時機是?

computed取得資料在head之後

cookie是在client端才拿到的，head不可使用它

trailing slash 前端也可以自己轉址

 https://www.npmjs.com/package/@nuxtjs/redirect-module

Java Udemy 學習筆記3--functional programming:

• functional programming:  they are first class citizen(就是個歷史稱呼)
  compare to structure programming(just like for loop), functional programming have two points:
  1. don't have mutation variable
  2. tell what to do, not how to do
• cheesy: adj 俗氣的
  
• lambda expression:  匿名函式

In Java, what are the advantages of streams over loops? [closed]

Interesting that the interview question asks about the advantages, without asking about disadvantages, for there are are both.

Streams are a more declarative style. Or a more expressive style. It may be considered better to declare your intent in code, than to describe how it's done:

 return people
     .filter( p -> p.age() < 19)
     .collect(toList());

... says quite clearly that you're filtering matching elements from a list, whereas:

 List<Person> filtered = new ArrayList<>();
 for(Person p : people) {
     if(p.age() < 19) {
         filtered.add(p);
     }
 }
 return filtered;

Says "I'm doing a loop". The purpose of the loop is buried deeper in the logic.

Streams are often terser. The same example shows this. Terser isn't always better, but if you can be terse and expressive at the same time, so much the better.

Streams have a strong affinity with functions. Java 8 introduces lambdas and functional interfaces, which opens a whole toybox of powerful techniques. Streams provide the most convenient and natural way to apply functions to sequences of objects.

Streams encourage less mutability. This is sort of related to the functional programming aspect -- the kind of programs you write using streams tend to be the kind of programs where you don't modify objects.

Streams encourage looser coupling. Your stream-handling code doesn't need to know the source of the stream, or its eventual terminating method.

Streams can succinctly express quite sophisticated behaviour. For example:

 stream.filter(myfilter).findFirst();

Might look at first glance as if it filters the whole stream, then returns the first element. But in fact findFirst() drives the whole operation, so it efficiently stops after finding one item.

Streams provide scope for future efficiency gains. Some people have benchmarked and found that single-threaded streams from in-memory Lists or arrays can be slower than the equivalent loop. This is plausible because there are more objects and overheads in play.

But streams scale. As well as Java's built-in support for parallel stream operations, there are a few libraries for distributed map-reduce using Streams as the API, because the model fits.

Disadvantages?

Performance: A for loop through an array is extremely lightweight both in terms of heap and CPU usage. If raw speed and memory thriftiness is a priority, using a stream is worse.

Familiarity.The world is full of experienced procedural programmers, from many language backgrounds, for whom loops are familiar and streams are novel. In some environments, you want to write code that's familiar to that kind of person.

Cognitive overhead. Because of its declarative nature, and increased abstraction from what's happening underneath, you may need to build a new mental model of how code relates to execution. Actually you only need to do this when things go wrong, or if you need to deeply analyse performance or subtle bugs. When it "just works", it just works.

Debuggers are improving, but even now, when you're stepping through stream code in a debugger, it can be harder work than the equivalent loop, because a simple loop is very close to the variables and code locations that a traditional debugger works with.

• The operations which return another stream as a result are called intermediate operations and the operations which return non-stream values like primitive or object or collection or return nothing are called terminal operations.
• functional interface: Predicate, Consumer, Function
• predicate: verb 斷言，結果true or false
• Method reference: 可以用在static method 和instance method
• multiThreading 讓CPU知道同時去執行程式
  
• parallelism: noun 並行性
• utilization: 使用率
• 有兩種方法可以做多執行續：
  1. extends Thread class
      (1) 在override run裡寫上要這個執行續執行的內容
      (2) 在呼叫這個class執行時必須用start方法，而非run方法
  2. implements Runnable interface
• 執行續有幾種狀態：
  1. new: 準備好了，但還沒start()
  2. runnable: start()了，但別的thread正在執行
  3. running: 正在執行
  4. blocked/ waiting: 等待外部服務給予response或database回應太慢或等待其他thread的資料
  5. terminated/ dead: thread中的程式全部執行結束
• setPriority() // 有1最小，5是default，10最大。須注意priority只是個請求，不見得真的會這樣執行，一個設最小，一個設最大，這樣去執行也大概只有50%的機率他真的符合。感覺就是沒用阿~
  
• .join()  // waits for the thread to die
• miscellaneous: adj 繁雜的
• yield: verb 讓步，讓位
• Thread有兩個static method:
  1. Thread.sleep(milisecond);
  2. Thread.yield(); // 讓出CPU，但這只是個請求，不見得會這樣執行。
• synchronized method 一次只能有一個thread在裡面執行。其他想執行的thread必須waiting。在Collection相關的class裡有許多方法是synchronized的，所以為了不讓thread有問題，出現了cocurrent Collections。
• executor service
  ExecutorService executorService = Executors.newSingleThreadExecutor(); //一次只會執行一個thread
  executorService.execute(new Task1());
  executorService.execute(new Thread(new Task2()));
  
  ExecutorService executorService = Executors.newFixedThreadPool(2); // 限制一次可以執行的Thread數量
  executorService.execute(new Task1());
  executorService.execute(new Thread(new Task2()));
  
  executorService.shutdown();  //最後要記得加上，否則會一直開著
• callable:adj 可召回的
• 如果多執行續想要有回傳值，需用implements Callable的class

class CallableTask implements Callable<String> {

String name;

CallableTask(String str) {

this.name = str;

}

@Override

public String call() throws Exception {

// TODO Auto-generated method stub

Thread.sleep(1000);

return "Hello " + name;

}

}

public class CallableRunner {

public static void main(String[] args) throws InterruptedException, ExecutionException {

ExecutorService executorService = Executors.newFixedThreadPool(2);

Future<String> welcomeFuture = executorService.submit(new CallableTask("David"));

// Future is not really a result, it's a promise that there will be a result. So

// after that, we need to use get()

System.out.println("new completed");

String welcomeMsg = welcomeFuture.get(); // Once we call a get() method on the Future, then this would wait for the task to complete execution.

System.out.println(welcomeMsg);

System.out.println("main down");

executorService.shutdown();

}

}

• exception handling
• gobble up: verb ph 吞噬
• Stack Trace: error且沒有ExceptionHandling 時，error msg從第二行開始會說明error來自哪一行，最上面是發生error的那一行，往下是觸發那一行的程式，...
  

        如果不處理error，在error之後的程式將不會執行。12行發現錯誤，且他沒有辦法處理，則回傳給6行，6行也不會處理，而他又是main，所以終止於error。

        處理了exception handling，在throw error以下的程式也不會執行！

• flowery: adj 華而不時的 (文字或話語)、文謅謅的

                try {

String a = null;

a.length();

System.out.println("method1 end");

} catch (Exception e) {  // Exception是一個class

e.printStackTrace();  // 如果這邊不做處理，那就是直接吞掉錯誤訊息

} finally {  

                    System.out.println("Here always excecutes");

                }

try {

String str = "456";

str.toString();

return;  // 造成just before close scanner印不出來

} catch (Exception e) {

e.printStackTrace();

} finally {

System.out.println("close");

}

System.out.println("just before close scanner");

結果印出close 而已，不論有沒有error，有沒有return，finally一定會執行

• finally不執行的狀況只有：
  1. 在finally中的程式出現error
  2. JVM crashes:
      System.exit(1);會造成，但別試，會造成entire application terminate，電腦會壞掉！
• fishy:adj 可疑的
• dicey: adj 有風險的，不確定的
• Exception Hierarchy
  1. class Error extends Throwable {} 
      //  Error是開發者無法處理的錯誤，You can prevent but not handle them
      //  例如: JVM is out of memory, or think about a stack overflow error.
      //  要注意不要create這個Error才對
  2. class Exception extends Throwable {}  
      //  Exception才是開發者可以處理的錯誤，所以這才是開發者要注意的錯誤
• recursion: noun 遞規
• Exception有兩種：
  1. class InterruptedException extends Exception {}
      //  checked exceptions，表示risky， 任何出checked exception的都要處理它
  2. class RuntimeException extends Exception {}
      //  unchecked exceptions，這個不是很risky
      //  class NullPointerException extends RuntimeException{}
  
• I'll put it on the back burner. （尤指因不緊急或不重要而）暫時擱置一旁
• Whenever you throw checked exception, your method need to tell that in its signature(即需要宣告這個method會throw err). Or get error msg "Unhandled exception type Exception"
• Exception本身也屬於checked exceptions 因為它有包含到~
  
• cumbersome: adj 累贅的、低效的

try{

}catch( IOException | SQLException e ){ // can define multiple exceptions in a block

e.printStackTrace();

}

• Never hide Exceptions
• Do not use it for flow control, like redirect traffic, if...else
• Spring framework makes most of the exceptions as RuntimeExceptions, so who use method don't need to consider exception!
• Having global exception handling.
• Make sure that in main method, you are not throwing exception to the outside world.
• cakewalk:noun 輕而易舉的事
• counter is not atomic
• Atomic是指不能分割成若干部分的意思
• concurrency:並發
• lock:

https://www.cnblogs.com/dolphin0520/p/3923167.html  ↓

我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

　　1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

　　2）线程执行发生异常，此时JVM会让线程自动释放锁。

　　那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。

　　因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

　　再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

　　但是采用synchronized关键字来实现同步的话，就会导致一个问题：

　　如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

　　因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。

• ConcurrentHashMap is Concurrent Collection.
• Concurrent Collection offer thread-safety without significant performance impact in specific scenarios.
• algorithm: noun 演算法
• CopyOnWrite 每次的修改都會複製一個新的出來，非常耗能，但thread-safety，建議用在read very much, but modify very few。他只在修改的方法上用synchronized，get方法沒有，而因為修改都會建新的，所以thread-safety
• java.lang import by default
• allocate: verb 分配
• takeaway:noun 主要資訊
• 當override equals()也要override hashCode() // 這個不懂為什麼要
• access modifiers: 
  
  關於class:
  1. private: 不可以用在class
  2. public: 在自己的和別的package裡都可以new它
  3. (default) 就是什麼都不加: 在自己的package裡都可以new它
  4. protected: 不可以用在class
  
  關於method和variable(兩者是一樣的觀念):
  1. private: 只能在同個class使用
  2. public: 在不同個package，也可以使用public method
  3. (default) 在同個package下都可用
  4. protected: 在同個package or subclass下都可用
  
  enforce Encapsulation
• non-access modifier
  
  關於class:
  5. final: 不能再被extend. Like wrapper class
  
  關於method和variable(兩者是一樣的觀念):
  5. final: 
         method: 不能再被override
         variable: 只能設定初始值
         argument: 不能重設初始值，其實好的編程本來就不會去重設argument啦(不論有沒有加final)
     到底什麼時候用final呢?實際上推薦所有的method and variables都用，這就是所謂immutable programming，這讓code容易被理解。當然實際上不可能所有的都是final，但我們會試圖達到這樣的編程。
  6. static:
        讓method 可以直接被className呼叫，但須注意在static method裡不可以調用非static variable or method。例子有List.of() , Collections.sort()。
        讓variable shared across all instances!
• public static final int CONSTANTNAME = value; // 這是個清楚設定constant value的寫法

• privilege: noun 特權
• nomenclature: noun 命名法
• Enumeration: Enum, 它可以有variable, constructor, method
  Enum name可以做為variable 的type
  ordinal() :即index

先去買個書，之類的了解下，再決定一下要看什麼學習

在chrome瀏覽器中的控制檯Network中size欄通常會有三種狀態: from memory cache, from disk cache, 資源本身的大小

 https://www.itread01.com/content/1544784485.html

樣式表一般在磁碟中，不會快取到記憶體中去。因為如果指令碼在磁碟當中，在執行該指令碼需要從磁碟中取到記憶體當中來，這樣的IO開銷是比較大的，有可能會導致瀏覽器失去響應

在Firefox下並沒有from memory cache以及from disk cache的狀態展現，相同的資源在chrome下是from disk/memory cache，但是Firefox統統是304狀態碼，即Firefox下會快取資源，但是每次都會請求伺服器對比當前快取是否更改，chrome不請求伺服器，直接拿過來用，這也是為啥chrome比較快的原因之一吧，當然以上是粗略的研究chrome資源的獲取策略，至於chrome如何保證資源的更新，即什麼時候200，什麼時候304還需要究

304状态码：服务端已经执行了GET，但文件未变化。

if 結果判斷

 https://docs.google.com/presentation/d/e/2PACX-1vS1g5NUzMGao-bBoU9LT2m1HlPqO2gYb3LOT0JGeg55hKW7RYpGpTjzMy-LZqRv-Hjy4kvrEvbfhMnH/pub?fbclid=IwAR1XdYsJ-ATsJDNEDt3_2p2LaJcF_KbJSKeGn6-k35hsPNQvox0v53ksUhI&slide=id.gaef0604d2a_0_2322

有些國家閱讀習慣是右到左，解法：手動修改和左右有關的css 或 安裝package

 http://www.moreonfew.com/how-to-convert-ltr-website-to-rtl-website/

瀏覽器console的方便指令

 document.designMode = 'on'

https://pjchender.blogspot.com/2017/06/chrome-dev-tools.html

Turn your Vue Web App into a PWA，教大家把網頁轉成PWA

https://www.youtube.com/watch?v=15Yr-J4X34M

https://whatwebcando.today/

https://app-manifest.firebaseapp.com/  製作manifest

registerserviceworker.js  為用戶在本地建立serviceworker以儲存資源，提升訪問速度

1. vue add @vue/pwa   (會裝上@vue/cli-plugin-pwa)

2. register-service-worker

amplitudejs:  Design your web audio player, the way you want.    https://521dimensions.com/open-source/amplitudejs

https://github.com/521dimensions/amplitudejs

The Web App Manifest is a JSON document that provides application metadata for Progressive Web Apps. Use the form below to generate the JSON file and optionally upload an app icon.

https://www.webnoob.dev/articles/turn-your-vue-web-app-into-a-pwa  教學

https://developers.google.com/web/tools/workbox   其實service worker背後的機制是來自Workbox

https://developer.mozilla.org/zh-TW/docs/Web/Manifest   Manifest-MDN

https://cli.vuejs.org/core-plugins/pwa.html#configuration   @vue/cli-plugin-pwa

build 出來的precache-manifest.e3b607af8fbd9cd138ce9d19eb88214a.js，就是他precache住的資源，所以之後要載入時可以非常快速

開發者工具中的lighthouse 可以產生關於PWA, SEO, Acessibility,...在你的網站中的評價報告，可以算是順便檢測網站問題

apple目前還不支援PWA

優勢減少手機開發成本

service worker提升網頁加載速度

service worker只在https才可用

service worker可以在offline時運作

service worker實際上不是存在於chrome tab

有三種cache策略：
1. cache first: like Google Fonts
2. network first: like Twitter API ( need to always get the latest post )
3. stale-while-revalidate: like css, js (會先驗證是不是新的檔案再決定要不要下載)

教學中還未提及的有background fetch, background sync, ...

快速建置行動和Web 應用程式| AWS Amplify | Amazon Web ...

a

ws.amazon.com › amplify

AWS Amplify 可協助前端Web 和行動開發人員建置安全、可擴充的完整堆疊應用程式。支援iOS、Android、JavaScript、Flutter 及React 等。
(還不知道AWS Amplify 是什麼，之後可以看看)  (在教學影片的45:44提到)

Java Udemy 學習筆記2--variable argument

• variable argument:   //  可變數量參數：參數數量不被限制，以陣列形式傳入。但必須注意variable argument必須為最後傳入的argument
  void print(int... hi){
     System.out.println(Arrays.toString(hi));
  }
  print(1,2)  //  [1,2]
  print(1,2,5,8)  //  [1,2,5,8]
• 陣列一旦生成，就不能修改陣列的長度，想增加只能create new Array，再把舊的複製到新的。但很麻煩，所以出現了ArrayList來處理( 它是collections的一部份 )
• ArrayList arrayList = new ArrayList();
  ArrayList.add(value)
  ArrayList.remove(value or index)
  
  ArrayList<Integer> arrayList = new ArrayList<Integer>();  // 限制型別為Integer，必須為完整大寫
• System.out.println(objectName);
  並在class裡添加
  public String toString() {   //  固定將它放在mehods的最後一個
    return <classData>;
  }
  這樣就能印出classData
• revise: verb 學習
• elaborate: verb, to add more information to or explain something that you have said
• zip code: 郵遞區號 (可以寫做Postal code)
• Object Composition: an object inside another object
• concanate: verb 把(兩件事)聯繫起來
• Inheritance: 繼承，欲使用它，必須確定兩者之間確有關係
  public class Student extends Person {   
  }
  從上面這個例子，Student( subclass )  繼承所有Person( superclass )的data和method
• ctrl+shift+R: 再輸入想要打開的fileName，就可以快速打開
• 如果class沒有繼承別的class，則會默認該class extends Object, which is a class that provides equals, toString, ... methods, is the root of the class hierarchy
• System.out.println( className );  //  事實上執行的是 System.out.println( className.toString() );
  
• Overriding: 在subclass寫入一個和superclass同名的method，最後執行時會執行subclass的
• #: 井字號唸做number sign, hash
• 在subclass裡想使用superclass的方法，可以用super.superClassMethod，想要取得data，則必需在superClass建立getData的method去取得
• constructor裡會自動在內容第一行加上super()，所以superclass的constructor必定會在subclass的之前執行。但如果要傳參數給super(para)，則必不能省略。
• public class Student extends Person {   
  }
  public class Employee extends Student {   
  }
  public class Employee extends Student, Person{   //wrong
  }
  Student stu1 = new Employee();   // ok，stu1本質上是Employee
  Employee stu2 = new Student ();  // wrong, Type mismatch: cannot convert from Student to Employee
  
  System.out.println(stu1 instanceof Employee);  // true，可以判斷該object是不是該class的實例
  // subclass 可以是superclass的實例
  System.out.println(stu1 instanceof Person);  // true
  System.out.println(stu1 instanceof Student);  // true
• Abstract: to define the basic algorithm，經常被用於製作framework(框架)，最後執行的是superclass的方法，因為這樣才會有共同的邏輯。
  abstract class Animal {
      abstract public void bark(); // abstract method沒有body，沒有definition, just declaration
  }
  class Dog extends Animal{   //欲繼承abstract必需implement method (實現抽象方法，填入body)
      public void bark() {  //  這是override
          System.out.println("bow");
      }
  }
  
  Animal cat = new Animal(); wrong, 抽象class不可以建立實例
  

public abstract class Animal {

public void execute() {  // 最後執行這個

say();

doSth();

}

abstract void say();

abstract void doSth();

}

• concrete class: adj 實際的, 具體的 class
• Interface: 結構跟Abstract有像，但是它不是要定義邏輯(內部)，而是定義它有的接口(外部)，最後執行的還是各自class下的method。
  Interface basically represents the common action s that can be performed.
  It establishes the communication agreement, it establishes the contract between two classes.
  一個是要有哪些方法
  一個是要來執行上面這個class
  
  有了interface，可以將決定好的interface給外包，讓外包去實現。例如有個interface是取的兩地間通行的時間，自己團隊在做利用飛機的通行時間，而把利用火車的通行時間包給別人
  
  implement相同interface的表示他們有相同的action，但是他們之間可能沒有關係，例如鳥跟飛機--飛的動作
• outsource: verb 外包
• dummy:noun 假
• polymorphism: noun 多型，多個相同名稱的程式，傳入不同的參數，會執行不同的動作，ex: for loop
• Abstract 和 Interface都可以在裡面建立data和一般method，在interface裡的method要加上default，有了default就不用在implements該interface的class裡再寫override。
  
• Abstract class implement interface不必override method，當然最後真的寫concrete的class時還是需要
• Interface
  1. interface彼此可以繼承
  2. interface裡的data一定要給予初始值。
  3. default method的用法: 使該method不用在implements該interface的class裡再寫override。default method一定要有body~
  
• Interface和abstract class的不同
  1. Interface所有的data跟方法都是public，abstract class則可以有private
  2. Interface's data value can't be changed
  3. class可以implement多個interfaces，和extend abstract只能一個(但可以寫做多層的關係)，這樣才不會有多個super()
• practitioner: noun 執業者
• Collections:
  
  there are 4 basic collection's interfaces: (下面四個都會有collection的方法跟屬性)
  1. List:
      有順序，index
      可以有重複的值
  2. Set
      沒有順序，no-index
      不可有重複的值
  3. Queue
     PriorityQueue is a collection optimized for finding the tail or head value quickly, using a partially ordered tree structure called heap (look it up on wikipedia). If you pop the elements, they will be ordered. If you want to iterate, use for example a SortedSet instead, which also stores the elements sorted.
  如果沒有comparator，不要用Queue來排序！它適合用來建立排序，可有重複的值
  4. Map
      它沒有繼承collection！(但它是collection的一部份)
      它用來儲存key-value pairs
  
  ArrayList is a collection
• 儲存資料的結構有幾種：Collection, LinkedList, Hashtable, Tree
• underlying: adj 深層的
• underneath: adv 在...之下
• List<String> words = List.of("Dog","Cat","Rat");  // [Dog, Cat, Rat]，這是java 9 的新功能，在之前要建立這樣一個陣列必須先new ArrayList再add value進去
  注意List不是class，是interface，interface和class都可以放在左邊變數之前定義該變數型態，右側才是真正要建立的東西
  
  words.size()  // 3, 和ArrayList一樣要用size，這是因為ArraList就是implement List
  
  words.get(1)  //  Cat
  
  words.contains("cow");  //  false
  
  words.indexOf("Cat")  // 1
  
  words.add("Cow")  // error
  
  List<String> wordsArrayList = new ArrayList<String>(words);  // 傳入陣列 (阿...事實上右邊的<String>可以寫<>就好，因為左邊已經定義要Stirng type了
  wordsArrayList.add("Cow");    //  wordsArrayList = [Dog, Cat, Rat, Cow]
  
  
• immutable: String class, BigDecimal, Wrapper class, and anything created from of, like List.of(), or Map.of()
  mutable: ArrayList, LinkedList(連結List), Vector(向量)
• ArrayList, Vector: 底層是Array,
  優點：有index的觀念，可以快速取出想要的index資料
  缺點：插入和刪除index資料事件消耗資源大的事情(ex: 如果我想刪除中間一個元素，我要把它後面的所有元素往前移動一格)
  
  LinkedList: 底層是LinkedList
  優點：插入和刪除只會影響前後兩個連結目標( Doubly Linked )，消耗小
  缺點：用連結的方式取得資料，像git的儲存，取出資料比較慢
  
  
  
  
  
  
  
  
  
• Vector:
  大部分method都有修飾符synchronized。如果想要thread-safe，則選擇用它。
  
  ArrayList: 
  method沒有修飾符synchronized。如果不在意thread-safe、想要快速，則選擇用它。
  
  synchronized: 同步，指在多執行續下，也只有一個執行續可以在synchronized method運作。這是想要的thread-safe一個基本作法。
• List 的方法有：
  1. .add(index, value)  //  index is option
  2. .addAll(index, anotherArray)  // index is option
  3. .set(index, editValue)
  4. .remove(index or value)
  5. .get(index)
  6. .indexOf(value)
  7. .lastIndexOf(value)
  
  注意
  List<String> wordsArrayList = new ArrayList<String>(words);  
  List<String> wordsArrayList2 = new LinkedList<String>(words);  
  wordsArrayList.addAll(wordsArrayList2); 可以成功執行，因為他們都是List型別
• iterator: noun 迭代器，是確使用戶可在容器物件（container，例如鏈表或陣列）上遍訪的對象，就像for迴圈。
  Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。
  它的method就只有next 、hasNext 和 remove，所以可以說它是為了remove Array item而存在。
  调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。所以連續執行 it.next() ，就會從陣列的item一個個輪過去。
  Iterator wordsIterator = words.iterator();
  while(wordsIterator.hasNext()){
      System.out.println(wordsIterator.next());
  }
  
  這段的結果就跟用for loop印出陣列是一樣的
• 在for loop 期間，不能修改目標陣列，尤其刪除item，否則結果可能有誤。
  例如下方例子：
  for(String word:wordsArrayList){
      if(word.endsWith("at")){
            wordsArrayList.remove(word);
      }
  }
  原本wordsArrayLis 是[Dog, Cat, Rat]，執行後變成[Dog, Rat]，這結果錯誤！
  
  欲達成刪除at結尾的item，建議使用iterator:
  Iterator<String> iterator =  wordsArrayList.iterator();
  while(iterator.hasNext()){
      if(iterator.next().endsWith("at")){
           iterator.remove();
      }
  }
  結果wordsArrayList 是[Dog]
• Generics 泛型: <T> ，T means type。class寫成泛型定義，之後真正使用時要在真的定義出型態。有時候會看到<E>，那些也都是泛型。

public class ExampleArrayList<T extends Number> { // 定義泛型並限制只能是Number型態的

ArrayList<T> array = new ArrayList<>();

public void addElement(T element) {  //傳入泛型

this.array.add(element);

}

public void removeElement(T element) {

this.array.remove(element);

}

public T get(Integer index) {  // 回傳泛型

return this.array.get(index);

}

@Override

public String toString() {

return String.format("ExampleArrayList [array=%s]", array);

}

}

• 在IDE反白想確認的型態，右鍵Quick Type Hierarchy 會出現該型態的層級
  Byte, Double, Float, Integer, Long, Short are all subclasses of Number.

上面提到的是泛型class，下面來說一個泛型方法：

static <X extends List> X value(X value2){  // 限制為List的泛型

  return value;

}

通配符wildcard字元'?'在使用上配合extends(配合class)或是implements(配合 interface)

可以用來控制輸入的類型(Upper Bounded Wildcards)：

        static double sum(List<? extends Number> numbers) { // upper bounded wildcard

double sum = 0.0;

for (Number num : numbers) {

sum += num.doubleValue();

}

return sum;

}

        static void addCouplesOfValue(List<? super Number> numbers) {  // lower bounded wildcard，會限制它的subclass

numbers.add(1.0);

numbers.add(5);

numbers.add(8.3f);

numbers.add(7l);

}

• In the List, we cannot store primitives. Every item gets autoBoxed.(自動變成wrapper class)
  List array = List.of("gg",'s',5, 1.0);  // [gg, s, 5, 1.0] 
  它們的型別分別是 String, Character, Integer, Double
  
• 當有一個數字陣列，使用remove時，傳入的參數有兩種可能: 1.value的值 2. index的位置
  如果想要確定為value的值，傳入Integer.valueOf(num)或new Integer(num)，前者比較推薦，因為不會相同的值也建一個新的object
  而直接傳入就是index的位置
• Collections.sort(mutable List);  
  (mutable List).sort(comparator);  
• class AscendingStudentComparator implements Comparator<Student> {  // 這就是個簡單的comparator class
      @Override
      public int compare(Student student1, Student student2) {
          return Integer.compare(student1.getId(), student2.getId());
      }
  }
  
  而在public static void main(String[] args) {}裡就可以執行下面程式：
  (mutable List).sort(new AscendingStudentComparator());
• ArrayList<Student> studentsAl = new ArrayList<>(students);  // 建立自己的class type array
  想要排列自己的class array:  Collections.sort(studentsAl);
  需要在自己的class上implements comparable<定義型別>: public class Student implements Comparable<Student>
  並實現需要override的method:
  public int compareTo(定義型別 that) {   // 傳入的變數常稱為that
     //  sort的規則
  }  
• ascending sorting: 上升排序，簡寫Asc
  descending sorting: 下降排序，簡寫Desc
• correction: noun 更正
• immutable: String class, BigDecimal, Wrapper class, and anything created from of, like Set.of()
  mutable: HashSet, TreeSet (They are implementations of Set interface)
• Set<String> set = Set.of("cat","cat1");
  Set<String> hashset = new HashSet<>(set);
  hashset.add("cat");  //  結果不會加入，因為Set interface不可以有重複的值
  System.out.println(set)  // 印出 [cat1, cat] ，他的順序已經亂了，沒順序可言，而且還是在immutable array上
• Data Structure: (關於如何儲存資料有三種)
   1. Array
   2. LinkedList
   3. Hashing:  他試圖結合上面兩者的優點
   4. Tree: 他會把根據資料內容有序的儲存資料。例如：儲存1-100，他的排列方式必定是中間50往左愈來愈小，往右越來越大。因此他要get, serted, delete data都可以輕鬆的處理，消耗不大。

• modulo: 簡寫mod，同餘。即%，取餘數。
  被除數 a 和除數 n， a modulo n (縮寫為 a mod n)
• Hash Table
  bucket
  hashing function : 這個func決定hash table的效率、速度
  mod
  
  它的運作舉例來說：有13個bucket作為fixed position來儲存數字資料，現在有個數字15要存入，該數字十五經過hashing function處理得到它該去position。hashing function最直覺的做法就是利用Modulus(mod)取餘數。以15為例，15/13餘2，在下圖它將存入position 2的bucket中。
  
  所以他們有了位置，而一個個相同位置間的關係又像linkedList的關聯。

• hashCode(): 它就是上面提到的hashing function
• Set<Integer> numbers = new HashSet<>();  
  
  implements Set interface的有三種class：
  HashSet: 無順序、不可重複
  LinkedHashSet: 有順序、不可重複(順序是依照存入的順序)
  TreeSet: 有順序、不可重複(順序是依照value 升序)

 

                List<Character> list = List.of('A', 'E', 'C', 'A', 'H');

Set<Character> linkedHashSet = new LinkedHashSet<>(list);

System.out.println(linkedHashSet);

Set<Character> treeSet = new TreeSet<>();

treeSet.addAll(list);

System.out.println(treeSet);

• TreeSet 還implements了NavigableSet: (注意要用這個的方法，必須左邊型態是TreeSet，不能只是Set，因為這個功能是基於TreeSet的內容依照value升序排列)
  所以它多了一些可用的method
  
  1. treeSet.floor(比較的目標值) 取比目標值小的且最接近目標值的數，包含目標值
  2. treeSet.lower() 取比目標值小的且最接近目標值的數，不包含目標值
  3. treeSet.ceiling()  取比目標值大的且最接近目標值的數，包含目標值
  4. treeSet.higher() 取比目標值大的且最接近目標值的數，不包含目標值
  5. treeSet.subSet(區間起始值, 區間終止值) 取得區間範圍內的所有值 (這個值包含起始，但不含終止)
   treeSet.subSet(區間起始值, true, 區間終止值, true) 這樣寫的話就兩邊都包含
  6. treeSet.headSet(目標值) 取得在目標值之前的所有數，不包含目標值
  7. treeSet.tailSet(目標值) 取得在目標值之後的所有數，包含目標值
• implementation of map interface的class 有:
   1. HashMap
       unsorted, unordered
       allows store a key with null value
   2. HashTable
       unsorted, unordered
       synchronized -- safe thread
       not allows store a key with null value
   3. LinkedHashMap
       insertion order
       iterator insert and delete more fast
   4. TreeMap
       Besides implements Map, it also implements NavigableMap interface.
       sorted order
  
  由於它是儲存key value的，在定義型別時也就要兩個型別：
  Map<String, Integer> map = Map.of("E",5,"R",17,"A",10);  // {A=10, R=17, E=5}
• 最後來點記憶的技巧：
  1. 當看見有hash詞的class時，記得她是unordered, unserted
  2. 當看見linked詞的class時，代表它是背後是以前後相接的形式，所以ordered 適合iterator，使用hashCode()
  3. 當看見tree詞的class時，它是sorted order，並且它會implement NavigableSet or NavigableMap
• angular brackets: <>