Java入門基礎知識有哪些

這篇文章主要介紹“Java入門基礎知識有哪些”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Java入門基礎知識有哪些”文章能幫助大家解決問題。

Java 是由Sun Microsystems公司于1995年5月推出的高級程序設計語言。

Java可運行于多個平臺，如Windows, Mac OS，及其他多種UNIX版本的系統。

創建java文件(文件名需與類名一致)

http:/ /www.iis7.com/b/wzjk/

String args[] 與 String[] args 都可以執行，但推薦使用 String[] args，這樣可以避免歧義和誤讀。

:::::::::::::::::::::::::::::::::::::::::::

Java 簡介

Java是由Sun Microsystems公司于1995年5月推出的Java面向對象程序設計語言和Java平臺的總稱。由James Gosling和同事們共同研發，并在1995年正式推出。

Java分為三個體系：

JavaSE(J2SE)    (Java2 Platform Standard Edition，java平臺標準版)

JavaEE(J2EE)    (Java 2 Platform,Enterprise Edition，java平臺企業版)

JavaME(J2ME) (Java 2 Platform Micro Edition，java平臺微型版)。

2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各種版本已經更名以取消其中的數字"2"：J2EE更名為Java EE, J2SE更名為Java SE，J2ME更名為Java ME。

。。。。。。

主要特性

1. Java語言是簡單的：

Java語言的語法與C語言和C++語言很接近，使得大多數程序員很容易學習和使用。另一方面，Java丟棄了C++中很少使用的、很難理解的、令人迷惑的那些特性，如操作符重載、多繼承、自動的強制類型轉換。特別地，Java語言不使用指針，而是引用。并提供了自動的廢料收集，使得程序員不必為內存管理而擔憂。

2. Java語言是面向對象的：

Java語言提供類、接口和繼承等面向對象的特性，為了簡單起見，只支持類之間的單繼承，但支持接口之間的多繼承，并支持類與接口之間的實現機制（關鍵字為implements）。Java語言全面支持動態綁定，而C++語言只對虛函數使用動態綁定。總之，Java語言是一個純的面向對象程序設計語言。

3. Java語言是分布式的：

Java語言支持Internet應用的開發，在基本的Java應用編程接口中有一個網絡應用編程接口（java net），它提供了用于網絡應用編程的類庫，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（遠程方法激活）機制也是開發分布式應用的重要手段。

4. Java語言是健壯的：

Java的強類型機制、異常處理、垃圾的自動收集等是Java程序健壯性的重要保證。對指針的丟棄是Java的明智選擇。Java的安全檢查機制使得Java更具健壯性。

5. Java語言是安全的：

Java通常被用在網絡環境中，為此，Java提供了一個安全機制以防惡意代碼的攻擊。除了Java語言具有的許多安全特性以外，Java對通過網絡下載的類具有一個安全防范機制（類ClassLoader裝載器），如分配不同的名字空間以防替代本地的同名類、字節代碼檢查，并提供安全管理機制（類SecurityManager）讓Java應用設置安全哨兵。

6. Java語言是體系結構中立的：

Java程序（后綴為java的文件）在Java平臺上被編譯為體系結構中立的字節碼格式（后綴為class的文件），然后可以在實現這個Java平臺的任何系統中運行。這種途徑適合于異構的網絡環境和軟件的分發。

7. Java語言是可移植的：

這種可移植性來源于體系結構中立性，另外，Java還嚴格規定了各個基本數據類型的長度。Java系統本身也具有很強的可移植性，Java編譯器是用Java實現的，Java的運行環境是用ANSI C實現的。

8. Java語言是解釋型的：

如前所述，Java程序在Java平臺上被編譯為字節碼格式，然后可以在實現這個Java平臺的任何系統中運行。在運行時，Java平臺中的Java解釋器對這些字節碼進行解釋執行，執行過程中需要的類在聯接階段被載入到運行環境中。

9. Java是高性能的：

