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

由于最近一個項目需要,需要學(xué)習(xí)JAVA知識,學(xué)習(xí)的過程中做了一些筆記,主要以知識點記錄為主,現(xiàn)在分享出來供參考.大部分內(nèi)容是參考的自強(qiáng)學(xué)堂.這里做了歸納.
接口:

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

JAVA面向?qū)ο笾兄С值幕靖拍?

封裝,繼承,多態(tài),抽象,類,對象,實例,方法,消息解析

類:

是一個模板,它描述一類對象的行為和狀態(tài),創(chuàng)建JAVA對象的模板

對象:

類的一個實例,有狀態(tài)和行為

類變量:

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

構(gòu)造方法:

在創(chuàng)建一個對象的時候,至少要調(diào)用一個構(gòu)造方法,構(gòu)造方法的名稱必須與類同名,一個類可以有多個構(gòu)造方法

創(chuàng)建對象:

需要三步:1.聲明,聲明一個對象,包括對象名稱和類型
         2.實例化,使用關(guān)鍵字new來創(chuàng)建一個對象
         3.初始化,使用new創(chuàng)建對象時,會調(diào)用構(gòu)造方法初始化對象

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

源文件聲明規(guī)則:

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

引用類型

引用類型變量由類的構(gòu)造函數(shù)創(chuàng)建,可以使用它們訪問所引用的對象.
對象、數(shù)組都是引用數(shù)據(jù)類型
所有引用類型的默認(rèn)值都是null
一個引用變量可以用來引用與任何與之兼容的類型

常量

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

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

轉(zhuǎn)義字符

Java支持一些特殊的轉(zhuǎn)義字符序列

 換行

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

Java支持的變量類型

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

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

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

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

訪問控制修飾符

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

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

private訪問修飾符的使用主要用來隱藏類的實現(xiàn)細(xì)節(jié)和保護(hù)類的數(shù)據(jù)
如果幾個相互訪問的public類分布在不同的包中,則需要導(dǎo)入相應(yīng)public類所在的包,
由于類的繼承性,類所有的公有方法和變量都能被其子類繼承

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

非訪問修飾符

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

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

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

運算符

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

Java Number類

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

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

Java Character類

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

Java String類

在Java中字符串屬于對象, Java提供了String類來創(chuàng)建和操作字符串
創(chuàng)建字符串:
    String類有11種構(gòu)造方法,這些方法提供不同的參數(shù)來初始化字符串
    
    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類是不可改變的,所以一旦創(chuàng)建了String對象,那它的值就無法改變了.
    如果需要對字符串做很多修改,那么應(yīng)該選擇使用StringBuffer & StringBuilder類
    
字符串長度
    用于獲取有關(guān)對象的信息的方法稱為訪問器方法
    String類的一個訪問器方法是length()方法,它返回字符串對象包含的字符數(shù)
連接字符串
    String類提供了連接兩個字符串的方法
        String s3 = string1.concat(string2);    //返回string1連接string2的新字符串
        也可對字符串常量使用concat()方法:
        String s4 = "My name is".concat("Zara");
        
        更常用的是使用"+"操作符來連接字符串
        String s5 = "Hello, " + " world" + "!";

