Java基础之：成员方法与传参机制

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;
    }

}

可以看到这里我们将 cal 成员方法封装了起来，它的功能是接收n ， 可以计算 1至n 的累加和。

而若外部需要实现这个功能只需要声明一个Person对象，调用cal成员方法即可。

这种模式大大提高了代码的复用性，将实现的细节进行封装，供其他用户调用。

成员方法定义格式：

访问修饰符 返回值类型 方法名(参数列表){

方法体；

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基础课程。
赞 (0)

相关推荐