第3章 Java的基本程序設計結構

2019-11-15 00:36:50

字體：大中小

來源：轉載

供稿：網友

第3章 java的基本程序設計結構3.1 一個簡單的Java應用程序public class FirstSample{ public static void main(String[] args){ System.out.

Java對大小寫敏感

public關鍵字稱為訪問修飾符（access modifier），用于控制程序的其他部分對這段代碼的訪問級別

class關鍵字 - 類是構建所有Java應用程序的構建塊，Java應用程序中的全部內容都必須放置在類中。

類名命名規范：

1)以大寫字母開頭，后面可以跟字母和數字的任意組合，但不能使用Java保留字作為類名 2)駱駝命名法：如果類名中有多個單詞組成，每個單詞的第一個字母都應該大寫 3)源代碼文件名必須與公共類的名字相同，并用.java作為擴展名。對于上面源代碼，文件命名為FirstSample.

javac FirstSample.java

編譯源代碼就會得到一個包含這個類字節碼的文件。編譯器將字節碼文件自動命名為FirstSample.class，并與源文件存儲在同一目錄下。

java FirstSample

運行程序時，Java虛擬機將從指定類中的main方法開始執行，因此，在類的源代碼中必須包含main方法。main方法必須聲明為public

每條語句必須由分號結束
可以將一條語句寫在多行上，回車不是語句結束的標志。

3.2 注釋

三種注釋方式

1)最常用的方式// ----單行注釋 2)/* */ -----多行注釋，注釋內容可以寫在多行，此注釋方式不能嵌套 3)/** *This is the first sample program in Core Java *@version 1.01 1997-03-22 *@author Gary Cornell */ public class FirstSample{ public static void main(String[] args){ System.out.println("We will not use 'Hello World!'"); } } 這種方式的注釋可以用來自動生成文檔3.3 數據類型

Java是一種強類型語言，即必須為每一個變量聲明一種數據類型。
8種基本類型（primitive type）

1)4種整型 byte short int long 2)2種浮點型 float double 3)1種字符類型char ---用于表示Unicode編碼的字符單元的字符類型char 4)1種用于表示真值的boolean類型

整型 ----用于表示沒有小數部分的數值，允許是負數

1)int類型最常用 2)表示地球上的人數，就要用long型了 3)byte和short類型主要用于特定場合 4)Java中整型的范圍與運行Java代碼的機器無關。這就解決了軟件在不同平臺或同平臺不同操作系統間移植的問題。由于Java程序必須保證在所有機器上都能夠得到相同的運行結果，所以每種數據類型的取值范圍必須固定。 5)長整型數值有一個后綴L（如4000000000L） 6)十六進制數有一個前綴0x（如0xCAFE） 7)八進制數有一個前綴0（如010） 8)二進制數有一個前綴（如0b1001，就是9）【Java7開始】 9)可以為數字字面量加下劃線,，（如1_000_000或0b1111_0100_0010_0000 表示1百萬），只是為了更易讀，Java編譯器會去除這些下劃線。 10)Java沒有任何無符號類型（unsighed）

浮點類型 -----用于表示有小數部分的數值

1)double表示這種類型的數據精度是float類型的兩倍，絕大部分應用程序都采用double類型 2)只有很少情況下，使用使用float類型 3)float類型的數值有一個后綴F(如3.14F)，沒有后綴F的浮點數值（如3.14）默認為double型 4)三個特殊的浮點數值 ---- 用于表示溢出和出錯的情況 a)正無窮大 ---- 對應常量Double.POSITIVE_INFINITY 一個正整數除以0的結果為正無窮大 b)負無窮大 ---- 對應常量Double.NEGATIVE_INFINITY c)NaN（不是一個數字） ----- 對應常量Double.NaN 0/0或者負數的平方根結果為NaN 5)所有非數值的值都是不相同的，可以使用Double.isNaN方法來檢驗某個值是否為NaN if(Double.isNaN(x)) 而不能使用如下方式檢驗 if(x==Double.NaN) 6)如果需要在數值計算中不含任何舍入誤差，就用該使用BigDecimal類

