複習下基礎的感覺自己浮躁了。。。
1、標識符
Java對各種變量、方法和類等要素命名時使用的字符序列稱爲標識符
記：約定俗成，Java表示符選取因注意“見名思意”且不能與Java語言的關鍵字重名。
標識符命名規則：
 標識符由字母、下劃線“_”、美元“$”或數字組成。
 標識符應以字母、下劃線、美元符開頭
 Java標識符大小寫敏感，長度無限制。
合法的標識符 不合法的標識符
$bS5_c7 class
DateClass DateClass#
_983 98.3
HellWorld Hell World
2、關鍵字
 Java中一些賦以特定的含義，用做專門用途的字符串成爲關鍵字（Keywrod）
！大多數編輯器會將關鍵字用特殊方式標出
 所有Java關鍵字都是小寫英文
 goto和const雖然從未使用，但也被作爲Java關鍵字保留。
3、Java常量
Java的常量值使用字符串表示，區分爲不同的數據類型。
 如整型常量123
 實型常量3.14
 字符常量‘a’
 邏輯常量 true、false
 字符串常量“helloworld”
注意：區分字符常量和字符串常量
注意：“常量”這個名詞還會用在另外其他語境中表示值不可變得變量
參見 final 關鍵字
4、Java變量
Java變量是程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域。
Java程序中每一個變量都是屬於特定的數據類型，在使用前必須對其聲明，聲明格式爲：
type varName [ = value ] [ {，varName [ = value ] } ]
例如：
int i = 100;
float f = 12.3f;
double d1, d2, d3 = 0.123;
String s = “hello” ;
從本質上講，變量其實是內存中的一塊區域，使用變量名來訪問這塊區域，因此，每一個變量使用前必須要先申請（聲明），然後必須進行賦值（填充內容），纔可使用
程序執行的過程（內存原理）
3、執行過程中的內存管理
5、Java變量的分類
1、 按被聲明的位置劃分：
◆ 局部變量：方法或語句塊內部定義的變量
◆ 成員變量：方法外部、類的內部定義的變量 (沒有全局變量的概念)
◆ 注意：類外面（與類對應的大括號外面）不能有變量的聲明
2、 按所屬的數據類型劃分：
◆ 基本數據類型變量
◆ 引用數據類型變量
變量的作用域：凡是在{}內聲明的變量，出了{}就沒有人認識它了
6、Java局部變量與成員變量
◆ 方法體內部聲明的變量（包括形參）稱爲局部變量：
◇ 方法體內部是指與方法對應的大括號內部
◆ 在方法體外，類體內聲明的變量稱爲成員變量，如：
public void method(){
int i;
int j = i + 5;//編譯出錯，變量i還未被初始化
double d = 3.14;
Dog dog;
dog = new Dog(22,7,1964);
}
7、Java數據類型：
7.1、Java數據類型的劃分
★基礎數據類型在內存中佔一塊區域，引用數據類型佔兩塊區域
7.2、Java的基本數據類型：
Java有4類8種基本數據類型，六種數字類型（四個整數型，兩個浮點型），一種字符類型，一種布爾型
一、整數型：包括int, short, byte, long
二、浮點數型：float，double
三、文字型（字符）：char
四、邏輯型（布爾）：boolean
1、 byte（字節類型）：有符號的整數，1個字節（8位），取值範圍 -127~-128
注意：定義時的錯誤方式：
public class TestByte
{
public static void main(String[] args){
byte b;
b = 3;
b = b * 3;
System.out.println(b);
}
}
如果按上面這樣的方式輸出，會出現損失精度問題（Possible loss of precision）
原因：字節類型參與運算的時候，JAVA做了一個自動類型的提升，爲了保證運算的精度，將這個運算轉換成了一個Int類型了，所以會出現錯誤，因爲Int類型的取值範圍與Byte類型的取值範圍不一樣。
處理方法如下：這裏我們需要用Byte 來做一個強制類型的轉換, 在前面加上(byte),把後面的運算內容括起來，把運算的結果用來轉化就不會有問題了
public class TestByte
{
public static void main(String[] args){
byte b;
b = 3;
b = (byte) (b * 3);
System.out.println(b);
}
}
2、 short: 有符號的整數，2個字節（也就是16位）取值範圍：-32768(-215 )~32767(215-1)
注意：byte類型可以直接賦值給short類型，short類型不能直接賦值給byte類
型。如果要把byte類型賦值給short類型同樣要做強制的類型轉換。
3、 int: 四個字節的整數，也是一個有符號的整數， 取值範圍：2 147 483 647(-231)~-2 147 483 648(231-1)
4、 long: 在JAVA中是八個字節的有符號的整數9 223 372 036 854 775 807(-263) ~ -9 223 372 036 854 775 808(263-1)
注意：以上4種整數類型：
◆Java 各整數類型有固定的表數範圍和字段長度，其不受具體操作系統的影響，以保證JAVA程序的可移植性。
◆Java語言整數常量的三種表示形式：
◇ 十進制整數， 如：12，-314，0。
◇ 八進制整數，要求以0開頭，如：012
◇ 十六進制數，要求0x或0X開頭，如：0x12。
◆Java語言的整型常量默認爲int型，聲明long型常量可以後加小寫L‘l’或大寫‘L’，如：
◇ int i1 = 600；//正確 long l1 = 888888888L;//必須加l 否則會出錯
類型 佔用存儲空間 表數範圍
byte 1字節 -128（-27）~127（27-1）
short 2字節 -215~215-1
int 4字節 -231~231-1
long 8字節 -263~263-1
5、 char字符類型: 用來存儲字符，Java中的字符采用Unicode編碼，其中前128個字符編碼與ASCII編碼兼容，在java中每個字符數據類型佔2個字節，是個無符號的字符類型，取值範圍：\u0000到uFFFF（也就是0~65535），由於採用Unicode編碼，一箇中文字與一個英文字母在Java中同樣都是一個字符來表示。
public class TestChar
{
public static void main(String[] args){
char ch;
ch = 'a';//使用單引號 也可以用ch=97這樣的整數來進行賦值，輸出也爲a
System.out.println(ch);
}
}
字符的表示在內存中都是用整數來表示的
◆char型數據用來便是通常意義上“字符”
◆字符常量爲用單引號括起來的單個字符，如：
◇ char eChar = ‘a’; char cChar = ‘中’;
◆Java字符采用Unicode編碼，Utf-16每個字符佔兩字字節，因而可用十六進制編碼形式表示，如：
◇ char c1 = ‘\u0061’;// \u 代表Unicode的16進制編碼
◇注：Unicode是全球語言統一編碼
◆Java語言中還允許使用轉義字符‘\’來將其後的字符轉變爲其他的含義，如：
◇ char c2 = ‘\n’; // ’\n’代表換行符
◆補充：2進制、10進制、16進制之間的轉換
◇ 1101 － 1×1 + 0×2 + 1×4 +1×8
◇ 13 －1 + 4 + 8
◇ 1101 －D
二進制、八進制、十進制、十六進制數的轉換方法
一)、數制
計算機中採用的是二進制，因爲二進制具有運算簡單，易實現且可靠，爲邏輯設計提供了有利的途徑、節省設備等優點，爲了便於描述，又常用八、十六進制作爲二進制的縮寫。
一般計數都採用進位計數，其特點是：
(1)逢N進一，N是每種進位計數製表示一位數所需要的符號數目爲基數。
(2)採用位置表示法，處在不同位置的數字所代表的值不同，而在固定位置上單位數字表示的值是確定的，這個固定位上的值稱爲權。
在計算機中：D7 D6 D5 D4 D3 D2 D1 D0 只有兩種0和1
8 4 2 1
二)、數制轉換
不同進位計數制之間的轉換原則：不同進位計數制之間的轉換是根據兩個有理數如相等，則兩數的整數和分數部分一定分別相等的原則進行的。也就是說，若轉換前兩數相等，轉換後仍必須相等。
有四進制
十進制：有10個基數：0 ~~ 9 ，逢十進一
二進制：有2 個基數：0 ~~ 1 ，逢二進一
八進制：有8個基數：0 ~~ 7 ，逢八進一
十六進制：有16個基數：0 ~~ 9，A，B，C，D，E，F (A=10,B=11,C=12,D=13,E=14,F=15) ，逢十六進一
1、數的進位記數法
N=a n-1*p n-1+a n-2*p n-2+…+a2*p2+a1*p1+a0*p0
2、十進制數與P進制數之間的轉換
①十進制轉換成二進制：十進制整數轉換成二進制整數通常採用除2取餘法，小數部分乘2取整法。例如，將(30)10轉換成二進制數。
將(30)10轉換成二進制數
2| 30 ….0 ----最右位
2 15 ….1
2 7 ….1
2 3 ….1
1 ….1 ----最左位
∴ (30)10=（11110)2
將(30)10轉換成八、十六進制數
8| 30 ……6 ------最右位
3 ------最左位
∴ (30)10 =(36)8
16| 30 …14(E)----最右位
1 ----最左位
∴ （30)10 =（1E)16
3、將P進制數轉換爲十進制數
把一個二進制轉換成十進制採用方法：把這個二進制的最後一位乘上20，倒數第二位乘上21，……,一直到最高位乘上2n,然後將各項乘積相加的結果就它的十進制表達式。
把二進制11110轉換爲十進制
（11110）2=1*24+1*23+1*22+1*21+0*20=
=16+8+4+2+0
=（30）10
把一個八進制轉換成十進制採用方法：把這個八進制的最後一位乘上80，倒數第二位乘上81，……,一直到最高位乘上8n,然後將各項乘積相加的結果就它的十進制表達式。
把八進制36轉換爲十進制
（36）8=3*81+6*80=24+6=（30）10
把一個十六進制轉換成十進制採用方法：把這個十六進制的最後一位乘上160，倒數第二位乘上161，……,一直到最高位乘上16n,然後將各項乘積相加的結果就它的十進制表達式。
把十六制1E轉換爲十進制
（1E）16=1*161+14*160=16+14=（30）10
3、二進制轉換成八進制數
(1)二進制數轉換成八進制數：對於整數，從低位到高位將二進制數的每三位分爲一組，若不夠三位時，在高位左面添0，補足三位，然後將每三位二進制數用一位八進制數替換，小數部分從小數點開始，自左向右每三位一組進行轉換即可完成。例如：
將二進制數1101001轉換成八進制數，則
(001 101 001)2
| | |
( 1 5 1)8
( 1101001)2=(151)8
(2)八進制數轉換成二進制數：只要將每位八進制數用三位二進制數替換，即可完成轉換，例如，把八進制數(643.503)8，轉換成二進制數，則
(6 4 3 . 5 0 3)8
| | | | | |
(110 100 011 . 101 000 011)2
(643.503)8=(110100011.101000011)2
4、二進制與十六進制之間的轉換
(1)二進制數轉換成十六進制數：由於2的4次方=16，所以依照二進制與八進制的轉換方法，將二進制數的每四位用一個十六進制數碼來表示，整數部分以小數點爲界點從右往左每四位一組轉換，小數部分從小數點開始自左向右每四位一組進行轉換。
(2)十六進制轉換成二進制數
如將十六進制數轉換成二進制數，只要將每一位十六進制數用四位相應的二進制數表示，即可完成轉換。
例如：將(163.5B)16轉換成二進制數，則
( 1 6 3 . 5 B )16
| | | | |
(0001 0110 0011. 0101 1011 )2
(163.5B)16=(101100011.01011011)2
6、 float浮點型: 4個字節，取值範圍3.402 823e +38 ~ 1.401 298e -45
注意：在Java裏面，小數常量，java會認爲是一個double類型，所以像下面那樣寫就是錯誤的，可以把f = 1.3 改寫成 f = 1.3f ，表明1.3是一個浮點數。
?? Float 是有一點誤差的，一般精度在7位左右
public class TestFloat
{
public static void main(String[] args){
float f;
f = 1.3;
System.out.println(f);
}
}
7、 double: 8個字節，精度比float更高，取值範圍：1.797 693e +308 ~ 4.900 000e -324
以上6、7浮點類型：
◆與整數類型類似，java浮點類型有固定的表數範圍和字段長度，不受平臺影響。
Java浮點類型常量有兩種表示形式。
◇ 十進制數形式， 如：3.14 314.0 .314
◇ 科學記數法形式，如：3.14e2 3.14E2 100E-2
◆Java 浮點型常量默認爲double型，如要聲明一個常量用float型，則需在數字後面加f或F，如：
◇ double d = 12345.6 ；//正確 float f = 12.3f; //必須加f否則會出錯
◆下面列出java的各浮點類型
類 型 佔用存儲空間 表數範圍
float 4字節 -3.403E38~3.403E38
double 8字節 -1.798E308~1.798E308
8、 boolean布爾型: 佔內存2個字節，可存儲True與False兩個數值，分別表示邏輯的真與假。沒有其他的標識類型。
◆boolean類型適合邏輯運算，一般用於程序流程控制。
◆boolean類型數據之允許取值true或false，不可以以0或非0的整數代替true和false，這點和C語言不同。
◆用法舉例：
boolean flag;
flag = true;
if(flag){
//do something
}
例子程序：
public class TestVar2
{
public static void main(String[] args){
boolean b = true;
int x, y = 9;
double d = 3.1415;
char c1, c2;
c1 = '\u534e'; c2 = 'c';
x = 12;
System.out.println("b=" + b);
System.out.println("x=" + x + ",y=" + y);
System.out.println("d=" + d);
System.out.println("c1=" + c1);
System.out.println("c2=" + c2);
}
}
8、基本數據類型轉換
◆boolean類型不可以轉換爲其他的數據類型。
◆整形，字符型，浮點型的數據在混合運算中相互轉換，轉換時遵循以下原則：
◆容量小的類型自動轉換爲容量大的數據類型，數據類型按容量大小排序爲：
◇ byte，short, char -> int -> long -> float -> double
◇ byte, short, char之間不會互相轉換，他們三者在計算時首先會轉換爲int類型
◆容量大的數據類型轉換爲容量小的數據類型時，要加上強制轉換符，但可能造成精度降低或溢出；使用時要格外注意。
◆有多種類型的數據混合運算時，系統首先自動的將所有數據轉換成容量最大的那一種數據類型，然後再進行計算。
◆實數常量（如：1.2）默認爲double
◆整數常量（如：123）默認爲int
public class TestConvert{
public static void main(String[] args){
int i1 = 123；
int i2 =456;
double d1 = (i1 + i2) * 1.2;//系統將轉換爲double型運算
float f1 = (float)((i1 + i2) * 1.2);//需要加強制轉換符
byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1 + b2);//系統將轉換爲int型運算，需要強制轉換符
double d2 = 1e200;
float f2 = (float)d2;//會產生溢出
System.out.println(f2);
float f3 = 1.23f;//必須加f
long l1 =123;
long l2 = 30000000000L;//必須加l
float f = l1 + l2 + f3;//系統將轉換爲float型計算
long l = (long)f;//強制轉換會捨去小數部分（不是四捨五入）
}
}
9、程序格式：（比算法還重要！！！）
格式應該注意的問題：
1. 大括號對齊
2. 遇到 { 縮進，Tab / Shift + Tab
3. 程序塊之間加空行
4. 並排語句之間加空格
5. 運算符兩則加空格
1、有特定條件
6. { 前面有空格
7. 成對編成
例子說明：
public class HelloWrold { //1.大括號對齊
// 3.程序塊之間加空行
static int j = 9; //2.遇到 { 縮進，Tab / Shift + Tab
public static void main(String[] args) {
System.out.println("HelloWorld");
}
//3.程序塊之間加空行
public static void m() {
int i = 9;空格int j = 4; //4.並排語句之間加空格，[ ]處
int i = 123; //5.運算符兩則加空格,=號兩邊加了空格
}
}
public class HelloWorld {
} //7.成對編成,寫完 { 後立即寫上 } 括號
程序格式的原則：
◆要讓別人看地清楚
◆要讓別人看得舒服
10、運算符
Java語言支持如下運算符：
 算術運算符：+，-，*，/，%，++，--
注意：
☆ ++（--）
☆ 在前面時先運算再取值。
☆ 在後面時先取值再運算
public class Test {
public static void main(String[] args){
int i1 =10, i2 = 20;
int i = (i2++);
System.out.print("i=" + i);
System.out.println(" i2=" + i2);
i = (++i2);
System.out.print("i=" + i);
System.out.println(" i2=" + i2);
i = (--i1);
System.out.print("i=" + i);
System.out.println(" i1=" + i1);
i = (i1--);
System.out.print("i=" + i);
System.out.println(" i1=" + i1);
}
}
結果: i=20 i2=21
i=22 i2=22
i=9 i1=9
i=9 i1=8
 關係運算符：>，<，>=，<=，==，!=
 邏輯運算符：!，&，|，^，&&，||
變量a 變量b 邏輯非 邏輯與 邏輯或 邏輯異或 短路與 短路或
a b !a a & b a | b a ^ b a && b a || b
true true false true true false true true
true false false false true true false true
false true true true true true false true
false false true false false false false false
 位運算符：&，|，^，~，>>，<<，>>>
 賦值運算符：=
 賦值運算符與擴展賦值運算符
 賦值運算符（=）
 當“=”兩側數據類型不一致時，可以適用默認類型轉換或使用強制類型轉換原則進行處理
 Long l = 100; int I = (int)1;
 注意：可以將整形常量直接賦值給byte, short, char等類型變量，兩不需要進行強制類型轉換，只要不超出其表數範圍
 byte b = 12; char c = 100;
 × byte bb =256; × short s = -32769;
運算符 用法舉例 等效的表達式
+= a += b a = a+b
-= a -= b a = a-b
*= a *= b a = a*b
/= a /= b a = a/b
%= a %= b a = a%b
 字符串連接運算符：+
◆“+”除用於算術加法運算外，還可用於對字符串進行連接操作
int id = 800 + 90;
String s = “hello” + “world”;
◆“+”運算符兩側的操作數中只要有一個是字符串（String）類型，系統會自動將另一個操作數轉換爲字符串後再進行連接。
int c = 12；
System.out.println(“c=” + c);
◆ 當進行打印時，無論任何類型，都自通轉爲字符串進行打印 。
System.out.println c);
11、表達式
◆表達式是符合一定語法規則的運算符和操作數的序列
◆a
◆5.0 + a
◆(a-b)*c-4
◆i < 30 && i %10 != 0
◆ 表達式的類型和值
◆ 對表達式中操作數進行運算得到的結果稱爲表達式的值。
◆ 表達式值得數據類型即位表達式的類型。
◆ 表達式的運算順序
◆ 應按照運算符的優先級從高到低的順序進行。
◆ 優先級相同的運算符按照事先約定的結合方向進行。
12、三目條件運算符：
◆ 三目條件運算符，語法格式：
x ？y : z
◆ 其中x爲boolean類型表達式，先計算x的值，若爲true，則整個三目運算的結果爲表達式y的值，否則整個結果爲表達式z的值。
◆ 舉例：
public class Test {
public static void main(String[] args){
int score = 80;
int x = -100;
String type = score < 60 ? "不及格" : "及格";
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type);
System.out.println("flag= " + flag);
}
}
13、語句
◆ 條件語句-根據不同條件，執行不同語句。
 if
 if..else
 if..else if
 if..else if..else if..else
 switch
