本章要點
- 一個簡單的Java應用程序
- 注釋
- 數據類型
- 變量
- 運算符
- 字符串
- 輸入輸出流
- 控制流
- 大數值
- 數組

---

3.1 一個簡單的Java應用程序

?

上圖是一個最簡單的Java程序，它表示：聲明一個名為FirstSample的public類，當運行這個類時，JVM會調用類中的main方法，該方法向控制臺打印“Hello, world!”這么一句話。麻雀雖小，但是Java程序的基本要素都包含在里面。

1）Java對大小寫敏感
- 這意味著，對Java而言，Main和main是兩個不同的名詞。

2）public：訪問修飾符
- 它用于控制程序的其他部分對這段代碼的訪問權限，有public，protected，default，private四種。

3）class：聲明一個類
- class用于聲明一個類。可以將類視為一個加載程序邏輯的容器，程序邏輯定義了應用程序的行為。
- 類是構建所有Java應用程序的構建塊。
- 一個源文件（.java文件）最多只能包含一個public類，且源文件與該類名字必須相同。
- enum用于聲明一個枚舉，聲明方法不需要特定的標識符。

4）編譯與運行
- 確保已安裝JDK且配置環境變量。
- 編譯：javac FirstSample.java，即javac + 空格 + 源文件名（含擴展名.java），可不區分大小寫（因Windows不區分大小寫）。
- 運行：java FirstSample，即java + 空格 + 程序名（不含擴展名.class），嚴格區分大小寫。
- 運行程序時，JVM將從public類中的main方法開始執行，這里就是程序的入口。所以一個源文件中只能包含一個public類，這個類中只能有一個main方法，這個方法必須擁有最高的訪問權限（public）。

5）代碼塊與語句
- 用｛｝來區分程序的各個部分，如類與類，方法與方法，局部代碼塊等。｛為該部分的起點，｝為該部分的結束。
- 在一對｛｝之間聲明的標識符只在這部分有效。
- “語句”表示一個句子，可視為代碼的基本單元，必須以；結束。

6）對成員的調用
- 成員指類的方法和變量
- .用于表示對成員的調用，如object.method(param)表示調用一個方法，object.variable表示調用一個變量。

---

3.2 注釋

• 注釋不會出現在編譯后的可執行程序中，它用于程序員對所寫代碼的說明，如這段代碼為什么要這么寫，別人調用我的接口需要注意什么，這個變量是用來做什么的等。
• Java有三種注釋。
  
  • // 單行注釋：注釋本行。
  • /* */ 多行注釋：注釋被包裹的內容。
  • /** */ 文檔注釋：注釋被包裹的內容，并且可以用javadoc命令自動生成文檔。

---

3.3 數據類型

• Java是一種強類型語言，即每個變量必須聲明一種類型，一旦聲明之后不可以改變。

• 8種基本數據類型：

類型存儲需求最大值最小值示例備注

long	8 Byte	?263	263?1	123456789L	?
int	4 Byte	?231	231?1 （約21億）	123456789	整數默認類型
short	2 Byte	?215	215?1 （32767）	12345	?
byte	1 Byte	?27	27?1（127）	123	?
double	8 Byte	約-1.798E+308	約1.798E+308（21024）	123456789.0	小數默認類型，有效位數15位
float	4 Byte	約-3.4E+38F	約3.4E+38F （2128）	123456789.0F	有效位數6～7位
char	2 Byte	0 （\u0000）	65535 （\uffff）	‘A’	轉換為數值時無負值
boolean	?	?	?	true/false	無法轉換為其他類型

注1：double和float計算遵循IEEE754規范。
注2：三個特殊值常量
- 正無窮 Double.POSITIVE_INFINITY，如 1/0.0
- 負無窮 Double.NEGATIVE_INFINITY，如 -1/0.0
- 非數值 Double.NaN，如 0/0.0
- 所有”非數值“均不相等，檢測非數值只能用Double.isNaN(x)

• java中的進制表示

  • 十進制 1234567890
  • 十六進制 0x123ABCDEF
  • 八進制 012345678
  • 二進制 0b00001111

• 十進制轉換為二進制：除以2取余 ，直到商為0，然后將余數倒序排列
  

  ?

• 二進制轉換為十進制：各位乘以2n?1并求和
  如 110： 1?22+1?21+0?20=4+2+0=6

• 負數的二進制表現形式：絕對值得二進制形式各位取反，然后+1
  

  ?

• 引用數據類型： class, enum, interface, array

---

3.4 變量

在Java中，每一個變量屬于一種類型。在聲明變量時，變量所屬的類型位于變量名之前。
如： int counter;
double salary;

