JAVA

簡介

1. 面向物件的特征主要有哪些：

   • 封裝

   • 繼承

   • 多型

   • 抽象

2. 輸入，輸出

   1. 輸出：System.out.println("Hello");

   2. 輸入：

   
   //在Java中的輸入需要使用Scanner的物件讀取來自System.in的輸入，Scanner類在包java.util中，使用時須匯入：
   
   import java.util.Scanner;
   
   Scanner物件中常用的獲取用戶輸入的方法有：
   
       String nextLine();
   
       boolean nextBoolean();
   
       short nextShort();
   
       int nextInt();
   
       long nextLong();
   
       double nextDouble();
   
       
   
       Scanner input = new Scanner(System.in);
   
       System.out.print("請輸入圓的半徑");
   
       double radius = input.nextDouble();
   
       double area = radius*radius*3.14;
   
       System.out.println("圓的面積是："+area);
   
   

3. 識別符號的組成：

   1. Java識別符號由：字母，數字，下劃線，美元符號\(組成，并且只能以字符，下劃線，\)開頭，

   2. 識別符號是大小寫敏感的并且未規定最大長度

   3. 識別符號不能是Java關鍵字或者保留字

4. 資料型別：程式設計語言描述事物，物件的方法，Java資料型別分為基本型別和參考型別兩大類，

   1. 基本型別

      • 整數型別：byte，short，int，long

      • 浮點型別：float，double

      • 字符型別：char

      • 布爾型別：boolean

   2. 參考型別：

      • 類

      • 介面

      • 陣列

      • 列舉

   3. Java是一種強型別語言，這就意味著必須為每一個變數宣告一個型別，在java中，一共有8種基本型別：4種整數型別，2種浮點型別，1種字符型別，一種布爾型別，

      • byte：1位元組

      • short：2個位元組

      • int：4個位元組

      • long：8個位元組

      • char：2個位元組

      • boolean：1個位元組

      • float：4個位元組

      • double：8個位元組

      • （默認10000000表示-128）

5. 常量的定義：