char類型 ----用于表示單個字符。通常用來表示字符常量。

1)特殊字符的轉義序列符

2)強烈建議不要在程序中使用char類型，最好將需要處理的字符串用抽象數據類型表示。

boolean類型

有兩個值false和true，用來判定邏輯條件。整型值和布爾值之間不能進行相互轉換。3.4 變量

每一個變量屬于一種類型（type），聲明變量時，變量所屬的類型位于變量名之前。聲明是完整語句，必須由分號結尾。變量名必須以字母開頭的由字母、下劃線和數字組成。

double salary; int vacationDays; long earthPopulation; boolean done;

也可以在一行中聲明多個同類型的變量，但不提倡這種做法，可讀性差。

int i,j;

變量名是大小寫敏感的。hireDay和hireday是兩個完全不同的變量。
變量名不能使用java保留字。
變量初始化

1)聲明一個變量后，必須使用賦值語句對一個變量進行顯示的初始化，千萬不能使用未經初始化的變量。 int vacationDays; //聲明變量 System.out.println(vacationDays); //未被初始化就使用了，出錯 variable not initialized 2)對已經聲明過的變量進行賦值 int vacationDays; vacationDays = 12; 3)也可以將變量的聲明和初始化放在同一行 int vacationDays = 12; 4)Java中可以將變量聲明放在代碼中的任何位置（有些語言必須將所有變量聲明放在最前面的位置） 5)在Java中，變量的聲明盡可能的靠近變量第一次使用的地方，這是一種良好的編程風格。

常量

1)函數作用域內的常量利用關鍵字final定義。表示這個變量只能被賦值一次，一旦被賦值之后，就不能再被改變了。習慣上常量名使用全大寫。 public class Constants{ public static void main(String[] args){ final double CM_PER_INCH = 2.54; //位于main方法內部 double paperWidth = 8.5; double paperHeight = 11; System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH); } } 2)類常量 Java中，經常希望某個常量能在一個類中的多個方法中使用，或者提供給其他類使用，通常將這些常量稱為類常量?？梢允褂藐P鍵字static final設置一個類常量。 public class Constants2{ public staticfinal double CM_PER_INCH = 2.54; //位于main方法外部（類的成員變量），因此可供類內部的所有方法使用，而且由于定義為public，因此其他類的方法也能使用這個常量，使用方法為Constants2.CM_PER_INCH public static void main(String[] args){ double paperWidth = 8.5; double paperHeight = 11; System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH); } }3.5 運算符

算術運算符

1) 加 + 2) 減 - 3) 乘 * 4) 除 / a)當參與/運算的兩個操作數都是整數時，表示整數除法； 15/2等于7 整數被0整除會產生一個異常 b)否則，表示浮點除法。 15.0/2等于7.5 浮點數被0除會得到無窮大或NaN結果。 5)求余（取模） % 15%2等于1 6)可以在賦值語句中采用簡化格式書寫二元算術運算符 x += 4; 等價于： x = x+4; 類似還有：*=或%=

自增運算符與自減運算符

int m = 7; int n = 7; int a = 2 * ++m; //a為16，m為8 前綴方式，先自增，后使用 int b = 2 * n++; //b為14, n為8 后綴方式，先使用，后自增

關系運算符和boolean運算符