與那些解釋型的高級腳本語言相比，Java的確是高性能的。事實上，Java的運行速度隨著JIT(Just-In-Time）編譯器技術的發展越來越接近于C++。

10. Java語言是多線程的：

在Java語言中，線程是一種特殊的對象，它必須由Thread類或其子（孫）類來創建。通常有兩種方法來創建線程：其一，使用型構為Thread(Runnable)的構造子將一個實現了Runnable接口的對象包裝成一個線程，其二，從Thread類派生出子類并重寫run方法，使用該子類創建的對象即為線程。值得注意的是Thread類已經實現了Runnable接口，因此，任何一個線程均有它的run方法，而run方法中包含了線程所要運行的代碼。線程的活動由一組方法來控制。Java語言支持多個線程的同時執行，并提供多線程之間的同步機制（關鍵字為synchronized）。

11. Java語言是動態的：

Java語言的設計目標之一是適應于動態變化的環境。Java程序需要的類能夠動態地被載入到運行環境，也可以通過網絡來載入所需要的類。這也有利于軟件的升級。另外，Java中的類有一個運行時刻的表示，能進行運行時刻的類型檢查。

。。。。。。

發展歷史

1995年5月23日，Java語言誕生

1996年1月，第一個JDK-JDK1.0誕生

1996年4月，10個最主要的操作系統供應商申明將在其產品中嵌入JAVA技術

1996年9月，約8.3萬個網頁應用了JAVA技術來制作

1997年2月18日，JDK1.1發布

1997年4月2日，JavaOne會議召開，參與者逾一萬人，創當時全球同類會議規模之紀錄

1997年9月，JavaDeveloperConnection社區成員超過十萬

1998年2月，JDK1.1被下載超過2,000,000次

1998年12月8日，JAVA2企業平臺J2EE發布

1999年6月，SUN公司發布Java的三個版本：標準版（JavaSE,以前是J2SE）、企業版（JavaEE以前是J2EE）和微型版（JavaME，以前是J2ME）

2000年5月8日，JDK1.3發布

2000年5月29日，JDK1.4發布

2001年6月5日，NOKIA宣布，到2003年將出售1億部支持Java的手機

2001年9月24日，J2EE1.3發布

2002年2月26日，J2SE1.4發布，自此Java的計算能力有了大幅提升

2004年9月30日18:00PM，J2SE1.5發布，成為Java語言發展史上的又一里程碑。為了表示該版本的重要性，J2SE1.5更名為Java SE 5.0

2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各種版本已經更名，以取消其中的數字"2"：J2EE更名為Java EE，J2SE更名為Java SE，J2ME更名為Java ME

2006年12月，SUN公司發布JRE6.0

2009年04月20日，甲骨文74億美元收購Sun。取得java的版權。

2010年11月，由于甲骨文對于Java社區的不友善，因此Apache揚言將退出JCP[4]。

2011年7月28日，甲骨文發布java7.0的正式版。

2014年3月18日，Oracle公司發表Java SE 8。

。。。。。。

JDK環境配置：

1. 到官網下載JDK

2. 安裝(根據提示就可以)

3. 打開我的電腦--高級系統設置--系統變量

添加JAVA_HOME：根據自己的實際安裝路徑來添加

添加CLASSPATH： .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;   //記得前面有個"."

編輯系統變量的path：在最前面加上：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

然后在開始那里找到cmd輸入java -version，java，javac，看看是否搭建成功。

。。。。。。

Java開發工具

Java語言盡量保證系統內存在1G以上，其他工具如下所示：

Linux 系統、Mac OS 系統、Windows 95/98/2000/XP，WIN 7/8系統。

Java JDK 7、8……

Notepad 編輯器或者其他編輯器。

IDE：Eclipse

安裝好以上的工具后，我們就可以輸出Java的第一個程序"Hello World！"

::::::::::::::::::::::::::::::::::::::::::::::::

Java 基礎語法

一個Java程序可以認為是一系列對象的集合，而這些對象通過調用彼此的方法來協同工作。下面簡要介紹下類、對象、方法和實例變量的概念。

對象：對象是類的一個實例，有狀態和行為。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。

類：類是一個模板，它描述一類對象的行為和狀態。

方法：方法就是行為，一個類可以有很多方法。邏輯運算、數據修改以及所有動作都是在方法中完成的。

實例變量：每個對象都有獨特的實例變量，對象的狀態由這些實例變量的值決定。

。。。。。。

基本語法

編寫Java程序時，應注意以下幾點：

大小寫敏感：Java是大小寫敏感的，這就意味著標識符Hello與hello是不同的。

類名：對于所有的類來說，類名的首字母應該大寫。如果類名由若干單詞組成，那么每個單詞的首字母應該大寫，例如 MyFirstJavaClass 。

方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則后面的每個單詞首字母大寫。

源文件名：源文件名必須和類名相同。當保存文件的時候，你應該使用類名作為文件名保存（切記Java是大小寫敏感的），文件名的后綴為.java。（如果文件名和類名不相同則會導致編譯錯誤）

主方法入口：所有的Java 程序由public static void main(String []args)方法開始執行。

。。。。。。

Java標識符

Java所有的組成部分都需要名字。類名、變量名以及方法名都被稱為標識符。

關于Java標識符，有以下幾點需要注意：

所有的標識符都應該以字母（A-Z或者a-z）,美元符（$）、或者下劃線（_）開始

首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下劃線（_）或數字的任何字符組合

關鍵字不能用作標識符

標識符是大小寫敏感的

合法標識符舉例：age、$salary、_value、__1_value

非法標識符舉例：123abc、-salary

。。。。。。

Java修飾符

像其他語言一樣，Java可以使用修飾符來修飾類中方法和屬性。主要有兩類修飾符：

訪問控制修飾符 : default, public , protected, private

非訪問控制修飾符 : final, abstract, strictfp

。。。。。。

Java變量

Java中主要有如下幾種類型的變量

局部變量

類變量（靜態變量）

成員變量（非靜態變量）

。。。。。。

Java數組

數組是儲存在堆上的對象，可以保存多個同類型變量。

。。。。。。

Java枚舉

Java 5.0引入了枚舉，枚舉限制變量只能是預先設定好的值。使用枚舉可以減少代碼中的bug。

例如，我們為果汁店設計一個程序，它將限制果汁為小杯、中杯、大杯。這就意味著它不允許顧客點除了這三種尺寸外的果汁。

注意：枚舉可以單獨聲明或者聲明在類里面。方法、變量、構造函數也可以在枚舉中定義。

。。。。。。

Java關鍵字

下面列出了Java保留字。這些保留字不能用于常量、變量、和任何標識符的名稱。

關鍵字        描述

abstract    抽象方法，抽象類的修飾符

assert        斷言條件是否滿足

boolean    布爾數據類型

break        跳出循環或者label代碼段

byte8-bit    有符號數據類型

caseswitch  語句的一個條件

catch        和try搭配捕捉異常信息

char16-bit  Unicode字符數據類型

class            定義類

const        未使用

continue    不執行循環體剩余部分

default        switch語句中的默認分支

do            循環語句，循環體至少會執行一次

double        64-bit雙精度浮點數

else            if條件不成立時執行的分支

enum        枚舉類型

extends    表示一個類是另一個類的子類

final            表示一個值在初始化之后就不能再改變了，表示方法不能被重寫，或者一個類不能有子類

finally        為了完成執行的代碼而設計的，主要是為了程序的健壯性和完整性，無論有沒有異常發生都執行代碼。

float            32-bit單精度浮點數

for            for循環語句

goto        未使用

if                條件語句

implements表示一個類實現了接口

import        導入類

instanceof測試一個對象是否是某個類的實例

int            32位整型數

interface    接口，一種抽象的類型，僅有方法和常量的定義

long            64位整型數

native        表示方法用非java代碼實現

new            分配新的類實例

package    一系列相關類組成一個包

private        表示私有字段，或者方法等，只能從類內部訪問

protected表示字段只能通過類或者其子類訪問，子類或者在同一個包內的其他類

public        表示共有屬性或者方法

return        方法返回值

short        16位數字

static         表示在類級別定義，所有實例共享的

strictfp         浮點數比較使用嚴格的規則

super         表示基類

switch         選擇語句

synchronized表示同一時間只能由一個線程訪問的代碼塊

this              表示調用當前實例，或者調用另一個構造函數

throw          拋出異常

throws          定義方法可能拋出的異常

transient      修飾不要序列化的字段

try              表示代碼塊要做異常處理或者和finally配合表示是否拋出異常都執行finally中的代碼

void              標記方法不返回任何值

volatile      標記字段可能會被多個線程同時訪問，而不做同步

while           while循環

。。。。。。

Java注釋

java中的，//單行注釋

java中的，/*多行注釋*/

類似于C/C++，Java也支持單行以及多行注釋。注釋中的字符將被Java編譯器忽略。

。。。。。。

Java 空行

空白行，或者有注釋的的行，Java編譯器都會忽略掉。

。。。。。。

繼承

在Java中，一個類可以由其他類派生。如果你要創建一個類，而且已經存在一個類具有你所需要的屬性或方法，那么你可以將新創建的類繼承該類。

利用繼承的方法，可以重用已存在類的方法和屬性，而不用重寫這些代碼。被繼承的類稱為超類（super class），派生類稱為子類（subclass）。

。。。。。。

接口

在Java中，接口可理解為對象間相互通信的協議。接口在繼承中扮演著很重要的角色。

接口只定義派生要用到的方法，但是方法的具體實現完全取決于派生類。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 對象和類

Java作為一種面向對象語言。支持以下基本概念：

：多態

：繼承

：封裝

：抽象

：類

：對象

：實例

：方法

：消息解析

。。。。。。

我們先來研究對象和類的概念。

對象：對象是類的一個實例，有狀態和行為。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。

類：類是一個模板，它描述一類對象的行為和狀態。(抽象類：如動物，人等)

。。。

Java中的對象

現在讓我們深入了解什么是對象。看看周圍真實的世界，會發現身邊有很多對象，車，狗，人等等。所有這些對象都有自己的狀態和行為。

拿一條狗來舉例，它的狀態有：名字、品種、顏色，行為有：叫、搖尾巴和跑。

對比現實對象和軟件對象，它們之間十分相似。

軟件對象也有狀態和行為。軟件對象的狀態就是屬性，行為通過方法體現。

在軟件開發中，方法操作對象內部狀態的改變，對象的相互調用也是通過方法來完成。

。。。

Java中的類

類可以看成是創建Java對象的模板。

通過下面一個簡單的類來理解下Java中類的定義：

public class Dog{

   String breed;

   int age;

   String color;

   void barking(){

   }

   void hungry(){

   }

   void sleeping(){

   }

}

一個類可以包含以下類型變量：

局部變量：在方法、構造方法或者語句塊中定義的變量被稱為局部變量。變量聲明和初始化都是在方法中，方法結束后，變量就會自動銷毀。

成員變量：成員變量是定義在類中，方法體之外的變量。這種變量在創建對象的時候實例化。成員變量可以被類中方法、構造方法和特定類的語句塊訪問。

類變量：類變量也聲明在類中，方法體之外，但必須聲明為static類型。

一個類可以擁有多個方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog類的方法。

。。。

構造方法

每個類都有構造方法。如果沒有顯式地為類定義構造方法，Java編譯器將會為該類提供一個默認構造方法。

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

下面是一個構造方法示例：

public class Puppy{

   public Puppy(){

   }

   public Puppy(String name){

      // 這個構造器僅有一個參數：name

   }

}

。。。

創建對象

對象是根據類創建的。在Java中，使用關鍵字new來創建一個新的對象。創建對象需要以下三步：

聲明：聲明一個對象，包括對象名稱和對象類型。

實例化：使用關鍵字new來創建一個對象。

初始化：使用new創建對象時，會調用構造方法初始化對象。

下面是一個創建對象的例子：

public class Puppy{

   public Puppy(String name){

      //這個構造器僅有一個參數：name

      System.out.println("Passed Name is :" + name ); 

   }

   public static void main(String []args){

      // 下面的語句將創建一個Puppy對象

      Puppy myPuppy = new Puppy( "tommy" );

   }

}

編譯并運行上面的程序，會打印出右面的結果：Passed Name is :tommy

。。。

訪問實例變量和方法

通過已創建的對象來訪問成員變量和成員方法，如下所示：

/* 實例化對象 */

ObjectReference = new Constructor();

/* 訪問其中的變量 */

ObjectReference.variableName;

/* 訪問類中的方法 */

ObjectReference.MethodName();

。。。

實例

下面的例子展示如何訪問實例變量和調用成員方法：

public class Puppy{

   int puppyAge;

   public Puppy(String name){

      // 這個構造器僅有一個參數：name

      System.out.println("Passed Name is :" + name ); 

   }

   public void setAge( int age ){

       puppyAge = age;

   }

   public int getAge( ){

       System.out.println("Puppy's age is :" + puppyAge ); 

       return puppyAge;

   }

   public static void main(String []args){

      /* 創建對象 */

      Puppy myPuppy = new Puppy( "tommy" );

      /* 通過方法來設定age */

      myPuppy.setAge( 2 );

      /* 調用另一個方法獲取age */

      myPuppy.getAge( );

      /*你也可以像下面這樣訪問成員變量 */

      System.out.println("Variable Value :" + myPuppy.puppyAge ); 

   }

}

編譯并運行上面的程序，產生如下結果：

Passed Name is :tommy

Puppy's age is :2

Variable Value :2

。。。

源文件聲明規則

我們來學習源文件的聲明規則。當在一個源文件中定義多個類，并且還有import語句和package語句時，要特別注意這些規則。

一個源文件中只能有一個public類

一個源文件可以有多個非public類

源文件的名稱應該和public類的類名保持一致。例如：源文件中public類的類名是Employee，那么源文件應該命名為Employee.java。

如果一個類定義在某個包中，那么package語句應該在源文件的首行。

如果源文件包含import語句，那么應該放在package語句和類定義之間。如果沒有package語句，那么import語句應該在源文件中最前面。

import語句和package語句對源文件中定義的所有類都有效。在同一源文件中，不能給不同的類不同的包聲明。

類有若干種訪問級別，并且類也分不同的類型：抽象類和final類等。

除了上面提到的幾種類型，Java還有一些特殊的類，如：內部類、匿名類。

。。。

Java包

包主要用來對類和接口進行分類。當開發Java程序時，可能編寫成百上千的類，因此很有必要對類和接口進行分類。

。。。

import語句

在Java中，如果給出一個完整的限定名，包括包名、類名，那么Java編譯器就可以很容易地定位到源代碼或者類。import語句就是用來提供一個合理的路徑，使得編譯器可以找到某個類。

例如，右面的命令行將會命令編譯器載入java_installation/java/io路徑下的所有類，import java.io.*;

一個簡單的例子

在該例子中，我們創建兩個類：Employee和EmployeeTest。

首先打開文本編輯器，把下面的代碼粘貼進去。注意將文件保存為Employee.java。

Employee類有四個成員變量：name、age、designation和salary。該類顯式聲明了一個構造方法，該方法只有一個參數。

import java.io.*;

public class Employee{

   String name;

   int age;

   String designation;

   double salary;

   // Employee 類的構造器

   public Employee(String name){

      this.name = name;

   }

   // 設置age的值

   public void empAge(int empAge){

      age =  empAge;

   }

   /* 設置designation的值*/

   public void empDesignation(String empDesig){

      designation = empDesig;

   }

   /* 設置salary的值*/

   public void empSalary(double empSalary){

      salary = empSalary;

   }

   /* 打印信息 */

   public void printEmployee(){

      System.out.println("Name:"+ name );

      System.out.println("Age:" + age );

      System.out.println("Designation:" + designation );

      System.out.println("Salary:" + salary);

   }

}

程序都是從main方法開始執行。為了能運行這個程序，必須包含main方法并且創建一個實例對象。

下面給出EmployeeTest類，該類實例化2個Employee類的實例，并調用方法設置變量的值。

將下面的代碼保存在EmployeeTest.java文件中。

import java.io.*;

public class EmployeeTest{

   public static void main(String args[]){

      /* 使用構造器創建兩個對象 */

      Employee empOne = new Employee("James Smith");

      Employee empTwo = new Employee("Mary Anne");

      // 調用這兩個對象的成員方法

      empOne.empAge(26);

      empOne.empDesignation("Senior Software Engineer");

      empOne.empSalary(1000);

      empOne.printEmployee();

      empTwo.empAge(21);

      empTwo.empDesignation("Software Engineer");

      empTwo.empSalary(500);

      empTwo.printEmployee();

   }

}

編譯這兩個文件并且運行EmployeeTest類，可以看到如下結果：

C :> javac Employee.java

C :> vi EmployeeTest.java

C :> javac  EmployeeTest.java

C :> java EmployeeTest

Name:James Smith

Age:26

Designation:Senior Software Engineer

Salary:1000.0

Name:Mary Anne

Age:21

Designation:Software Engineer

Salary:500.0

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 基本數據類型

變量就是申請內存來存儲值。也就是說，當創建變量的時候，需要在內存中申請空間。

內存管理系統根據變量的類型為變量分配存儲空間，分配的空間只能用來儲存該類型數據。

因此，通過定義不同類型的變量，可以在內存中儲存整數、小數或者字符。

Java的兩大數據類型：內置數據類型，引用數據類型

。。。

內置數據類型

Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字符類型，還有一種布爾型。

byte：

byte數據類型是8位、有符號的，以二進制補碼表示的整數；

最小值是-128（-2^7）；

最大值是127（2^7-1）；

默認值是0；

byte類型用在大型數組中節約空間，主要代替整數，因為byte變量占用的空間只有int類型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short數據類型是16位、有符號的以二進制補碼表示的整數

最小值是-32768（-2^15）；

最大值是32767（2^15 - 1）；

Short數據類型也可以像byte那樣節省空間。一個short變量是int型變量所占空間的二分之一；

默認值是0；

例子：short s = 1000，short r = -20000。

int：

int數據類型是32位、有符號的以二進制補碼表示的整數；

最小值是-2,147,483,648（-2^31）；

最大值是2,147,483,647（2^31 - 1）；

一般地整型變量默認為int類型；

默認值是0；

例子：int a = 100000, int b = -200000。

long：

long數據類型是64位、有符號的以二進制補碼表示的整數；

最小值是-9,223,372,036,854,775,808（-2^63）；

最大值是9,223,372,036,854,775,807（2^63 -1）；

這種類型主要使用在需要比較大整數的系統上；

默認值是0L；

例子： long a = 100000L，long b = -200000L。

float：

float數據類型是單精度、32位、符合IEEE 754標準的浮點數；

float在儲存大型浮點數組的時候可節省內存空間；

默認值是0.0f；

浮點數不能用來表示精確的值，如貨幣；

例子：float f1 = 234.5f。

double：

double數據類型是雙精度、64位、符合IEEE 754標準的浮點數；

浮點數的默認類型為double類型；

double類型同樣不能表示精確的值，如貨幣；

默認值是0.0d；

例子：double d1 = 123.4。

boolean：

boolean數據類型表示一位的信息；

只有兩個取值：true和false；

這種類型只作為一種標志來記錄true/false情況；

默認值是false；

例子：boolean one = true。

char：

char類型是一個單一的16位Unicode字符；

最小值是’\u0000’（即為0）；

最大值是’\uffff’（即為65,535）；

char數據類型可以儲存任何字符；

例子：char letter = ‘A’。

對于數值類型的基本類型的取值范圍，我們無需強制去記憶，因為它們的值都已經以常量的形式定義在對應的包裝類中了。

Float和Double的最小值和最大值都是以科學記數法的形式輸出的，結尾的"E+數字"表示E之前的數字要乘以10的“數字”次冪。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

實際上，JAVA中還存在另外一種基本類型void，它也有對應的包裝類 java.lang.Void，不過我們無法直接對它們進行操作。

。。。

引用類型

引用類型變量由類的構造函數創建，可以使用它們訪問所引用的對象。這些變量在聲明時被指定為一個特定的類型，比如Employee、Pubby等。變量一旦聲明后，類型就不能被改變了。

對象、數組都是引用數據類型。

所有引用類型的默認值都是null。

一個引用變量可以用來引用與任何與之兼容的類型。例子：Animal animal = new Animal(“giraffe”)。

。。。

Java常量

常量就是一個固定值。它們不需要計算，直接代表相應的值。

常量指不能改變的量。 在Java中用final標志，聲明方式和變量類似：

final double PI = 3.1415927;

雖然常量名也可以用小寫，但為了便于識別，通常使用大寫字母表示常量。

字面量可以賦給任何內置類型的變量。例如：

byte a = 68;

char a = 'A'

byte、int、long、和short都可以用十進制、16進制以及8進制的方式來表示。

當使用常量的時候，前綴0表明是8進制，而前綴0x代表16進制。例如：

int decimal = 100;

int octal = 0144;

int hexa =  0x64;

和其他語言一樣，Java的字符串常量也是包含在兩個引號之間的字符序列。下面是字符串型字面量的例子：

"Hello World"

"two\nlines"

"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';

String a = "\u0001";

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

符號    字符含義

\n        換行 (0x0a)

\r        回車 (0x0d)

\f        換頁符(0x0c)

\b        退格 (0x08)

\s        空格 (0x20)

\t        制表符

\"        雙引號

\'        單引號

\        反斜杠

\ddd    八進制字符 (ddd)

\uxxxx16進制Unicode字符 (xxxx)

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 變量類型

在Java語言中，所有的變量在使用前必須聲明。聲明變量的基本格式如右：type identifier [ = value][, identifier [= value] ...] ;

格式說明：type為Java數據類型。identifier是變量名。可以使用逗號隔開來聲明多個同類型變量。

以下列出了一些變量的聲明實例。注意有些包含了初始化過程。

int a, b, c;                   // 聲明三個int型整數：a、b、c。

int d = 3, e, f = 5;      // 聲明三個整數并賦予初值。

byte z = 22;               // 聲明并初始化z。

double pi = 3.14159; // 聲明了pi。

char x = 'x';                // 變量x的值是字符'x'。

Java語言支持的變量類型有：局部變量，實例變量，類變量

。。。

Java局部變量

-局部變量聲明在方法、構造方法或者語句塊中；

-局部變量在方法、構造方法、或者語句塊被執行的時候創建，當它們執行完成后，變量將會被銷毀；

-訪問修飾符不能用于局部變量；

-局部變量只在聲明它的方法、構造方法或者語句塊中可見；

-局部變量是在棧上分配的。

-局部變量沒有默認值，所以局部變量被聲明后，必須經過初始化，才可以使用。

實例1

在以下實例中age是一個局部變量。定義在pupAge()方法中，它的作用域就限制在這個方法中。

public class Test{ 

   public void pupAge(){

      int age = 0;

      age = age + 7;

      System.out.println("Puppy age is : " + age);

   }

   public static void main(String args[]){

      Test test = new Test();

      test.pupAge();

   }

}

以上實例編譯運行結果如右：Puppy age is: 7

實例2

在下面的例子中age變量沒有初始化，所以在編譯時出錯。

public class Test{ 

   public void pupAge(){

      int age;

      age = age + 7;

      System.out.println("Puppy age is : " + age);

   }

   public static void main(String args[]){

      Test test = new Test();

      test.pupAge();

   }

}

以上實例編譯運行結果如下:

Test.java:4:variable number might not have been initialized

age = age + 7;

         ^

1 error

。。。

Java實例變量

-實例變量聲明在一個類中，但在方法、構造方法和語句塊之外；

-當一個對象被實例化之后，每個實例變量的值就跟著確定；

-實例變量在對象創建的時候創建，在對象被銷毀的時候銷毀；

-實例變量的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取實例變量信息；

-實例變量可以聲明在使用前或者使用后；

-訪問修飾符可以修飾實例變量；

-實例變量對于類中的方法、構造方法或者語句塊是可見的。一般情況下應該把實例變量設為私有。通過使用訪問修飾符可以使實例變量對子類可見；

-實例變量具有默認值。數值型變量的默認值是0，布爾型變量的默認值是false，引用類型變量的默認值是null。變量的值可以在聲明時指定，也可以在構造方法中指定；

-實例變量可以直接通過變量名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。

實例子：

import java.io.*;

public class Employee{

   // 這個成員變量對子類可見

   public String name;

   // 私有變量，僅在該類可見

   private double salary;

   //在構造器中對name賦值

   public Employee (String empName){

      name = empName;

   }

   //設定salary的值

   public void setSalary(double empSal){

      salary = empSal;

   }  

   // 打印信息

   public void printEmp(){

      System.out.println("name  : " + name );

      System.out.println("salary :" + salary);

   }

   public static void main(String args[]){

      Employee empOne = new Employee("Ransika");

      empOne.setSalary(1000);

      empOne.printEmp();

   }

}

以上實例編譯運行結果如下:

name  : Ransika

salary :1000.0

。。。

Java類變量（靜態變量）

-類變量也稱為靜態變量，在類中以static關鍵字聲明，但必須在方法、構造方法和語句塊之外。

-無論一個類創建了多少個對象，類只擁有類變量的一份拷貝。

-靜態變量除了被聲明為常量外很少使用。常量是指聲明為public/private，final和static類型的變量。常量初始化后不可改變。

-靜態變量儲存在靜態存儲區。經常被聲明為常量，很少單獨使用static聲明變量。

-靜態變量在程序開始時創建，在程序結束時銷毀。

-與實例變量具有相似的可見性。但為了對類的使用者可見，大多數靜態變量聲明為public類型。

-默認值和實例變量相似。數值型變量默認值是0，布爾型默認值是false，引用類型默認值是null。變量的值可以在聲明的時候指定，也可以在構造方法中指定。此外，靜態變量還可以在靜態語句塊中初始化。

-靜態變量可以通過：ClassName.VariableName的方式訪問。

-類變量被聲明為public static final類型時，類變量名稱必須使用大寫字母。如果靜態變量不是public和final類型，其命名方式與實例變量以及局部變量的命名方式一致。

實例子：

import java.io.*;

public class Employee{

   //salary是靜態的私有變量

   private static double salary;

   // DEPARTMENT是一個常量

   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]){

      salary = 1000;

      System.out.println(DEPARTMENT+"average salary:"+salary);

   }

}

以上實例編譯運行結果如下:

Development average salary:1000

注意：如果其他類想要訪問該變量，可以這樣訪問：Employee.DEPARTMENT。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 修飾符

Java語言提供了很多修飾符，主要分為兩類：訪問修飾符，非訪問修飾符

修飾符用來定義類、方法或者變量，通常放在語句的最前端。我們通過下面的例子來說明：

public class className {

   // ...

}

private boolean myFlag;

static final double weeks = 9.5;

protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {

   // 方法體

}

。。。

訪問控制修飾符

-Java中，可以使用訪問控制符來保護對類、變量、方法和構造方法的訪問。Java支持4種不同的訪問權限。

-默認的，也稱為default，在同一包內可見，不使用任何修飾符。

-私有的，以private修飾符指定，在同一類內可見。

-共有的，以public修飾符指定，對所有類可見。

-受保護的，以protected修飾符指定，對同一包內的類和所有子類可見。

1. 默認訪問修飾符-不使用任何關鍵字

使用默認訪問修飾符聲明的變量和方法，對同一個包內的類是可見的。接口里的變量都隱式聲明為public static final,而接口里的方法默認情況下訪問權限為public。

實例：

如下例所示，變量和方法的聲明可以不使用任何修飾符。

String version = "1.5.1";

boolean processOrder() {

   return true;

}

2. 私有訪問修飾符-private

私有訪問修飾符是最嚴格的訪問級別，所以被聲明為private的方法、變量和構造方法只能被所屬類訪問，并且類和接口不能聲明為private。

聲明為私有訪問類型的變量只能通過類中公共的getter方法被外部類訪問。

Private訪問修飾符的使用主要用來隱藏類的實現細節和保護類的數據。

下面的類使用了私有訪問修飾符：

public class Logger {

   private String format;

   public String getFormat() {

      return this.format;

   }

   public void setFormat(String format) {

      this.format = format;

   }

}

實例中，Logger類中的format變量為私有變量，所以其他類不能直接得到和設置該變量的值。為了使其他類能夠操作該變量，定義了兩個public方法：getFormat() （返回format的值）和setFormat(String)（設置format的值）

3. 公有訪問修飾符-public

被聲明為public的類、方法、構造方法和接口能夠被任何其他類訪問。

如果幾個相互訪問的public類分布在不同的包中，則需要導入相應public類所在的包。由于類的繼承性，類所有的公有方法和變量都能被其子類繼承。

以下函數使用了公有訪問控制：

public static void main(String[] arguments) {

   // ...

}

Java程序的main() 方法必須設置成公有的，否則，Java解釋器將不能運行該類。

4. 受保護的訪問修飾符-protected

被聲明為protected的變量、方法和構造器能被同一個包中的任何其他類訪問，也能夠被不同包中的子類訪問。