3.4.1 變量初始化

• 聲明一個變量之后，必須用賦值語句對變量進行顯式初始化（原文如此，這里應特指局部變量），變量被初始化之前不能使用。
• 變量的賦值和使用：

int i; i = 20; i = 30;String str = "abc"; str = str + "def";

3.4.2 常量

• 常量用關鍵字”final”指示，表示這個變量只能被賦值一次，即一旦被賦值之后，就不能再更改。
• 聲明為final的成員變量無默認值，必須顯式初始化。
• 常量的賦值和使用：

class Demo{static final int sCounter = 0; // 靜態常量必須在聲明時顯式初始化final int iSalary = 25000; // 非靜態的常量可在聲明時初始化或在構造方法中初始化final int iDays;Demo(){iDays = 10;} }

---

3.5 運算符

• +, -, *, /, % : 加、減、乘、除、取余

3.5.1 自增運算符與自減運算符

• ++, –
• ++i : 先進行加1運算，再參與其他運算；
• i++ : 先參與其他運算，再進行加1運算；
• 因容易混淆，并且可能產生bug（曾聽說過在某些版本的JDK下向控制臺打印i++與++i輸出同樣的值），不建議在其他表達式內部使用自增/自減運算；

int i = 1; int j = 1; int k = i++ * j++; // 不建議使用 System.out.println(++i); // 2 System.out.println(j++); // 1

3.5.2 關系運算符與boolean運算符

• ==， ！= ：相等，不相等（用于基本類型時判斷字面值，用于引用類型時判斷引用地址）
• <, <=, >, >=
• &, &&, |, ||
• 三元操作符?:，如String str = 1 == 2 ? “1等于2” : “1不等于2”;

3.5.3 位運算符

• 在處理整型數值時，可以直接對組成整型數值的各個位進行操作。
• &, |, ^, ~, >>, >>>, << 與，或，異或，非，右移，無符號右移，左移
• 應用例子：用一個變量的每個二進制位各代表一個flag：

class Test{int mod1 = 0b1;int mod2 = 0b10;int mod3 = 0b100;int mod4 = 0b1000;int mod5 = 0b10000;int mod6 = 0b100000;int mod7 = 0b1000000;int mod8 = 0b10000000;boolean isMod1(int mod){return ((mod & mod1) != 0) ? true : false;}boolean isMod2(int mod){return ((mod & mod2) != 0) ? true : false;}... }

3.5.4 數學函數與常量

• 請查閱java.lang.Math類

3.5.5 數值類型之間的轉換

• byte, short, char三種類型之間的運算自動提升為int
• int -> long -> float -> double，自動向上轉型

3.5.6 強制類型轉換

• 轉換方式：(targerType) variable。
• 通過截斷小數部分而不是四舍五入將浮點值轉換為整型。
• 當變量超過目標類型的表示范圍時，會根據補碼截斷，而不是保留目標類型的最大/最小值。

3.5.7 括號與運算符級別

優先級運算符結合性

1	[] . ()(方法調用)	從左向右
2	! ~ ++ – +(正號) -(負號) ()(強制類型轉換) new	從右向左
3	*/%	從左向右
4	+-	從左向右
5	<< >> >>>	從左向右
6	< <= > >= instanceof	從左向右
7	== !=	從左向右
8	&	從左向右
9	^	從左向右
10	|	從左向右
11	&&	從左向右
12	||	從左向右
13	?:(三元運算符)	從右向左
14	= += -= *= /= %= &= |= ^= <<= >>= >>>=	從右向左

3.5.8 枚舉類型

• 枚舉類型包括有限和命名的值。如 enum Size{S,M,L,XL,XXL,XXXL}

class Demo{enum Size{S,M,L,XL,XXL,XXXL}void test(){Size s = Size.S;} }

---

3.6 字符串

• 從概念上講，Java字符串就是Unicode字符序列。Java沒有內置的字符串類型，而是在標準Java類庫中提供了一個預定義類String，每個用”“括起來的字符串都是String類的一個實例。

3.6.1 子串

• 一個字符串中“一段”稱為它的一個子串。
• 空串”“是任何字符串的子串。
• String類的substring(a,b)方法可以從截取子串，截取范圍為[a,b)。contains(str)方法判斷是否包含該子串。

3.6.2 拼接

• 可以使用+號拼接任意兩個字符串。
• 當將一個字符串與任意非字符串的值拼接時，后者被轉換為字符串（基本類型根據字面值轉換，引用類型根據toString()方法轉換）。

public class Demo {public static void main(String[] args) {Demo1 demo1 = new Demo1();Demo2 demo2 = new Demo2();System.out.println(demo1 + ""); // 輸出demo1的引用地址System.out.println(demo2 + ""); // 輸出“Demo”} }class Demo1{}class Demo2{@Overridepublic String toString() {return "Demo";} }

3.6.3 不可變字符串

• 由于不能修改Java字符串中的字符，所以在Java文檔中將String類對象稱為不可變字符串。例如，”Hello”永遠包含字符H,e,l,l,o的代碼單元序列，一旦改變，就不再是”Hello”。
• 字符串不可改變，但字符串變量所引用的字符串對象是可以改變的。
• 一個經典的面試題：String s = new String(“abc”)共創建立多少個對象。
  
