对于人类而言，具体个例不止有一些特别属性，还可以做出一些特别动作。
比如小范，不仅他的年龄是20岁，他还可以做计算题。
而做出的这些特别动作，我们在java面向对象中就称为成员方法（也可以叫做成员函数）。
简单案例
声明一个person类
定义 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
", a, b); //30 50
}
}
class T2
{
public void swap( int num1, int num2) {
System.out.println("swap方法中...");
System.out.printf("num1=%d num2=%d
", num1, num2); // 30 50
int temp = 0;
temp = num1;
num1 = num2;
num2 = temp;
System.out.printf("num1=%d num2=%d
", 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] + " "); //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]+" ");
}
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]+" ");
}
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基础课程。