1)關系運算符 a) == 檢測是否相等 3 == 7 的值為false b) != 檢測是否不想等 3 != 7 的值為true c) 經常使用的關系運算符還有： < 小于 > 大于 <= 小于等于 >= 大于等于 2)boolean邏輯運算符 a) && 表示邏輯“與” 按照短路方式求值，如果第一個操作數能夠確定表達式的值，第二個操作數就不必計算了。 expression1 && expression2 若expression1值為false，則整個邏輯表達式的值為false，因此expression2就不計算了，即expression2有異常也不會報錯。 b) || 表示邏輯“或” 按照短路方式求值，如果第一個操作數能夠確定表達式的值，第二個操作數就不必計算了。 expression1 || expression2 若expression1值為true，則整個邏輯表達式的值為true，因此expression2就不計算了，即expression2有異常也不會報錯。 c) ！表示邏輯“非” 3) ? 三元操作符 condition ? expression1 : expression2 當條件condition為真時，計算第一個表達式，并將表達式值作為整個三元表達式的值。當條件condition為假時，計算第二個表達式，并將表達式值作為整個三元表達式的值。

位運算符

1) & 與 2) | 或 3) ^ 異或 4) ~ 非 5) >> 右移位 6) << 左移位 7) >>> 右移位public class BitOperator { public static void main(String[] args) { //轉換為十進制輸出，結果為8 int i = 0b1000; System.out.println(i); //取非,結果為-9，不明白為什么？ int j = ~i; System.out.println(j); //取余，結果為8 int x = i & 0b11000; System.out.println(x); //取或，結果為9 int y = i | 0b0001; System.out.println(y); //取異或，結果為5 int z = i ^ 0b1101; System.out.println(z); //向左移兩位，結果為32 int a = i << 2; System.out.println(a); //向右移兩位，結果為2 int b = i >> 2; System.out.println(b); //向右移兩位，結果為2.和上面的區別還是不清楚。>>>運算符將用0填充高位；>>運算符用符號位填充高位 int c = i >>> 2; System.out.println(c); //當int類型時，需要對>>右側的操作數求摸32預算后，再移位.結果為2 int d = i >> 34; System.out.println(d); //當int類型時，需要對>>右側的操作數求摸64預算后，再移位,結果為2 long e = i >> 66; System.out.println(e);}

數學函數與常量

1) Math(java.lang.Math)類中，包含了各種各樣的數學函數 a) Math.sqrt(x) //計算一個數值的平方根 b) Math.power(x,a) //冪運算求x的a次冪 c) 常用三角函數 Math.sin Math.cos Math.tan Math.atan Math.atan2 d) 指數函數以及他的反函數——自然對數以及以10為底的對數 Math.exp Math.log Math.log10 e) Math.round(x) //舍入運算符，返回long類型的數值 2)Java還提供兩個表示π和e常量的近似值 Math.PI Math.E

數值類型之間的轉換

1)上圖6個實心箭頭，表示無信息丟失的轉換。有三個虛箭頭，表示可能有精度損失的轉換。當兩個數值進行二元操作時，先要將兩個操作數轉換為同一種類型，然后再進行計算。如果兩個操作數中有一個是double類型，另一個操作數就會轉換為double類型。否則，如果其中一個操作數是float類型，另一個操作數將會轉換為float類型。否則，如果其中一個操作數是long類型，另一個操作數將會轉換為long類型。否則，兩個操作數都會被轉換成int類型。

強制類型轉換

1)強制類型轉換（cast）的語法格式是在圓括號里給出想要轉換的目標類型，后面緊跟待轉換的變量名。

括號與運算符級別

枚舉類型

1)有時候，變量的取值只在一個有限的集合內，可以定義枚舉類型。枚舉類型包含有限個命名的值。 enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE}; Size s = Size.MEDIUM; Size類型的變量只能存儲這個類型聲明中給定的某個枚舉值，或者null值。null表示這個變量沒有設置任何值。3.6 字符串

Java字符串就是Unicode字符序列。Java沒有內置的字符串類型，而是在標準的Java類庫中提供一個預定義類，很自然的叫做String。每個用雙引號括起來的字符串都是String類的一個實例。

String e=""; //an empty string String greeting="Hello";

子串