  • String s: 一個String類型的變量，位于stack區。
  • “abc”: 一個String類型對象，位于PermGen區的常量池（如果池中已有字面值為”abc”的對象則不會重復創建）。
  • new String(“abc”): 一個String類型對象，位于heap區。

• String類中用于存儲對象的值的變量使用了final修飾，只能在構造時賦值一次。即，一個String對象所記的value永遠不能改變，這就是不可變字符串的代碼實現。

• 我對這里有一個疑惑
  書中表示“原始字符串放置在堆中”，可以自動回收。但是，根據我查閱的其他資料，原始的字符串”abc”應該位于方法區，方法區在主程序運行期間是不會自動回收的。這里似乎有矛盾。
  簡單看了下《深入理解Java虛擬機》：Java虛擬機規范把方法區描述為堆的一個邏輯部分，但是它卻有一個別名叫做“非堆”，目的應該是與Java堆區分開來。也就是說，方法區應該是堆的一部分，但方法區的實現屬于虛擬機實現細節，不受虛擬機規范約束。為防止內存溢出以及極少數方法在不同虛擬機下有不同的表現，目前傾向于不將方法區實現為“永久代”，但需要為方法區單獨編寫內存管理代碼。由于對這一塊了解較少，這個問題尚待深入了解。

private final char value[];public String() {this.value = "".value; }public String(String original) {this.value = original.value;this.hash = original.hash; }public String(char value[]) {this.value = Arrays.copyOf(value, value.length); } ...

3.6.4 檢測字符串是否相等

• 可以使用equals(Object)和equalsIgnoreCase(String)方法檢測字符串是否相等（后者忽略大小寫。）為避免NullPointerException，當比較常量與變量時，應該以常量調用equals()方法。
• equals(Object)雖然形式參數被聲明為Object，但實際上在比較時會先做instanceof String判斷，所以實際上只能比較String類型。

String string = "abc";StringBuffer sBuffer = new StringBuffer("abc");System.out.println(string.equals(sBuffer)); // false public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}

3.6.5 空串與Null串

• 空串”“是長度為0的字符串對象，可以用來調用String類的所有成員方法和屬性。
• Null串null表示字符串變量目前沒有引用任何字符串對象，不能作任何調用。

3.6.6 代碼點與代碼單元

• char數據類型是一個采用UTF-16編碼表示Unicode代碼點的代碼單元。大多數常用的Unicode字符使用一個代碼單元就可以表示（即一個char對應一個實際字符），而輔助字符需要一對代碼單元表示（即兩個char對應一個實際字符）。
• 一個實際字符為一個代碼點（codePoint）。
• leng()和charA()方法都是基于代碼單元，所以在字符串中含有輔助字符的情況下，返回的結果可能不是想要的。這時候，需要用codePointCount()和offsetByCodePonits()+codePointAt()方法代替。

3.6.7 字符串API(java.lang.String)

• char charAt(int index)
  返回給定位置的代碼單元。不建議調用這個方法獲取實際字符。
• int codePointAt(int index)
  返回從給定位置開始或結束的代碼點。主要這里的index是代碼單元的index，而不是代碼點的index。建議使用該方法獲取實際字符。
• int offsetByCodePoints(int startIndex, int cpCount)
  返回從startIndex開始，位移cpCount代碼點后的index。
• int compareTo(String other)
• boolean endsWith(String suffix)
• bollean equals(Object other)
• equalsIgnoreCase(String other)
• int indexOf(String subString)
• int indexOf(String subString, int fromIndex)
• int indexOf(int cp)
• int indexOf(int cp, int fromIndex)
• int lastIndexOf(String subString)
• int lastIndexOf(String subString, int fromIndex)
• int lastIndexOf(int cp)
• int lastIndexOf(int cp, int fromIndex)
• int length()
• int codePointCount(int startIndex, int endIndex)
• String replace(CharSequence oldString, CharSequence newString)
• boolean startsWith(String prefix)
• String substring(int beginIndex)
• String substring(int beginIndex, int endIndex)
• String toLowerCase()
• String toUpperCase()
• String trim()
  注意：凡是(begin, end)形式的參數，對應的都是半閉合區間，即[begin, end)，包含開始而不包含結束。

3.6.9 構建字符串

• 由于String對象是不可變的，當需要用多個較短的字符串拼接成一個長字符串時，一般應使用StringBuilder或StringBuffer以提高效率。
• StringBuilder()/StringBuffer()
• int length()
• StringBuilder append(String str)
• StringBuilder append(char c)
• StringBuilder appendCodePoint(int cp)
• void setCharAt(int index, char c)
• StringBuilder insert(int offset, String str)
  在offset位置插入字符串
• StringBuilder insert(int offset, char c)
• StringBuilder delete(int startIndex, int endIndex)
• String toString()
• 注意：以上返回值類型為StringBuilder的方法返回的均是調用者自身。

---

3.7 輸入輸出

3.7.1 讀取輸入

• java.lang.Scanner
  