◆ 循環語句-重複執行某些動作。
 for (JDK1.5語法)
 while
 do..while;
13.1、if語句：
注意：如果在條件中只有一行代碼，可以省略{}，如果有多行，必須要有{}
13.2、for循環語句
 for語句爲如下形式：
for（表達式1；表達式2；表達式3）{語句；…;}
 執行過程：
首先計算表達式1，接着執行表達式2，若表達式2的值=ture則執行語句，接着計算表達式3，再判斷表達式2的值；依次重複下去，直到表達式2的值=false
For語句中三個表達式都可以省略
JDK1.5新補充的for語句（後面介紹，數組）
public class Test {
public static void main(String[] args){
long result = 0;
long f = 1;
for (int i = 1; i <=10; i++ ){
f = f * i;
result += f;
}
System.out.println("result=" + result);
}
}
用for計算1加到99的運算，要求按奇數進行相加，1+3+5……99，並輸出結果：代碼如下：
public class OddSum {
public static void main(String[] args) {
long result = 0;
for (int i=1; i<=99 ; i+=2 ){
System.out.println(result + "+" + i + "=" + (result += i));//打印每次輸出
//result += i;
}
System.out.println(result);
}
}
13.3 while& do while語句
◆while語句格式如下：
while （邏輯表達式）{語句;…;}
◆執行過程
先判斷邏輯表達式的值。若=true。則執行其後面的語句，然後再次判斷條件並反覆執行，直到條件不成立爲止。
◆do-while語句格式如下：(用的比較少)
do{語句；…；}while（邏輯表達式）；//後面有個分號，不能忘記
◆執行過程
先執行語句，再判斷邏輯表達式的值，若爲true，再執行語句，否則結束循環。
while & do while 例子：
public class TestWhile{
public static void main(String[] args) {
int i = 0;
while(i < 10) {
System.out.println(i);
i++;
}
i = 0;
do {
System.out.println(i);//注意，如果把i++放這上面結果是10
i++;
}
while (i > 10);
}
}
13.4 break & Continue 語句
◆break語句用於終止某個語句塊的執行。用在循環語句體中，可以強行退出循環；如：
public class TestBreak {
public static void main(String[] args){
int stop = 4;
for (int i = 1; i<=10 ; i++ ){
//當i等於stop時,退出循環
if (i == stop) break; //特別注意，在if (i == stop)不要加“；”號，
System.out.println("i= " + i);
}
}
}
結果：i=1、i=2、i=3
◆Continue語句用在循環語句體中，用於終止某次循環過程，跳出循環體中continue語句下面未執行的循環，開始下一次循環過程；如：
public class TestContinue {
public static void main(String[] args){
int skip = 4;
for (int i = 1; i<=5 ; i++ ){
//當i等於skip時,跳出當次循環
if (i == skip) continue; {
System.out.println("i= " + i);
}
}
}
}
結果：i=1、i=2、i=3、i=5
13.5循環語句綜合舉例：
1、請輸出1~100內前5個可以被3整除的數
public class TestForA {
public static void main(String[] args){
int num = 0;
int i = 1;
while(i <= 100){
if (i % 3 == 0){
System.out.println(i);
num++;
}
if(num == 5){
break;
}
i++;
}
}
}
2.請輸出101~200內的質數（prime number 質數的意思：只能被其本身或1整除而沒有餘數的整數）
public class TestPrimeNumber {
public static void main(String[] args){
for (int i = 101; i<=200 ; i+=2){
boolean f = true;
for(int j = 2 ; j<i ; j++) {
if (i % j ==0){
f = false;
break;
}
}
if (!f) {
continue;
}
System.out.println("i= " + i);
}
}
}
13.6 switch條件語句
◆switch語句格式：
switch(){
case xx :
…
case xx :
…
default:
…
}
◆ 小心case穿透，推薦使用break語句
◆ 多個case可以合併到一起
◆ deault可以省略，但不推薦省略
◆ java中switch語句只能探測int類型值
public class TestSwitch {
public static void main(String[] args){
int i =18;
switch(i){//裏面可以放byte、short、char類型，因爲它們會自動轉換成int類型
case 1 :
//System.out.print("1"); //如果1這裏面什麼都不寫，表示1和2合併，意思是1or2，打印的結果都是2
case 2 :
System.out.print("2");
break;//注意使用break小心case穿透，有時候執行完這句後會連下句也執行
case 3 :
System.out.print("3");
break;
case 8 :
System.out.print("8");
break;
default:
System.out.print("18");
}
}
}
13.7 方法（Method）
◆方法的本質其實是提高我們程序的複用性
◆Java的方法類似於其他語句的函數，使一段用來完成特定功能的代碼片斷，聲明格式：
[修飾符1 修飾符2 ……]返回值類型 方法名（形式參數列表）{
Java語句；……
}
如：
public static void main(String[] args){
}
◆形式參數：在方法被調用時用於接受外界輸入的數據。
◆實參：調用方法時實際傳給方法的數據。
◆返回值：方法在執行完畢後返還給調用它的環境的數據。
◆返回值類型：事先約定的返回值的數據類型，如無返回值，必須給出返回值類型 void。
void 表示不返回任何值
◆Java語言中使用下述形式調用方法：對象名.方法名（實參類標）
◆實參的數目、數據類型和次序必須和所調用方法聲明的形參列表匹配，
◆return 語句終止方法的運行並指定要返回的數據。
◆Java中進行函數調用中傳遞參數時，遵循值傳遞的原則：
◇基本類型傳遞的是該數據值本身。引用類型傳遞的是對對象的引用，而不是對象本身。
例子程序：
public class TestMethod {
public static void main(String[] args){
m();
m2(5);
m3('3',4);//注意,'3'傳過去的是一格ASCll碼,它會自動轉換成int類型,但不一定是3+4=7
m4(4,6);//m4的方法調用有兩種方法，這是第一種方法，調用了但是沒有使用，返回的值保存到了一個臨時的空間中；就是說這個方法有返回值，但是你可以不用它。
int i = m4(4,6);//這是第二種方法，調用了m4，同時取得了它的返回值
System.out.println(i);
}
public static void m(){
//return;//表示方法執行到這裏,無論下面是什麼,都不再執行,程序結束並返回
System.out.println("ok");
System.out.println("hello");
}
public static void m2(int i) {//傳來的值必須是int類型,不能使其他的
if(i > 3)
return;
System.out.println(i);
}
public static void m3(int i, int j) {
System.out.println(i + j);
}
public static int m4(int i, int j) {//注意:沒有用viod，用的int，意思是：當調用完以後會返回一個int類型的值回去
return i > j ? i : j;//要想返回一個值，直接在retrun後面跟上想要返回的值就可以了，但要注意的是返回的值必須是事先約定好的類型
}
}
14 遞歸(recursion)調用
在一個方法裏面，對自身進行調用
以上程序在內存中執行的過程：算5的階層
◆ 遞歸調用指在方法執行過程中出現該方法本身的調用。如：
◇ 求Fibonacci（斐波納契數列：一種整數數列，其中每數等於前面兩數之和）數列：1，1，2，3，5，8，……第40個數的值。數列滿足遞推公式：
◇ F1=1，F2=1 Fn=Fn-1 + Fn-2 (n>2)
public class TestFibonacci {
public static void main(String[] args){
System.out.println(f(5));
}
public static int f(int n){
if(n == 1 || n == 2){
return 1;
}else{
return f(n - 1) + f(n - 2);
}
}
}
結果：102334155
以上程序在內存中執行的過程
◆ 練習：使用非遞歸的方法解決上面的問題
public class Fab {
public static void main(String[] args){
System.out.println(f(40));
}
public static long f(int index){
if(index < 1){
System.out.println("invalid parameter!");
return -1;
}
if (index == 1 || index == 2){
return 1;
}
long f1 = 1L;
long f2 = 1L;
long f = 0;
for (int i=0; i<index-2; i++){
f = f1 + f2;
f1 = f2;
f2 = f;
}
return f;
}
}
結果：102234155
