摘要：由于最近一個項目需要需要學習知識學習的過程中做了一些筆記主要以知識點記錄為主現在分享出來供參考大部分內容是參考的自強學堂這里做了歸納接口在中接口可理解為對象間相互通信的協議接口在繼承中扮演著很重要的角色接口只定義派生要用到的方法但方法的具體

由于最近一個項目需要,需要學習JAVA知識,學習的過程中做了一些筆記,主要以知識點記錄為主,現在分享出來供參考.大部分內容是參考的自強學堂.這里做了歸納.
接口:

在JAVA中,接口可理解為對象間相互通信的協議,接口在繼承中扮演著很重要的角色
接口只定義派生要用到的方法,但方法的具體實現完全取決于派生類

JAVA面向對象中支持的基本概念:

封裝,繼承,多態,抽象,類,對象,實例,方法,消息解析

類:

是一個模板,它描述一類對象的行為和狀態,創建JAVA對象的模板

對象:

類的一個實例,有狀態和行為

類變量:

聲明在類中,方法體之外,但必須聲明為static類型

構造方法:

在創建一個對象的時候,至少要調用一個構造方法,構造方法的名稱必須與類同名,一個類可以有多個構造方法

創建對象:

需要三步:1.聲明,聲明一個對象,包括對象名稱和類型
         2.實例化,使用關鍵字new來創建一個對象
         3.初始化,使用new創建對象時,會調用構造方法初始化對象

public class Puppy{
    public Puppy(String name){
        //這個構造器僅有一個參數:name
        System.out.println("Passed Name is :" + name);
    }
    public static void main(String[] args){
        Puppy myPuppy = new Puppy("zhangtong");
    }
}

源文件聲明規則:

一個源文件中只能有一個public類
一個源文件可以有多個非public類
源文件的名稱應該和public的類名保持一致.
如果一個類定義在某個包中,那么package語句應該放在源文件的首行
如果源文件包含import語句，那么應該放在package語句和類定義之間。如果沒有package語句，那么import語句應該在源文件中最前面
import語句和package語句對源文件中定義的所有類都有效。在同一源文件中，不能給不同的類不同的包聲明

引用類型

引用類型變量由類的構造函數創建,可以使用它們訪問所引用的對象.
對象、數組都是引用數據類型
所有引用類型的默認值都是null
一個引用變量可以用來引用與任何與之兼容的類型

常量

是一個固定值,不需要計算,直接代表相應的值,不能改變
final double PI = 3.1415926;
常量名一般大寫
字面量可以賦給任何內置類型的變量
byte a = 68;
char a = "A";

字符串常量和字符常量都可以包括任何Unicode字符
char a = "u0001";
String a = "u0001";

轉義字符

Java支持一些特殊的轉義字符序列

 換行

 回車
f 換頁符
 退格
s 空格
	 制表符
" 雙引號
" 單引號
反斜杠
ffffd 八進制字符
uxxx 16進制unicode字符

Java支持的變量類型

局部變量, 成員變量, 類變量(靜態變量)

局部變量聲明在方法,構造方法或者語句塊中
局部變量在方法,構造方法,或者語句塊被執行的時候創建,當它們執行完成后,變量將會被銷毀
訪問修飾符不能用于局部變量
局部變量只能在聲明它的方法,構造方法或者語句塊中可見
局部變量在棧上分配
局部變量沒有默認值,所以局部變量被聲明后,必須經過初始化才可使用

實例變量聲明在一個類中,但在方法,構造方法和語句塊之外
當一個對象被實例化之后,每個實例變量的值就跟著確定
實例變量在對象創建的時候創建,在對象銷毀的時候銷毀
實例變量的值應該至少被一個方法,構造方法或者語句塊引用,使得外部能夠通過這些方式獲取實例變量的信息
訪問修飾符可以修飾實例變量
實例變量對于類中的方法,構造方法或者語句塊是可見的,一般情況下應該把實例變量設為私有.
實例變量具有默認值,數值類型的默認值是0,布爾變量的默認值是false,引用類型變量的默認值是null.

類變量以static關鍵字聲明,但必須在構造方法和語句塊之外.
無論一個類創建了多少個對象,類只擁有類變量的一份拷貝
靜態變量除了被聲明為常量外很少使用,常量是指聲明為public/private, final 和 static類型的變量,常量初始化后不可改變
靜態變量存儲在靜態存儲區,經常被聲明為常量
靜態變量在程序開始時創建,在程序結束時銷毀
與實例變量具有相似的可見性,但為了對類的使用者可見,大多數靜態變量聲明為public
靜態變量可通過: ClassName.VariableName的方式訪問
類變量被聲明為public static final類型時,類變量名稱必須使用大寫字母.
如果靜態變量不是public和final類型,其命名方式與實例變量以及局部變量的命名方式一致

訪問控制修飾符

默認的,default,在同一包內可見,不使用任何修飾符
私有的, 以private修飾符指定,在同一類內可見
共有的, 以public修飾符指定,對所有的類可見
受保護的, 以protected修飾符指定,對 同一包內的類和所有子類 可見

接口里的變量都隱式聲明為public static final,而接口里的方法默認情況下訪問權限是public
類和接口不能被聲明為private

private訪問修飾符的使用主要用來隱藏類的實現細節和保護類的數據
如果幾個相互訪問的public類分布在不同的包中,則需要導入相應public類所在的包,
由于類的繼承性,類所有的公有方法和變量都能被其子類繼承

接口的成員變量和方法不能聲明為protected

非訪問修飾符

static修飾符,用來創建方法和類變量
final修飾符,用來修飾類,方法和變量,final修飾的類不能被繼承,修飾的方法不能被繼承類重新定義,
修飾的變量為常量,是不可修改的.
abstract修飾符,用來創建抽象類和抽象方法
synchronized和volatile修飾符,主要用于線程的編程

static修飾符:
    靜態變量:
        static 關鍵字用來聲明獨立于對象的靜態變量,無論一個類實例化多少對象,它的靜態變量只有
        一份拷貝.靜態變量也被稱為類變量.
    靜態方法：
        static 關鍵字用來聲明獨立于對象的靜態方法, 靜態方法不能使用類的非靜態變量.
    對類變量和方法的訪問可以直接使用classname.variablename和classname.methodname的方式訪問.
    
final修飾符:
    final變量能被顯式地初始化且只能初始化一次,被聲明為final的對象的引用不能指向不同的對象.
    但是final對象里的數據可以被改變.也就是說final對象的引用不能改變,但是里面的值可以改變
    
    final修飾符通常和static修飾符一起使用來創建類常量
    
    類中的final方法可以被子類繼承,但是不能被子類修改
    聲明final方法 的主要目的 是防止該方法的內容被修改.
    
    
abstract修飾符
    抽象類:
        不能用來實例化對象,聲明抽象類的 唯一 目的是為了將來對該類進行擴充
        一個類不能同時被abstract和final修飾.如果一個類包含抽象方法,那么該類一定要聲明為抽象類
        抽象類可以包含抽象方法和非抽象方法
    抽象方法:
        抽象方法是一種沒有任何實現的方法,該方法的具體實現由子類提供.抽象方法不能同時被聲明為final和static
        任何繼承抽象類的子類必須實現父類的所有抽象方法,除非該子類也是抽象類
        