創(chuàng)建格式化字符串
    String類使用靜態(tài)方法format()返回一個String對象而不是PrintStream對象
    String類的靜態(tài)方法format()能用來創(chuàng)建可復(fù)用的格式化字符串,而不僅僅是用于一次打印輸出
    //例子:
    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): 將指定字符串連接到此字符串的結(jié)尾
    boolean contentEquals(StringBuffer sb): 當(dāng)且僅當(dāng)字符串與指定的StringButter有相同順序的字符時候返回真
    static String copyValueOf(char[] data): 返回指定數(shù)組中表示該字符序列的 String
    boolean endsWith(String suffix): 測試此字符串是否以指定的后綴結(jié)束
    boolean equals(Object anObject): 將此字符串與指定的對象比較
    boolean equalsIgnoreCase(String anotherString): 將此 String 與另一個 String 比較，不考慮大小寫
    byte[] getBytes(): 使用平臺的默認(rèn)字符集將此 String 編碼為 byte 序列，并將結(jié)果存儲到一個新的 byte 數(shù)組中
    void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):    將字符從此字符串復(fù)制到目標(biāo)字符數(shù)組
    int hashCode(): 返回此字符串的哈希碼
    int indexOf(int ch): 返回指定字符在此字符串中第一次出現(xiàn)處的索引
    int lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出現(xiàn)處的索引
    boolean matches(String regex): 告知此字符串是否匹配給定的正則表達(dá)式
    boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len):
        測試兩個字符串區(qū)域是否相等
    String[] split(String regex): 根據(jù)給定正則表達(dá)式的匹配拆分此字符串
    boolean startsWith(String prefix): 測試此字符串是否以指定的前綴開始
    String substring(int beginIndex): 返回一個新的字符串，它是此字符串的一個子字符串
    char[] toCharArray(): 將此字符串轉(zhuǎn)換為一個新的字符數(shù)組
    String toLowerCase(): 使用默認(rèn)語言環(huán)境的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為小寫
    String toUpperCase(): 使用默認(rèn)語言環(huán)境的規(guī)則將此 String 中的所有字符都轉(zhuǎn)換為大寫
    String trim(): 返回字符串的副本，忽略前導(dǎo)空白和尾部空白
    

Java StringBuffer和StringBuilder類

對字符串進(jìn)行修改的時候,需要使用StringBuffer和StringBuilder類
和String類不同的是,StringBuffer和StringBuilder類的對象能夠被多次的修改,且不產(chǎn)生新的未使用對象
StringBuffer和StringBuilder類之間的最大不同在于StringBuilder的方法不是線程安全的(不能同步訪問)
由于StringBuilder相較于StringBuffer有速度優(yōu)勢,大多數(shù)情況下建議使用StringBuilder類.
然而在應(yīng)用程序要求線程安全的情況下,則必須使用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(): 將此字符序列用其反轉(zhuǎn)形式取代
    public delete(int start, int end): 移除此序列的子字符串中的字符
    public insert(int offset, int i): 將 int 參數(shù)的字符串表示形式插入此序列中
    replace(int start, int end, String str): 使用給定 String 中的字符替換此序列的子字符串中的字符
    ...

Java數(shù)組

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

數(shù)組作為函數(shù)的參數(shù)
    數(shù)組可以作為參數(shù)傳遞給方法

數(shù)組作為函數(shù)的返回值

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};
        //打印所有數(shù)組元素
        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類能方便地操作數(shù)組,它提供的所有方法都是靜態(tài)的.
    1.給數(shù)組賦值: 通過fill方法
    2.對數(shù)組排序: 通縮sort方法,按升序.
    3.比較數(shù)組: 通過equals方法比較數(shù)組中元素值是否相等
    4.查找數(shù)組元素: 通過binarySearch方法能對排序好的數(shù)組進(jìn)行二分查找法操作
    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類來封裝當(dāng)前的日期和時間,Date類提供兩個構(gòu)造函數(shù)來實例化Date對象