Protected訪問修飾符不能修飾類和接口，方法和成員變量能夠聲明為protected，但是接口的成員變量和成員方法不能聲明為protected。

子類能訪問Protected修飾符聲明的方法和變量，這樣就能保護不相關的類使用這些方法和變量。

下面的父類使用了protected訪問修飾符，子類重載了父類的openSpeaker()方法。

class AudioPlayer {

   protected boolean openSpeaker(Speaker sp) {

      // 實現細節

   }

}

class StreamingAudioPlayer {

   boolean openSpeaker(Speaker sp) {

      // 實現細節

   }

}

如果把openSpeaker()方法聲明為private，那么除了AudioPlayer之外的類將不能訪問該方法。如果把openSpeaker()聲明為public，那么所有的類都能夠訪問該方法。如果我們只想讓該方法對其所在類的子類可見，則將該方法聲明為protected。

。。

訪問控制和繼承

請注意以下方法繼承的規則：

-父類中聲明為public的方法在子類中也必須為public。

-父類中聲明為protected的方法在子類中要么聲明為protected，要么聲明為public。不能聲明為private。

-父類中默認修飾符聲明的方法，能夠在子類中聲明為private。

-父類中聲明為private的方法，不能夠被繼承。

。。。。。。

非訪問修飾符

為了實現一些其他的功能，Java也提供了許多非訪問修飾符。

static修飾符，用來創建類方法和類變量。

final修飾符，用來修飾類、方法和變量，final修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量為常量，是不可修改的。

abstract修飾符，用來創建抽象類和抽象方法。

synchronized和volatile修飾符，主要用于線程的編程。

。。。

1. static修飾符

靜態變量：

static關鍵字用來聲明獨立于對象的靜態變量，無論一個類實例化多少對象，它的靜態變量只有一份拷貝。靜態變量也被稱為類變量。局部變量不能被聲明為static變量。

靜態方法：

static關鍵字用來聲明獨立于對象的靜態方法。靜態方法不能使用類的非靜態變量。靜態方法從參數列表得到數據，然后計算這些數據。

對類變量和方法的訪問可以直接使用classname.variablename和classname.methodname的方式訪問。

2. final修飾符

final變量：

final變量能被顯式地初始化并且只能初始化一次。被聲明為final的對象的引用不能指向不同的對象。但是final對象里的數據可以被改變。也就是說final對象的引用不能改變，但是里面的值可以改變。

final修飾符通常和static修飾符一起使用來創建類常量。

。。

final方法

類中的Final方法可以被子類繼承，但是不能被子類修改。

聲明final方法的主要目的是防止該方法的內容被修改。

。。

final類

final類不能被繼承，沒有類能夠繼承final類的任何特性。

3. abstract修飾符

抽象類：

抽象類不能用來實例化對象，聲明抽象類的唯一目的是為了將來對該類進行擴充。

一個類不能同時被abstract和final修飾。如果一個類包含抽象方法，那么該類一定要聲明為抽象類，否則將出現編譯錯誤。

抽象類可以包含抽象方法和非抽象方法。

。。

抽象方法

抽象方法是一種沒有任何實現的方法，該方法的的具體實現由子類提供。抽象方法不能被聲明成final和static。

任何繼承抽象類的子類必須實現父類的所有抽象方法，除非該子類也是抽象類。

如果一個類包含若干個抽象方法，那么該類必須聲明為抽象類。抽象類可以不包含抽象方法。

抽象方法的聲明以分號結尾，例如：public abstract sample();

4. synchronized修飾符

synchronized關鍵字聲明的方法同一時間只能被一個線程訪問。Synchronized修飾符可以應用于四個訪問修飾符。

5. transient修飾符

序列化的對象包含被transient修飾的實例變量時，java虛擬機(JVM)跳過該特定的變量。

該修飾符包含在定義變量的語句中，用來預處理類和變量的數據類型。

6. volatile修飾符

volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。而且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。一個volatile對象引用可能是null。

:::::::::::::::::::::::::::::::::::::::::::::::::

Java 運算符

計算機的最基本用途之一就是執行數學運算，作為一門計算機語言，Java也提供了一套豐富的運算符來操縱變量。我們可以把運算符分成以下幾組：

1. 算術運算符

2. 關系運算符

3. 位運算符

4. 邏輯運算符

5. 賦值運算符

6. 其他運算符

。。。

算術運算符

算術運算符用在數學表達式中，它們的作用和在數學中的作用一樣。下表列出了所有的算術運算符。

下面的實例假設整數變量A的值為10，變量B的值為20：

操作符     描述                                               例子

+             加法 - 相加運算符兩側的值               A + B等于30

-             減法 - 左操作數減去右操作數           A – B等于-10

*             乘法 - 相乘操作符兩側的值               A * B等于200

/             除法 - 左操作數除以右操作數           B / A等于2

％             取模 - 左操作數除以右操作數的余數   B%A等于0

++        自增 - 操作數的值增加1                   B++ 或 ++B 等于 21

--            自減 - 操作數的值減少1                   B-- 或 --B 等于 19

。。。

關系運算符

下面為Java支持的關系運算符

下面中的實例整數變量A的值為10，變量B的值為20：

運算符    描述                                                                                                         例子

==        檢查如果兩個操作數的值是否相等，如果相等則條件為真。                    （A == B）為假(非真)。

!=        檢查如果兩個操作數的值是否相等，如果值不相等則條件為真。             (A != B) 為真。

>            檢查左操作數的值是否大于右操作數的值，如果是那么條件為真。            （A> B）非真。

<            檢查左操作數的值是否小于右操作數的值，如果是那么條件為真。            （A <B）為真。

> =        檢查左操作數的值是否大于或等于右操作數的值，如果是那么條件為真。（A> = B）為假。

<=        檢查左操作數的值是否小于或等于右操作數的值，如果是那么條件為真。（A <= B）為真。

。。。

位運算符

Java定義了位運算符，應用于整數類型(int)，長整型(long)，短整型(short)，字符型(char)，和字節型(byte)等類型。

位運算符作用在所有的位上，并且按位運算。假設a = 60，和b = 13;它們的二進制格式表示將如下：

A = 0011 1100

B = 0000 1101

-----------------

A&b = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

下面列出了位運算符的基本運算,假設整數變量A的值為60和變量B的值為13：

操作符   描述                                                                                                                                    例子

＆           按位與操作符，當且僅當兩個操作數的某一位都非0時候結果的該位才為1。                       （A＆B） 得到12，即0000 1100

|           按位或操作符，只要兩個操作數的某一位有一個非0時候結果的該位就為1。                       （A | B）  得到61，即 0011 1101

^           按位異或操作符，兩個操作數的某一位不相同時候結果的該位就為1。                               （A ^ B）得到49，即 0011 0001

?           按位補運算符翻轉操作數的每一位。                                                                                   （?A）     得到-60，即1100 0011

<<       按位左移運算符。左操作數按位左移右操作數指定的位數。                                                A << 2   得到240，即 1111 0000

>>       按位右移運算符。左操作數按位右移右操作數指定的位數。                                                A >> 2   得到15即 1111

>>>   按位右移補零操作符。左操作數的值按右操作數指定的位數右移，移動得到的空位以零填充。A>>>2   得到15即0000 1111

。。。

邏輯運算符

下面列出了邏輯運算符的基本運算，假設布爾變量A為真，變量B為假

操作符  描述                                                                                                                                             例子

&&      稱為邏輯與運算符。當且僅當兩個操作數都為真，條件才為真。                                                    （A && B）為假。

| |          稱為邏輯或操作符。如果任何兩個操作數任何一個為真，條件為真。                                            （A | | B）為真。

！          稱為邏輯非運算符。用來反轉操作數的邏輯狀態。如果條件為true，則邏輯非運算符將得到false。！（A && B）為真。

。。。

賦值運算符

下面是Java語言支持的賦值運算符：

操作符    描述                                                                                                   例子

=            簡單的賦值運算符，將右操作數的值賦給左側操作數                           C = A + B將把A + B得到的值賦給C

+ =        加和賦值操作符，它把左操作數和右操作數相加賦值給左操作數       C + = A等價于C = C + A

- =        減和賦值操作符，它把左操作數和右操作數相減賦值給左操作數       C - = A等價于C = C -A

* =        乘和賦值操作符，它把左操作數和右操作數相乘賦值給左操作數       C * = A等價于C = C * A

/ =        除和賦值操作符，它把左操作數和右操作數相除賦值給左操作數       C / = A等價于C = C / A

（％）=取模和賦值操作符，它把左操作數和右操作數取模后賦值給左操作數   C％= A等價于C = C％A

<< =    左移位賦值運算符                                                                               C << = 2等價于C = C << 2

>> =    右移位賦值運算符                                                                               C >> = 2等價于C = C >> 2

＆=        按位與賦值運算符                                                                               C＆= 2等價于C = C＆2

^ =        按位異或賦值操作符                                                                           C ^ = 2等價于C = C ^ 2

| =        按位或賦值操作符                                                                               C | = 2等價于C = C | 2

。。。

條件運算符（?:）

條件運算符也被稱為三元運算符。該運算符有3個操作數，并且需要判斷布爾表達式的值。該運算符的主要是決定哪個值應該賦值給變量。

variable x = (expression) ? value if true : value if false

。。。

instanceOf 運算符

該運算符用于操作對象實例，檢查該對象是否是一個特定類型（類類型或接口類型）。

instanceof運算符使用格式如右：( Object reference variable ) instanceOf  (class/interface type)

如果運算符左側變量所指的對象，是操作符右側類或接口(class/interface)的一個對象，那么結果為真。

。。。

Java運算符優先級

當多個運算符出現在一個表達式中，誰先誰后呢？這就涉及到運算符的優先級別的問題。在一個多運算符的表達式中，運算符優先級不同會導致最后得出的結果差別甚大。

例如，（1+3）＋（3+2）*2，這個表達式如果按加號最優先計算，答案就是 18，如果按照乘號最優先，答案則是 14。

再如，x = 7 + 3 * 2，這里x得到13，而不是20，因為乘法運算符比加法運算符有較高的優先級，所以先計算3 * 2得到6，然后再加7。

下面具有最高優先級的運算符在最上面，最低優先級的在底部。

類別          操作符            關聯性

后綴         () [] . (點操作符)左到右

一元         + + - ！?        從右到左

乘性     * /％                左到右

加性     + -                    左到右

移位     >> >>>  <<    左到右

關系     >> = << =    左到右

相等     ==  !=            左到右

按位與     ＆                    左到右

按位異或 ^                     左到右

按位或     |                        左到右

邏輯與     &&                    左到右

邏輯或     | |                    左到右

條件        ？：                    從右到左

賦值= + = - = * = / =％= >> = << =＆= ^ = | =從右到左

逗號，                                左到右

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 循環結構 - for, while 及 do…while

。。。。。。

Java 循環結構 - for, while 及 do...while

順序結構的程序語句只能被執行一次。如果您想要同樣的操作執行多次,，就需要使用循環結構。

Java中有三種主要的循環結構：

1. while循環

2. do…while循環

3. for循環

在Java5中引入了一種主要用于數組的增強型for循環。

。。。

while循環

while是最基本的循環，它的結構為：

while( 布爾表達式 ) {

//循環內容

}

只要布爾表達式為true，循環體會一直執行下去。

。。。

do…while循環

對于while語句而言，如果不滿足條件，則不能進入循環。但有時候我們需要即使不滿足條件，也至少執行一次。

do…while循環和while循環相似，不同的是，do…while循環至少會執行一次。

do {

       //代碼語句

}while(布爾表達式);

注意：布爾表達式在循環體的后面，所以語句塊在檢測布爾表達式之前已經執行了。如果布爾表達式的值為true，則語句塊一直執行，直到布爾表達式的值為false。

。。。

for循環

雖然所有循環結構都可以用while或者do...while表示，但Java提供了另一種語句 —— for循環，使一些循環結構變得更加簡單。

for循環執行的次數是在執行前就確定的。語法格式如下：

for(初始化; 布爾表達式; 更新) {

    //代碼語句

}

關于for循環有以下幾點說明：

-最先執行初始化步驟。可以聲明一種類型，但可初始化一個或多個循環控制變量，也可以是空語句。

-然后，檢測布爾表達式的值。如果為true，循環體被執行。如果為false，循環終止，開始執行循環體后面的語句。

-執行一次循環后，更新循環控制變量。

-再次檢測布爾表達式。循環執行上面的過程。

。。。

Java增強for循環

Java5引入了一種主要用于數組的增強型for循環。

Java增強for循環語法格式如下:

for(聲明語句 : 表達式)

{

   //代碼句子

}

聲明語句：聲明新的局部變量，該變量的類型必須和數組元素的類型匹配。其作用域限定在循環語句塊，其值與此時數組元素的值相等。

表達式：表達式是要訪問的數組名，或者是返回值為數組的方法。

。。。

break關鍵字

break主要用在循環語句或者switch語句中，用來跳出整個語句塊。

break跳出最里層的循環，并且繼續執行該循環下面的語句。

語法：break的用法很簡單，就是循環結構中的一條語句：break;

。。。

continue關鍵字

continue適用于任何循環控制結構中。作用是讓程序立刻跳轉到下一次循環的迭代。

在for循環中，continue語句使程序立即跳轉到更新語句。

在while或者do…while循環中，程序立即跳轉到布爾表達式的判斷語句。

語法：continue就是循環體中一條簡單的語句：continue;

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 分支結構 - if…else/switch

。。。。。。

Java 分支結構 - if...else/switch

順序結構只能順序執行，不能進行判斷和選擇，因此需要分支結構。

Java有兩種分支結構：

1. if語句

2. switch語句

。。。

if語句

一個if語句包含一個布爾表達式和一條或多條語句。

語法：

If語句的用語法如下：

if(布爾表達式)

{

   //如果布爾表達式為true將執行的語句

}

如果布爾表達式的值為true，則執行if語句中的代碼塊。否則執行If語句塊后面的代碼。

。。。

if...else語句

if語句后面可以跟else語句，當if語句的布爾表達式值為false時，else語句塊會被執行。

語法：

if…else的用法如下：

if(布爾表達式){

   //如果布爾表達式的值為true

}else{

   //如果布爾表達式的值為false

}

。。。

if...else if...else語句

if語句后面可以跟else if…else語句，這種語句可以檢測到多種可能的情況。

使用if，else if，else語句的時候，需要注意下面幾點：

if語句至多有1個else語句，else語句在所有的else if語句之后。

If語句可以有若干個else if語句，它們必須在else語句之前。

一旦其中一個else if語句檢測為true，其他的else if以及else語句都將跳過執行。

語法：

if...else語法格式如下:

if(布爾表達式 1){

   //如果布爾表達式 1的值為true執行代碼

}else if(布爾表達式 2){

   //如果布爾表達式 2的值為true執行代碼

}else if(布爾表達式 3){

   //如果布爾表達式 3的值為true執行代碼

}else {

   //如果以上布爾表達式都不為true執行代碼

}

。。。

嵌套的if…else語句

使用嵌套的if-else語句是合法的。也就是說你可以在另一個if或者else if語句中使用if或者else if語句。

語法：

嵌套的if…else語法格式如下：

if(布爾表達式 1){

       ////如果布爾表達式 1的值為true執行代碼

   if(布爾表達式 2){

      ////如果布爾表達式 2的值為true執行代碼

   }

}

你可以像 if 語句一樣嵌套 else if...else。

。。。

switch語句

switch語句判斷一個變量與一系列值中某個值是否相等，每個值稱為一個分支。

語法：

switch語法格式如下：

switch(expression){

    case value :

       //語句

       break; //可選

    case value :

       //語句

       break; //可選

    //你可以有任意數量的case語句

    default : //可選

       //語句

}

switch語句有如下規則：

-switch語句中的變量類型只能為byte、short、int或者char。

-switch語句可以擁有多個case語句。每個case后面跟一個要比較的值和冒號。

-case語句中的值的數據類型必須與變量的數據類型相同，而且只能是常量或者字面常量。

-當變量的值與case語句的值相等時，那么case語句之后的語句開始執行，直到break語句出現才會跳出switch語句。

-當遇到break語句時，switch語句終止。程序跳轉到switch語句后面的語句執行。case語句不必須要包含break語句。如果沒有break語句出現，程序會繼續執行下一條case語句，直到出現break語句。