synchronized修飾符
    synchronized關鍵字聲明的方法同一時間只能被一個線程訪問.
    synchronized修飾符可以應用于四個訪問修飾符.

transient修飾符
    序列化的對象包好被transient修飾的實例變量時,java虛擬機跳過該特定的變量
    該修飾符包含在定義變量的語句中,用來預處理類和變量的數據類型
    一般變量被transient修飾,變量將不再是對象持久化的一部分,該變量內容在序列化后無法獲得訪問
    
volatile修飾符
    volatile修飾的成員變量在每次被線程訪問時,都強迫從共享內存中重讀該成員變量的值.
    當成員變量發生變化時,強迫線程將變化值回寫到共享內存.這樣在任何時刻,兩個不同的線程總是看到某個成員變量的同一個值.

運算符

算數運算符,關系運算符,位運算符,邏輯運算符,賦值運算符,其它運算符
條件運算符(?:),也稱為三元運算符
variable x = (expression) ? value if true : value if false
instanceOf運算符:該運算符用于操作對象實例,檢查該對象是否是一個特定類型(類類型或接口類型)

Java Number類

當需要使用數字的時候,我們通常使用內置數據類型,如: byte,int,long,double等
然鵝,在實際開發中,我們經常會遇到需要使用對象,而不是內置數據類型的情形,
為了解決這個問題,Java語言為每一個內置數據類型提供了對應的包裝類
所有的包裝類(Integer、Long、Byte、Double、Float、Short)都是抽象類Number的子類
這種由 編譯器 特別支持的包裝稱為 裝箱, 所以當內置數據類型被當作對象使用的時候,
編譯器會把內置類型裝箱為包裝類.相似的,編譯器也可把一個對象拆箱為內置類型.
Number類屬于java.lang包

Number類的成員方法
    xxxValue(): 將number對象轉換為xxx數據類型的值并返回
    compareTo(): 將number對象與參數比較
    equals(): 判斷number對象是否與參數相等
    valueOf(): 返回一個Integer對象指定的內置數據類型
    toString(): 以字符串形式返回值
    parseInt(): 將字符串解析為int類型
    abs(): 返回參數的絕對值
    ceil(): 對整形變量向左取整，返回類型為double型
    floor(): 對整型變量向右取整。返回類型為double類型
    rint(): 返回與參數最接近的整數。返回類型為double
    round(): 返回一個最接近的int、long型值
    min(): 返回兩個參數中的最小值
    max(): 返回兩個參數中的最大值
    exp(): 返回自然數底數e的參數次方
    log(): 返回參數的自然數底數的對數值
    pow(): 返回第一個參數的第二個參數次方
    sqrt(): 求參數的算術平方根
    sin(): 求指定double類型參數的正弦值
    cos(): 求指定double類型參數的余弦值
    tan(): 求指定double類型參數的正切值
    random(): 返回一個隨機數
    

Java Character類

    使用字符時,我們通常使用的是內置數據類型cahr
    然后在實際開發中,我們經常會遇到需要使用對象,為了解決這個問題,Java語言為內置數據
    類型char提供了包裝類Character類.
    
    Character類提供了一系列方法來操縱字符,可以使用Character的構造方法創建一個Character類對象
    Character ch = new Character("a");
    
Character類的成員方法
    isLetter(): 是否是一個字母
    isDigit(): 是否是一個數字字符
    isWhitespace(): 是否一個空格
    isUpperCase(): 是否是大寫字母
    isLowerCase(): 是否是小寫字母
    toUpperCase(): 指定字母的大寫形式
    toLowerCase(): 指定字母的小寫形式
    toString(): 返回字符的字符串形式，字符串的長度僅為1
    ...請參考java.lang.Character API規范
    

Java String類

在Java中字符串屬于對象, Java提供了String類來創建和操作字符串
創建字符串:
    String類有11種構造方法,這些方法提供不同的參數來初始化字符串
    
    public class Main {

    public static void main(String[] args) {
        String greeting = "Hello world!";
        char[] helloArray = {"h", "e", "l", "l", "o", "."};
        String helloString = new String(helloArray);
        System.out.println(helloString);
    }
}
注意: String類是不可改變的,所以一旦創建了String對象,那它的值就無法改變了.
    如果需要對字符串做很多修改,那么應該選擇使用StringBuffer & StringBuilder類
    
字符串長度
    用于獲取有關對象的信息的方法稱為訪問器方法
    String類的一個訪問器方法是length()方法,它返回字符串對象包含的字符數
連接字符串
    String類提供了連接兩個字符串的方法
        String s3 = string1.concat(string2);    //返回string1連接string2的新字符串
        也可對字符串常量使用concat()方法:
        String s4 = "My name is".concat("Zara");
        
        更常用的是使用"+"操作符來連接字符串
        String s5 = "Hello, " + " world" + "!";

創建格式化字符串
    String類使用靜態方法format()返回一個String對象而不是PrintStream對象
    String類的靜態方法format()能用來創建可復用的格式化字符串,而不僅僅是用于一次打印輸出
    //例子:
    String fs;
    float floatVar = 9.8f;
    int intVar = 125;
    String stringVar = "Jimy";
    fs = String.format("The value of the float variable is " +
                        "%f, while the value of the integer" +
                        "variable is %d, and the string " +
                        "is %s", floatVar, intVar, stringVar);
    System.out.println(fs); //The value of the float variable is 9.800000, while the value of the integervariable is 125, and the string is Jimy

String 方法
    char charAt(int index): 返回指定索引處的 char 值
    int compareTo(Object o): 把這個字符串和另一個對象比較
    int compareTo(String anotherString): 按字典順序比較兩個字符串
    int compareToIgnoreCase(String str): 按字典順序比較兩個字符串，不考慮大小寫
    String concat(String str): 將指定字符串連接到此字符串的結尾
    boolean contentEquals(StringBuffer sb): 當且僅當字符串與指定的StringButter有相同順序的字符時候返回真
    static String copyValueOf(char[] data): 返回指定數組中表示該字符序列的 String
    boolean endsWith(String suffix): 測試此字符串是否以指定的后綴結束
    boolean equals(Object anObject): 將此字符串與指定的對象比較
    boolean equalsIgnoreCase(String anotherString): 將此 String 與另一個 String 比較，不考慮大小寫
    byte[] getBytes(): 使用平臺的默認字符集將此 String 編碼為 byte 序列，并將結果存儲到一個新的 byte 數組中
    void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):    將字符從此字符串復制到目標字符數組
    int hashCode(): 返回此字符串的哈希碼
    int indexOf(int ch): 返回指定字符在此字符串中第一次出現處的索引
    int lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出現處的索引
    boolean matches(String regex): 告知此字符串是否匹配給定的正則表達式
    boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len):
        測試兩個字符串區域是否相等
    String[] split(String regex): 根據給定正則表達式的匹配拆分此字符串
    boolean startsWith(String prefix): 測試此字符串是否以指定的前綴開始
    String substring(int beginIndex): 返回一個新的字符串，它是此字符串的一個子字符串
    char[] toCharArray(): 將此字符串轉換為一個新的字符數組
    String toLowerCase(): 使用默認語言環境的規則將此 String 中的所有字符都轉換為小寫
    String toUpperCase(): 使用默認語言環境的規則將此 String 中的所有字符都轉換為大寫
    String trim(): 返回字符串的副本，忽略前導空白和尾部空白
    

