java中如何类与类传参_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

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

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

//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基础课程。