-switch語句可以包含一個default分支，該分支必須是switch語句的最后一個分支。default在沒有case語句的值和變量值相等的時候執行。default分支不需要break語句。

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java Number類

一般地，當需要使用數字的時候，我們通常使用內置數據類型，如：byte、int、long、double等。

然而，在實際開發過程中，我們經常會遇到需要使用對象，而不是內置數據類型的情形。為了解決這個問題，Java語言為每一個內置數據類型提供了對應的包裝類。

所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類Number的子類。

這種由編譯器特別支持的包裝稱為裝箱，所以當內置數據類型被當作對象使用的時候，編譯器會把內置類型裝箱為包裝類。相似的，編譯器也可以把一個對象拆箱為內置類型。Number類屬于java.lang包。

。。。

Java Math類

Java 的 Math 包含了用于執行基本數學運算的屬性和方法，如初等指數、對數、平方根和三角函數。

Math 的方法都被定義為 static 形式，通過 Math 類可以在主函數中直接調用。

Number & Math 類方法

下面的列出的是常用的Number類和Math類的方法：

序號       方法                  描述

1           xxxValue()        將number對象轉換為xxx數據類型的值并返回。

2           compareTo()    將number對象與參數比較。

3           equals()            判斷number對象是否與參數相等。

4           valueOf()          返回一個Integer對象指定的內置數據類型

5           toString()         以字符串形式返回值。

6           parseInt()         將字符串解析為int類型。

7           abs()                 返回參數的絕對值。

8           ceil()                 對整形變量向左取整，返回類型為double型。

9           floor()               對整型變量向右取整。返回類型為double類型。

10       rint()                 返回與參數最接近的整數。返回類型為double。

11       round()             返回一個最接近的int、long型值。

12       min()                 返回兩個參數中的最小值。

13       max()                返回兩個參數中的最大值。

14       exp()                 返回自然數底數e的參數次方。

15       log()                  返回參數的自然數底數的對數值。

16       pow()                返回第一個參數的第二個參數次方。

17       sqrt()                 求參數的算術平方根。

18       sin()                   求指定double類型參數的正弦值。

19       cos()                  求指定double類型參數的余弦值。

20       tan()                  求指定double類型參數的正切值。

21       asin()                 求指定double類型參數的反正弦值。

22       acos()                求指定double類型參數的反余弦值。

23       atan()                求指定double類型參數的反正切值。

24       atan2()              將笛卡爾坐標轉換為極坐標，并返回極坐標的角度值。

25       toDegrees()      將參數轉化為角度。

26       toRadians()       將角度轉換為弧度。

27       random()          返回一個隨機數。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java Character類

。。。。。。

Java Character類

使用字符時，我們通常使用的是內置數據類型char。

然而，在實際開發過程中，我們經常會遇到需要使用對象，而不是內置數據類型的情況。為了解決這個問題，Java語言為內置數據類型char提供了包裝類Character類。

Character類提供了一系列方法來操縱字符。你可以使用Character的構造方法創建一個Character類對象，例如：Character ch = new Character('a');

在某些情況下，Java編譯器會自動創建一個Character對象。

例如，將一個char類型的參數傳遞給需要一個Character類型參數時，那么編譯器會自動地將char類型參數轉換為Character對象。 這種特征稱為裝箱，反過來稱為拆箱。

。。。

轉義序列

前面有反斜杠（\）的字符代表轉義字符，它對編譯器來說是有特殊含義的。

下面列表展示了Java的轉義序列：

轉義序列描述

\t            在文中該處插入一個tab鍵

\b          在文中該處插入一個后退鍵

\n            在文中該處換行

\r            在文中該處插入回車

\f            在文中該處插入換頁符

\'            在文中該處插入單引號

\"            在文中該處插入雙引號

\\            在文中該處插入反斜杠

。。。

Character 方法

下面是Character類的方法：

序號   方法                    描述

1       isLetter()            是否是一個字母

2       isDigit()              是否是一個數字字符

3       isWhitespace()   是否一個空格

4       isUpperCase()    是否是大寫字母

5       isLowerCase()    是否是小寫字母

6       toUpperCase()   指定字母的大寫形式

7       toLowerCase()   指定字母的小寫形式

8       toString()           返回字符的字符串形式，字符串的長度僅為1

對于方法的完整列表，請參考的java.lang.Character API規范。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java String類

字符串廣泛應用在Java編程中，在Java中字符串屬于對象，Java提供了String類來創建和操作字符串。

創建字符串：創建字符串最簡單的方式如右：String greeting = "Hello world!";

在代碼中遇到字符串常量時，這里的值是"Hello world!"，編譯器會使用該值創建一個String對象。和其它對象一樣，可以使用關鍵字和構造方法來創建String對象。

注意：String類是不可改變的，所以你一旦創建了String對象，那它的值就無法改變了。 如果需要對字符串做很多修改，那么應該選擇使用StringBuffer & StringBuilder 類。

String類有11種構造方法，這些方法提供不同的參數來初始化字符串。

。。。

字符串長度

用于獲取有關對象的信息的方法稱為訪問器方法。

String類的一個訪問器方法是length()方法，它返回字符串對象包含的字符數。

。。。

連接字符串

String類提供了連接兩個字符串的方法：string1.concat(string2);

返回string2連接string1的新字符串。也可以對字符串常量使用concat()方法，如："My name is ".concat("Zara");

更常用的是使用'+'操作符來連接字符串，如："Hello," + " world" + "!"

。。。

創建格式化字符串

我們知道輸出格式化數字可以使用printf()和format()方法。String類使用靜態方法format()返回一個String對象而不是PrintStream對象。

String類的靜態方法format()能用來創建可復用的格式化字符串，而不僅僅是用于一次打印輸出。

。。。

String 方法

下面是String類支持的方法，更多詳細，參看Java API文檔：

序號    方法                                                                       描述

1        char charAt(int index)                                           返回指定索引處的 char 值。

2        int compareTo(Object o)                                      把這個字符串和另一個對象比較。

3        int compareTo(String anotherString)                   按字典順序比較兩個字符串。

4        int compareToIgnoreCase(String str)                   按字典順序比較兩個字符串，不考慮大小寫。

5        String concat(String str)                                       將指定字符串連接到此字符串的結尾。

6        boolean contentEquals(StringBuffer sb)               當且僅當字符串與指定的StringButter有相同順序的字符時候返回真。

7        static String copyValueOf(char[] data)                 返回指定數組中表示該字符序列的 String。

8        static String copyValueOf(char[] data, int offset, int count)  返回指定數組中表示該字符序列的 String。

9        boolean endsWith(String suffix)                           測試此字符串是否以指定的后綴結束。

10        boolean equals(Object anObject)                         將此字符串與指定的對象比較。

11        boolean equalsIgnoreCase(String anotherString)              將此 String 與另一個 String 比較，不考慮大小寫。

12        byte[] getBytes()                                                    使用平臺的默認字符集將此 String 編碼為 byte 序列，并將結果存儲到一個新的 byte 數組中。

13    byte[] getBytes(String charsetName)                    使用指定的字符集將此 String 編碼為 byte 序列，并將結果存儲到一個新的 byte 數組中。

14    void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)      將字符從此字符串復制到目標字符數組。

15    int hashCode()                                                       返回此字符串的哈希碼。

16    int indexOf(int ch)                                                  返回指定字符在此字符串中第一次出現處的索引。

17    int indexOf(int ch, int fromIndex)                           返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。

18    int indexOf(String str)                                             返回指定子字符串在此字符串中第一次出現處的索引。

19    int indexOf(String str, int fromIndex)                      返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。

20    String intern()                                                          返回字符串對象的規范化表示形式。

21    int lastIndexOf(int ch)                                              返回指定字符在此字符串中最后一次出現處的索引。

22    int lastIndexOf(int ch, int fromIndex)                       返回指定字符在此字符串中最后一次出現處的索引，從指定的索引處開始進行反向搜索。

23    int lastIndexOf(String str)                                         返回指定子字符串在此字符串中最右邊出現處的索引。

24    int lastIndexOf(String str, int fromIndex)                  返回指定子字符串在此字符串中最后一次出現處的索引，從指定的索引開始反向搜索。

25    int length()                                                                返回此字符串的長度。

26    boolean matches(String regex)                                 告知此字符串是否匹配給定的正則表達式。

27    boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)          測試兩個字符串區域是否相等。

28    boolean regionMatches(int toffset, String other, int ooffset, int len)                                            測試兩個字符串區域是否相等。

29    String replace(char oldChar, char newChar)                    返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的。

30    String replaceAll(String regex, String replacement         使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。

31    String replaceFirst(String regex, String replacement)     使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。

32    String[] split(String regex)                                               根據給定正則表達式的匹配拆分此字符串。

33    String[] split(String regex, int limit)                                 根據匹配給定的正則表達式來拆分此字符串。

34    boolean startsWith(String prefix)                                    測試此字符串是否以指定的前綴開始。

35    boolean startsWith(String prefix, int toffset)                   測試此字符串從指定索引開始的子字符串是否以指定前綴開始。

36    CharSequence subSequence(int beginIndex, int endIndex)   返回一個新的字符序列，它是此序列的一個子序列。

37    String substring(int beginIndex)                                      返回一個新的字符串，它是此字符串的一個子字符串。

38    String substring(int beginIndex, int endIndex)                返回一個新字符串，它是此字符串的一個子字符串。

39    char[] toCharArray()                                                         將此字符串轉換為一個新的字符數組。

40    String toLowerCase()                                                        使用默認語言環境的規則將此 String 中的所有字符都轉換為小寫。

41    String toLowerCase(Locale locale)                                   使用給定 Locale 的規則將此 String 中的所有字符都轉換為小寫。

42    String toString()                                                               返回此對象本身（它已經是一個字符串！）。

43    String toUpperCase()                                                       使用默認語言環境的規則將此 String 中的所有字符都轉換為大寫。

44    String toUpperCase(Locale locale)                                   使用給定 Locale 的規則將此 String 中的所有字符都轉換為大寫。

45    String trim()                                                                      返回字符串的副本，忽略前導空白和尾部空白。

46    static String valueOf(primitive data type x)                      返回給定data type類型x參數的字符串表示形式。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java StringBuffer和StringBuilder類

當對字符串進行修改的時候，需要使用StringBuffer和StringBuilder類。

和String類不同的是，StringBuffer和StringBuilder類的對象能夠被多次的修改，并且不產生新的未使用對象。

StringBuilder類在Java5中被提出，它和StringBuffer之間的最大不同在于StringBuilder的方法不是線程安全的（線程安全就是多線程訪問時，采用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。線程不安全就是不提供數據訪問保護，有可能出現多個線程先后更改數據造成所得到的數據是臟數據）。

由于StringBuilder相較于StringBuffer有速度優勢，所以多數情況下建議使用StringBuilder類。然而在應用程序要求線程安全的情況下，則必須使用StringBuffer類。

。。。。。。

StringBuffer 方法

以下是StringBuffer類支持的主要方法：

序號   方法                                                            描述

1       public StringBuffer append(String s)         將指定的字符串追加到此字符序列。

2       public StringBuffer reverse()                      將此字符序列用其反轉形式取代。

3       public delete(int start, int end)                  移除此序列的子字符串中的字符。

4       public insert(int offset, int i)                      將 int 參數的字符串表示形式插入此序列中。

5       replace(int start, int end, String str)           使用給定 String 中的字符替換此序列的子字符串中的字符。

下面的列表里的方法和String類的方法類似：

序號  方法                                                               描述

1      int capacity()                                                 返回當前容量。

2      char charAt(int index)                                   返回此序列中指定索引處的 char 值。

3      void ensureCapacity(int minimumCapacity) 確保容量至少等于指定的最小值。

4      void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)   將字符從此序列復制到目標字符數組 dst。

5      int indexOf(String str)                                   返回第一次出現的指定子字符串在該字符串中的索引。

6      int indexOf(String str, int fromIndex)            從指定的索引處開始，返回第一次出現的指定子字符串在該字符串中的索引。

7      int lastIndexOf(String str)                              返回最右邊出現的指定子字符串在此字符串中的索引。

8      int lastIndexOf(String str, int fromIndex)       返回最后一次出現的指定子字符串在此字符串中的索引。

9      int length()                                                     返回長度（字符數）。

10  void setCharAt(int index, char ch)                 將給定索引處的字符設置為 ch。

11  void setLength(int newLength)                      設置字符序列的長度。

12  CharSequence subSequence(int start, int end)     返回一個新的字符序列，該字符序列是此序列的子序列。

13  String substring(int start)                               返回一個新的 String，它包含此字符序列當前所包含的字符子序列。

14  String substring(int start, int end)                  返回一個新的 String，它包含此序列當前所包含的字符子序列。

15  String toString()                                             返回此序列中數據的字符串表示形式。

:::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 數組

數組對于每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。

Java語言中提供的數組是用來存儲固定大小的同類型元素。

你可以聲明一個數組變量，如numbers[100]來代替直接聲明100個獨立變量number0，number1，....，number99。

現在將為大家介紹Java數組的聲明、創建和初始化，并給出其對應的代碼

。。。。。。

聲明數組變量

首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法：

dataType[] arrayRefVar;   // 首選的方法(建議采用這種聲明方法)

或

dataType arrayRefVar[];  // 效果相同，但不是首選方法

注意: 建議使用dataType[] arrayRefVar 的聲明風格聲明數組變量。 dataType arrayRefVar[] 風格是來自 C/C++ 語言 ，在Java中采用是為了讓 C/C++ 程序員能夠快速理解java語言。

。。。

創建數組

Java語言使用new操作符來創建數組，語法如右：arrayRefVar = new dataType[arraySize];

右面的語法語句做了兩件事：

一、使用dataType[arraySize]創建了一個數組。

二、把新創建的數組的引用賦值給變量 arrayRefVar。

數組變量的聲明，和創建數組可以用一條語句完成，如右所示：dataType[] arrayRefVar = new dataType[arraySize];

另外，你還可以使用如右的方式創建數組：dataType[] arrayRefVar = {value0, value1, ..., valuek};

數組的元素是通過索引訪問的。數組索引從0開始，所以索引值從0到arrayRefVar.length-1。

。。。

處理數組

數組的元素類型和數組的大小都是確定的，所以當處理數組元素時候，我們通常使用基本循環或者foreach循環。

。。。

foreach循環

JDK 1.5 引進了一種新的循環類型，被稱為foreach循環或者加強型循環，它能在不使用下標的情況下遍歷數組。

。。。

數組作為函數的參數

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

。。。

Arrays 類

java.util.Arrays類能方便地操作數組，它提供的所有方法都是靜態的。具有以下功能：

-給數組賦值：通過fill方法。

-對數組排序：通過sort方法,按升序。

-比較數組：通過equals方法比較數組中元素值是否相等。

-查找數組元素：通過binarySearch方法能對排序好的數組進行二分查找法操作。

具體說明請查看下面：

序號    方法                                                                              說明

1        public static int binarySearch(Object[] a, Object key)    用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。如果查找值包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。

2        public static boolean equals(long[] a, long[] a2)        如果兩個指定的 long 型數組彼此相等，則返回 true。如果兩個數組包含相同數量的元素，并且兩個數組中的所有相應元素對都是相等的，則認為這兩個數組是相等的。換句話說，如果兩個數組以相同順序包含相同的元素，則兩個數組是相等的。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

3        public static void fill(int[] a, int val) 將指定的 int 值分配給指int型數組指定范圍中的每個元素。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。

4        public static void sort(Object[] a) 對指定對象數組根據其元素的自然順序進行升序排列。同樣的方法適用于所有的其他基本數據類型（Byte，short，Int等）。                 

:::::::::::::::::::::::::::::::::::::::::::::::::::

Java 日期時間

java.util包提供了Date類來封裝當前的日期和時間。 Date類提供兩個構造函數來實例化Date對象。

第一個構造函數使用當前日期和時間來初始化對象：Date( )

第二個構造函數接收一個參數，該參數是從1970年1月1日起的微秒數：Date(long millisec)

。。。

Date對象創建以后，可以調用下面的方法。

序號方法                                            描述

1    boolean after(Date date)           若當調用此方法的Date對象在指定日期之后返回true,否則返回false。

2    boolean before(Date date)        若當調用此方法的Date對象在指定日期之前返回true,否則返回false。

3    Object clone( )                           返回此對象的副本。

4int compareTo(Date date)     比較當調用此方法的Date對象和指定日期。兩者相等時候返回0。調用對象在指定日期之前則返回負數。調用對象在指定日期之后則返回正數。