String類的substring方法，從一個較大的字符串中提取出一個字串。 String greeting = "Hello"; String s = greeting.substring(0,3); //第二個參數是不想賦值的第一個位置，從0開始計數，指導3為止，但不包含3. 創建一個由“Hel”組成的字符串 substring的工作方式有一個優點：容易計算字串的長度，字符串s.substring(a,b)的長度為b-a

拼接

Java語言允許使用+號連接（拼接）兩個字符串當將一個字符串與一個非字符串拼接時，后者被轉換成字符串，任何一個Java對象都可以轉換為字符串

不可變字符串

1)String類沒有提供用于修改字符串的方法。 greeting = greeting.substring(0,3) + "p!"; 2)由于不能修改Java字符串中的字符，所以在Java文檔中將String類對象稱為不可變字符串。當然可以修改字符串變量 greeting，讓他引用另外一個字符串。 3)不可變字符串有一個優點，編譯器可以讓字符串共享。字符串放在公共的存儲池中，字符串變量指向存儲池中相應的位置，如果復制一個字符串變量，原始字符串變量和復制的字符串變量共享相同的字符。Java設計者認為，共享的效率遠遠勝過提取、拼接字符串帶來的低效率。

檢測字符串是否相等

1)可以使用equals方法檢測兩個字符串是否相等 s.equals(t) 相等返回true，不相等返回false。 s與t可以是字符串變量，也可以是字符串常量。 "Hello".equals(greeting); 檢查兩個字符串是否相等，而不區分大小寫 "Hello".equalsIgnoreCase("hello"); 2)一定不能使用==運算符檢測兩個字符串是否相等。這個預算符只能檢查這兩個字符串是否放在同一個位置上。當然如果字符串放置在同一個位置上必然相等，但是，完全有可能將內容相同的多個字符串拷貝放置在不同的位置上。 String greeting = "Hello"; if(greeting == "Hello") ... 也許返回true if(greeting.substring(0,3) == "Hel")... 也許返回false 如果虛擬機始終將相同的字符串共享，就可以使用==運算符檢測是否相等。但實際上只有字符串常量是共享的，而+或substring等操作的結果并不是共享的。

空串和Null串

1)空串""是長度為0的字符串?？梢哉{用以下代碼檢查一個字符串是否為空。 if(str.length() == 0) 或 if(str.equals("")) 空串是一個Java對象，有自己的串長度（0）和內容（空） 2)String變量還可以存放一個特殊值，null 表示目前沒有任何對象與該變量關聯。要檢查一個字符串是否為null，要使用以下條件： if(str == null) 要檢查一個字符串即不是null也不為空 if(str != null && str.length() != 0) 如果在一個null值上調用方法，會出現錯誤。

代碼點與代碼單元
字符串API
閱讀聯機API文檔
構建字符串

1)StringBuilder 由較短的字符串構建字符串，解決字符串連接方式低效率問題。 StringBuilder builder = new StringBuilder(); builder.append(ch); //追加單個字符 builder.append(str); //追加字符串在需要構建字符串時，就調用toString()方法，得到一個String對象。 String completeString = builder.toString(); 2)StringBuffer 是StringBuilder的前身，其效率稍低。但允許采用多線程執行添加或刪除字符的操作。如果所有字符串在一個單線程中編輯（通常都是這樣），則應該用StringBuilder替代。這兩個類的API是相同的。

讀取輸入（標準輸入流 System.in）

1)采用Scanner類進行收入 import java.util.*;

public class InputTest {

public static void main(String[] args) {
Scanner in = new Scanner(System.in); //構造一個Scanner對象，并于標準輸入流關聯
System.out.print("What's your name?");
String name = in.nextLine(); //輸入一行
System.out.print("How old are you?");
int age = in.nextInt(); //輸入一個整型數值
System.out.println("Hello, " + name + ". Next year, you'll be" + (age + 1));
}

}

格式化輸出
文件輸入與輸出