Java StringBuffer和StringBuilder類

對字符串進行修改的時候,需要使用StringBuffer和StringBuilder類
和String類不同的是,StringBuffer和StringBuilder類的對象能夠被多次的修改,且不產生新的未使用對象
StringBuffer和StringBuilder類之間的最大不同在于StringBuilder的方法不是線程安全的(不能同步訪問)
由于StringBuilder相較于StringBuffer有速度優勢,大多數情況下建議使用StringBuilder類.
然而在應用程序要求線程安全的情況下,則必須使用StringBuffer類
//例子
public class Main {

    public static void main(String[] args) {
        StringBuffer sBuffer = new StringBuffer("test");
        sBuffer.append(" String Buffer");
        System.out.println(sBuffer);    //test String Buffer
    }
}

StringBuffer 方法
    public StringBuffer append(String s): 將指定的字符串追加到此字符序列
    public StringBuffer reverse(): 將此字符序列用其反轉形式取代
    public delete(int start, int end): 移除此序列的子字符串中的字符
    public insert(int offset, int i): 將 int 參數的字符串表示形式插入此序列中
    replace(int start, int end, String str): 使用給定 String 中的字符替換此序列的子字符串中的字符
    ...

Java數組

用來存儲固定大小的同類型元素
double[] myList;    //首選的聲明寫法
myList = new double[1024];    //創建數組

數組作為函數的參數
    數組可以作為參數傳遞給方法

數組作為函數的返回值

public class Main {

    public static void printArray(double[] array){
        for(int i = 0;i < array.length;i++){
            System.out.println(array[i] + " ");
        }
    }
    public static double[] reverse(double[] list){
        double[] result = new double[list.length];
        for(int i = 0, j = result.length - 1; i < list.length; i++, j--){
            result[j] = list[i];
        }
        return result;
    }
    public static void main(String[] args) {
        StringBuffer sBuffer = new StringBuffer("test");
        sBuffer.append(" String Buffer");
        System.out.println(sBuffer);    //test String Buffer

        double[] myList = {1.9, 2.9, 3.4, 3.5};
        //打印所有數組元素
        for(int i = 0; i < myList.length; i++){
            System.out.println(myList[i] + " ");
        }
        for(double ele:myList){
            System.out.println(ele);
        }
        printArray(myList);
        //計算所有元素的總和
        double total = 0;
        for(int i = 0;i < myList.length;i++){
            total += myList[i];
        }
        System.out.println("Total is " + total);
        //查找最大元素
        double max = myList[0];
        for(int i = 1;i < myList.length; i++){

            if(myList[i] > max){
                max = myList[i];
            }
        }
        System.out.println("Max is " + max);

        double[] reverse = reverse(myList);
        printArray(reverse);
    }
}

Arrays類
    java.util.Arrays類能方便地操作數組,它提供的所有方法都是靜態的.
    1.給數組賦值: 通過fill方法
    2.對數組排序: 通縮sort方法,按升序.
    3.比較數組: 通過equals方法比較數組中元素值是否相等
    4.查找數組元素: 通過binarySearch方法能對排序好的數組進行二分查找法操作
    public static void fill(int[] a, int val)
    public static void sort(Object[] a)
    public static boolean equals(long[] a, long[] a2)
    public static int binarySearch(Object[] a, Object key)

Java日期時間

java.util包提供了Date類來封裝當前的日期和時間,Date類提供兩個構造函數來實例化Date對象
1.Date(): 使用當前日期和時間來初始化對象
2.Date(long millisec): 該參數從1970年一月一日起的微秒數
Date對象創建后,可調用下面的方法:
    boolean after(Date date): 若當調用此方法的Date對象在指定日期之后返回true,否則返回false
    boolean before(Date date): 若當調用此方法的Date對象在指定日期之前返回true,否則返回false
    Object clone(): 返回此對象的副本
    int compareTo(Date date): 比較當調用此方法的Date對象和指定日期。兩者相等時候返回0。調用對象在指定日期之前則返回負數。調用對象在指定日期之后則返回正數
    int compareTo(Object obj): 若obj是Date類型則操作等同于compareTo(Date) 。否則它拋出ClassCastException
    boolean equals(Object date): 當調用此方法的Date對象和指定日期相等時候返回true,否則返回false
    long getTime(): 返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數
    int hashCode(): 返回此對象的哈希碼值
    void setTime(long time): 用自1970年1月1日00:00:00 GMT以后time毫秒數設置時間和日期
    String toString(): 轉換Date對象為String表示形式，并返回該字符串

使用SimpleDateFormat格式化日期
    import java.text.SimpleDateFormat;
    import java.util.Date;

    //時間日期專題
    public class Main {

        public static void main(String[] args) {
            //初始化 Date 對象
            Date date = new Date();
            //使用toString()函數顯示日期時間
            System.out.println(date.toString());    //Thu Jun 06 17:13:04 CST 2019

            //使用SimpleDateFormat格式化日期
            SimpleDateFormat ft = new SimpleDateFormat("E yyyy.MM.dd "at" hh:mm:ss a zzz");
            System.out.println("Current Date: " + ft.format(date)); //Current Date: 周四 2019.06.06 at 05:17:07 下午 CST
        }
    }
    