5    int compareTo(Object obj)        若obj是Date類型則操作等同于compareTo(Date) 。否則它拋出ClassCastException。

6    boolean equals(Object date)     當調用此方法的Date對象和指定日期相等時候返回true,否則返回false。

7    long getTime( )                          返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。

8    int hashCode( )                          返回此對象的哈希碼值。

9    void setTime(long time)            用自1970年1月1日00:00:00 GMT以后time毫秒數設置時間和日期。

10String toString( )                       轉換Date對象為String表示形式，并返回該字符串。

。。。

獲取當前日期時間

Java中獲取當前日期和時間很簡單，使用Date對象的 toString()方法來打印當前日期和時間，如下所示：

import java.util.Date;

  public class DateDemo {

   public static void main(String args[]) {

       // 初始化 Date 對象

       Date date = new Date();

       // 使用 toString() 函數顯示日期時間

       System.out.println(date.toString());

   }

}

以上實例編譯運行結果如右：Mon May 04 09:51:52 CDT 2013

。。。

日期比較

Java使用以下三種方法來比較兩個日期：

-使用getTime( ) 方法獲取兩個日期（自1970年1月1日經歷的微秒數值），然后比較這兩個值。

-使用方法before()，after()和equals()。例如，一個月的12號比18號早，則new Date(99, 2, 12).before(new Date (99, 2, 18))返回true。

-使用compareTo()方法，它是由Comparable接口定義的，Date類實現了這個接口。

。。。

使用SimpleDateFormat格式化日期

SimpleDateFormat是一個以語言環境敏感的方式來格式化和分析日期的類。SimpleDateFormat允許你選擇任何用戶自定義日期時間格式來運行。

。。。

簡單的DateFormat格式化編碼

時間模式字符串用來指定時間格式。在此模式中，所有的ASCII字母被保留為模式字母，定義如下：

字母      描述                                    示例

G          紀元標記                                AD

y          四位年份                                2001

M          月份                                    July or 07

d          一個月的日期                        10

h         A.M./P.M. (1~12)格式小時    12

H         一天中的小時 (0~23)            22

m         分鐘數                                    30

s         秒數                                        55

S         微妙數                                    234

E         星期幾                                    Tuesday

D         一年中的日子                        360

F         一個月中第幾周的周幾            2 (second Wed. in July)

w         一年中第幾周                        40

W         一個月中第幾周                    1

a         A.M./P.M. 標記                    PM

k         一天中的小時(1~24)                24

K         A.M./P.M. (0~11)格式小時    10

z         時區                                        Eastern Standard Time

'         文字定界符                            Delimiter

"         單引號                                    `

。。。

使用printf格式化日期

printf方法可以很輕松地格式化時間和日期。使用兩個字母格式，它以t開頭并且以下面表格中的一個字母結尾。

如果你需要重復提供日期，那么利用這種方式來格式化它的每一部分就有點復雜了。因此，可以利用一個格式化字符串指出要被格式化的參數的索引。

索引必須緊跟在%后面，而且必須以$結束。或者，你可以使用<標志。它表明先前被格式化的參數要被再次使用。

。。。

日期和時間轉換字符

字符   描述                                                例子

c       完整的日期和時間                            Mon May 04 09:51:52 CDT 2009

F       ISO 8601 格式日期                            2004-02-09

D       U.S. 格式日期 (月/日/年)                    02/09/2004

T       24小時時間                                    18:05:19

r       12小時時間                                    06:05:19 pm

R       24小時時間，不包含秒                    18:05

Y       4位年份(包含前導0)                        2004

y       年份后2位(包含前導0)                        04

C       年份前2位(包含前導0)                        20

B       月份全稱                                        February

b       月份簡稱                                        Feb

n       2位月份(包含前導0)                        02

d       2位日子(包含前導0)                        03

e       2位日子(不包含前導0)                        9

A       星期全稱                                        Monday

a       星期簡稱                                        Mon

j      3位年份(包含前導0)                            069

H      2位小時(包含前導0), 00 到 23            18

k      2位小時(不包含前導0),  0 到 23        18

I      2位小時(包含前導0), 01 到 12            06

l      2位小時(不包含前導0),  1 到 12        6

M      2位分鐘(包含前導0)                            05

S      2位秒數(包含前導0)                            19

L      3位毫秒(包含前導0)                            047

N      9位納秒(包含前導0)                            047000000

P      大寫上下午標志                                PM

p      小寫上下午標志                                pm

z      從GMT的RFC 822數字偏移                -0800

Z      時區                                                PST

s      自 1970-01-01 00:00:00 GMT的秒數1078884319

Q      自 1970-01-01 00:00:00 GMT的毫妙1078884319047

還有其他有用的日期和時間相關的類。對于更多的細節，你可以參考到Java標準文檔。

。。。

解析字符串為時間

SimpleDateFormat 類有一些附加的方法，特別是parse()，它試圖按照給定的SimpleDateFormat 對象的格式化存儲來解析字符串。

。。。

Java 休眠(sleep)

你可以讓程序休眠一毫秒的時間或者到您的計算機的壽命長的任意段時間。

。。。

測量時間

下面的一個例子表明如何測量時間間隔（以毫秒為單位）：

import java.util.*;

public class DiffDemo {

   public static void main(String args[]) {

      try {

         long start = System.currentTimeMillis( );

         System.out.println(new Date( ) + "\n");

         Thread.sleep(5*60*10);

         System.out.println(new Date( ) + "\n");

         long end = System.currentTimeMillis( );

         long diff = end - start;

         System.out.println("Difference is : " + diff);

      } catch (Exception e) {

         System.out.println("Got an exception!");

      }

   }

}

以上實例編譯運行結果如下:

Sun May 03 18:16:51 GMT 2009

Sun May 03 18:16:57 GMT 2009

Difference is : 5993

。。。

Calendar類

我們現在已經能夠格式化并創建一個日期對象了，但是我們如何才能設置和獲取日期數據的特定部分呢，比如說小時，日，或者分鐘? 我們又如何在日期的這些部分加上或者減去值呢? 答案是使用Calendar 類。

Calendar類的功能要比Date類強大很多，而且在實現方式上也比Date類要復雜一些。

Calendar類是一個抽象類，在實際使用時實現特定的子類的對象，創建對象的過程對程序員來說是透明的，只需要使用getInstance方法創建即可。

創建一個代表系統當前日期的Calendar對象：Calendar c = Calendar.getInstance();//默認是當前日期

創建一個指定日期的Calendar對象，使用Calendar類代表特定的時間，需要首先創建一個Calendar的對象，然后再設定該對象中的年月日參數來完成。

//創建一個代表2009年6月12日的Calendar對象

Calendar c1 = Calendar.getInstance();

c1.set(2009, 6 - 1, 12);

。。。

Calendar類對象字段類型

Calendar類中用一下這些常量表示不同的意義，jdk內的很多類其實都是采用的這種思想

常量                                      描述

Calendar.YEAR                      年份

Calendar.MONTH              月份

Calendar.DATE                      日期

Calendar.DAY_OF_MONTH  日期，和上面的字段意義完全相同

Calendar.HOUR                  12小時制的小時

Calendar.HOUR_OF_DAY      24小時制的小時

Calendar.MINUTE              分鐘

Calendar.SECOND              秒

Calendar.DAY_OF_WEEK      星期幾

。。。

Calendar類對象信息的設置

Set設置

如：Calendar c1 = Calendar.getInstance();

調用：

public final void set(int year,int month,int date)

c1.set(2009, 6 - 1, 12);//把Calendar對象c1的年月日分別設這為：2009、6、12

利用字段類型設置

如果只設定某個字段，例如日期的值，則可以使用如右set方法：public void set(int field,int value)

把 c1對象代表的日期設置為10號，其它所有的數值會被重新計算：c1.set(Calendar.DATE,10);

把c1對象代表的年份設置為2008年，其他的所有數值會被重新計算：c1.set(Calendar.YEAR,2008);

其他字段屬性set的意義以此類推

。。。

Add設置

Calendar c1 = Calendar.getInstance();

把c1對象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的數值會被重新計算：c1.add(Calendar.DATE, 10);

把c1對象的日期減去10，也就是c1所表的日期的10天前的日期，其它所有的數值會被重新計算：c1.add(Calendar.DATE, -10);

其他字段屬性的add的意義以此類推

。。。

Calendar類對象信息的獲得

Calendar c1 = Calendar.getInstance();            // 獲得年份

int year = c1.get(Calendar.YEAR);                   // 獲得月份

int month = c1.get(Calendar.MONTH) + 1;    // 獲得日期

int date = c1.get(Calendar.DATE);                  // 獲得小時

int hour = c1.get(Calendar.HOUR_OF_DAY);  // 獲得分鐘

int minute = c1.get(Calendar.MINUTE);         // 獲得秒

int second = c1.get(Calendar.SECOND);       // 獲得星期幾（注意（這個與Date類是不同的）：1代表星期日、2代表星期1、3代表星期二，以此類推）

int day = c1.get(Calendar.DAY_OF_WEEK);

。。。

GregorianCalendar類

Calendar類實現了公歷日歷，GregorianCalendar是Calendar類的一個具體實現。

Calendar的getInstance（）方法返回一個默認用當前的語言環境和時區初始化的GregorianCalendar對象。GregorianCalendar定義了兩個字段：AD和BC。這些代表公歷定義的兩個時代。

下面列出GregorianCalendar對象的幾個構造方法：

序號  構造函數                                          說明

1      GregorianCalendar()                       在具有默認語言環境的默認時區內使用當前時間構造一個默認的 GregorianCalendar。

2      GregorianCalendar(int year, int month, int date)        在具有默認語言環境的默認時區內構造一個帶有給定日期設置的 GregorianCalendar

3      GregorianCalendar(int year, int month, int date, int hour, int minute)         為具有默認語言環境的默認時區構造一個具有給定日期和時間設置的      GregorianCalendar。

4      GregorianCalendar(int year, int month, int date, int hour, int minute, int second)    為具有默認語言環境的默認時區構造一個具有給定日期和時間設置的GregorianCalendar。

5      GregorianCalendar(Locale aLocale)   在具有給定語言環境的默認時區內構造一個基于當前時間的 GregorianCalendar。

6      GregorianCalendar(TimeZone zone)  在具有默認語言環境的給定時區內構造一個基于當前時間的 GregorianCalendar。

7      GregorianCalendar(TimeZone zone, Locale aLocale)  在具有給定語言環境的給定時區內構造一個基于當前時間的 GregorianCalendar。

這里是GregorianCalendar 類提供的一些有用的方法列表：

序號      方法                                                   說明

1         void add(int field, int amount)         根據日歷規則，將指定的（有符號的）時間量添加到給定的日歷字段中。

2         protected void computeFields()       轉換UTC毫秒值為時間域值

3         protected void computeTime()        覆蓋Calendar ，轉換時間域值為UTC毫秒值

4         boolean equals(Object obj)              比較此 GregorianCalendar 與指定的 Object。

5         int get(int field)                                 獲取指定字段的時間值

6         int getActualMaximum(int field)       返回當前日期，給定字段的最大值

7         int getActualMinimum(int field)        返回當前日期，給定字段的最小值

8         int getGreatestMinimum(int field)    返回此 GregorianCalendar 實例給定日歷字段的最高的最小值。

9         Date getGregorianChange()             獲得格里高利歷的更改日期。

10     int getLeastMaximum(int field)        返回此 GregorianCalendar 實例給定日歷字段的最低的最大值

11     int getMaximum(int field)                返回此 GregorianCalendar 實例的給定日歷字段的最大值。

12     Date getTime()                                 獲取日歷當前時間。

13     long getTimeInMillis()                      獲取用長整型表示的日歷的當前時間

14     TimeZone getTimeZone()                 獲取時區。

15     int getMinimum(int field)                 返回給定字段的最小值。

16     int hashCode()                                  重寫hashCode.

17     boolean isLeapYear(int year)            確定給定的年份是否為閏年。

18     void roll(int field, boolean up)          在給定的時間字段上添加或減去（上/下）單個時間單元，不更改更大的字段。

19     void set(int field, int value)               用給定的值設置時間字段。

20     void set(int year, int month, int date)    設置年、月、日的值。

21     void set(int year, int month, int date, int hour, int minute)     設置年、月、日、小時、分鐘的值。

22     void set(int year, int month, int date, int hour, int minute, int second)      設置年、月、日、小時、分鐘、秒的值。

23     void setGregorianChange(Date date)    設置 GregorianCalendar 的更改日期。

24     void setTime(Date date)                   用給定的日期設置Calendar的當前時間。

25     void setTimeInMillis(long millis)       用給定的long型毫秒數設置Calendar的當前時間。

26     void setTimeZone(TimeZone value) 用給定時區值設置當前時區。

27     String toString()                               返回代表日歷的字符串。

關于Calender 類的完整列表，你可以參考標準的Java文檔。

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 正則表達式

正則表達式定義了字符串的模式。

正則表達式可以用來搜索、編輯或處理文本。

正則表達式并不僅限于某一種語言，但是在每種語言中有細微的差別。

Java正則表達式和Perl的是最為相似的。

java.util.regex包主要包括以下三個類：

1. Pattern類：

pattern對象是一個正則表達式的編譯表示。Pattern類沒有公共構造方法。要創建一個Pattern對象，你必須首先調用其公共靜態編譯方法，它返回一個Pattern對象。該方法接受一個正則表達式作為它的第一個參數。

2. Matcher類：

Matcher對象是對輸入字符串進行解釋和匹配操作的引擎。與Pattern類一樣，Matcher也沒有公共構造方法。你需要調用Pattern對象的matcher方法來獲得一個Matcher對象。

3. PatternSyntaxException：PatternSyntaxException是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

。。。

捕獲組

捕獲組是把多個字符當一個單獨單元進行處理的方法，它通過對括號內的字符分組來創建。

例如，正則表達式(dog) 創建了單一分組，組里包含"d"，"o"，和"g"。

捕獲組是通過從左至右計算其開括號來編號。例如，在表達式（（A）（B（C））），有四個這樣的組：

((A)(B(C)))

(A)

(B(C))

(C)

可以通過調用matcher對象的groupCount方法來查看表達式有多少個分組。groupCount方法返回一個int值，表示matcher對象當前有多個捕獲組。

還有一個特殊的組（組0），它總是代表整個表達式。該組不包括在groupCount的返回值中。

。。。

正則表達式語法

字符        說明