package corejava;import java.io.FileNotFoundException;import java.io.IOException;import java.io.PrintWriter;import java.nio.file.Paths;import java.util.*;public class FileInOutput {public static void main(String[] args) throws FileNotFoundException,IOException {

//PrintWriter out = new PrintWriter("F://Java//corejava//book.txt"); 絕對路徑寫法
PrintWriter out = new PrintWriter("book.txt"); //相對路徑寫法
out.println("code complete");
out.println("Spring in action");
out.close();
//Scanner in = new Scanner(Paths.get("F://Java//corejava//book.txt"));
Scanner in = new Scanner(Paths.get("book.txt"));
String book1 = in.nextLine();
String book2 = in.nextLine();
in.close();
System.out.println("book1:" + book1);
System.out.println("book2:" + book2);
System.out.println(System.getProperty("user.dir")); //Java虛擬機啟動路徑為F:/Java/corejava/ 因此上面的絕對路徑和相對路徑寫法是等價的。
}

}

3.8 控制流程

塊（block）作用域

1)塊（即復合語句），是指由以對花括號括起來的若干簡單的Java語句。2)塊確定了變量的作用域3)一個塊可以嵌套在另一個塊中，但是不能在兩個嵌套的塊中聲明同名的變量。

條件語句

if(condition) { statement; }

循環

1) while循環 while (condition) statement; //循環體中的內容，可能一次都不被執行 2)do..while循環 do statement while(condition); //循環體中的內容，至少被執行一次 3)for循環

多重選擇：switch語句

1)case標簽類型支持：char、byte、short或int或對應的包裝器類（Character、Byte、Short和Integer） 2)枚舉常量 enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE}; Size sz = Size.LARGE; switch(sz) { case SMALL: //no need to use Size.SMALL .... break; ... } 3)Java SE7開始，case標簽還可以是字符串字面量 String input = ...; switch(input.toLowerCase()) { case "yes"; .... break; ..... }

中斷控制流程語句

1) break語句用于退出switch語句、while語句、do..while語句、for語句 2)帶標簽的break語句，用于跳出多重嵌套的循環語句。只能跳出語句塊，而不能跳入語句塊。 ...... read_data: while(...) { .... for(...) { ...... break read_data: ....... } } //跳出標簽后，從下面語句開始執行 ................ 3)continue語句越過當前循環體的剩余部分，立刻跳到循環首部。計數器自增后，繼續執行循環體。 4)帶標簽的continue語句將跳到與標簽匹配的循環首部。 3.9 大數值

java.Math包中的兩個很有用的類：BigInteger和BigDecimal
這兩個類實現了可以處理包含任意長度數字序列的數值
BigInteger a= BigInteger.valueOf(100); //使用靜態的valueOf方法將普通的數值轉換為大數值
不能使用普通的算術運算符 + - * /來處理大數值，而需要使用大數值類中的add和multipy方法。

BigInteger c = a.add(b); //c= a+b; BigInteger d = c.multiply(b.add(BigInter.valueOf(2))); // d= c*(b + 2)

import java.math.BigInteger;

public class BigIntegerTest {
public static void main(String[] args) {
BigInteger a = BigInteger.valueOf(5);
BigInteger b = BigInteger.valueOf(6);
BigInteger c = a.add(b);
BigInteger d = a.multiply(b);
System.out.println(c);
System.out.println(d);
}
}

3.10 數組

數組是一種數據結構，用來存儲同類型的值的集合。
通過一個整型小標可以訪問數組中的每個值。a[i]表示整型數組中，第i個元素。
申明數據變量

int[] a; //只聲明了變量a，并沒有將a初始化為一個真正的數組。

初始化數組

int[] a = new int[100]; //這個數組的下標是0-99，若訪問a[100]，或任何在0-99之外下標的元素，就會引發“array index out of bounds”異常而終止執行。

創建一個數字數組時，所有元素都初始為0，boolean數組的元素會初始化為false。對象數組的元素則初始化為null

