Java基礎之：成員方法與傳參機制

對于人類而言，具體個例不止有一些特別屬性，還可以做出一些特別動作，

比如小范，不僅他的年齡是20歲，他還可以做計算題，

而做出的這些特別動作，我們在java面向物件中就稱為成員方法（也可以叫做成員函式），

簡單案例

宣告一個person類

定義 speak 成員方法，輸出物件的名字，

定義 sum 成員方法，可以計算兩個數的和

定義 cal 成員方法，接收n ，可以計算 1至n 的累加和，

public class Test{
    public static void main(String[] args){
        //物件p1
        Person p1 = new Person();
        //物件p1 的屬性賦值
        p1.name = "小范";
        p1.age = 20;
       
        p1.speak;       
        System.out.println(p1.sum(1,2));    //輸出3
        System.out.println(p1.cal(10));     //輸出55
    }
}
?
class Person{
    String name;
    int age;
    
    public void speak(){
        System.out.println("name ： " + name);
    }
    
    public int sum(int a,int b){
        return a + b; 
    }
    
    public int cal(int n){
        int res;
        for(int i = 1;i<=n;i++){
            res += i;
        }
        return res;
    }
    
}

成員方法定義格式：

訪問修飾符回傳值型別方法名(引數串列){

方法體；

return 回傳值;

}

說明

訪問修飾符：
- 省略就取默認值，public > protected > 默認(default) > private
回傳型別：
- 一個方法至多有一個回傳值 [思考，如何回傳多個結果, 陣列]
- 回傳型別可以為任意型別，包含基本型別或參考型別(陣列，物件)
- 如果方法有回傳值，則方法體中最后的執行陳述句必須為return陳述句，而且要求回傳型別必須和return的值型別一致或兼容
- 如果方法沒有回傳值，則方法體中可以沒有return陳述句，回傳型別要求寫void，
方法名：
- 駝峰命名，例如 sumDouble，
引數串列：
- 一個方法可以有0個引數，也可以有多個引數，中間用逗號隔開(型別名,型別名)
- 引數型別可以為任意型別，包含基本型別或參考型別
- 呼叫帶引數的方法時，一定對應著引數串列傳入相同型別或兼容型別的引數！
- 方法定義時的引數稱為形式引數，簡稱形參；方法呼叫時的引數稱為實際引數，簡稱實參，實參和形參的型別（兼容）、個數、順序必須一致！
方法體：
- 里面寫完成功能的具體的陳述句，可以為輸入、輸出、變數、運算、分支、回圈、方法呼叫，但里面不能再定義方法！即：方法不能嵌套定義，

成員方法的呼叫

public class Test{
    public static void main(String[] args){
       B b = new B();   //不同類下的成員方法要通過創建物件來呼叫
       b.show(); 
    }
}
?
class A{
    public void show(){
        
    }
}
?
class B{
    public void print(){
        
    }
    public void show(){
        print();    //在同一類下的成員方法直接呼叫即可
        
        A a = new A();  //不同類下的成員方法要通過創建物件來呼叫
        a.show()
    }
}

成員方法傳參機制

先看一個簡單案例：

import java.util.Scanner;
?
//基本資料型別傳遞
public class Test
{
    public static void main(String[] args) {
        
        T2 t2 = new T2();
        int a = 30;
        int b = 50;
        t2.swap(a, b);
        System.out.printf("a=%d b=%d\n", a, b);     //30 50
    }
}
?
class T2
{
    public void swap( int num1, int num2) {
        
        System.out.println("swap方法中...");
        System.out.printf("num1=%d num2=%d\n", num1, num2);     // 30 50
        int temp = 0;
        temp = num1;
        num1 = num2;
        num2 = temp;
        System.out.printf("num1=%d num2=%d\n", num1, num2);     // 50 30
    }
}

記憶體分析圖

參考資料型別的傳參機制

案例：

T3類中撰寫一個方法test100，可以接收一個陣列，在方法中修改該陣列，看看原來的陣列是否變化