1.Date(): 使用當(dāng)前日期和時間來初始化對象
2.Date(long millisec): 該參數(shù)從1970年一月一日起的微秒數(shù)
Date對象創(chuàng)建后,可調(diào)用下面的方法:
    boolean after(Date date): 若當(dāng)調(diào)用此方法的Date對象在指定日期之后返回true,否則返回false
    boolean before(Date date): 若當(dāng)調(diào)用此方法的Date對象在指定日期之前返回true,否則返回false
    Object clone(): 返回此對象的副本
    int compareTo(Date date): 比較當(dāng)調(diào)用此方法的Date對象和指定日期。兩者相等時候返回0。調(diào)用對象在指定日期之前則返回負(fù)數(shù)。調(diào)用對象在指定日期之后則返回正數(shù)
    int compareTo(Object obj): 若obj是Date類型則操作等同于compareTo(Date) 。否則它拋出ClassCastException
    boolean equals(Object date): 當(dāng)調(diào)用此方法的Date對象和指定日期相等時候返回true,否則返回false
    long getTime(): 返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數(shù)
    int hashCode(): 返回此對象的哈希碼值
    void setTime(long time): 用自1970年1月1日00:00:00 GMT以后time毫秒數(shù)設(shè)置時間和日期
    String toString(): 轉(zhuǎn)換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()函數(shù)顯示日期時間
            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格式化編碼
    日期和時間轉(zhuǎn)換字符
    解析字符串為時間
        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秒,不準(zhǔn)確
        System.out.println(new Date() + "
");
        long end = System.currentTimeMillis();
        long diff = end - start;
        System.out.println("Difference is :" + diff/1000);    //秒

Calendar類
    如何設(shè)置和獲取日期數(shù)據(jù)的特定部分,比如小時,日,或者分鐘?
    使用Calendar類
        Calendar類的功能要比Date類強(qiáng)大很多,而且實現(xiàn)方式上也比Date類要復(fù)雜一些
        Calendar類是一個抽象類,在實際使用時實現(xiàn)特定的子類的對象,創(chuàng)建對象的過程對程序員來說時透明的
        ,只需使用getInstance方法創(chuàng)建即可
        Calendar c = Calendar.getInstance();    //默認(rèn)是當(dāng)前日期
        
GregorianCalendar類
    Calendar類實現(xiàn)了公歷日歷,GregorianCalendar是Calendar類的一個具體實現(xiàn)
    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 日歷
            //使用當(dāng)前時間和日期
            //默認(rèn)為本地時間和時區(qū)
            GregorianCalendar gcalendar = new GregorianCalendar();
            //顯示當(dāng)前時間和日期的信息
            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));

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

JAVA方法

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

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

JAVA流、文件、IO

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

//FileInputStream
//該流用于從文件讀取數(shù)據(jù),用關(guān)鍵字new來創(chuàng)建對象

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

//FileReader,FileWriter類

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

//讀取目錄:
    一個目錄其實就是一個File對象,它包含其它文件或文件夾
    如果創(chuàng)建一個File對象并且它是一個目錄,那么調(diào)用isDirectory()方法會返回true
    可通過調(diào)用該對象上的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異常處理

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

多重捕獲塊
    一個try代碼塊后面跟隨多個catch代碼塊的情況叫多重捕獲
throws/throw關(guān)鍵字
    如果一個方法沒有捕獲一個檢查性異常,那么該方法必須使用throws關(guān)鍵字類聲明
    throws關(guān)鍵字放在方法簽名的尾部
    
    import java.io.*;
    public class className
    {
       public void withdraw(double amount) throws RemoteException,
                                  InsufficientFundsException
       {
           // Method implementation
       }
       //Remainder of class definition
    }
    
finally關(guān)鍵字
    finally關(guān)鍵字用來創(chuàng)建在try代碼塊后面執(zhí)行的代碼塊
    無論是否發(fā)生異常,finally代碼塊中的代碼總會被執(zhí)行
    在finally代碼塊中,可以運行清理類型等收尾善后性質(zhì)的語句
    finally代碼塊出現(xiàn)在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類

字節(jié)數(shù)組輸入流在內(nèi)存中創(chuàng)建一個字節(jié)數(shù)組緩沖區(qū),從輸入流讀取的數(shù)據(jù)保存在該字節(jié)數(shù)組緩沖區(qū).
用法:
    ByteArrayInputStream bArray = new ByteArrayInputStream(byte[] a);
    ByteArrayInputStream bArray = new ByteArrayInputStream(byte[] a, int off, int len);
    
成功創(chuàng)建字節(jié)數(shù)組流對象后,可用以下方法對流進(jìn)行讀操作或其它操作:
    1.public int read(): 從此輸入流中讀取下一個數(shù)據(jù)字節(jié)
    2.public int read(byte[] r, int off, int len): 將最多 len 個數(shù)據(jù)字節(jié)從此輸入流讀入字節(jié)數(shù)組
    3.public int available(): 返回可不發(fā)生阻塞地從此輸入流讀取的字節(jié)數(shù)
    4.public void mark(int read): 設(shè)置流中的當(dāng)前標(biāo)記位置
    5.public long skip(long n): 從此輸入流中跳過 n 個輸入字節(jié)
    
例子:
    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類

數(shù)據(jù)輸入流允許應(yīng)用程序以與機(jī)器無關(guān)方式從底層輸入流中讀取基本JAVA數(shù)據(jù)類型
用法:
    DataInputStream dis = DataInputStream(InputStream in);