使用printf格式化日期
    import java.util.Date;
    public class DateDemo {

      public static void main(String args[]) {
         // 初始化 Date 對象
         Date date = new Date();

         // 使用toString()顯示日期和時間
         String str = String.format("Current Date/Time : %tc", date );

         System.out.printf(str);
      }
    }
    /---------------------------------------/
    import java.util.Date;
    public class DateDemo {

       public static void main(String args[]) {
           // 初始化 Date 對象
           Date date = new Date();
            
           // 使用toString()顯示日期和時間
           System.out.printf("%1$s %2$tB %2$td, %2$tY", 
                             "Due date:", date);
       }
    }
    DateFormat格式化編碼
    日期和時間轉換字符
    解析字符串為時間
        SimpleDateFormat類有一些附加的方法,特別是parse(),它試圖按照給定的SimpleDateFormat對象的格式化存儲
        來解析字符串
        
    Java 休眠(sleep)
        可以讓程序休眠
            Thread.sleep(5*60*10);
            
    測量時間
        long start = System.currentTimeMillis();
        System.out.println(new Date() + "
");
        Thread.sleep(5*60*10);  //休眠10秒,不準確
        System.out.println(new Date() + "
");
        long end = System.currentTimeMillis();
        long diff = end - start;
        System.out.println("Difference is :" + diff/1000);    //秒

Calendar類
    如何設置和獲取日期數據的特定部分,比如小時,日,或者分鐘?
    使用Calendar類
        Calendar類的功能要比Date類強大很多,而且實現方式上也比Date類要復雜一些
        Calendar類是一個抽象類,在實際使用時實現特定的子類的對象,創建對象的過程對程序員來說時透明的
        ,只需使用getInstance方法創建即可
        Calendar c = Calendar.getInstance();    //默認是當前日期
        
GregorianCalendar類
    Calendar類實現了公歷日歷,GregorianCalendar是Calendar類的一個具體實現
    import java.util.Calendar;
    import java.util.GregorianCalendar;

    public class Main {
        public static void main(String[] args){
            String months[] = {"Jan", "Feb", "Mar", "Apr",
                                "May", "Jun", "Jul", "Aug",
                                "Sep", "Oct", "Nov", "Dec"};

            int year;
            //初始化Gregorian 日歷
            //使用當前時間和日期
            //默認為本地時間和時區
            GregorianCalendar gcalendar = new GregorianCalendar();
            //顯示當前時間和日期的信息
            System.out.print("Date: ");
            System.out.print(months[gcalendar.get(Calendar.MONTH)]);
            System.out.print(" "+ gcalendar.get(Calendar.DATE) + " ");
            System.out.println(year = gcalendar.get(Calendar.YEAR));
            System.out.print("Time: ");
            System.out.print(gcalendar.get(Calendar.HOUR) + ":");
            System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
            System.out.println(gcalendar.get(Calendar.SECOND));

            //判斷當前年份是否為潤年
            if(gcalendar.isLeapYear(year)){
                System.out.println("當前年份是潤年");
            }else{
                System.out.println("當前年份不是潤年");
            }
        }
    }

JAVA方法

方法是解決一類問題的步驟的有序組合
方法包含于類和對象中
方法在程序中被創建,在其它地方被引用
方法的定義:
    修飾符 返回值類型 方法名(參數類型 參數名)
        ...
        方法體
        ...
        return 返回值
    main方法是被JVM調用
重載的方法必須具有不同的參數列表,不能僅僅依據修飾符或返回類型的不同來重載方法

構造方法:
    所有的類都有構造方法,因為JAVA自動提供了一個默認構造方法,它把所有成員初始化為0.
    一旦你定義了自己的構造方法,默認構造方法就會失效
finalize()方法:
    JAVA允許定義這樣的方法,它在對象被垃圾收集器析構(回收)之前調用,用來清除回收對象
    例如:可以使用finalize()方法來確保一個對象打開的文件被關閉了.
    在finalize()方法里,必須指定在對象銷毀時候要執行的操作.
    

JAVA流、文件、IO

輸入流：表示從一個源讀取數據
輸出流: 表示向一個目標寫數據
讀取控制臺輸入:
    JAVA的控制臺輸入由System.in完成
    為了獲得一個綁定到控制臺的字符流,可以把System.in包裝在BufferedReader對象中來創建一個字符流
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in))
        BufferedReader對象創建后,我們可以使用read()方法從控制臺讀取一個字符,或者用readLine()方法來讀取一個字符串
        
//讀寫文件,一個流被定義為一個數據序列,輸入流用于從源讀取數據,輸出流用于向目標寫數據
//Object---(OutputStream, InputStream)
//OutputStream---(FilterOutputStream,FileOutputStream,ByteArrayOutputStream)
//FilterOutputStream---(BufferedOutputStream, DataOutputStream, PrintStream)
//InputStream---(ByteArrayInputStream,FileInputStream,FilterInputStream,StringBufferInputStream,SequenceInputStream)
//FilterInputStream---(BufferedInputStream, DataInputStream, PushbackInputStream)

//FileInputStream
//該流用于從文件讀取數據,用關鍵字new來創建對象

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        try{
            //創建輸入流對象來讀取文件
            FileInputStream f = new FileInputStream("C:Usersjasmintungmeijumain.cpp");
            File ff = new File("C:Usersjasmintungmeijumain.cpp");
            //也可使用一個文件對象來創建一個輸入輸出流對象來讀取文件
            InputStream fs = new FileInputStream(ff);
        }catch(FileNotFoundException ex) {
            System.out.println(ex);
        }
    }
}
創建了InputStream對象,就可以使用下面方法來讀取流或進行其它的操作
    1:public void close() throws IOException{}
        關閉此文件輸入流并釋放與此流有關的所有系統資源。拋出IOException異常。
    2:protected void finalize()throws IOException {}
        這個方法清除與該文件的連接。確保在不再引用文件輸入流時調用其 close 方法。拋出IOException異常
    3:public int read(int r)throws IOException{}
        這個方法從InputStream對象讀取指定字節的數據。返回為整數值。返回下一字節數據，如果已經到結尾則返回-1
    4:public int read(byte[] r) throws IOException{}
        這個方法從輸入流讀取r.length長度的字節。返回讀取的字節數。如果是文件結尾則返回-1
    5:public int available() throws IOException{}
        返回下一次對此輸入流調用的方法可以不受阻塞地從此輸入流讀取的字節數。返回一個整數值
        
//FileOutputStream
該類用來創建一個文件并向文件中寫數據

//FileReader,FileWriter類

//JAVA中的目錄
創建目錄: mkdir(),mkdirs()

//讀取目錄:
    一個目錄其實就是一個File對象,它包含其它文件或文件夾
    如果創建一個File對象并且它是一個目錄,那么調用isDirectory()方法會返回true
    可通過調用該對象上的list()方法,來提取它包含的文件和文件夾的列表
    import java.io.File;

    public class DirList {
       public static void main(String args[]) {
          String dirname = "/tmp";
          File f1 = new File(dirname);
          if (f1.isDirectory()) {
             System.out.println( "Directory of " + dirname);
             String s[] = f1.list();
             for (int i=0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                   System.out.println(s[i] + " is a directory");
                } else {
                   System.out.println(s[i] + " is a file");
                }
             }
          } else {
             System.out.println(dirname + " is not a directory");
        }
      }
    }
    

JAVA異常處理

異常是程序中的一些錯誤,但并不是所有的錯誤都是異常,并且錯誤有時候可以避免
異常發生的原因有很多,通常包含一下幾大類:
    1.用戶輸入了非法數據
    2.要打開的文件不存在
    3.網絡通信時連接中斷,或者JVM內存溢出
要理解Java異常處理是如何工作的，你需要掌握以下三種類型的異常：
    檢查性異常: 最具代表的檢查性異常是用戶錯誤或問題引起的異常，這是程序員無法預見的。例如要打開一個不存在文件時，一個異常就發生了，這些異常在編譯時不能被簡單地忽略。
    運行時異常: 運行時異常是可能被程序員避免的異常。與檢查性異常相反，運行時異?？梢栽诰幾g時被忽略。
    錯誤: 錯誤不是異常，而是脫離程序員控制的問題。錯誤在代碼中通常被忽略。例如，當棧溢出時，一個錯誤就發生了，它們在編譯也檢查不到的
Exception類的層次:
    所有的異常類都是從java.lang.Exception類繼承的子類
    Exception類是Throwable類的子類.
    除了Exception類外,Throwable還有一個子類Error.
    
    在Java內置類中,有大部分常用檢查性和非檢查性異常
    Java 語言定義了一些異常類在java.lang標準包中
    由于java.lang包是默認加載到所有的Java程序的,所以大部分從運行時異常類繼承而來的異常都可以直接使用
    