String[] names = new String[10]; //此時，數組中的元素都為null for(int i =0;i<10;i++){ names[i] = ""; } //此時，數組中的元素都為""，空串。

一旦創建了數組，就不能改變它的大小，盡管可以改變數組中的每個元素的值。
如果經常需要在運行的過程中擴展數組的大小，則應該使用另一種數據結構：數組列表(array list)
for each循環

for(variable : collection){ statement; } //variable--定義一個變量用于暫存集合中的每一個元素 //collection--這一集合表達式必須是一個數組或者是一個實現了Iterable接口的類對象。如，ArrayList

在很多情況下，還是需要使用傳統的for循環，例如，不希望遍歷集合中的每個元素，或者在循環內部需要使用下標等。
打印數組中的所有值

Arrays類的toString方法: Arrays.toString(a); //返回一個包含數組元素的字符串 [2,3,5,10]

數組初始化

int[] smallPrimes = {2,3,5,7,11,13}; 使用這種語法，不需要調用new 利用括號中提供的值進行初始化，數組的大小就是初始值的個數。

匿名數組

new int[]{17,19,23,29,31,37} 這種語法形式可以在不創建新變量的情況下重新初始化一個數組。 smallPrimes = new int[]{17,19,23,29,31,37}

Java中，允許數組長度為0

new elementType[0]; //數組長度為0與null不同。

數組拷貝

1)Java中允許將一個數組變量拷貝給另一個數組變量。這時，兩個變量將引用同一個數組。 int[] a = {1,2,3,4,5}; int[] b = a; //兩個引用指向堆上的相同數組數組對象。 b[2] = 30; //此時a[2]的值也變成了30 2)將一個數組的值拷貝到新的數組中去（開辟新的空間保存，互不影響），則使用Arrays類的copyTo方法： int[] b= Arrays.copyOf(a,a.length); //第二個參數是新數組的長度，這個方法通常用來增加數組的大小。 int[] c =Arrays.copyOf(b,b.length*2); 如果數組元素的類型是數值型，那么多余的元素將被賦予0；如果數組元素是布爾型，則將賦值為false。相反，如果長度小于原始數組的長度，則只拷貝最前面的數據元素。

命令行參數

//main方法接受一個字符串數組，也就是命令行參數。 package corejava;

public class CommandLineArgs {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(args.length);
for(String s:args){
System.out.println(s);
}

}}

java CommandLineArgs -jrr tmac -lbj

數組排序

package corejava;

import java.util.Arrays;public class SortTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = {1,3,2,5,9,7};
System.out.println(Arrays.toString(a));
Arrays.sort(a); //采用優化的快速排序法，對數組進行排序
System.out.println(Arrays.toString(a));
}

}

數組搜索

Arrays.binarySearch

Arrays.equals(type[] a,type[] b)

如果兩個數組大小相同，并且下標相同的元素都對應相等，則返回true

多維數組

double[][] balance; //聲明數組 balance = new double[2][3]; //初始化數組 //另一種初始化方式 int[][] magicSquare ={ {16,3,2,13}, {5,10,11,8}, {9,6,7,12}, {4,15,14,1} } 一旦數組被初始化，就可以利用兩個方括號訪問每個元素，balances[i][j] for each循環處理二維數組時，必須使用兩個for each循環進行嵌套遍歷 for(double[] row:a) for(double value:row) do something with value; 快速打印一個二維數組元素的列表 System.out.println(Arrays.deepToString(a));

不規則數組

1)Java實際上沒有多維數組，只有一維數組，多維數組被解釋為“數組的數組” 2)不規則數組：即數組的每一行有不同的長度 //首先需要分配一個具有所含行數的數組 int[][] odds = new int[NMAX + 1][]; for(int n=0; n < NMAX; n++) odds[n] = new int[n+1];

上一篇：JavaWeb學習總結第五篇--認識Cookie機制

下一篇：Struts2框架實現簡單的用戶登入