例如1.
方法的基本用法
1.1
什么是方法
(method)
方法就是一個代碼片段
.
類似于
C
語言中的
"
函式
".
方法存在的意義
(
不要背
,
重在體會
):
1.
是能夠模塊化的組織代碼
(
當代碼規模比較復雜的時候
).
2.
做到代碼被重復使用
,
一份代碼可以在多個位置使用
.
3.
讓代碼更好理解更簡單
.
4.
直接呼叫現有方法開發
,
不必重復造輪子，
例如，計算1！+3！+2！+4！+5！
int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
}
sum += tmp; }
System.out.println("sum = " + sum);
這個代碼運用的嵌套，容易寫錯，接下里通過方法來優化代碼，
class Test {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += factor(i);
}
System.out.println("sum = " + sum);
}
public static int factor(int n) {
System.out.println("計算 n 的階乘中! n = " + n);
int result = 1
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
}
// 執行結果
計算 n 的階乘中! n = 1
計算 n 的階乘中! n = 2
計算 n 的階乘中! n = 3
計算 n 的階乘中! n = 4
計算 n 的階乘中! n = 5
sum = 1531.2 方法呼叫程序
定義方法的時候
,
不會執行方法的代碼
.
只有呼叫的時候才會執行
.
當方法被呼叫的時候
,
會將實參賦值給形參
.
引數傳遞完畢后
,
就會執行到方法體代碼
.
當方法執行完畢之后
(
遇到
return
陳述句
),
就執行完畢
,
回到方法呼叫位置繼續往下執行
.
//
方法定義
public static
方法回傳值 方法名稱（
[
引數型別 形參
...]){
方法體代碼
;
[
return
回傳值
];
}
//
方法呼叫
回傳值變數
=
方法名稱
(
實參
...);
class
Test
{
public static
void
main
(
String
[]
args
) {
int
a
=
10
;
int
b
=
20
;
//
方法的呼叫
int
ret
=
add
(
a
,
b
);
System
.
out
.
println
(
"ret = "
+
ret
);
}
//
方法的定義
public static
int
add
(
int
x
,
int
y
) {
return
x
+
y
;
}
}
//
執行結果
ret
=
30
一個方法可以被多次呼叫
.
1.3 形參和實參的關系
代碼示例
:
交換兩個整型變數
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a, b);
System.out.println("a = " + a + " b = " + b);
}
public static void swap(int x, int y) {
int tmp = x;
x = y;
y = tmp;
}
}
// 運行結果
a = 10 b = 20
原因分析
剛才的代碼
,
沒有完成資料的交換
.
對于
基礎型別
來說
,
形參相當于實參的拷貝.
即
傳值呼叫
int a = 10;
int b = 20;
int x = a;
int y = b;
int tmp = x; x = y; y = tmp;
可以看到
,
對
x
和
y
的修改
,
不影響
a
和
b.
解決辦法
:
傳參考型別引數
(
例如陣列來解決這個問題
)
class Test {
public static void main(String[] args) {
int[] arr = {10, 20};
swap(arr);
System.out.println("a = " + arr[0] + " b = " + arr[1]);
}
public static void swap(int[] arr) {
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
}
// 運行結果
a = 20 b = 10
1.4
沒有回傳值的方法
方法的回傳值是可選的
.
有些時候可以沒有的
.
代碼示例
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
print(a, b);
}
public static void print(int x, int y) {
System.out.println("x = " + x + " y = " + y);
}
}
另外
,
如剛才的交換兩個整數的方法
,
就是沒有回傳值的
.
2.
方法的多載
有些時候我們需要用一個函式同時兼容多種引數的情況
,
我們就可以使用到方法多載
.
2.1
多載要解決的問題
代碼示例
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = add(a2, b2);
System.out.println("ret2 = " + ret2);
}
public static int add(int x, int y) {
return x + y;
}
}
// 編譯出錯
Test.java:13: 錯誤: 不兼容的型別: 從double轉換到int可能會有損失
double ret2 = add(a2, b2);
^
由于引數型別不匹配
,
所以不能直接使用現有的
add
方法
那么是不是應該創建這樣的代碼呢
?
代碼示例
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = addInt(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = addDouble(a2, b2);
System.out.println("ret2 = " + ret2);
}
public static int addInt(int x, int y) {
return x + y;
}
public static double addDouble(double x, double y) {
return x + y;
}
}
這樣的寫法是對的
(
例如
Go
語言就是這么做的
),
但是
Java
認為
addInt
這樣的名字不友好
,
不如直接就叫
add
2.2
使用多載
代碼示例
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = add(a2, b2);
System.out.println("ret2 = " + ret2);
double a3 = 10.5;
double b3 = 10.5;
double c3 = 20.5;
double ret3 = add(a3, b3, c3);
System.out.println("ret3 = " + ret3);
}
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}
方法的名字都叫
add.
但是有的
add
是計算
int
相加
,
有的是
double
相加
;
有的計算兩個數字相加
,
有的是計算三個數
字相加
.
同一個方法名字
,
提供不同版本的實作
,
稱為
方法多載
2.3
多載的規則
針對同一個類
:
方法名相同
方法的引數不同
(
引數個數或者引數型別
)
方法的回傳值型別不影響多載
3.
方法遞回
3.1
遞回的概念
一個方法在執行程序中呼叫自身
,
就稱為
"
遞回
".
遞回相當于數學上的
"
數學歸納法
",
有一個起始條件
,
然后有一個遞推公式
.
例如
,
我們求
N!
起始條件
: N = 1
的時候
, N!
為
1.
這個起始條件相當于遞回的結束條件
.
遞回公式
:
求
N! ,
直接不好求
,
可以把問題轉換成
N! => N * (N-1)！
代碼示例：遞回求n的階乘
public static void main(String[] args) {
int n = 5;
int ret = factor(n);
System.out.println("ret = " + ret);
}
public static int factor(int n) {
if (n == 1) {
return 1;
}
return n * factor(n - 1); // factor 呼叫函式自身
}
// 執行結果
ret = 120注：初來乍到，才疏學淺，如有不當之處，多多指教，我自己也會堅持學習，期待更好的自己！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/293947.html
標籤：java
下一篇：# Day10-Java基礎