捕獲異常:
    使用try和catch關鍵字可以捕獲異常.

多重捕獲塊
    一個try代碼塊后面跟隨多個catch代碼塊的情況叫多重捕獲
throws/throw關鍵字
    如果一個方法沒有捕獲一個檢查性異常,那么該方法必須使用throws關鍵字類聲明
    throws關鍵字放在方法簽名的尾部
    
    import java.io.*;
    public class className
    {
       public void withdraw(double amount) throws RemoteException,
                                  InsufficientFundsException
       {
           // Method implementation
       }
       //Remainder of class definition
    }
    
finally關鍵字
    finally關鍵字用來創建在try代碼塊后面執行的代碼塊
    無論是否發生異常,finally代碼塊中的代碼總會被執行
    在finally代碼塊中,可以運行清理類型等收尾善后性質的語句
    finally代碼塊出現在catch代碼塊最后
    
    try{
        // 程序代碼
     }catch(異常類型1 異常的變量名1){
        // 程序代碼
     }catch(異常類型2 異常的變量名2){
        // 程序代碼
     }finally{
        // 程序代碼
     }
     
聲明自定義異常
    在java中可以自定義異常
    注意:
        1.所有異常都必須是Throwable的子類
        2.如果希望寫一個檢查性異常類,則需要繼承Exception類
        3.如果想寫一個運行時異常,那么需要繼承RuntimeException類
    例如:
        class MyException extends Exception{
            //
        }
        
        一個異常類和其它任何類一樣,包含有變量和方法
    如何使用自定義的異常類:
        // 文件名InsufficientFundsException.java
        import java.io.*;

        public class InsufficientFundsException extends Exception
        {
           private double amount;
           public InsufficientFundsException(double amount)
           {
              this.amount = amount;
           } 
           public double getAmount()
           {
              return amount;
           }
        }
        
        // 文件名稱 CheckingAccount.java
        import java.io.*;

        public class CheckingAccount
        {
           private double balance;
           private int number;
           public CheckingAccount(int number)
           {
              this.number = number;
           }
           public void deposit(double amount)
           {
              balance += amount;
           }
           public void withdraw(double amount) throws
                                      InsufficientFundsException
           {
              if(amount <= balance)
              {
                 balance -= amount;
              }
              else
              {
                 double needs = amount - balance;
                 throw new InsufficientFundsException(needs);
              }
           }
           public double getBalance()
           {
              return balance;
           }
           public int getNumber()
           {
              return number;
           }
        }
        
        //文件名稱 BankDemo.java
        public class BankDemo
        {
           public static void main(String [] args)
           {
              CheckingAccount c = new CheckingAccount(101);
              System.out.println("Depositing $500...");
              c.deposit(500.00);
              try
              {
                 System.out.println("
Withdrawing $100...");
                 c.withdraw(100.00);
                 System.out.println("
Withdrawing $600...");
                 c.withdraw(600.00);
              }catch(InsufficientFundsException e)
              {
                 System.out.println("Sorry, but you are short $"
                                          + e.getAmount());
                 e.printStackTrace();
              }
            }
        }
通用異常
    在java中定義了兩種類型的異常和錯誤
    1.JVM異常: 由JVM拋出的異?；蝈e誤.如:NullPointerException類,
        ArrayIndexOutOfBoundsException類,ClassCastException類
    2.程序級異常: 由程序或者API程序拋出的異常
        例如IllegalArgumentException類,IllegalStateException類
        

JAVA ByteArrayInputStream類

字節數組輸入流在內存中創建一個字節數組緩沖區,從輸入流讀取的數據保存在該字節數組緩沖區.
用法:
    ByteArrayInputStream bArray = new ByteArrayInputStream(byte[] a);
    ByteArrayInputStream bArray = new ByteArrayInputStream(byte[] a, int off, int len);
    
成功創建字節數組流對象后,可用以下方法對流進行讀操作或其它操作:
    1.public int read(): 從此輸入流中讀取下一個數據字節
    2.public int read(byte[] r, int off, int len): 將最多 len 個數據字節從此輸入流讀入字節數組
    3.public int available(): 返回可不發生阻塞地從此輸入流讀取的字節數
    4.public void mark(int read): 設置流中的當前標記位置
    5.public long skip(long n): 從此輸入流中跳過 n 個輸入字節
    
例子:
    import java.io.*;

    public class ByteStreamTest {
       public static void main(String args[])throws IOException {
          ByteArrayOutputStream bOutput = new ByteArrayOutputStream(12);

          while( bOutput.size()!= 10 ) {
             // 獲取用戶輸入值
             bOutput.write(System.in.read());
          }

          byte b [] = bOutput.toByteArray();
          System.out.println("Print the content");
          for(int x= 0 ; x < b.length; x++) {
             // 打印字符
             System.out.print((char)b[x]  + "   ");
          }
          System.out.println("   ");

          int c;

          ByteArrayInputStream bInput = new ByteArrayInputStream(b);

          System.out.println("Converting characters to Upper case " );
          for(int y = 0 ; y < 1; y++ ) {
             while(( c= bInput.read())!= -1) {
                System.out.println(Character.toUpperCase((char)c));
             }
             bInput.reset();
          }
       }
    }
    

JAVA DataInputStream類

數據輸入流允許應用程序以與機器無關方式從底層輸入流中讀取基本JAVA數據類型
用法:
    DataInputStream dis = DataInputStream(InputStream in);
方法:
    1.public final int read(byte[] r, int off, int len)throws IOException
        從所包含的輸入流中將 len 個字節讀入一個字節數組中。如果len為-1，則返回已讀字節數
    2.Public final int read(byte [] b)throws IOException
        從所包含的輸入流中讀取一定數量的字節，并將它們存儲到緩沖區數組 b 中
    3.public final Boolean readBooolean()throws IOException,
        public final byte readByte()throws IOException,
        public final short readShort()throws IOException
        public final Int readInt()throws IOException
        從輸入流中讀取字節，返回輸入流中兩個字節作為對應的基本數據類型返回值
    4.public String readLine() throws IOException
        從輸入流中讀取下一文本行
例子:
    DataInputStream和DataOutputStream的使用，該例從文本文件test.txt中讀取5行，并轉換成大寫字母，最后保存在另一個文件test1.txt中
    
    import java.io.*;

    public class Test{
       public static void main(String args[])throws IOException{

          DataInputStream d = new DataInputStream(new
                                   FileInputStream("test.txt"));

          DataOutputStream out = new DataOutputStream(new
                                   FileOutputStream("test1.txt"));

          String count;
          while((count = d.readLine()) != null){
              String u = count.toUpperCase();
              System.out.println(u);
              out.writeBytes(u + "  ,");
          }
          d.close();
          out.close();
       }
    }
    

JAVA ByteArrayOutputStream 類

字節數組輸出流在內存中創建一個字節數組緩沖區，所有發送到輸出流的數據保存在該字節數組緩沖區中
用法:
    OutputStream bOut = new ByteArrayOutputStream();
    OutputStream bOut = new ByteArrayOutputStream(int a)
方法:
    1.public void reset()
        將此字節數組輸出流的 count 字段重置為零，從而丟棄輸出流中目前已累積的所有數據輸出
    2.public byte[] toByteArray()
        創建一個新分配的字節數組。數組的大小和當前輸出流的大小，內容是當前輸出流的拷貝
    3.public String toString()
        將緩沖區的內容轉換為字符串，根據平臺的默認字符編碼將字節轉換成字符
    4.public void write(int w)
        將指定的字節寫入此字節數組輸出流
    5.public void write(byte []b, int of, int len)
        將指定字節數組中從偏移量 off 開始的 len 個字節寫入此字節數組輸出流
    6.public void writeTo(OutputStream outSt)
        將此字節數組輸出流的全部內容寫入到指定的輸出流參數中
    
    

JAVA DataoutputStream 類

數據輸出流允許應用程序以與機器無關方式將Java基本數據類型寫到底層輸出流
用法:
    DataOutputStream out = DataOutputStream(OutputStream  out);
方法:
    1.public final void write(byte[] w, int off, int len)throws IOException
        將指定字節數組中從偏移量 off 開始的 len 個字節寫入此字節數組輸出流
    2.Public final int write(byte [] b)throws IOException
        將指定的字節寫入此字節數組輸出流
    3.public final void writeBooolean()throws IOException,
        public final void writeByte()throws IOException,
        public final void writeShort()throws IOException,
        public final void writeInt()throws IOException
        這些方法將指定的基本數據類型以字節的方式寫入到輸出流
    4.Public void flush()throws IOException
        刷新此輸出流并強制寫出所有緩沖的輸出字節
    5.public final void writeBytes(String s) throws IOException
        將字符串以字節序列寫入到底層的輸出流，字符串中每個字符都按順序寫入，并丟棄其高八位
    

JAVA File類

JAVA文件類以抽象的方式代表文件名和目錄路徑名.該類主要用于文件和目錄的創建,文件的查找和文件的刪除等
File對象代表磁盤中實際存在的文件和目錄
用法:
    File(File parent, String child);
    File(String pathname);
    File(String parent, String child);
    File(URI uri);
    
方法:
    1    public String getName()
    返回由此抽象路徑名表示的文件或目錄的名稱。
    2    public String getParent()、
     返回此抽象路徑名的父路徑名的路徑名字符串，如果此路徑名沒有指定父目錄，則返回 null。
    3    public File getParentFile()
    返回此抽象路徑名的父路徑名的抽象路徑名，如果此路徑名沒有指定父目錄，則返回 null。
    4    public String getPath()
    將此抽象路徑名轉換為一個路徑名字符串。
    5    public boolean isAbsolute()
    測試此抽象路徑名是否為絕對路徑名。
    6    public String getAbsolutePath()
    返回抽象路徑名的絕對路徑名字符串。
    7    public boolean canRead()
    測試應用程序是否可以讀取此抽象路徑名表示的文件。
    8    public boolean canWrite()
    測試應用程序是否可以修改此抽象路徑名表示的文件。
    9    public boolean exists()
    測試此抽象路徑名表示的文件或目錄是否存在。
    10    public boolean isDirectory()
    測試此抽象路徑名表示的文件是否是一個目錄。
    11    public boolean isFile()
    測試此抽象路徑名表示的文件是否是一個標準文件。
    12    public long lastModified()
    返回此抽象路徑名表示的文件最后一次被修改的時間。
    13    public long length()
    返回由此抽象路徑名表示的文件的長度。
    14    public boolean createNewFile() throws IOException
    當且僅當不存在具有此抽象路徑名指定的名稱的文件時，原子地創建由此抽象路徑名指定的一個新的空文件。
    15    public boolean delete()
     刪除此抽象路徑名表示的文件或目錄。
    16    public void deleteOnExit()
    在虛擬機終止時，請求刪除此抽象路徑名表示的文件或目錄。
    17    public String[] list()
    返回由此抽象路徑名所表示的目錄中的文件和目錄的名稱所組成字符串數組。
    18    public String[] list(FilenameFilter filter)
    返回由包含在目錄中的文件和目錄的名稱所組成的字符串數組，這一目錄是通過滿足指定過濾器的抽象路徑名來表示的。
    19    public File[] listFiles()
      返回一個抽象路徑名數組，這些路徑名表示此抽象路徑名所表示目錄中的文件。
    20    public File[] listFiles(FileFilter filter)
    返回表示此抽象路徑名所表示目錄中的文件和目錄的抽象路徑名數組，這些路徑名滿足特定過濾器。
    21    public boolean mkdir()
    創建此抽象路徑名指定的目錄。
    22    public boolean mkdirs()
    創建此抽象路徑名指定的目錄，包括創建必需但不存在的父目錄。
    23    public boolean renameTo(File dest)
     重新命名此抽象路徑名表示的文件。
    24    public boolean setLastModified(long time)
    設置由此抽象路徑名所指定的文件或目錄的最后一次修改時間。
    25    public boolean setReadOnly()
    標記此抽象路徑名指定的文件或目錄，以便只可對其進行讀操作。
    26    public static File createTempFile(String prefix, String suffix, File directory) throws IOException
    在指定目錄中創建一個新的空文件，使用給定的前綴和后綴字符串生成其名稱。
    27    public static File createTempFile(String prefix, String suffix) throws IOException
    在默認臨時文件目錄中創建一個空文件，使用給定前綴和后綴生成其名稱。
    28    public int compareTo(File pathname)
    按字母順序比較兩個抽象路徑名。
    29    public int compareTo(Object o)
    按字母順序比較抽象路徑名與給定對象。
    30    public boolean equals(Object obj)
    測試此抽象路徑名與給定對象是否相等。
    31    public String toString()
     返回此抽象路徑名的路徑名字符串
     
例子:
    import java.io.File;
    public class DirList {
       public static void main(String args[]) {
          String dirname = "/java";
          File f1 = new File(dirname);
          if (f1.isDirectory()) {
             System.out.println( "Directory of " + dirname);
             String s[] = f1.list();
             for (int i=0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                   System.out.println(s[i] + " is a directory");
                } else {
                   System.out.println(s[i] + " is a file");
                }
             }
          } else {
             System.out.println(dirname + " is not a directory");
        }
      }
    }

JAVA FileReader類

FileReader類從InputStreamReader類繼承而來,該類按字符讀取流中數據.
用法:
    FileReader(File file);
    FileReader(FileDescriptor fd);
    FileReader(String fileName;
方法:
    1    public int read() throws IOException
    讀取單個字符，返回一個int型變量代表讀取到的字符
    2    public int read(char [] c, int offset, int len)
    讀取字符到c數組，返回讀取到字符的個數
例子:
    import java.io.*;
    public class FileRead{
       public static void main(String args[])throws IOException{
          File file = new File("Hello1.txt");
          // 創建文件
          file.createNewFile();
          // creates a FileWriter Object
          FileWriter writer = new FileWriter(file); 
          // 向文件寫入內容
          writer.write("This
 is
 an
 example
"); 
          writer.flush();
          writer.close();
          // 創建 FileReader 對象
          FileReader fr = new FileReader(file); 
          char [] a = new char[50];
          fr.read(a); // 讀取數組中的內容
          for(char c : a)
              System.out.print(c); // 一個一個打印字符
          fr.close();
       }
    }
    

JAVA FileWriter類

FileWriter類從OutputStreamReader類繼承而來。該類按字符向流中寫入數據
用法:
    FileWriter(File file);
    FileWriter(File file, boolean append);
    FileWriter(FileDescriptor fd);
    FileWriter(String fileName, boolean append);
方法:
    1    public void write(int c) throws IOException
    寫入單個字符c。
    2    public void write(char [] c, int offset, int len)
    寫入字符數組中開始為offset長度為len的某一部分。
    3    public void write(String s, int offset, int len)
    寫入字符串中開始為offset長度為len的某一部分。

Java 繼承

JAVA中,類的繼承是單一繼承,一個子類只能擁有一個父類
繼承中最常使用的兩個關鍵字: extends 和 implements
這兩個關鍵字的使用決定了一個對象和另一個對象是否是IS-A(是一個)關系
通過使用這兩個關鍵字,我們能實現一個對象獲取另一個對象的屬性
所有JAVA的類均是由java.lang.Object類繼承而來的,所以Object是所有類的祖先類,
除了Object外,所有類必須有一個父類
// A.java
public class A {
    private int i;
    protected int j;
 
    public void func() {
 
    }
}
 
// B.java
public class B extends A {

}
B由A繼承而來的, B是A的子類. 而A是Object的子類, 這里可以不顯示地聲明
作為子類,B的實例擁有A所有的成員變量,但對于 private 的成員變量B卻沒有訪問權限,這保障了A的封裝性

什么是IS-A關系?
    一個對象是另一個對象的一個分類
    public class Animal{
    }

    public class Mammal extends Animal{
    }

    public class Reptile extends Animal{
    }

    public class Dog extends Mammal{
    }
    分析以上示例中的IS-A關系,如下：
        Mammal IS-A Animal
        Reptile IS-A Animal
        Dog IS-A Mammal
        因此 : Dog IS-A Animal
通過使用關鍵字 extends,子類可以繼承父類的除private屬性外所有的屬性.
我們通過使用 instanceof 操作符,能夠確定Mammal IS-A Animal(返回true or false)
    public class Dog extends Mammal{

       public static void main(String args[]){

          Animal a = new Animal();
          Mammal m = new Mammal();
          Dog d = new Dog();

          System.out.println(m instanceof Animal);    //true
          System.out.println(d instanceof Mammal);    //true
          System.out.println(d instanceof Animal);    //true
       }
    }

implements 關鍵字
    使用在類繼承接口的情況下.這種情況下不能使用extends

HAS-A 關系
    代表類和它的成員之間的從屬關系.有助于代碼的重用和減少代碼的錯誤
    例子:
        public class Vehicle{}
        public class Speed{}
        public class Van extends Vehicle{
            private Speed sp;
        }
        Van類和Speed類是HAS-A關系(Van有一個Speed),這樣就不用將Speed類的全部代碼粘貼到Van類中了
        并且Speed類也可以重復利用于多個應用程序
    
JAVA只支持單繼承(繼承基本類和抽象類),但是我們可以用接口來實現(多繼承接口來實現)
    public class Apple extends Fruit implements Fruit1, Fruit2{
    
    }
    
一般我們繼承基本類和抽象類用 extends 關鍵字,實現接口類的繼承用 implements 關鍵字

JAVA重寫Override與重載Overload

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫,返回值和形參不能改變
重寫的好處在于子類可以根據需求,定義特定于自己的行為
也就是說子類能夠根據需要實現父類的方法
例子:
    class Animal{
        public void move(){
            System.out.println("動物可以移動");
        }
    }
    
    class Dog extends Animal{
        public void move(){
            System.out.println("dog can run and walk");
        }
    }
    
    public class TestDog{
        public static void main(String args[]){
            Animal a = new Animal();
            Animal b = new Dog();    //Dog對象
            a.move();    //執行 Animal 類的方法
            b.moev();    //執行 Dog 類的方法
        }
    }
    
    在上面的例子中可以看到，盡管b屬于Animal類型，但是它運行的是Dog類的move方法。
    這是由于在編譯階段，只是檢查參數的引用類型。
    然而在運行時，Java虛擬機(JVM)指定對象的類型并且運行該對象的方法。
    因此在上面的例子中，之所以能編譯成功，是因為Animal類中存在move方法，然而運行時，運行的是特定對象的方法
    
思考例子:
    class Animal{

       public void move(){
          System.out.println("動物可以移動");
       }
    }

    class Dog extends Animal{

       public void move(){
          System.out.println("狗可以跑和走");
       }
       public void bark(){
          System.out.println("狗可以吠叫");
       }
    }

    public class TestDog{

       public static void main(String args[]){
          Animal a = new Animal(); // Animal 對象
          Animal b = new Dog(); // Dog 對象

          a.move();// 執行 Animal 類的方法
          b.move();//執行 Dog 類的方法
          b.bark();
       }
    }
    運行結果:
        TestDog.java:30: cannot find symbol
        symbol  : method bark()
        location: class Animal
                        b.bark();
                        
    該程序將拋出一個編譯錯誤,因為b的引用類型Animal沒有bark方法
    
方寫重寫的規則
    參數列表必須完全與被重寫方法的相同；
    返回類型必須完全與被重寫方法的返回類型相同；
    訪問權限不能比父類中被重寫的方法的訪問權限更高。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected。
    父類的成員方法只能被它的子類重寫。
    聲明為 final 的方法不能被重寫。
    聲明為 static 的方法不能被重寫，但是能夠被再次聲明。
    如果一個方法不能被繼承，那么該方法不能被重寫。
    子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為 private 和 final 的方法。
    子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為 public 和 protected 的非 final 方法。
    重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更廣泛的強制性異常，反之則可以。
    構造方法不能被重寫。
    如果不能繼承一個方法，則不能重寫這個方法

Super關鍵字的使用
    當需要在子類中調用父類的被重寫方法時,要使用super關鍵字
    class Animal{
        public void move(){
            System.out.println("anmial can move");
        }
    }
    
    class Dog extends Animall{
        public void move(){
            super.move();    //調用 super類的方法
            System.out.println("dog can run and walk");
        }
    }
    
    public class TestDog{
        public static void main(String args[]){
            Animal b = new Dog();
            b.move();
        }
    }
    
重載(Overload)
    重載(overloading) 是在一個類里面, 方法名字相同, 而參數不同.返回類型呢？可以相同也可以不同
    
    重載規則:
        被重載的方法必須改變參數列表；
        被重載的方法可以改變返回類型；
        被重載的方法可以改變訪問修飾符；
        被重載的方法可以聲明新的或更廣的檢查異常；
        方法能夠在同一個類中或者在一個子類中被重載
        
    例子:
        public class Overloading {

        public int test(){
            System.out.println("test1");
            return 1;
        }
     
        public void test(int a){
            System.out.println("test2");
        }    
     
        //以下兩個參數類型順序不同
        public String test(int a,String s){
            System.out.println("test3");
            return "returntest3";
        }    
     
        public String test(String s,int a){
            System.out.println("test4");
            return "returntest4";
        }    
     
        public static void main(String[] args){
            Overloading o = new Overloading();
            System.out.println(o.test());
            o.test(1);
            System.out.println(o.test(1,"test3"));
            System.out.println(o.test("test4",1));
        }

重寫與重載之間的區別
    區別點       重載方法            重寫方法
    參數列表    必須修改         一定不能修改
    返回類型    可以修改         一定不能修改
    異常        可以修改         可以減少或刪除，一定不能拋出新的或者更廣的異常
    訪問        可以修改         一定不能做更嚴格的限制（可以降低限制）    
    

JAVA多態

多態,是同一個行為具有多個不同表現形式或形態的能力
比如我們說"寵物"這個對象，它就有很多不同的表達或實現，比如有小貓、小狗、蜥蜴等等。
那么我到寵物店說"請給我一只寵物"，服務員給我小貓、小狗或者蜥蜴都可以，我們就說"寵物"這個對象就具備多態性

例子:
    public interface Vegetarian{}
    public class Animal{}
    public class Deer extends Animal implements Vegetarian{}
    此時,Deer類具有多重繼承,具有多態性
        一個 Deer IS-A（是一個） Animal
        一個 Deer IS-A（是一個） Vegetarian
        一個 Deer IS-A（是一個） Deer
        一個 Deer IS-A（是一個）Object
在JAVA中,所有的對象都具有多態性.
訪問一個對象的唯一方法是: 通過引用型變量
引用型變量只能有一種類型,一旦被聲明,引用型變量的類型就不能被改變了
引用型變量不僅能夠被重置為其它對象,前提是這些對象沒有被聲明為final.
還可以引用和它類型相同的或者相兼容的對象.它可以聲明為類類型或者接口類型

當我們將引用變量應用于Deer對象的引用時,下面的聲明時合法的:
    Deer d = new Deer();
    Animal a = d;
    Vegetarian v = d;
    Object o = d;
    所有的引用型變量d,a,v,o都指向堆中相同的Deer對象

虛方法(可以理解為C++中的虛函數)
    當子類對象調用重載的方法時,調用的是子類的方法,而不是父類中被重載的方法
    想要調用父類中被重載的方法,必須使用關鍵字super

    例子(仔細看):
        /* 文件名 : Employee.java */
        public class Employee
        {
           private String name;
           private String address;
           private int number;
           public Employee(String name, String address, int number)
           {
              System.out.println("Constructing an Employee");
              this.name = name;
              this.address = address;
              this.number = number;
           }
           public void mailCheck()
           {
              System.out.println("Mailing a check to " + this.name
               + " " + this.address);
           }
           public String toString()
           {
              return name + " " + address + " " + number;
           }
           public String getName()
           {
              return name;
           }
           public String getAddress()
           {
              return address;
           }
           public void setAddress(String newAddress)
           {
              address = newAddress;
           }
           public int getNumber()
           {
             return number;
           }
        }
        
        /* 文件名 : Salary.java */
        public class Salary extends Employee
        {
           private double salary; //Annual salary
           public Salary(String name, String address, int number, double
              salary)
           {
               super(name, address, number);
               setSalary(salary);
           }
           public void mailCheck()
           {
               System.out.println("Within mailCheck of Salary class ");
               System.out.println("Mailing check to " + getName()
               + " with salary " + salary);
           }
           public double getSalary()
           {
               return salary;
           }
           public void setSalary(double newSalary)
           {
               if(newSalary >= 0.0)
               {
                  salary = newSalary;
               }
           }
           public double computePay()
           {
              System.out.println("Computing salary pay for " + getName());
              return salary/52;
           }
        }
        
        /* 文件名 : VirtualDemo.java */
        public class VirtualDemo
        {
           public static void main(String [] args)
           {
              Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
              Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
              System.out.println("Call mailCheck using Salary reference --");
              s.mailCheck();
              System.out.println("
 Call mailCheck using Employee reference--");
              e.mailCheck();
            }
        }
        
        運行結果:
            Constructing an Employee
            Constructing an Employee
            Call mailCheck using Salary reference --
            Within mailCheck of Salary class
            Mailing check to Mohd Mohtashim with salary 3600.0

            Call mailCheck using Employee reference--
            Within mailCheck of Salary class
            Mailing check to John Adams with salary 2400.0

        例子中，我們實例化了兩個Salary對象。一個使用Salary引用s，另一個使用Employee引用。
            編譯時，編譯器檢查到mailCheck()方法在Salary類中的聲明。
            在調用s.mailCheck()時，Java虛擬機(JVM)調用Salary類的mailCheck()方法。
            因為e是Employee的引用，所以調用e的mailCheck()方法則有完全不同的結果。
            當編譯器檢查e.mailCheck()方法時，編譯器檢查到Employee類中的mailCheck()方法。
            在編譯的時候，編譯器使用Employee類中的mailCheck()方法驗證該語句， 但是在運行的時候，Java虛擬機(JVM)調用的是Salary類中的mailCheck()方法。
            該行為被稱為虛擬方法調用，該方法被稱為虛擬方法。
            
            Java中所有的方法都能以這種方式表現，借此，重寫的方法能在運行時調用，不管編譯的時候源代碼中引用變量是什么數據類型。
            

JAVA抽象類

在面向對象的概念中,所有的對象都是通過類來描繪的,但是反過來,并不是所有的類都是用來描繪對象的,
如果一個類中沒有包含足夠的信息來描述一個具體的對象,這樣的類就是抽象類

抽象類除了不能實例化對象之外,類的其它功能依然存在,成員變量,成員方法和構造方法的訪問方式和普通類一樣
由于抽象類不能實例化對象,所以抽象類必須被繼承,才能被使用.也就是因為這個原因,通常在設計階段決定要不要設計抽象類

定義一個抽象類:
    /* 文件名 : Employee.java */
    public abstract class Employee
    {
       private String name;
       private String address;
       private int number;
       public Employee(String name, String address, int number)
       {
          System.out.println("Constructing an Employee");
          this.name = name;
          this.address = address;
          this.number = number;
       }
       public double computePay()
       {
         System.out.println("Inside Employee computePay");
         return 0.0;
       }
       public void mailCheck()
       {
          System.out.println("Mailing a check to " + this.name
           + " " + this.address);
       }
       public String toString()
       {
          return name + " " + address + " " + number;
       }
       public String getName()
       {
          return name;
       }
       public String getAddress()
       {
          return address;
       }
       public void setAddress(String newAddress)
       {
          address = newAddress;
       }
       public int getNumber()
       {
         return number;
       }
    }
    該Employee類沒有什么不同,盡管該類是抽象類,但是它仍然有3個成員變量,7個成員方法和1個構造方法.
    現在如果你嘗試如下的例子:
        /* 文件名 : AbstractDemo.java */
        public class AbstractDemo
        {
           public static vo