我们需要很多方法去解决问题,但是一个主函数中,写很多的方法是冗杂,效率慢的,而且比较容易使程序崩溃,所以我们使用类中的成员方法,在主函数中调用,提高了方法的复用性,而且可以将实现的细节封装起来,然后供其他用户调用。
快速入门
public class Method01 {
public static void main(String[] args) {
//方法使用
//1. 方法写好后,如果不去调用(使用),不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
p1.speak(); //调用方法
p1.cal01(); //调用 cal01 方法
p1.cal02(5); //调用 cal02 方法,同时给 n = 5
p1.cal02(10); //调用 cal02 方法,同时给 n = 10
//调用 getSum 方法,同时 num1=10, num2=20
//把 方法 getSum 返回的值,赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum 方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法(成员方法)
//添加 speak 成员方法,输出 “我是一个好人”
//老韩解读
//1. public 表示方法是公开
//2. void : 表示方法没有返回值
//3. speak() : speak 是方法名, () 形参列表
//4. {} 方法体,可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
public void speak() {
System.out.println("我是一个好人");
}
//添加 cal01 成员方法,可以计算从 1+..+1000 的结果
public void cal01() {
//循环完成
int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01 方法 计算结果=" + res);
}
//添加 cal02 成员方法,该方法可以接收一个数 n,计算从 1+..+n 的结果
//老韩解读
//1. (int n) 形参列表, 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02 方法 计算结果=" + res);
}
//添加 getSum 成员方法,可以计算两个数的和
//老韩解读
//1. public 表示方法是公开的
//2. int :表示方法执行后,返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表,2 个形参,可以接收用户传入的两个数
//5. return res; 表示把 res 的值, 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
看如上这个代码:
我们在类中创建不同的成员方法,成员方法也有访问修饰符。
成员方法有一定格式。
在主方法中调用也有规则。
成员方法
访问修饰符 返回数据类型 方法名(形参列表
..
)
{//
方法体
语句;
return 返回值;
}
1)
形参列表:表示成员方法输入
cal(int n)
,
getSum(int num1, int num2)
2) 返回数据类型:表示成员方法输出
, void
表示没有返回值
3)
方法主体:表示为了实现某一功能代码块
4) return
语句不是必须的。
注意:
1.
调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型 的参数。
2.实参和形参的类型要一致或兼容、个数、顺序必须一致。
3.方法不能嵌套定义。
4.一个方法最多有一个返回值。
5.形参列表如:
(int num1, int num2),代表可以传入用户输入的两个数,供成员方法使用。
参数类型可以是任何类型,包含基本类型和引用类型。
6.
返回类型可以为任意类型,包含基本类型或引用类型
(
数组,对象
)。
7.如果方法要求有返回数据类型,则方法体中最后的执行语句必须为
return
值
;
而且要求返回值类型必须和 return
的值类型一致或兼容。
说到这里有一个很混乱的点:实参和形参
实参和形参的区别
形参就是非数字的字符,实参是有确切数字的。
在调用函数过程中,系统会把实参的值传递给被调用函数的形参。或者说,形参从实参得到一个值。该值在函数调用期间有效,可以参加该函数中的运算。
但是形参的本质是一个名字,不占用内存空间。
这篇文章从内存分配机制来介绍实参与形参,可以参考。
JAVA基本语法:形参与实参的区别与联系_对于基本数据类型的参数,形式参数的改变会影响实际参数的值吗?-CSDN博客
方法调用
方法调用机制
方法调用细节
同一个类中的方法调用:直接调用即可。
跨类中的方法
A
类调用
B
类方法:需要通过对象名调用。
如图:
class A {
public void m1() {
//创建 B 对象, 然后在调用方法即可
System.out.println("m1() 方法被调用");
B b = new B();
b.hi();
System.out.println("m1() 继续执行:)");
}
}
class B {
public void hi() {
System.out.println("B 类中的 hi()被执行");
}
}
成员方法传参机制
基本数据类型的传参机制
public class MethodParameter01 {
//编写一个 main 方法
public static void main(String[] args) {
int a = 10;
int b = 20;
//创建 AA 对象 名字 obj
AA obj = new AA();
obj.swap(a, b); //调用 swap
System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
}
}
class AA {
public void swap(int a,int b){
System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b 的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}
这样一个代码他的运行机制如下图所示:
1.在主方法创建对象,调用方法,然后进行方法。
2.在swap方法中,ab进行交换,此时a=20,b=10
3.但是在主方法中进行swap后再输出ab的值,却是没有swap,a还是10,b还是20
引用数据类型的传参机制
public class MethodParameter02 {
//编写一个 main 方法
public static void main(String[] args) {
//测试
B b = new B();
// int[] arr = {1, 2, 3};
// b.test100(arr);//调用方法
// System.out.println(" main 的 arr 数组 ");
// //遍历数组
// for(int i = 0; i < arr.length; i++) {
// System.out.print(arr[i] + "\t");
// }
// System.out.println();
//测试
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是 10
System.out.println("main 的 p.age=" + p.age);//10000
}
}
class Person {
String name;
int age;
}
class B {
public void test200(Person p) {
//p.age = 10000; //修改对象属性
//思考
p = new Person();
p.name = "tom";
p.age = 99;
//思考
//p = null;
}
//B 类中编写一个方法 test100,
//可以接收一个数组,在方法中修改该数组,看看原来的数组是否变化
public void test100(int[] arr) {
arr[0] = 200;//修改元素
//遍历数组
System.out.println(" test100 的 arr 数组 ");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
}
问:
B
类中编写一个方法
test100
,可以接收一个数组,在方法中修改该数组,看看原来的数组是否变化?
B
类中编写一个方法
test200
,可以接收一个
Person(age,sal)
对象,在方法中修改该对象属性,看看原来的对象是否变化?
答案是都会变化,这是与基本数据了类型截然不同的。
引用类型传递的是地址(传递也是值,但是值是地址),可以通过形参影响实参!
还有其他小问题,比如说编写一个方法 copyPerson,可以复制一个 Person 对象,返回复制的对象。克隆对象, 注意要求得到新对象和原来的对象是两个独立的对象,只是他们的属性相同,他们是否为同一个对象。
答案是否定的。
总结
成员方法最主要的是如何调用,在调用的时候又有很多细节,同时两个不同的传参机制也是值得去琢磨的。如果不认真敲打几个题,知识只能左耳朵进右耳朵出。
有没有觉得,看代码才是学习代码的最好的方法。