  • Scanner(InputStream in)
  • String nextLine()
  • String next()
  • int nextInt()
  • double nextDouble()
  • boolean hasNext()
  • boolean hasNextInt()
  • boolean hasNextDouble()
• java.lang.System
  
  • static Console console()
• java.io.Console
  
  • char[] readPassword(String prompt, Object… args)
    提供一個格式化提示，然后從控制臺讀取密碼，禁用回顯。
  • String readLine(String prompt, Object… args)
    提供一個格式化提示，然后從控制臺讀取單行文本。

3.7.2 格式化輸出

• System.out.print(Object obj)
• System.out.printf(String format, Object… args)

3.7.2 文件輸入與輸出

• java.util.Scanner
  
  • Scanner(File f)
  • Scanner(Path p)
  • Scanner(String data)
• java.io.PrintWriter
  
  • PrintWriter(String fileName)
• java.nio.file.Paths
  
  • static Path get(String pahtName)

---

3.8 控制流程

3.8.1 塊作用域

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

3.8.2 條件語句

if(condition){statement; // 如果condition為true，執行statement；否則什么都不執行。 } if(condition){statement1; // 如果condition為true，執行statement1； }else{statement2; // 否則，執行statement2。 } if(condition1){statement1; // 如果condition1為true，執行statement1； }else if(condition2){statement2; // 如果condition2為true，執行statement2；依次類推； }... else{statement(n+1); // 如果所有condition都為false，執行statement(n+1)。 }

3.8.3 循環語句

while(condition){statement; // 循環判斷condition，當為true時執行statement；當為false時停止循環。 } do{statement; // 執行statement，然后循環判斷condition，當為true時執行statement；當為false時停止循環。 }while(condition)

3.8.4 確定循環

for(initialize counter; condition; update counter){statment; // 執行initialize counter，然后循環判斷condition，當為true時依次執行statement及update counter；當為fasle時停止循環。 }

3.8.5 多重選擇：switch語句

switch(key){ // 可以是char,byte,short,int,enum,String(1.7)。 case value1:statement1; // 當key的值等于value1時，執行statement1。break; // break或}表示退出switch語句。 case value2:statement2; // 當key的值等于value2時，執行statement2，依次類推。break; ... default:statement(n+1); // 當key的值不等于任何value，執行statement(n+1)。break; }

3.8.6 中斷控制流程語句

• break：可用于循環語句或switch語句。跳出循環語句或switch語句，不再執行剩余部分（停止循環）。

A: for(int i = 0; i <= 9; i ++){B: for(int j = 0; j <= 9; j ++){C: for(int k = 0; k <= 9; k ++){if(k == 1){break; // 當k=1時，跳出所在循環(C)}System.out.println("" + i + j + k);}}} A: for(int i = 0; i <= 9; i ++){B: for(int j = 0; j <= 9; j ++){C: for(int k = 0; k <= 9; k ++){if(k == 1){break A; // 當k=1時，跳出所在循環A}System.out.println("" + i + j + k);}}}

• coutinue：僅用于循環語句，用法語break相同，但只跳過當次循環的剩余部分，跳轉到下一次判斷(while)或更新計數器(for)部分。

---

3.9 大數值

• BigInteger可以表示任意精度的整數，BigDecimal可以表示任意精度的浮點數。
• java.math.BigInteger
  
  • BigInteger add(BigInteger other)
  • BigInteger subtract(BigInteger other)
  • BigInteger multiply(BigInteger other)
  • BigInteger divide(BigInteger other)
  • BigInteger mod(BigInteger other)
  • int compareTo(BigInteger other)
  • static BigInteger valueOf(long x)
• java.math.BigDecimal
  
  • BigDecimal add(BigDecimal other)
  • BigDecimal subtract(BigDecimalother)
  • BigDecimal multiply(BigDecimalother)
  • BigDecimal divide(BigDecimal other, RoundingMode mode) // mode表示舍入方式，RoundingMode.HALF_UP表示四舍五入。
  • int compareTo(BigDecimal other)
  • static BigDecimal valueOf(double x)

---

3.10 數組

• 數組是一種數據結構，用來存儲同一類型值的集合。通過一個整型下標可以訪問數組中的每一個值。
• 聲明數組：
  
  • int[] a = new int[n];
  • int a[] = new int[n];
  • 數組元素存儲在heap中，因此具有默認初始化值。數值類型為0，char為\u0000，boolean為false，引用類型為null。
  • 一旦創建了數組，就不能再改變它的大小。
  • Arrays.toString(Object[] arr)將返回一個包含數組所有元素的字符串，格式為”[e0, e1,e2…]”。
  • 數組長度可以為0.

3.10.1 for each循環（增強for循環）

• for (type variable : collection){ statement }，意為”for each element in collection”。
• collection可以是數組或任意實現了Iterable接口的 類對象。

3.10.2 數組初始化以及匿名數組

// 先聲明一個數組，然后初始化每個元素。 int[] arr = new int[5]; arr[0] = 1; arr[1] = 2; arr[2] = 3; arr[3] = 4; arr[4] = 5; // 聲明數組的同時初始化。 int[] arr = new int[]{1,2,3,4,5}; // 簡寫。 int[] arr = {1,2,3,4,5}; // 創建一個匿名數組。 new int[]{1,2,3,4}; // 注意，不能單獨創建一個匿名數組而沒有其他任何操作（如傳值、打印等），編譯會報錯。 // 用一個匿名數組重新初始化一個數組變量。 arr = new int[]{1,2,3,4}; // 簡寫。 arr = {1,2,3,4}; // 以下的寫法是錯誤的，不能同時聲明數組的長度和具體元素。 int[] arr = new int[5]{1,2,3,4,5};

3.10.3 數組拷貝

• Java中允許將一個引用變量拷貝給另一個引用變量，此時，兩個變量引用同一個對象。

int[] a = new int[5]; int[] b = a; b[0] = 1; System.out.println("a[0]=" + a[0]); // a[0]=1

• 可以使用Arrays.copyOf(Object[] obj, int newLength)方法將一個數組中的全部或部分元素拷貝到一個新的數組中。

int[] a = new int[]{1,2,3,4,5}; int[] b = Arrays.copyOf(a, 3); // 只拷貝前3個元素，超出新數組長度部分被舍棄。 System.out.println(Arrays.toString(b)); // [1, 2, 3] int[] c = Arrays.copyOf(a, 7); // 拷貝全部元素，新數組不足部分用默認值補足。 System.out.println(Arrays.toString(c)); [1, 2, 3, 4, 5, 0, 0]

3.10.4 命令行參數

• Java中的main方法接收一個字符串數組，這個數組可以通過命令行參數傳入。

// java Demo -1 2 3 public class Demo {public static void main(String[] args) {System.out.println(Arrays.toString(args)); // [1,2,3]} }

3.10.5 數組排序

• java.util.Arrays
  
  • static String toString(type[] a)
  • static type[] copyOf(type[] a, int newLength)
  • static type[] copyOfRange(type[] a, int start, int end)
  • static void sort(type[] a)
  • static int binarySearch(type[] a, type v)
  • static int binarySearch(type[] a, int start, int end, type v)
  • static void fill(type[] a, type v)
  • static boolean equals(type[] a, type[] b)

3.10.6 多維數組

• 多維數組將使用多個下標訪問數組元素，它適用于表示表格或更加復雜的排列形式。二維數組也稱為矩陣。
• Arrays.deepToString(Object[] arr)將返回包含一維數組和二維數組全部元素的字符串。

3.10.7 不規則數組

• Java實際上沒有多維數組，只有一維數組。多維數組被解釋為“數組的數組”，即元素是另一個數組的數組。
• 數組的每一行（即每個元素數組）長度不相等的二維數組，稱為不規則數組。

int[][] odds = new int[10][]; odds[0] = new int[1]; odds[1] = new int[2]; // ...

轉載于:https://www.cnblogs.com/leeqihe/p/9061179.html

總結

以上是生活随笔為你收集整理的【Java核心计算 基础知识（第9版）】第3章 Java的基本程序设计结构的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。