\             將下一字符標記為特殊字符、文本、反向引用或八進制轉義符。例如，"n"匹配字符"n"。"\n"匹配換行符。序列"\\"匹配"\"，"\("匹配"("。

^            匹配輸入字符串開始的位置。如果設置了 RegExp 對象的 Multiline 屬性，^ 還會與"\n"或"\r"之后的位置匹配。

$            匹配輸入字符串結尾的位置。如果設置了 RegExp 對象的 Multiline 屬性，$ 還會與"\n"或"\r"之前的位置匹配。

*             零次或多次匹配前面的字符或子表達式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。

+            一次或多次匹配前面的字符或子表達式。例如，"zo+"與"zo"和"zoo"匹配，但與"z"不匹配。+ 等效于 {1,}。

?             零次或一次匹配前面的字符或子表達式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。

{n}          n 是非負整數。正好匹配 n 次。例如，"o{2}"與"Bob"中的"o"不匹配，但與"food"中的兩個"o"匹配。

{n,}         n 是非負整數。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。

{n,m}      M 和 n 是非負整數，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的頭三個 o。'o{0,1}' 等效于 'o?'。注意：您不能將空格插入逗號和數字之間。

?            當此字符緊隨任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后時，匹配模式是"非貪心的"。"非貪心的"模式匹配搜索到的、盡可能短的字符串，

而默認的"貪心的"模式匹配搜索到的、盡可能長的字符串。例如，在字符串"oooo"中，"o+?"只匹配單個"o"，而"o+"匹配所有"o"。

.                   匹配除"\r\n"之外的任何單個字符。若要匹配包括"\r\n"在內的任意字符，請使用諸如"[\s\S]"之類的模式。

(pattern)      匹配 pattern 并捕獲該匹配的子表達式。可以使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要匹配括號字符 ( )，請使用"\("或者"\)"。

(?:pattern)   匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供以后使用的匹配。這對于用"or"字符 (|) 組合模式部件的情況很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更經濟的表達式。

(?=pattern)   執行正向預測先行搜索的子表達式，該表達式匹配處于匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配，即不能捕獲供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。預測先行不占用字符，即發生匹配后，下一匹配的搜索緊隨上一匹配之后，而不是在組成預測先行的字符后。

(?!pattern)     執行反向預測先行搜索的子表達式，該表達式匹配不處于匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配，即不能捕獲供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。預測先行不占用字符，即發生匹配后，下一匹配的搜索緊隨上一匹配之后，而不是在組成預測先行的字符后。

x|y          匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。

[xyz]       字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。

[^xyz]    反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。

[a-z]      字符范圍。匹配指定范圍內的任何字符。例如，"[a-z]"匹配"a"到"z"范圍內的任何小寫字母。

[^a-z]   反向范圍字符。匹配不在指定的范圍內的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范圍內的任何字符。

\b         匹配一個字邊界，即字與空格間的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。

\B         非字邊界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。

\cx        匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。如果不是這樣，則假定 c 就是"c"字符本身。

\d          數字字符匹配。等效于 [0-9]。

\D         非數字字符匹配。等效于 [^0-9]。

\f           換頁符匹配。等效于 \x0c 和 \cL。

\n          換行符匹配。等效于 \x0a 和 \cJ。

\r           匹配一個回車符。等效于 \x0d 和 \cM。

\s           匹配任何空白字符，包括空格、制表符、換頁符等。與 [ \f\n\r\t\v] 等效。

\S           匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。

\t           制表符匹配。與 \x09 和 \cI 等效。

\v          垂直制表符匹配。與 \x0b 和 \cK 等效。

\w          匹配任何字類字符，包括下劃線。與"[A-Za-z0-9_]"等效。

\W         與任何非單詞字符匹配。與"[^A-Za-z0-9_]"等效。

\xn        匹配 n，此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如，"\x41"匹配"A"。"\x041"與"\x04"&"1"等效。允許在正則表達式中使用 ASCII 代碼。

\num     匹配 num，此處的 num 是一個正整數。到捕獲匹配的反向引用。例如，"(.)\1"匹配兩個連續的相同字符。

\n          標識一個八進制轉義碼或反向引用。如果 \n 前面至少有 n 個捕獲子表達式，那么 n 是反向引用。否則，如果 n 是八進制數 (0-7)，那么 n 是八進制轉義碼。

\nm       標識一個八進制轉義碼或反向引用。如果 \nm 前面至少有 nm 個捕獲子表達式，那么 nm 是反向引用。如果 \nm 前面至少有 n 個捕獲，則 n 是反向引用，后面跟有字符 m。如果兩種前面的情況都不存在，則 \nm 匹配八進制值 nm，其中 n 和 m 是八進制數字 (0-7)。

\nml      當 n 是八進制數 (0-3)，m 和 l 是八進制數 (0-7) 時，匹配八進制轉義碼 nml。

\un        匹配 n，其中 n 是以四位十六進制數表示的 Unicode 字符。例如，\u00A9 匹配版權符號 (?)。

。。。。。。

Matcher類的方法

。。。

索引方法

索引方法提供了有用的索引值，精確表明輸入字符串中在哪能找到匹配：

序號  方法                                      說明

1      public int start()                   返回以前匹配的初始索引。

2      public int start(int group)    返回在以前的匹配操作期間，由給定組所捕獲的子序列的初始索引

3      public int end()                    返回最后匹配字符之后的偏移量。

4      public int end(int group)     返回在以前的匹配操作期間，由給定組所捕獲子序列的最后字符之后的偏移量。

。。。

研究方法

研究方法用來檢查輸入字符串并返回一個布爾值，表示是否找到該模式：

序號  方法                                          說明

1      public boolean lookingAt()      嘗試將從區域開頭開始的輸入序列與該模式匹配。

2      public boolean find()               嘗試查找與該模式匹配的輸入序列的下一個子序列。

3      public boolean find(int start）重置此匹配器，然后嘗試查找匹配該模式、從指定索引開始的輸入序列的下一個子序列。

4      public boolean matches()       嘗試將整個區域與模式匹配。

。。。

替換方法

替換方法是替換輸入字符串里文本的方法：

序號   方法                                                                                                                 說明

1       public Matcher appendReplacement(StringBuffer sb, String replacement)    實現非終端添加和替換步驟。

2       public StringBuffer appendTail(StringBuffer sb)                                              實現終端添加和替換步驟。

3       public String replaceAll(String replacement)                                                   替換模式與給定替換字符串相匹配的輸入序列的每個子序列。

4       public String replaceFirst(String replacement)                                                替換模式與給定替換字符串匹配的輸入序列的第一個子序列。

5       public static String quoteReplacement(String s)                                             返回指定字符串的字面替換字符串。這個方法返回一個字符串，

就像傳遞給Matcher類的appendReplacement 方法一個字面字符串一樣工作。

。。。

start 和end 方法

。。。

matches 和lookingAt 方法

matches 和lookingAt 方法都用來嘗試匹配一個輸入序列模式。它們的不同是matcher要求整個序列都匹配，而lookingAt 不要求。

這兩個方法經常在輸入字符串的開始使用。

。。。

replaceFirst 和replaceAll 方法

replaceFirst 和replaceAll 方法用來替換匹配正則表達式的文本。不同的是，replaceFirst 替換首次匹配，replaceAll 替換所有匹配。

。。。

appendReplacement 和 appendTail 方法

Matcher 類也提供了appendReplacement 和appendTail 方法用于文本替換：

。。。

PatternSyntaxException 類的方法

PatternSyntaxException 是一個非強制異常類，它指示一個正則表達式模式中的語法錯誤。

PatternSyntaxException 類提供了下面的方法來幫助我們查看發生了什么錯誤。

序號方法                                            說明

1    public String getDescription()   獲取錯誤的描述。

2    public int getIndex()                  獲取錯誤的索引。

3    public String getPattern()          獲取錯誤的正則表達式模式。

4    public String getMessage()        返回多行字符串，包含語法錯誤及其索引的描述、錯誤的正則表達式模式和模式中錯誤索引的可視化指示。

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 方法

在前面我們經常使用到System.out.println()，那么它是什么呢？

println()是一個方法(Method)，而System是系統類(Class)，out是標準輸出對象(Object)。這句話的用法是調用系統類System中的標準輸出對象out中的方法println()。

那么什么是方法呢？

Java方法是語句的集合，它們在一起執行一個功能。

-方法是解決一類問題的步驟的有序組合

-方法包含于類或對象中

-方法在程序中被創建，在其他地方被引用

。。。

方法的定義

一般情況下，定義一個方法包含以下語法：

修飾符 返回值類型 方法名 (參數類型 參數名){

    ...

    方法體

    ...

    return 返回值;

}

方法包含一個方法頭和一個方法體。下面是一個方法的所有部分：

--修飾符：修飾符，這是可選的，告訴編譯器如何調用該方法。定義了該方法的訪問類型。

--返回值類型 ：方法可能會返回值。returnValueType是方法返回值的數據類型。有些方法執行所需的操作，但沒有返回值。在這種情況下，returnValueType是關鍵字void。

--方法名：是方法的實際名稱。方法名和參數表共同構成方法簽名。

--參數類型：參數像是一個占位符。當方法被調用時，傳遞值給參數。這個值被稱為實參或變量。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法可以不包含任何參數。

--方法體：方法體包含具體的語句，定義該方法的功能。

注意： 在一些其它語言中方法指過程和函數。一個返回非void類型返回值的方法稱為函數；一個返回void類型返回值的方法叫做過程。

。。。

方法調用

Java支持兩種調用方法的方式，根據方法是否返回值來選擇。

當程序調用一個方法時，程序的控制權交給了被調用的方法。當被調用方法的返回語句執行或者到達方法體閉括號時候交還控制權給程序。

當方法返回一個值的時候，方法調用通常被當做一個值。例如：int larger = max(30, 40);

如果方法返回值是void，方法調用一定是一條語句。例如，方法println返回void。右面的調用是個語句：System.out.println("Welcome to Java!");

。。。

void 關鍵字

如何聲明和調用一個void方法。

printGrade方法是一個void類型方法，它不返回值，一個void方法的調用一定是一個語句。

。。。

通過值傳遞參數

調用一個方法時候需要提供參數，你必須按照參數列表指定的順序提供。

。。。

方法的重載

Java編譯器根據方法簽名判斷哪個方法應該被調用。

方法重載可以讓程序更清晰易讀。執行密切相關任務的方法應該使用相同的名字。

重載的方法必須擁有不同的參數列表。你不能僅僅依據修飾符或者返回類型的不同來重載方法。

。。。

變量作用域

變量的范圍是程序中該變量可以被引用的部分。

方法內定義的變量被稱為局部變量。

局部變量的作用范圍從聲明開始，直到包含它的塊結束。

局部變量必須聲明才可以使用。

方法的參數范圍涵蓋整個方法。參數實際上是一個局部變量。

for循環的初始化部分聲明的變量，其作用范圍在整個循環。

但循環體內聲明的變量其適用范圍是從它聲明到循環體結束。

你可以在一個方法里，不同的非嵌套塊中多次聲明一個具有相同的名稱局部變量，但你不能在嵌套塊內兩次聲明局部變量。

。。。

命令行參數的使用

有時候你希望運行一個程序時候再傳遞給它消息。這要靠傳遞命令行參數給main()函數實現。

命令行參數是在執行程序時候緊跟在程序名字后面的信息。

。。。

構造方法

當一個對象被創建時候，構造方法用來初始化該對象。構造方法和它所在類的名字相同，但構造方法沒有返回值。

通常會使用構造方法給一個類的實例變量賦初值，或者執行其它必要的步驟來創建一個完整的對象。

不管你與否自定義構造方法，所有的類都有構造方法，因為Java自動提供了一個默認構造方法，它把所有成員初始化為0。

一旦你定義了自己的構造方法，默認構造方法就會失效。

。。。

可變參數

JDK 1.5 開始，Java支持傳遞同類型的可變參數給一個方法。

方法的可變參數的聲明如下右示：typeName... parameterName

在方法聲明中，在指定參數類型后加一個省略號(...) 。

一個方法中只能指定一個可變參數，它必須是方法的最后一個參數。任何普通的參數必須在它之前聲明。

。。。

finalize() 方法

Java允許定義這樣的方法，它在對象被垃圾收集器析構(回收)之前調用，這個方法叫做finalize( )，它用來清除回收對象。

例如，你可以使用finalize()來確保一個對象打開的文件被關閉了。

在finalize()方法里，你必須指定在對象銷毀時候要執行的操作。

finalize()一般格式是：

protected void finalize()

{

   // 在這里終結代碼

}

關鍵字protected是一個限定符，它確保finalize() 方法不會被該類以外的代碼調用。

當然，Java的內存回收可以由JVM(Java虛擬機)來自動完成。如果你手動使用，則可以使用上面的方法。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 流(Stream)、文件(File)和IO(輸入/輸出)

Java.io包幾乎包含了所有操作輸入、輸出需要的類。所有這些流類代表了輸入源和輸出目標。

Java.io包中的流支持很多種格式，比如：基本類型、對象、本地化字符集等等。

一個流可以理解為一個數據的序列。輸入流表示從一個源讀取數據，輸出流表示向一個目標寫數據。

Java為I/O提供了強大的而靈活的支持，使其更廣泛地應用到文件傳輸和網絡編程中。

現在講述最基本的和流與I/O相關的功能。   VPS(虛擬服務器)

。。。

讀取控制臺輸入

Java的控制臺輸入由System.in完成。

為了獲得一個綁定到控制臺的字符流，你可以把System.in包裝在一個BufferedReader(緩沖流) 對象中來創建一個字符流。

右面是創建BufferedReader的基本語法：BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

BufferedReader對象創建后，我們便可以使用read()方法從控制臺讀取一個字符，或者用readLine()方法讀取一個字符串。

。。。

從控制臺讀取多字符輸入

從BufferedReader對象讀取一個字符要使用read()方法，它的語法如右：int read() throws IOException

每次調用read()方法，它從輸入流讀取一個字符并把該字符作為整數值返回。 當流結束的時候返回-1。該方法拋出IOException。

。。。

從控制臺讀取字符串

從標準輸入讀取一個字符串需要使用BufferedReader的readLine()方法。

它的一般格式是：String readLine() throws IOException

。。。

控制臺輸出

在此前已經介紹過，控制臺的輸出由 print() 和println()完成。這些方法都由類PrintStream(輸出流) 定義，System.out是該類對象的一個引用。

PrintStream 繼承了OutputStream類，并且實現了方法write()。這樣，write()也可以用來往控制臺寫操作。

PrintStream 定義write()的最簡單格式如右所示：void write(int byteval)

該方法將byteval的低八位字節寫到流中。

注意：write()方法不經常使用，因為print()和println()方法用起來更為方便。

。。。

讀寫文件

如前所述，一個流被定義為一個數據序列。輸入流用于從源讀取數據，輸出流用于向目標寫數據。

。。。

FileInputStream(文件輸入流)

該流用于從文件讀取數據，它的對象可以用關鍵字new來創建。

有多種構造方法可用來創建對象。

可以使用字符串類型的文件名來創建一個輸入流對象來讀取文件：InputStream f = new FileInputStream("C:/java/hello");

也可以使用一個文件對象來創建一個輸入流對象來讀取文件。我們首先得使用File()方法來創建一個文件對象：

File f = new File("C:/java/hello");

InputStream f = new FileInputStream(f);

創建了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{}          返回下一次對此輸入流調用的方法可以不受阻塞地從此輸入流讀取的字節數。返回一個整數值。

除了InputStream外，還有一些其他的輸入流，更多的細節參考javaInputStream。

。。。

FileOutputStream(文件輸出流)

該類用來創建一個文件并向文件中寫數據。

如果該流在打開文件進行輸出前，目標文件不存在，那么該流會創建該文件。

有兩個構造方法可以用來創建FileOutputStream 對象。

使用字符串類型的文件名來創建一個輸出流對象：OutputStream f = new FileOutputStream("C:/java/hello")

也可以使用一個文件對象來創建一個輸出流來寫文件。我們首先得使用File()方法來創建一個文件對象：

File f = new File("C:/java/hello");

OutputStream f = new FileOutputStream(f);

創建OutputStream 對象完成后，就可以使用下面的方法來寫入流或者進行其他的流操作。

序號 方法                                                                    描述

1    public void close() throws IOException{}        關閉此文件輸入流并釋放與此流有關的所有系統資源。拋出IOException異常。

2    protected void finalize()throws IOException {} 這個方法清除與該文件的連接。確保在不再引用文件輸入流時調用其 close 方法。拋出IOException異常。

3    public void write(int w)throws IOException{}  這個方法把指定的字節寫到輸出流中。

4    public void write(byte[] w)                                把指定數組中w.length長度的字節寫到OutputStream中。

除了OutputStream外，還有一些其他的輸出流，更多的細節參考javaFileOutputStream。

。。。

文件和I/O(輸入/輸出)

還有一些關于文件和I/O的類，我們也需要知道：

-File Class(類)

-FileReader Class(類)

-FileWriter Class(類)

。。。

Java中的目錄

創建目錄：

File類中有兩個方法可以用來創建文件夾：

mkdir( )方法創建一個文件夾，成功則返回true，失敗則返回false。失敗表明File對象指定的路徑已經存在，或者由于整個路徑還不存在，該文件夾不能被創建。

mkdirs()方法創建一個文件夾和它的所有父文件夾。

注意：Java在UNIX和Windows自動按約定分辨文件路徑分隔符。如果你在Windows版本的Java中使用分隔符(/) ，路徑依然能夠被正確解析。

。。。

讀取目錄

一個目錄其實就是一個File對象，它包含其他文件和文件夾。

如果創建一個File對象并且它是一個目錄，那么調用isDirectory( )方法會返回true。

可以通過調用該對象上的list()方法，來提取它包含的文件和文件夾的列表。

:::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java Scanner(掃描儀) 類

java.util.Scanner是Java5的新特征，我們可以通過 Scanner 類來獲取用戶的輸入。

右面是創建 Scanner 對象的基本語法：Scanner s = new Scanner(System.in); 

接下來我們演示一個最簡單的的數據輸入，并通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字符串，在讀取前我們一般需要 使用 hasNext 與 hasNextLine 判斷是否還有輸入的數據：

::::::::::使用 next 方法：

import java.util.Scanner; 

public class ScannerDemo {  

    public static void main(String[] args) {  

        Scanner scan = new Scanner(System.in); 

// 從鍵盤接收數據  

//next方式接收字符串

        System.out.println("next方式接收：");

        // 判斷是否還有輸入

        if(scan.hasNext()){   

        String str1 = scan.next();

        System.out.println("輸入的數據為："+str1);  

        }  

    }  

} 

執行以上程序輸出結果為：

$ javac ScannerDemo.java

$ java ScannerDemo

next方式接收：

youj com

輸入的數據為：youj

可以看到 com 字符串并未輸出，接下來我們看 nextLine。

::::::::::使用 nextLine 方法：

import java.util.Scanner; 

public class ScannerDemo {  

    public static void main(String[] args) {  

        Scanner scan = new Scanner(System.in); 

// 從鍵盤接收數據  

//nextLine方式接收字符串

        System.out.println("nextLine方式接收：");

        // 判斷是否還有輸入

        if(scan.hasNextLine()){   

        String str2 = scan.nextLine();

        System.out.println("輸入的數據為："+str2);  

        }  

    }  

} 

執行以上程序輸出結果為：

$ javac ScannerDemo.java

$ java ScannerDemo

nextLine方式接收：

youj com

輸入的數據為：youj com

可以看到 com 字符串輸出。

。。。

next()與nextLine()區別

next():

1、一定要讀取到有效字符后才可以結束輸入。

2、對輸入有效字符之前遇到的空白，next()方法會自動將其去掉。

3、只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結束符。

next()不能得到帶有空格的字符串。

nextLine()：

1、以Enter為結束符,也就是說nextLine()方法返回的是輸入回車之前的所有字符。

2、可以獲得空白。

如果要輸入int或float類型的數據，在Scanner類中也有支持，但是在輸入之前最好先使用 hasNextXxx() 方法進行驗證，再使用 nextXxx() 來讀取

::::::::::::::::::::::::::::::::::::::::::::

Java 異常處理

異常是程序中的一些錯誤，但并不是所有的錯誤都是異常，并且錯誤有時候是可以避免的。

比如說，你的代碼少了一個分號，那么運行出來結果是提示是錯誤java.lang.Error；如果你用System.out.println(11/0)，那么你是因為你用0做了除數，會拋出java.lang.ArithmeticException的異常。

異常發生的原因有很多，通常包含以下幾大類：

-用戶輸入了非法數據。

-要打開的文件不存在。

-網絡通信時連接中斷，或者JVM(java虛擬機)內存溢出。

這些異常有的是因為用戶錯誤引起，有的是程序錯誤引起的，還有其它一些是因為物理錯誤引起的。-

要理解Java異常處理是如何工作的，你需要掌握以下三種類型的異常：

-檢查性異常：最具代表的檢查性異常是用戶錯誤或問題引起的異常，這是程序員無法預見的。例如要打開一個不存在文件時，一個異常就發生了，這些異常在編譯時不能被簡單地忽略。

-運行時異常： 運行時異常是可能被程序員避免的異常。與檢查性異常相反，運行時異常可以在編譯時被忽略。

-錯誤： 錯誤不是異常，而是脫離程序員控制的問題。錯誤在代碼中通常被忽略。例如，當棧溢出時，一個錯誤就發生了，它們在編譯也檢查不到的。

。。。

(異常)Exception類的層次

所有的異常類是從java.lang.Exception類繼承的子類。

Exception類是Throwable類的子類。除了Exception類外，(可拋出)Throwable還有一個子類Error(錯誤) 。

Java程序通常不捕獲錯誤。錯誤一般發生在嚴重故障時，它們在Java程序處理的范疇之外。Error用來指示運行時環境發生的錯誤。

例如，JVM內存溢出。一般地，程序不會從錯誤中恢復。

異常類有兩個主要的子類：(輸入輸出異常)IOException類和(運行異常)RuntimeException類。

在Java 內置類中，有大部分常用檢查性和非檢查性異常。

。。。

Java 內置異常類

Java 語言定義了一些異常類在java.lang標準包中。

標準運行時異常類的子類是最常見的異常類。由于java.lang包是默認加載到所有的Java程序的，所以大部分從運行時異常類繼承而來的異常都可以直接使用。

Java根據各個類庫也定義了一些其他的異常。

下面的列出了Java的非檢查性異常。

異常                                                            描述

-ArithmeticException     當出現異常的運算條件時，拋出此異常。例如，一個整數"除以零"時，拋出此類的一個實例。

-ArrayIndexOutOfBoundsException  用非法索引訪問數組時拋出的異常。如果索引為負或大于等于數組大小，則該索引為非法索引。

-ArrayStoreException 試圖將錯誤類型的對象存儲到一個對象數組時拋出的異常。

-ClassCastException 當試圖將對象強制轉換為不是實例的子類時，拋出該異常。

-IllegalArgumentException拋出的異常表明向方法傳遞了一個不合法或不正確的參數。

-IllegalMonitorStateException拋出的異常表明某一線程已經試圖等待對象的監視器，或者試圖通知其他正在等待對象的監視器而本身沒有指定監視器的線程。

-IllegalStateException       在非法或不適當的時間調用方法時產生的信號。換句話說，即 Java 環境或 Java 應用程序沒有處于請求操作所要求的適當狀態下。

-IllegalThreadStateException       線程沒有處于請求操作所要求的適當狀態時拋出的異常。

-IndexOutOfBoundsException指示某排序索引（例如對數組、字符串或向量的排序）超出范圍時拋出。

-NegativeArraySizeException如果應用程序試圖創建大小為負的數組，則拋出該異常。

-NullPointerException      當應用程序試圖在需要對象的地方使用 null 時，拋出該異常

-NumberFormatException    當應用程序試圖將字符串轉換成一種數值類型，但該字符串不能轉換為適當格式時，拋出該異常。

-SecurityException            由安全管理器拋出的異常，指示存在安全侵犯。

-StringIndexOutOfBoundsException     此異常由 String 方法拋出，指示索引或者為負，或者超出字符串的大小。

-UnsupportedOperationException    當不支持請求的操作時，拋出該異常。

下面列出了Java定義在java.lang包中的檢查性異常類。

異常                                                   描述

-ClassNotFoundException    應用程序試圖加載類時，找不到相應的類，拋出該異常。

-CloneNotSupportedException   當調用 Object 類中的 clone 方法克隆對象，但該對象的類無法實現 Cloneable 接口時，拋出該異常。

-IllegalAccessException      拒絕訪問一個類的時候，拋出該異常。

-InstantiationException     當試圖使用Class類中的newInstance方法創建一個類的實例，

而指定的類對象因為是一個接口或是一個抽象類而無法實例化時，拋出該異常。

-InterruptedException    一個線程被另一個線程中斷，拋出該異常。

-NoSuchFieldException          請求的變量不存在

-NoSuchMethodException      請求的方法不存在

。。。

異常方法

下面的列表是Throwable 類的主要方法:

序號  方法                                                       說明

1     public String getMessage()                 返回關于發生的異常的詳細信息。這個消息在Throwable 類的構造函數中初始化了。

2     public Throwable getCause()              返回一個Throwable 對象代表異常原因。

3     public String toString()                        使用getMessage()的結果返回類的串級名字。

4     public void printStackTrace()              打印toString()結果和棧層次到System.err，即錯誤輸出流。

5     public StackTraceElement [] getStackTrace()   返回一個包含堆棧層次的數組。下標為0的元素代表棧頂，最后一個元素代表方法調用堆棧的棧底。

6     public Throwable fillInStackTrace()     用當前的調用棧層次填充Throwable 對象棧層次，添加到棧層次任何先前信息中。

。。。

捕獲異常

使用try和catch關鍵字可以捕獲異常。try/catch代碼塊放在異常可能發生的地方。

try/catch代碼塊中的代碼稱為保護代碼，使用 try/catch的語法如下：

try

{

   // 程序代碼

}catch(ExceptionName e1)

{

   //Catch 塊

}

Catch語句包含要捕獲異常類型的聲明。當保護代碼塊中發生一個異常時，try后面的catch塊就會被檢查。

如果發生的異常包含在catch塊中，異常會被傳遞到該catch塊，這和傳遞一個參數到方法是一樣。

。。。

多重捕獲塊

一個try代碼塊后面跟隨多個catch代碼塊的情況就叫多重捕獲。

多重捕獲塊的語法如下所示：

 try{

    // 程序代碼

 }catch(異常類型1 異常的變量名1){

    // 程序代碼

 }catch(異常類型2 異常的變量名2){

    // 程序代碼

 }catch(異常類型2 異常的變量名2){

    // 程序代碼

 }

上面的代碼段包含了3個catch塊。

可以在try語句后面添加任意數量的catch塊。

如果保護代碼中發生異常，異常被拋給第一個catch塊。

如果拋出異常的數據類型與ExceptionType1匹配，它在這里就會被捕獲。

如果不匹配，它會被傳遞給第二個catch塊。

如此，直到異常被捕獲或者通過所有的catch塊。

。。。

throws/throw關鍵字：

如果一個方法沒有捕獲一個檢查性異常，那么該方法必須使用throws 關鍵字來聲明。throws關鍵字放在方法簽名的尾部。

也可以使用throw關鍵字拋出一個異常，無論它是新實例化的還是剛捕獲到的。

下面方法的聲明拋出一個RemoteException異常：

import java.io.*;

public class className

{

   public void deposit(double amount) throws RemoteException

   {

      // Method implementation

      throw new RemoteException();

   }

   //Remainder of class definition

}

一個方法可以聲明拋出多個異常，多個異常之間用逗號隔開。

。。。

finally關鍵字

finally關鍵字用來創建在try代碼塊后面執行的代碼塊。

無論是否發生異常，finally代碼塊中的代碼總會被執行。

在finally代碼塊中，可以運行清理類型等收尾善后性質的語句。

finally代碼塊出現在catch代碼塊最后，語法如下：

 try{

    // 程序代碼

 }catch(異常類型1 異常的變量名1){

    // 程序代碼

 }catch(異常類型2 異常的變量名2){

    // 程序代碼

 }finally{

    // 程序代碼

 }

注意下面事項：

catch不能獨立于try存在。

在try/catch后面添加finally塊并非強制性要求的。

try代碼后不能既沒catch塊也沒finally塊。

try, catch, finally塊之間不能添加任何代碼。

。。。

聲明自定義異常

在Java中你可以自定義異常。編寫自己的異常類時需要記住下面的幾點。

-所有異常都必須是Throwable的子類。

-如果希望寫一個檢查性異常類，則需要繼承Exception類。

-如果你想寫一個運行時異常類，那么需要繼承RuntimeException 類。

可以像下面這樣定義自己的異常類：

class MyException extends Exception{

}

只繼承Exception 類來創建的異常類是檢查性異常類。

一個異常類和其它任何類一樣，包含有變量和方法。

。。。

通用異常

在Java中定義了兩種類型的異常和錯誤。

1. JVM(Java虛擬機)異常：由JVM拋出的異常或錯誤。例如：NullPointerException類，ArrayIndexOutOfBoundsException類，ClassCastException類。

2. 程序級異常：由程序或者API程序拋出的異常。例如(非法數據異常)IllegalArgumentException類，(非法語句異常)IllegalStateException類。

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 面向對象

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Java 繼承

繼承是java面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。繼承可以理解為一個對象從另一個對象獲取屬性的過程。

如果類A是類B的父類，而類B是類C的父類，我們也稱C是A的子類，類C是從類A繼承而來的。在Java中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類

繼承中最常使用的兩個關鍵字是extends和implements。

這兩個關鍵字的使用決定了一個對象和另一個對象是否是IS-A(是一個)關系。

通過使用這兩個關鍵字，我們能實現一個對象獲取另一個對象的屬性。

所有Java的類均是由java.lang.Object類繼承而來的，所以Object是所有類的祖先類，而除了Object外，所有類必須有一個父類。

通過過extends關鍵字可以申明一個類是繼承另外一個類而來的，一般形式如下：

// 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關系

IS-A就是說:一個對象是另一個對象的一個分類。

下面是使用關鍵字extends實現繼承。

public class Animal{

}

public class Mammal extends Animal{

}

public class Reptile extends Animal{

}

public class Dog extends Mammal{

}

基于上面的例子，以下說法是正確的：

-Animal類是Mammal類的父類。

-Animal類是Reptile類的父類。

-Mammal類和Reptile類是Animal類的子類。

-Dog類既是Mammal類的子類又是Animal類的子類。

分析以上示例中的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

。。。

介紹完extends關鍵字之后，我們再來看下implements關鍵字是怎樣使用來表示IS-A關系。

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

。。。

instanceof 關鍵字

可以使用 instanceof 運算符來檢驗B和C對象是否是A類的一個實例。

。。。

HAS-A 關系

HAS-A代表類和它的成員之間的從屬關系。這有助于代碼的重用和減少代碼的錯誤。

在面向對象特性中，用戶不必擔心類的內部怎樣實現。

Java只支持單繼承，也就是說，一個類不能繼承多個類。

Java只支持單繼承（繼承基本類和抽象類），但是我們可以用接口來實現（多繼承接口來實現）,腳本結構如下：

public class Apple extends Fruit implements Fruit1, Fruit2{}

一般我們繼承基本類和抽象類用extends關鍵字，實現接口類的繼承用implements關鍵字。

::::::::::::::::::::::::::::::::::::::::

Java 重寫(Override)與重載(Overload)

。。。

重寫(Override)

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫！返回值和形參都不能改變。即外殼不變，核心重寫！

重寫的好處在于子類可以根據需要，定義特定于自己的行為。

也就是說子類能夠根據需要實現父類的方法。

在面向對象原則里，重寫意味著可以重寫任何現有方法。

。。。

方法重寫的規則

1. 參數列表必須完全與被重寫方法的相同；

2. 返回類型必須完全與被重寫方法的返回類型相同；

3. 子類方法的訪問權限必須大于或等于父類方法的訪問權限。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected。

4. 父類的成員方法只能被它的子類重寫。

5. 聲明為final的方法不能被重寫。

6. 聲明為static的方法不能被重寫，但是能夠被再次聲明。

7. 如果一個方法不能被繼承，那么該方法不能被重寫。

8. 子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為private和final的方法。

9. 子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為public和protected的非final方法。

10.重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更廣泛的強制性異常，反之則可以。

11. 構造方法不能被重寫。

12. 如果不能繼承一個方法，則不能重寫這個方法。

。。。

Super關鍵字的使用

當需要在子類中調用父類的被重寫方法時，要使用super關鍵字。

。。。

重載(Overload)

重載(overloading) 是在一個類里面，方法名字相同，而參數不同。返回類型呢？可以相同也可以不同。

每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

只能重載構造函數

重載規則

1. 被重載的方法必須改變參數列表；

2. 被重載的方法可以改變返回類型；

3. 被重載的方法可以改變訪問修飾符；

4. 被重載的方法可以聲明新的或更廣的檢查異常；

5. 方法能夠在同一個類中或者在一個子類中被重載。

。。。

重寫與重載之間的區別

區別點         重載方法          重寫方法

參數列表     必須修改          一定不能修改

返回類型     可以修改          一定不能修改

異常             可以修改          可以減少或刪除，一定不能拋出新的或者更廣的異常

訪問             可以修改          一定不能做更嚴格的限制（可以降低限制）

::::::::::::::::::::::::::::::::::::::::::::::

Java 多態

多態是同一個行為具有多個不同表現形式或形態的能力。

多態性是對象多種表現形式的體現。

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

接下來讓我們通過實例來了解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中，所有的對象都具有多態性，因為任何對象都能通過IS-A測試的類型和Object類。

訪問一個對象的唯一方法就是通過引用型變量。

引用型變量只能有一種類型，一旦被聲明，引用型變量的類型就不能被改變了。

引用型變量不僅能夠被重置為其他對象，前提是這些對象沒有被聲明為final(最后)。還可以引用和它類型相同的或者相兼容的對象。它可以聲明為類類型或者接口類型。

當我們將引用型變量應用于Deer對象的引用時，下面的聲明是合法的：

Deer d = new Deer();

Animal a = d;

Vegetarian v = d;

Object o = d;

所有的引用型變量d,a,v,o都指向堆中相同的Deer對象。

。。。

虛方法

我們將介紹在Java中，當設計類時，被重寫的方法的行為怎樣影響多態性。

我們已經討論了方法的重寫，也就是子類能夠重寫父類的方法。

當子類對象調用重寫的方法時，調用的是子類的方法，而不是父類中被重寫的方法。

要想調用父類中被重寫的方法，則必須使用關鍵字super。

:::::::::::::::::::::::::::::::::::::::::

Java 抽象類

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

抽象類除了不能實例化對象之外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類一樣。

由于抽象類不能實例化對象，所以抽象類必須被繼承，才能被使用。也是因為這個原因，通常在設計階段決定要不要設計抽象類。

父類包含了子類集合的常見的方法，但是由于父類本身是抽象的，所以不能使用這些方法。

。。。

抽象類

在Java語言中使用abstract class來定義抽象類。

。。。

繼承抽象類

我們能通過一般的方法繼承抽象類

。。。

抽象方法

如果你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類確定，那么你可以在父類中聲明該方法為抽象方法。

Abstract關鍵字同樣可以用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名后面直接跟一個分號，而不是花括號。

聲明抽象方法會造成以下兩個結果：

1. 如果一個類包含抽象方法，那么該類必須是抽象類。

2. 任何子類必須重寫父類的抽象方法，或者聲明自身為抽象類。

繼承抽象方法的子類必須重寫該方法。否則，該子類也必須聲明為抽象類。最終，必須有子類實現該抽象方法，否則，從最初的父類到最終的子類都不能用來實例化對象。

:::::::::::::::::::::::::::::::::::::

Java 封裝

在面向對象程式設計方法中，封裝（英語：Encapsulation）是指，一種將抽象性函式接口的實作細節部份包裝、隱藏起來的方法。

封裝可以被認為是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。

要訪問該類的代碼和數據，必須通過嚴格的接口控制。

封裝最主要的功能在于我們能修改自己的實現代碼，而不用修改那些調用我們代碼的程序片段。

適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。

讓我們來看一個java封裝類的例子：

/* 文件名: EncapTest.java */

public class EncapTest{

   private String name;

   private String idNum;

   private int age;

   public int getAge(){

      return age;

   }

   public String getName(){

      return name;

   }

   public String getIdNum(){

      return idNum;

   }

   public void setAge( int newAge){

      age = newAge;

   }

   public void setName(String newName){

      name = newName;

   }

   public void setIdNum( String newId){

      idNum = newId;

   }

}

以上實例中public方法是外部類訪問該類成員變量的入口。

通常情況下，這些方法被稱為getter和setter方法。

因此，任何要訪問類中私有成員變量的類都要通過這些getter和setter方法。

通過如下的例子說明EncapTest類的變量怎樣被訪問：

/* F文件名 : RunEncap.java */

public class RunEncap{

   public static void main(String args[]){

      EncapTest encap = new EncapTest();

      encap.setName("James");

      encap.setAge(20);

      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName()+ 

                             " Age : "+ encap.getAge());

    }

}

以上代碼編譯運行結果如右：Name : James Age : 20

:::::::::::::::::::::::::::::::::::::::::::::

Java 接口

接口（英文：Interface），在JAVA編程語言中是一個抽象類型，是抽象方法的集合，接口通常以interface來聲明。一個類通過繼承接口的方式，從而來繼承接口的抽象方法。

接口并不是類，編寫接口的方式和類很相似，但是它們屬于不同的概念。類描述對象的屬性和方法。接口則包含類要實現的方法。

除非實現接口的類是抽象類，否則該類要定義接口中的所有方法。

接口無法被實例化，但是可以被實現。一個實現接口的類，必須實現接口內所描述的所有方法，否則就必須聲明為抽象類。另外，在Java中，接口類型可用來聲明一個變量，他們可以成為一個空指針，或是被綁定在一個以此接口實現的對象。

接口與類相似點：

-一個接口可以有多個方法。

-接口文件保存在.java結尾的文件中，文件名使用接口名。

-接口的字節碼文件保存在.class結尾的文件中。

-接口相應的字節碼文件必須在與包名稱相匹配的目錄結構中。 

接口與類的區別：

-接口不能用于實例化對象。

-接口沒有構造方法。

-接口中所有的方法必須是抽象方法。

-接口不能包含成員變量，除了static和final變量。

-接口不是被類繼承了，而是要被類實現。

-接口支持多重繼承。

。。。

接口的聲明

接口的聲明語法格式如下：

[可見度] interface 接口名稱 [extends 其他的類名] {

        // 聲明變量

        // 抽象方法

}

Interface關鍵字用來聲明一個接口。下面是接口聲明的一個簡單例子。

/* 文件名 : NameOfInterface.java */

import java.lang.*;

//引入包

public interface NameOfInterface

{

   //任何類型 final, static 字段

   //抽象方法

}

接口有以下特性：

-接口是隱式抽象的，當聲明一個接口的時候，不必使用abstract關鍵字。

-接口中每一個方法也是隱式抽象的，聲明時同樣不需要abstract關鍵子。

-接口中的方法都是公有的。

例子：

/* 文件名 : Animal.java */

interface Animal {

   public void eat();

   public void travel();

}

。。。

接口的實現

當類實現接口的時候，類要實現接口中所有的方法。否則，類必須聲明為抽象的類。

類使用implements關鍵字實現接口。在類聲明中，Implements關鍵字放在class聲明后面。

實現一個接口的語法，可以使用這個公式：... implements 接口名稱[, 其他接口, 其他接口..., ...] ...

。。。

重寫接口中聲明的方法時，需要注意以下規則：

-類在實現接口的方法時，不能拋出強制性異常，只能在接口中，或者繼承接口的抽象類中拋出該強制性異常。

-類在重寫方法時要保持一致的方法名，并且應該保持相同或者相兼容的返回值類型。

-如果實現接口的類是抽象類，那么就沒必要實現該接口的方法。

在實現接口的時候，也要注意一些規則：

-一個類可以同時實現多個接口。

-一個類只能繼承一個類，但是能實現多個接口。

-一個接口能繼承另一個接口，這和類之間的繼承比較相似。

。。。

接口的繼承

一個接口能繼承另一個接口，和類之間的繼承方式比較相似。接口的繼承使用extends關鍵字，子接口繼承父接口的方法。

。。。

接口的多重繼承

在Java中，類的多重繼承是不合法，但接口允許多重繼承。

在接口的多重繼承中extends關鍵字只需要使用一次，在其后跟著繼承接口。 如右所示：public interface Hockey extends Sports, Event

以上的程序片段是合法定義的子接口，與類不同的是，接口允許多重繼承，而 Sports及 Event 可能定義或是繼承相同的方法

。。。

標記接口

最常用的繼承接口是沒有包含任何方法的接口。

標識接口是沒有任何方法和屬性的接口.它僅僅表明它的類屬于一個特定的類型,供其他代碼來測試允許做一些事情。

標識接口作用：簡單形象的說就是給某個對象打個標（蓋個戳），使對象擁有某個或某些特權。

例如：java.awt.event包中的MouseListener接口繼承的java.util.EventListener接口定義如下：

package java.util;

public interface EventListener

{}

沒有任何方法的接口被稱為標記接口。標記接口主要用于以下兩種目的：

1. 建立一個公共的父接口：

正如EventListener接口，這是由幾十個其他接口擴展的JavaAPI，你可以使用一個標記接口來建立一組接口的父接口。例如：當一個接口繼承了EventListener接口，Java虛擬機(JVM)就知道該接口將要被用于一個事件的代理方案。

2. 向一個類添加數據類型：

這種情況是標記接口最初的目的，實現標記接口的類不需要定義任何接口方法(因為標記接口根本就沒有方法)，但是該類通過多態性變成一個接口類型。

:::::::::::::::::::::::::::::::::::::::

Java 包(package)

為了更好地組織類，Java提供了包機制，用于區別類名的命名空間。

包的作用：

1. 把功能相似或相關的類或接口組織在同一個包中，方便類的查找和使用。

2.如同文件夾一樣，包也采用了樹形目錄的存儲方式。同一個包中的類名字是不同的，不同的包中的類的名字是可以相同的，當同時調用兩個不同包中相同類名的類時，應該加上包名加以區別。因此，包可以避免名字沖突。

3. 包也限定了訪問權限，擁有包訪問權限的類才能訪問某個包中的類。

Java使用包（package）這種機制是為了防止命名沖突，訪問控制，提供搜索和定位類（class）、接口、枚舉（enumerations）和注釋（annotation）等。

包語句的語法格式為：package pkg1[．pkg2[．pkg3…]];

例如,一個Something.java 文件它的內容

package net.java.util

public class Something{

   ...

}

那么它的路徑應該是 net/java/util/Something.java 這樣保存的。 package(包)的作用是把不同的java程序分類保存，更方便的被其他java程序調用。

一個包（package）可以定義為一組相互聯系的類型（類、接口、枚舉和注釋），為這些類型提供訪問保護和命名空間管理的功能。

以下是一些Java中的包：

java.lang-打包基礎的類

java.io-包含輸入輸出功能的函數

開發者可以自己把一組類和接口等打包，并定義自己的package。而且在實際開發中這樣做是值得提倡的，當你自己完成類的實現之后，將相關的類分組，可以讓其他的編程者更容易地確定哪些類、接口、枚舉和注釋等是相關的。

由于package創建了新的命名空間（namespace），所以不會跟其他package中的任何名字產生命名沖突。使用包這種機制，更容易實現訪問控制，并且讓定位相關類更加簡單。

。。。

創建包

創建package的時候，你需要為這個package取一個合適的名字。之后，如果其他的一個源文件包含了這個包提供的類、接口、枚舉或者注釋類型的時候，都必須將這個package的聲明放在這個源文件的開頭。

包聲明應該在源文件的第一行，每個源文件只能有一個包聲明，這個文件中的每個類型都應用于它。

如果一個源文件中沒有使用包聲明，那么其中的類，函數，枚舉，注釋等將被放在一個無名的包（unnamed package）中。

通常使用小寫的字母來命名避免與類、接口名字的沖突。

。。。

import關鍵字

為了能夠使用某一個包的成員，我們需要在 Java 程序中明確導入該包。使用"import"語句可完成此功能。

在 java 源文件中 import 語句應位于 package 語句之后，所有類的定義之前，可以沒有，也可以有多條，其語法格式為：import package1[.package2…].(classname|*);

如果在一個包中，一個類想要使用本包中的另一個類，那么該包名可以省略。

注意：類文件中可以包含任意數量的import聲明。import聲明必須在包聲明之后，類聲明之前。

。。。

package的目錄結構

類放在包中會有兩種主要的結果：

1. 包名成為類名的一部分，正如我們前面討論的一樣。

2. 包名必須與相應的字節碼所在的目錄結構相吻合。

下面是管理你自己java中文件的一種簡單方式：

將類、接口等類型的源碼放在一個文件中，這個文件的名字就是這個類型的名字，并以.java作為擴展名。

例如：

// 文件名 :  Car.java

package vehicle;

public class Car {

   // 類實現  

}

接下來，把源文件放在一個目錄中，這個目錄要對應類所在包的名字：....\vehicle\Car.java

現在，正確的類名和路徑將會是如下樣子：

類名 -> vehicle.Car

路徑名 -> vehicle\Car.java (in windows)

通常，一個公司使用它互聯網域名的顛倒形式來作為它的包名.例如：互聯網域名是apple.com，所有的包名都以com.apple開頭。包名中的每一個部分對應一個子目錄。

例如：這個公司有一個com.apple.computers的包，這個包包含一個叫做Dell.java的源文件，那么相應的，應該有如下面的一連串子目錄：

....\com\apple\computers\Dell.java

編譯的時候，編譯器為包中定義的每個類、接口等類型各創建一個不同的輸出文件，輸出文件的名字就是這個類型的名字，并加上.class作為擴展后綴。 

例如：

// 文件名: Dell.java

package com.apple.computers;

public class Dell{

}

class Ups{

}

現在，我們用-d選項來編譯這個文件，如右：$javac -d . Dell.java

這樣會像右面這樣放置編譯了的文件：.\com\apple\computers\Dell.class.\com\apple\computers\Ups.class

你可以像右面這樣來導入所有 \com\apple\computers\中定義的類、接口等：import com.apple.computers.*;

編譯之后的.class文件應該和.java源文件一樣，它們放置的目錄應該跟包的名字對應起來。但是，并不要求.class文件的路徑跟相應的.java的路徑一樣。你可以分開來安排源碼和類的目錄。

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

這樣，你可以將你的類目錄分享給其他的編程人員，而不用透露自己的源碼。用這種方法管理源碼和類文件可以讓編譯器和java虛擬機（JVM）可以找到你程序中使用的所有類型。

類目錄的絕對路徑叫做class path。設置在系統變量CLASSPATH中。編譯器和java虛擬機通過將package名字加到class path后來構造.class文件的路徑。

<path- two>\classes是class path，package名字是com.apple.computers,而編譯器和JVM會在 <path-two>\classes\com\apple\compters中找.class文件。

一個class path可能會包含好幾個路徑。多路徑應該用分隔符分開。默認情況下，編譯器和JVM查找當前目錄。JAR文件按包含Java平臺相關的類，所以他們的目錄默認放在了class path中。

。。。

設置CLASSPATH系統變量

用下面的命令顯示當前的CLASSPATH變量：

Windows平臺（DOS 命令行下）-> C:\> set CLASSPATH

UNIX平臺（Bourne shell下）-> % echo $CLASSPATH

刪除當前CLASSPATH變量內容：

Windows平臺（DOS 命令行下）-> C:\> set CLASSPATH=

UNIX平臺（Bourne shell下）-> % unset CLASSPATH; export CLASSPATH

設置CLASSPATH變量:

Windows平臺（DOS 命令行下）-> set CLASSPATH=C:\users\jack\java\classes

UNIX平臺（Bourne shell下）-> % CLASSPATH=/home/jack/java/classes; export CLASSPATH

:::::::::::::::::::::::::::::::::::::::

Java 高級

:::::::::::::::::::::::::::::::::::::::

Java 數據結構

Java工具包提供了強大的數據結構。在Java中的數據結構主要包括以下幾種接口和類：

1. 枚舉（Enumeration）

2. 位集合（BitSet）

3. 向量（Vector）

4. 棧（Stack）

5. 字典（Dictionary）

6. 哈希表（Hashtable）

7. 屬性（Properties）

以上這些類是傳統遺留的，在Java2中引入了一種新的框架-集合框架(Collection)

。。。

枚舉（Enumeration）

枚舉（Enumeration）接口雖然它本身不屬于數據結構,但它在其他數據結構的范疇里應用很廣。 枚舉（TheEnumeration）接口定義了一種從數據結構中取回連續元素的方式。

例如，枚舉定義了一個叫nextElement 的方法，該方法用來得到一個包含多元素的數據結構的下一個元素。

。。。

位集合（BitSet）

位集合類實現了一組可以單獨設置和清除的位或標志。

該類在處理一組布爾值的時候非常有用，你只需要給每個值賦值一"位"，然后對位進行適當的設置或清除，就可以對布爾值進行操作了。

。。。

向量（Vector）

向量（Vector）類和傳統數組非常相似，但是Vector的大小能根據需要動態的變化。

和數組一樣，Vector對象的元素也能通過索引訪問。

使用Vector類最主要的好處就是在創建對象的時候不必給對象指定大小，它的大小會根據需要動態的變化。

。。。

棧（Stack）

棧（Stack）實現了一個后進先出（LIFO）的數據結構。

你可以把棧理解為對象的垂直分布的棧，當你添加一個新元素時，就將新元素放在其他元素的頂部。

當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最后進棧的元素最先被取出。

。。。

字典（Dictionary）

字典（Dictionary） 類是一個抽象類，它定義了鍵映射到值的數據結構。

當你想要通過特定的鍵而不是整數索引來訪問數據的時候，這時候應該使用Dictionary。

由于Dictionary類是抽象類，所以它只提供了鍵映射到值的數據結構，而沒有提供特定的實現。

。。。

哈希表（Hashtable）

Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

例如，在地址列表的哈希表中，你可以根據郵政編碼作為鍵來存儲和排序數據，而不是通過人的名字。

哈希表鍵的具體含義完全取決于哈希表的使用情景和它包含的數據。

。。。

屬性（Properties）

Properties 繼承于 Hashtable.Properties 類表示了一個持久的屬性集.屬性列表中每個鍵及其對應值都是一個字符串。

Properties 類被許多Java類使用。例如，在獲取環境變量時它就作為System.getProperties()方法的返回值。

關于“Java入門基礎知識有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。