方法:
    1.public final int read(byte[] r, int off, int len)throws IOException
        從所包含的輸入流中將 len 個字節(jié)讀入一個字節(jié)數(shù)組中。如果len為-1，則返回已讀字節(jié)數(shù)
    2.Public final int read(byte [] b)throws IOException
        從所包含的輸入流中讀取一定數(shù)量的字節(jié)，并將它們存儲到緩沖區(qū)數(shù)組 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
        從輸入流中讀取字節(jié)，返回輸入流中兩個字節(jié)作為對應(yīng)的基本數(shù)據(jù)類型返回值
    4.public String readLine() throws IOException
        從輸入流中讀取下一文本行
例子:
    DataInputStream和DataOutputStream的使用，該例從文本文件test.txt中讀取5行，并轉(zhuǎn)換成大寫字母，最后保存在另一個文件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 類

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

JAVA DataoutputStream 類

數(shù)據(jù)輸出流允許應(yīng)用程序以與機(jī)器無關(guān)方式將Java基本數(shù)據(jù)類型寫到底層輸出流
用法:
    DataOutputStream out = DataOutputStream(OutputStream  out);
方法:
    1.public final void write(byte[] w, int off, int len)throws IOException
        將指定字節(jié)數(shù)組中從偏移量 off 開始的 len 個字節(jié)寫入此字節(jié)數(shù)組輸出流
    2.Public final int write(byte [] b)throws IOException
        將指定的字節(jié)寫入此字節(jié)數(shù)組輸出流
    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
        這些方法將指定的基本數(shù)據(jù)類型以字節(jié)的方式寫入到輸出流
    4.Public void flush()throws IOException
        刷新此輸出流并強(qiáng)制寫出所有緩沖的輸出字節(jié)
    5.public final void writeBytes(String s) throws IOException
        將字符串以字節(jié)序列寫入到底層的輸出流，字符串中每個字符都按順序?qū)懭?，并丟棄其高八位
    

JAVA File類

JAVA文件類以抽象的方式代表文件名和目錄路徑名.該類主要用于文件和目錄的創(chuàng)建,文件的查找和文件的刪除等
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()
    將此抽象路徑名轉(zhuǎn)換為一個路徑名字符串。
    5    public boolean isAbsolute()
    測試此抽象路徑名是否為絕對路徑名。
    6    public String getAbsolutePath()
    返回抽象路徑名的絕對路徑名字符串。
    7    public boolean canRead()
    測試應(yīng)用程序是否可以讀取此抽象路徑名表示的文件。
    8    public boolean canWrite()
    測試應(yīng)用程序是否可以修改此抽象路徑名表示的文件。
    9    public boolean exists()
    測試此抽象路徑名表示的文件或目錄是否存在。
    10    public boolean isDirectory()
    測試此抽象路徑名表示的文件是否是一個目錄。
    11    public boolean isFile()
    測試此抽象路徑名表示的文件是否是一個標(biāo)準(zhǔn)文件。
    12    public long lastModified()
    返回此抽象路徑名表示的文件最后一次被修改的時間。
    13    public long length()
    返回由此抽象路徑名表示的文件的長度。
    14    public boolean createNewFile() throws IOException
    當(dāng)且僅當(dāng)不存在具有此抽象路徑名指定的名稱的文件時，原子地創(chuàng)建由此抽象路徑名指定的一個新的空文件。
    15    public boolean delete()
     刪除此抽象路徑名表示的文件或目錄。
    16    public void deleteOnExit()
    在虛擬機(jī)終止時，請求刪除此抽象路徑名表示的文件或目錄。
    17    public String[] list()
    返回由此抽象路徑名所表示的目錄中的文件和目錄的名稱所組成字符串?dāng)?shù)組。
    18    public String[] list(FilenameFilter filter)
    返回由包含在目錄中的文件和目錄的名稱所組成的字符串?dāng)?shù)組，這一目錄是通過滿足指定過濾器的抽象路徑名來表示的。
    19    public File[] listFiles()
      返回一個抽象路徑名數(shù)組，這些路徑名表示此抽象路徑名所表示目錄中的文件。
    20    public File[] listFiles(FileFilter filter)
    返回表示此抽象路徑名所表示目錄中的文件和目錄的抽象路徑名數(shù)組，這些路徑名滿足特定過濾器。
    21    public boolean mkdir()
    創(chuàng)建此抽象路徑名指定的目錄。
    22    public boolean mkdirs()
    創(chuàng)建此抽象路徑名指定的目錄，包括創(chuàng)建必需但不存在的父目錄。
    23    public boolean renameTo(File dest)
     重新命名此抽象路徑名表示的文件。
    24    public boolean setLastModified(long time)
    設(shè)置由此抽象路徑名所指定的文件或目錄的最后一次修改時間。
    25    public boolean setReadOnly()
    標(biāo)記此抽象路徑名指定的文件或目錄，以便只可對其進(jìn)行讀操作。
    26    public static File createTempFile(String prefix, String suffix, File directory) throws IOException
    在指定目錄中創(chuàng)建一個新的空文件，使用給定的前綴和后綴字符串生成其名稱。
    27    public static File createTempFile(String prefix, String suffix) throws IOException
    在默認(rèn)臨時文件目錄中創(chuàng)建一個空文件，使用給定前綴和后綴生成其名稱。
    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類繼承而來,該類按字符讀取流中數(shù)據(jù).