import java.util.Scanner;
?
//基本資料型別傳遞
public class Test
{
    public static void main(String[] args) {
        
        int[] arr = {1,2,3};
        T3 t3 = new T3();
        t3.test100(arr);    /
        //看看 arr 的情況
        for( int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");     //100，2，3
        }
    }
}
class T3
{
    public void test100(int[] arr ) {
        
        arr[0] = 100;
    }
}

記憶體分析圖

由上面兩個案例可以看出，參考型別的物件，在傳遞引數程序中會被改變，而基本型別的物件不會改變，

本質上是因為，基本型別物件直接放在堆疊空間中；而參考型別物件內容放在堆空間中，堆疊空間只保存堆地址，

實際應用案例

/**
    1)  撰寫類MyTools類，撰寫一個方法可以列印二維陣列的資料，
    2)  撰寫一個方法copyArray，可以復制一個陣列，回傳復制的陣列，
            擴展：可以接收一個引數，指定拷貝原陣列的多少個元素，
            比如：{1,2, 0, 78, 999} 
    3)  撰寫一個方法copyPerson，可以復制一個Person物件，回傳復制的物件，(克隆物件)
        注意得到新物件和原來的物件是兩個獨立的物件，只是他們的屬性相同
*/
?
?
import java.util.Scanner;   
public class ClassWork2
{
    public static void main(String[] args){
        MyTools my = new MyTools();
?
        //列印二維陣列
        int[][] arrDouble = {{1,2,3},{4,5,6},{7,8,9}};
        my.printArray(arrDouble);
?
        //復制陣列
        int[] arr = {1,2, 0, 78, 999} ;
        int[] temp =  my.copyArray(arr);
        for(int i = 0 ;i<temp.length;i++){
            System.out.print(temp[i]+"\t");
        }
        System.out.println();
?
        //拷貝Person
        Person p = new Person();
        p.name = "tom";
        p.age = 12;
        Person p2 = my.copyPerson(p);
        System.out.println("name:" + p2.name + " age:" + p2.age);
    }
}
?
class MyTools
{
    //列印二維陣列方法
    public void printArray(int[][] arr){
        for(int i = 0 ;i < arr.length ; i++){
            for(int j = 0 ; j < arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
?
    //復制陣列方法
    public int[] copyArray(int[] arr){
        //  復制一個陣列，回傳復制的陣列，可以指定回傳元素個數，并進行判斷，
        //  若超過原陣列，則回傳整個陣列，若少于則詢問需要回傳的下標范圍
        //  擴展：可以接收一個引數，指定拷貝原陣列的多少個元素，
        //  比如：{1,2, 0, 78, 999} 
        System.out.println("請輸入要復制的陣列元素個數：");
        Scanner input = new Scanner(System.in);
        int count = input.nextInt();
        int[] temp = new int[arr.length]; 
        if(count >= arr.length){        //若超過原陣列，則回傳整個陣列
            
            for(int i = 0;i<arr.length;i++){
                temp[i] = arr[i];
            }
        }else{  //若少于則詢問需要回傳的下標范圍
            int[] temp2 = new int[count];  // 用于為temp陣列縮容的中間陣列變數
            System.out.println("請輸入要回傳的下標起始位置：");
            int begin = input.nextInt();
            if(begin + count < arr.length){
                for(int i = begin ,j = 0; i <(begin + count) ;i++){ 
                    //i代表arr陣列的下標 ， j代表temp2陣列的下標
                    temp2[j] = arr[i];
                    j++;
                }
            }else{
                int[] temp3 = new int[arr.length - begin];  
    //這里還會出現陣列縮容的情況
for(int i = begin ,j = 0; i < arr.length;i++){
temp3[j] = arr[i];
j++;
    }
temp2 = temp3;
    }
temp = temp2;
    }
?
return temp;
    } 
?
//拷貝Person物件
public Person copyPerson(Person p){
Person temp = new Person();
temp.name = p.name;
temp.age = p.age;
return temp;
    }
?
}
?
class Person
{
String name;
int age;
}
?

 本文內容，部分選擇自 韓順平老師 java基礎課程，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/227462.html

標籤：其他

上一篇：快速排序

下一篇：JWT工具類