文章目录
- 一、什么是方法
- 二、方法的声明格式
- 三、方法的分类
- 四、方法的调用
- 五、方法的注意点
- 六、方法的重载
- 七、可变形参的方法
- 八、方法参数的值传递机制
- 九、递归方法
一、什么是方法
- 方法(method)是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
- 将功能封装为方法的目的是，可以实现代码重用，简化代码。
- Java里的方法不能独立存在，所有的方法必须定义在类里。
二、方法的声明格式
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, …）｛
方法体程序代码
return 返回值;
｝
- 修饰符：public,缺省,private, protected等。
- 返回值类型：
①没有返回值：void。
②有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用。 - 方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”。
- 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开。
- 返回值：方法在执行完毕后返还给调用它的程序的数据。
三、方法的分类
- 按照是否有形参及返回值
四、方法的调用
- 方法通过方法名被调用，且只有被调用才会执行。
五、方法的注意点
- 方法被调用一次，就会执行一次。
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
- 方法中只能调用方法或属性，不可以在方法内部定义方法。
/*
* 类中方法的声明和使用
*
* 方法：描述类应该具有的功能。
* 比如：Math类：sqrt()\random() \...
* Scanner类：nextXxx() ...
* Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
*
* 1.举例：
* public void eat(){}
* public void sleep(int hour){}
* public String getName(){}
* public String getNation(String nation){}
*
* 2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
*
* 3. 说明：
* 3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
* Java规定的4种权限修饰符：private、public、缺省、protected
*
* 3.2 返回值类型： 有返回值 vs 没有返回值
* 3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
* return关键字来返回指定类型的变量或常量：“return 数据”。
* 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
* 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
*
* 3.2.2 我们定义方法该不该有返回值？
* ① 题目要求
* ② 凭经验：具体问题具体分析
*
* 3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
*
* 3.4 形参列表： 方法可以声明0个，1个，或多个形参。
* 3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
*
* 3.4.2 我们定义方法时，该不该定义形参？
* ① 题目要求
* ② 凭经验：具体问题具体分析
*
* 3.5 方法体：方法功能的体现
*
* 4.return关键字的使用：
* 1.使用范围：使用在方法体中
* 2.作用：① 结束方法 ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
* 3.注意点：return关键字后面不可以声明执行语句。
*
* 5. 方法的使用中，可以调用当前类的属性或方法
* 特殊的：方法A中又调用了方法A:递归方法。
* 方法中，不可以定义方法。
*/
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
// 测试形参是否需要设置的问题
// int[] arr = new int[]{3,4,5,2,5};
// cust1.sort();
cust1.sleep(8);
}
}
//客户类
class Customer {
// 属性
String name;
int age;
boolean isMale;
// 方法
public void eat() {
System.out.println("客户吃饭");
return;
// return后不可以声明表达式
// System.out.println("hello");
}
public void sleep(int hour) {
System.out.println("休息了" + hour + "个小时");
eat();
// sleep(10);
}
public String getName() {
if (age > 18) {
return name;
} else {
return "Tom";
}
}
public String getNation(String nation) {
String info = "我的国籍是：" + nation;
return info;
}
// 体会形参是否需要设置的问题
// public void sort(int[] arr){
//
// }
// public void sort(){
// int[] arr = new int[]{3,4,5,2,5,63,2,5};
// //。。。。
// }
public void info() {
// 错误的
// public void swim(){
//
// }
}
}
六、方法的重载
- 重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
- 重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。例如：
①返回两个整数的和
int add(int x,int y){return x+y;}
②返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
③返回两个小数的和
double add(double x,double y){return x+y;}
/*
* 方法的重载（overload）
*
* 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
*
* "两同一不同":同一个类、相同方法名
* 参数列表不同：参数个数不同，参数类型不同
*
* 2. 举例：
* Arrays类中重载的sort() / binarySearch()
*
* 3.判断是否是重载：
* 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
*
* 4. 在通过对象调用方法时，如何确定某一个指定的方法：
* 方法名 ---> 参数列表
*/
public class OverLoadTest {
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1, 2);
}
// 如下的4个方法构成了重载
public void getSum(int i, int j) {
System.out.println("1");
}
public void getSum(double d1, double d2) {
System.out.println("2");
}
public void getSum(String s, int i) {
System.out.println("3");
}
public void getSum(int i, String s) {
System.out.println("4");
}
// 如下的3个方法不能与上述4个方法构成重载
// public int getSum(int i,int j){
// return 0;
// }
// public void getSum(int m,int n){
//
// }
// private void getSum(int i,int j){
//
// }
}
七、可变形参的方法
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String ... books);
- 声明格式：方法名(参数的类型名 …参数名)
- 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个。
- 可变个数形参的方法与同名的方法之间，彼此构成重载。
- 可变参数方法的使用与方法参数部分使用数组是一致的。
- 方法的参数部分有可变形参，需要放在形参声明的最后。
- 在一个方法的形参位置，最多只能声明一个可变个数形参。
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
test.show("hello");
test.show("hello", "world");
test.show();
test.show(new String[] { "AA", "BB", "CC" });
}
public void show(int i) {
}
public void show(String s) {
System.out.println("show(String)");
}
public void show(String... strs) {
System.out.println("show(String ... strs)");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
// 不能与上一个方法同时存在
// Duplicate method show(String[]) in type MethodArgsTest
// public void show(String[] strs){
//
// }
// The variable argument type String of the method show must be the last parameter
// public void show(String ...strs,int i){
//
// }
}
八、方法参数的值传递机制
- 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
①形参：方法声明时的参数。
②实参：方法调用时实际传给形参的参数值。 - Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本传入方法内，而参数本身不受影响。
①形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参。
②形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。
/*
* 关于变量的赋值：
* 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
* 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
*/
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("基本数据类型");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("引用数据类型");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;// 赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
}
}
class Order {
int orderId;
}
ValueTransferTest1
/*
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数。
* 实参：方法调用时，实际传递给形参的数据。
*
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
*/
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
// 交换两个变量的值的操作
// int temp = m ;
// m = n;
// n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
}
public void swap(int m, int n) {
int temp = m;
m = n;
n = temp;
}
}
ValueTransferTest2
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
// 交换m和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data) {
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data {
int m;
int n;
}
九、递归方法
- 递归方法：一个方法体内调用它自身。
- 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
- 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
- 递归方法举例：
public class RecursionTest {
public static void main(String[] args) {
// 例1：计算1-100之间所有自然数的和
// 方式一：
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
// 方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);
System.out.println("----------");
int value = test.f(10);
System.out.println(value);
}
// 例1：计算1-n之间所有自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所有自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
// 例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
// 其中n是大于0的整数，求f(10)的值。
public int f(int n) {
if (n == 0) {
return 1;
} else if (n == 1) {
return 4;
} else {
// return f(n + 2) - 2 * f(n + 1);
return 2 * f(n - 1) + f(n - 2);
}
}
}