用法:
    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數(shù)組，返回讀取到字符的個數(shù)
例子:
    import java.io.*;
    public class FileRead{
       public static void main(String args[])throws IOException{
          File file = new File("Hello1.txt");
          // 創(chuàng)建文件
          file.createNewFile();
          // creates a FileWriter Object
          FileWriter writer = new FileWriter(file); 
          // 向文件寫入內(nèi)容
          writer.write("This
 is
 an
 example
"); 
          writer.flush();
          writer.close();
          // 創(chuàng)建 FileReader 對象
          FileReader fr = new FileReader(file); 
          char [] a = new char[50];
          fr.read(a); // 讀取數(shù)組中的內(nèi)容
          for(char c : a)
              System.out.print(c); // 一個一個打印字符
          fr.close();
       }
    }
    

JAVA FileWriter類

FileWriter類從OutputStreamReader類繼承而來。該類按字符向流中寫入數(shù)據(jù)
用法:
    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)
    寫入字符數(shù)組中開始為offset長度為len的某一部分。
    3    public void write(String s, int offset, int len)
    寫入字符串中開始為offset長度為len的某一部分。

Java 繼承

JAVA中,類的繼承是單一繼承,一個子類只能擁有一個父類
繼承中最常使用的兩個關(guān)鍵字: extends 和 implements
這兩個關(guān)鍵字的使用決定了一個對象和另一個對象是否是IS-A(是一個)關(guān)系
通過使用這兩個關(guān)鍵字,我們能實現(xiàn)一個對象獲取另一個對象的屬性
所有JAVA的類均是由java.lang.Object類繼承而來的,所以O(shè)bject是所有類的祖先類,
除了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卻沒有訪問權(quán)限,這保障了A的封裝性

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

    public class Mammal extends Animal{
    }

    public class Reptile extends Animal{
    }

    public class Dog extends Mammal{
    }
    分析以上示例中的IS-A關(guān)系,如下：
        Mammal IS-A Animal
        Reptile IS-A Animal
        Dog IS-A Mammal
        因此 : Dog IS-A Animal
通過使用關(guān)鍵字 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 關(guān)鍵字
    使用在類繼承接口的情況下.這種情況下不能使用extends

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

JAVA重寫Override與重載Overload

重寫是子類對父類的允許訪問的方法的實現(xiàn)過程進(jìn)行重新編寫,返回值和形參不能改變
重寫的好處在于子類可以根據(jù)需求,定義特定于自己的行為
也就是說子類能夠根據(jù)需要實現(xiàn)父類的方法
例子:
    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();    //執(zhí)行 Animal 類的方法
            b.moev();    //執(zhí)行 Dog 類的方法
        }
    }
    
    在上面的例子中可以看到，盡管b屬于Animal類型，但是它運行的是Dog類的move方法。
    這是由于在編譯階段，只是檢查參數(shù)的引用類型。
    然而在運行時，Java虛擬機(jī)(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();// 執(zhí)行 Animal 類的方法
          b.move();//執(zhí)行 Dog 類的方法
          b.bark();
       }
    }
    運行結(jié)果:
        TestDog.java:30: cannot find symbol
        symbol  : method bark()
        location: class Animal
                        b.bark();
                        
    該程序?qū)伋鲆粋€編譯錯誤,因為b的引用類型Animal沒有bark方法
    