final int NUM = 12;
//常量一旦被初始化，就不能再改變值
```1. java種支持的運算子
![](image.png)1. 型別轉換：

   1. 隱式轉換：int n = 5;double f = n;

   1. 強制轉換：double f = 5.5;int n = \(int \)f;

   1. 資料型別按容量大小排序：byte\-\-short\-\-char\-\-int\-\-long\-\-float\-\-double

## 陣列

1. 陣列的初始化：陣列只是宣告的話，JVM并沒有給陣列分配記憶體空間，在使用陣列前還需要對其進行初始化（即為其分配記憶體空間），給陣列元素分配記憶體并未陣列元素賦初始值的程序稱為陣列初始化，
1. 靜態初始化

int ids[] = {1,2,3}

int ids[] = new int[4];
for(int i = 0;i<3;i++){
ids[i]=i;
}

int i = ids[0];

   1. 宣告：

1.int[][] ids;

2.int [] ids[];

3.int ids[][];

   1. 靜態初始化

   ```

   int num [][] = {{1,2},{3,4}};

   ```1. 動態初始化

   ```

   String[][] names = new Stirng[3][4];

   ```
1. Arrays類的引入

1. 常用方法

1.copyOf：實作陣列的賦值

2.fill：可以為陣列填充相同的值

   Arrays.fill(names,"Hello!");

3.sort：實作陣列的排序

   Arrays.sort(names);

   Arrays.sort(names,0,3); //對第一個到第四個進行排序

4.binarySearch：實作排序后的陣列元素查找

5.copyOfRange();

   int[] b = Arrays.copyOfRange();

List

str.add("Hello!");

## 類和物件

1. 封裝：將屬性（資料）和處理這些屬性的行為結合起來，僅對外公開介面以達到資訊隱藏的目的，

1. 繼承：在軟體開發種，若已有類A，要創建類B，而類A和B屬性，行為基本相同，則只需要在A的基礎上增加些新內容即可，提高了代碼的重用率，提高了編程的效率，

1. 多型：同一個操作作用于不同的類的物件，將產生不同的執行結果，

1. new是一個關鍵字，它為新創建的物件開辟記憶體空間，用于保存物件的成員變數和成員方法

## 類和繼承

1. final修飾的類不能有派生類，String是典型的例子
1. Object類是所有java類的頂級基類，
1. 繼承程序：

1. 吸識訓類成員：派生類把基類全部的成員接收過來

1. 增加派生類成員：這部分內容是派生類對基類功能的擴展，要根據需要仔細考慮應當增加那些成員，在宣告派生類時，一般還應當自己定義派生類的構造方法，因為構造風法時不能從基類繼承的，

1. 調整基類成員：隱藏同名基類成員，

1. 方法重寫的規則：

   1. 重寫的方法回傳值型別時基類方法回傳值型別的子類或者相同

   1. 重寫的方法具有相同的方法名

   1. 重寫的方法引數串列必須相同

   1. 不能重寫被標記為final的方法

   1. 重寫的方法不能縮小訪問權限，

   1. 不能重寫基類私有的方法，

1. 基類的參考可以指向派生類的物件：向上轉型

   1. 好處：可以使用派生類強大的功能，可以抽取基類的共性，

   1. 指向派生類物件的基類的參考可以呼叫基類中定義的屬性和方法

   1. 指向派生類的基類的參考不能呼叫派生類中定義而基類中沒有定義的方法，
1. 包：命名空間，避免命名沖突，

1. 包的名稱就像是我們的姓，而class名稱就像是我們的名字，

1. 如果希望自己的類從屬于一個包，可以使用package關鍵字

package com.baidu.www;

## 抽象類和介面

1. abstract修飾的類稱為抽象類，抽象類的特點：

1. 不能實體化物件

1. 類中可以定義抽象方法（abstract修飾的方法）

1. 抽象類中可以沒有抽象方法
1. 抽象類和介面

1. 介面中的方法默認修飾符為public abstract

1. 介面中所有的屬性的修飾符默認為public static final;

1. 介面和抽象類的區別：

   * 抽象類描述的是“是不是”的問題，而介面描述的是“有沒有”的問題

   * 介面只有定義，不能有方法的實作，抽象類可以有定義和實作，方法可以在抽象類中實作，

   * 介面interface，抽象類abstract，

   * 實作介面的關鍵字implements，繼承抽象類的關鍵字為extends，一個類可以實作多個介面，但是一個類只能繼承一個抽象類，
1. abstract修飾的方法稱為抽象方法，抽象方法只有方法的宣告而沒有方法的實作，即沒有方法體，包含抽象方法的類本身必須是被宣告為抽象的，
1. 抽象類的繼承：派生類繼承抽象類必須實作抽象類中所有的抽象方法，否則派生類也必須定義為抽象類，
1. Java中介面是一系列方法的宣告，是一些方法特征的集合，介面可以看做事一種特殊的抽象類，其中包含常量和方法的宣告，而沒有變數和方法的實作，
1. 介面的定義：

interface Test{
int compareTo();
}

1. 介面的實作

class Student implements 介面名{
...
}

1. 抽象類

   * 不能實體化，但是可以宣告抽象類的參考，

   * 包含抽象方法的類必須定義為抽象類

   * 不包含抽象方法的類不一定不是抽象類

   * 抽象方法不含方法體，必須顯式定義為abstract

   * 抽象類的派生類必須實作基類的所有抽象方法
1. 介面

   * 彌補Java單一繼承機制的不足

   * 不能實體化，但是可以宣告介面變數

   * 包含常量和方法的宣告，不包含變數和方法的實作（常量可以沒有final修飾，但是必須初始化，在介面實作類中不能修改值，方法可以沒有abstract，在交界口裂實作類中必須實作）

   * 介面中的抽象方法不能有方法體

   * 介面不能繼承類
1. Object類：所有Java類的祖先，每個類都可以使用Object作為基類，所有物件都是先這個類的方法，

   1. 在不明確給出超累的情況下，Java會自動把Object作為要定義類的超類，

   1. 可以使用型別為Object的變數指向任意型別的物件，

   1. Object類有一個默認構造方法public Object（），在構造派生類實體時，都會先呼叫這個默認構造方法，

   1. Object類的變數只能用作各種值的通用持有者，要對他們進行任何專門的操作，都要知道他們的原始型別并進行型別轉換，

Object obj = new MyObject();

MyObject x = (MyObject)obj;

   1. Object（）：默認構造方法

   1. clone（）：創建并回傳此物件的一個副本

   1. equals（Object obj）：指示某個其他物件是否與此物件相等，

   1. finalize（）：當垃圾回收期確定不存在對改物件更對的運用時，由杜希昂的垃圾回收器呼叫此方法，

   1. getClass（）：回傳一個物件運行時類，

   1. hashCode（）：回傳該物件的哈希碼值

   1. notify（）：喚醒在此物件監視器上等待的單個執行緒，

   1. notifuAll（）：喚醒在此物件監視器上等待的所有執行緒，

   1. toString（）：回傳該物件的字串表示

   1. wait（）：導致當前的執行緒等待，直到其他執行緒呼叫此物件的notify或者notifyAll方法，

   1. equals方法：用于測驗某個物件是否和另一個物件相等，它在Object類中的實作是判斷兩個物件是否指向同一塊記憶體區域，

      * String中重寫了equals方法，判斷物件的值是否相同，==判斷地址是否相同，

   1. toString方法：

      * Object類的toStirng方法回傳一個字串，該字串由類名（物件是海內的一個實體），at標記符@和此物件哈希碼的無符號十六進制表示組成，

      ```

      getClass().getName()+"@"+Integer.toHexString(hashCode())

      ```

## 多型

1. 一個對外介面，多個內在實作方法
1. 向上轉型：就是基類參考指向派生類物件，既可以使用派生類強大的功能，也可以抽取基類的共性，
1. 在運行時期，將根據person這個物件參考實際的型別來獲取對應的方法，所以才有多型性，對于基類中定義的方法，如果派生類中重寫了該方法，那么基型別別的參考將會呼叫派生類中定義的這個方法，
1. 對于派生類中定義而基類中沒有的方法無法呼叫，

## 包裝器類

1. 概念：Java中的八種基本資料型別本身只能表示一種資料，為了能將基本型別是為物件來處理，并能鏈接相關的方法，Java為每個基本型別提供了包裝類，
1. Java的八種基本資料型別對應的包裝器類分別為Byte，Short，Character，Integer，Long，Float，Double，Boolean，
1. 創建包裝器型別的物件：

1. Java可以直接處理基本資料型別，但是在有些情況下需要將其作為物件來處理，這時就需要將其轉化為包裝器型別，在一定的場合，運用Java包裝器類來解決問題，能大大提高編程效率，

1. 創建的兩種方法

1.Integer i = new Integer(1);

2.Double d = Double.valueOf(3.14);

物件一旦賦值，其值將不能再改變，

![](image.png)

## 內部類

1. 內部類是定義在另一個類中的類，也稱內置類或者嵌套類
1. 特點：

1. 內部類是一種編譯時的語法，編譯后生成的兩個類是獨立的兩個類，（對于一個名為other的外部類和其內部定義的名為inner的內部類，編譯完成后出現other.class和other$inner.class兩個類）

1. 內部類可以訪問外部類的任何成員（包括私有成員），但是外部類不能直接訪問內部類的成員，

1. 內部類可為靜態，可以用procected，private修飾，而外部類只能使用public和預設的包訪問權限，

1. 用內部類定義再外部類中不可訪問的屬性，這樣就可以再外部類中實作了比外部類的private還要小的訪問權限，
1. 內部類的形式：

1. 成員內部類

   * 作為外部類的一個成員存在，與外部類的屬性，方法并列，內部類和外部類的實體變數可以共存，

   * 在外部類中使用內部類首先在外部類中new出內部類，

1. 區域內部類

   * 區域內部類不能宣告為介面

   * 想要使用區域內部類時，需要生成外部類物件，通過外部類物件呼叫外包方法，在方法中才能呼叫區域內部類，

1. 匿名內部類

   * 匿名類沒有類名，它必須繼承一個類或者時實作一個介面，不能有顯式的extends和implements子句，

1. 靜態內部類

   * 靜態內部類定義在類中，在任何方法之外，使用static定義，

## static修飾符

1. 靜態屬性特點：

* 宣告為static的屬性也被稱為類屬性，

* 當創建一個物件時，并不產生static屬性的拷貝，

* 該類所有的實體共享同一個static屬性

* 在類裝載時，只分配一塊存盤空間，蘇頗有此類的物件都可以操控此存盤空間，
1. 訪問形式：

1. 通過類名.共有靜態屬性名

1. 通過物件名.共有靜態屬性名
1. 使用規則：

1. 在靜態方法中，僅能直接呼叫其他的static型別的方法，

1. 在靜態方法中，只能直接訪問static型別的屬性，

1. 在靜態方法中，不能以任何方式使用this或者super，

1. 靜態代碼塊盡在該類貝介在時執行一次，

1. 涉及到繼承的時候，會優先初始化父類的static代碼塊，然后是子類的靜態代碼塊，
1. 總結：

1. static表示“全域”或者“靜態”的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全域變數的概念，

1. 被static修飾的成員變數和成員方法獨立于該類的任何物件，他不依賴特定的實體，被類的所有實體共享，

1. static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用，但是不餓能在其他類中通過類名來直接參考，

1. 用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）加載類時，就會執行該代碼塊，

## 列舉

1. 定義

enum enum_name{num1,num2,num3}
定義星期的列舉：
enum day{monday,tuesday,wensday,thursday,friday}
使用
day.monday

## 例外和斷言

1. 例外分為兩大類：

   * Error：描述了Java運行系統中的內部錯誤以及資源耗盡錯誤，唯一的解決方法：盡力使程式安全的終止，

   * Exception：程式中需要關注的，1.運行時例外，在Java虛擬機正常運行期間排除的例外，由程式錯誤導致，Java編譯器允許程式中不對這類例外做出處理，2.其他例外：一般都是外部錯誤，Java編譯器要求在程式中必須處理這類例外，
1. 小結：

   1. 系統自動排出的例外：所有系統定義的編譯和運行例外都可以由系統自動拋出，稱為標準例外，并且Java強烈要求程式進行完整的例外處理，給用戶友好的提示，或者修正后使程式繼續執行，

   1. 陳述句拋出的例外：用戶程式自定義的例外和應用程式特ing的例外，必須借助于throws和throw陳述句來定義拋出的例外，

   1. throw和throws的區別：

      * throws陳述句用在方法宣告后面，表示該方法會拋出哪些例外，使它的呼叫者知道要捕獲這些例外

      * throw陳述句用在方法體內，表示拋出例外，是具體向外拋例外的動作，它拋出一個例外實體，

      * throws表示出現例外的一種可能性，濱海不是一定會發生這些例外；throw則是跑出來例外，執行throw則i頂跑出來某種例外，
1. 斷言：assert

   1. 當需要在一個值為FALSE時中斷當前操作的話，可以使用斷言，

   1. assert后買你跟著冒號運算式，如果冒號之前為true，則冒號后面的被忽略，否則拋出AssertionError，錯誤內容為冒號后面的文字，

## JDK8中的日期

1. Java中用于表示日期的類：Date類，Calendar類
1. 日期的格式化和決議：

   * DateFormate

   * SimpleDateFormate
1. java\.time:

   * 瞬時時間：Instant

   * 年月日：LocalDate

   * 時間：LocalTime

   * 年月日時間：LocalDateTime
1. java\.time.format

   * DateTimeFormatter
1. Instant類\-\-\-時間戳

   * 獲取當前時間，類似于java.util.Date:

      * Instant now = Instant.now\(\);

      * Instant t = Instant.ofEpochSecond\(100\)

   * 和Date的轉換

      * Date\.from\(now\);

      * new Date\(\).toInstant\(\);
1. LocalDate類

   * LocalDate類只有年月日部分，沒有小時分鐘秒

   * 實體化

      * LocalDate today = LocalDate.now\(\);

      * LocalDate christmas = LocalDate.of\(2018,12,25\);
1. LocalTime

   * LocalTime類只有小時分鐘秒，沒有年月日

   * 實體化：

      * LocalTime now = LocalTime.now\(\);

      * LocalTime zero = LocalTime.of\(0,0,0\);//00:00:00

      * LocalTime mid

## 字串，日期

1. 字串常量類：String

   * String物件一經賦值，其值不可修改

   * 指的是所指向的記憶體值不可修改，但是指向可以修改
1. 字串變數類：StringBuffer，StringBuilder

   1. 構造方法初始化

String name = new String("Hello!");

String name = "Hello!";

   * String str = "a"; 這個只是一個參考，記憶體中如果有“a"的話，str就指向它；如果沒有，才創建它;

   

     如果你以后還用到"a"這個字串的話并且是這樣用：

   

     String str1 = "a"; String str2 = "a"; String str2 = "a"; 這4個變數都共享一個字串"a"，

   

     

   * 而String str = new String\("a"\);是根據"a"這個String物件再次構造一個String物件，將新構造出來的String物件的參考賦給str，

1. String類是final的，無法被繼承，
1. 字串分割決議類：StringTokenizer
1. String類：

1. 出于安全考慮，String類實作了值的不可變

1. String中常用的字串處理方法：

   * 字串連接：concat（String str）/“\+”運算子

   * 字串查找：

      1. indexOf（String str）；

      1. lastIndexOf（String str）；

      1. charAt（int indexOf）；

      1. startsWith（String prefix）；

   * 字串分割：

      1. split（String regex）字串分割

      1. compareTo（String str）字串比較

      1. equalslgnoreCase（String str）忽略大小寫

   * 字串替換：

      1. replace（char oldChar，char newChar）

   * 字串求子串

      1. substring（int beginIndex，int endIndex）

   * 字串大小寫轉換

      1. toUpperCase（）小寫轉大寫

      1. toLowerCase（）大寫轉小寫
1. StringBuffer類

1. StringBuffer類是一個字串變數類

   * StringBuffer物件的值可以修改

   * 主要用于對字串做大量修改的操作時

1. StringBuffer變數的初始化：

   * 構造方法初始化

   * StringBuffer stringBuffer = new StringBuffer（“Hello”）；

1. StringBuffer類中常用的方法：

   * 字串連接：append（Object obj）；

   * 字串洗掉：delete（int start，int end）；

   * 字串插入：insert（int offset，Object obj）；

   * 轉換為String物件：toString（）；
1. StringBuilser類：

1. StringBuilder類和StringBuffer類的呼叫是一致的，

1. StringBuilder類和StringBuffer類的區別：

   * StringBuffer是執行緒安全的

   * StringBuilder是非執行緒安全的
1. StringTokenzier類

1. StringTokenizer類主要用途是將字串以界定符為界，分析為一個個獨立的token（單詞）

1. StringTokenizer中的定界符可以自己指定，

1. StringTokenizer常用的方法：

   * hasMoreTokens：是否有更多的分隔符

   * nextToken：回傳下一個分隔符前的內容值
1. 日期的格式化：

1. Java中用于表示日期的類

   * Date類

   * Calendar類

1. 日期的格式化和決議

   * DateFormate

   * SimpleDateFormate

1. Date類

   1. java\.util.Date類實際上是一個包裹類，它包含的是一個長整型資料，表示的是從GMT1970年1月1日00：00：00這一刻之前或者之后經歷的毫秒數

   1. Date類提供了兩個多載的構造方法

      * Date\(\)：以本地當前時間構造一個Date物件，

      * Date（long date）：以距離基準時間的毫秒數構造Date物件，

      ```

      Date date = new Date();

      System.out.println(date.getTime)

      ```

1. Calendar類

1. 日歷類，Calendar類定義了足夠的方法來表述日歷的規則

1. Calendar是一個抽象類，Java中提供了Calendar的一個具體的實作類GregorianCalendar

1. Calender和Date的轉換

   1. 從一個Calendar物件中獲取Date物件

   ```

   Calendar calendar6

   ```1.

標籤：Android

上一篇：Android 自定義View手寫簽名并保存圖片

下一篇：還記得第一個看到的Flutter組件嗎？