方寫重寫的規(guī)則
    參數(shù)列表必須完全與被重寫方法的相同；
    返回類型必須完全與被重寫方法的返回類型相同；
    訪問權(quán)限不能比父類中被重寫的方法的訪問權(quán)限更高。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected。
    父類的成員方法只能被它的子類重寫。
    聲明為 final 的方法不能被重寫。
    聲明為 static 的方法不能被重寫，但是能夠被再次聲明。
    如果一個方法不能被繼承，那么該方法不能被重寫。
    子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為 private 和 final 的方法。
    子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為 public 和 protected 的非 final 方法。
    重寫的方法能夠拋出任何非強(qiáng)制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強(qiáng)制性異常，或者比被重寫方法聲明的更廣泛的強(qiáng)制性異常，反之則可以。
    構(gòu)造方法不能被重寫。
    如果不能繼承一個方法，則不能重寫這個方法

Super關(guān)鍵字的使用
    當(dāng)需要在子類中調(diào)用父類的被重寫方法時,要使用super關(guān)鍵字
    class Animal{
        public void move(){
            System.out.println("anmial can move");
        }
    }
    
    class Dog extends Animall{
        public void move(){
            super.move();    //調(diào)用 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) 是在一個類里面, 方法名字相同, 而參數(shù)不同.返回類型呢？可以相同也可以不同
    
    重載規(guī)則:
        被重載的方法必須改變參數(shù)列表；
        被重載的方法可以改變返回類型；
        被重載的方法可以改變訪問修飾符；
        被重載的方法可以聲明新的或更廣的檢查異常；
        方法能夠在同一個類中或者在一個子類中被重載
        
    例子:
        public class Overloading {

        public int test(){
            System.out.println("test1");
            return 1;
        }
     
        public void test(int a){
            System.out.println("test2");
        }    
     
        //以下兩個參數(shù)類型順序不同
        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));
        }

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

JAVA多態(tài)

多態(tài),是同一個行為具有多個不同表現(xiàn)形式或形態(tài)的能力
比如我們說"寵物"這個對象，它就有很多不同的表達(dá)或?qū)崿F(xiàn)，比如有小貓、小狗、蜥蜴等等。
那么我到寵物店說"請給我一只寵物"，服務(wù)員給我小貓、小狗或者蜥蜴都可以，我們就說"寵物"這個對象就具備多態(tài)性

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

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

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

    例子(仔細(xì)看):
        /* 文件名 : 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();
            }
        }
        
        運行結(jié)果:
            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類中的聲明。
            在調(diào)用s.mailCheck()時，Java虛擬機(jī)(JVM)調(diào)用Salary類的mailCheck()方法。
            因為e是Employee的引用，所以調(diào)用e的mailCheck()方法則有完全不同的結(jié)果。
            當(dāng)編譯器檢查e.mailCheck()方法時，編譯器檢查到Employee類中的mailCheck()方法。
            在編譯的時候，編譯器使用Employee類中的mailCheck()方法驗證該語句， 但是在運行的時候，Java虛擬機(jī)(JVM)調(diào)用的是Salary類中的mailCheck()方法。
            該行為被稱為虛擬方法調(diào)用，該方法被稱為虛擬方法。
            
            Java中所有的方法都能以這種方式表現(xiàn)，借此，重寫的方法能在運行時調(diào)用，不管編譯的時候源代碼中引用變量是什么數(shù)據(jù)類型。
            

JAVA抽象類

在面向?qū)ο蟮母拍钪?所有的對象都是通過類來描繪的,但是反過來,并不是所有的類都是用來描繪對象的,
如果一個類中沒有包含足夠的信息來描述一個具體的對象,這樣的類就是抽象類

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

定義一個抽象類:
    /* 文件名 : 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個構(gòu)造方法.
    現(xiàn)在如果你嘗試如下的例子:
        /* 文件名 : AbstractDemo.java */
        public class AbstractDemo
        {
           public static vo