方法的定义
方法是程序中最小的执行单元。
main() 方法也叫主方法。
方法的定义的位置可以在调用的位置的上面或下面，位置无所谓，只要定义了这个方法，这个方法就能被调用。
方法的定义要写在 main() 的外面，类的里面。main() 也是方法，方法不能嵌套定义。
方法的编写顺序和执行顺序无关，执行顺序要根据调用顺序来看。
方法名遵循驼峰法。
方法与方法之间是平级关系，不能嵌套定义。谁在前谁在后无所谓，但是为了程序的可读性，一般都是将 main() 方法放在第一个，表示程序的主入口。
不带返回值的方法，不要写 return 语句，如果写也行，但是只能是单独的一条 return 语句，后面不能跟别的内容，即 return;。
方法的定义的格式：
java
public static 返回值类型 方法名(参数) {
方法体;
return 返回值;
}最简单的方法的定义和调用
java
public class MethodDemo1 {
public static void main(String[] args) {
greeting();
System.out.println("++++++++++++++++++++++++++++");
greeting();
}
public static void greeting() {
System.out.println("Good Morning");
System.out.println("Good Afternoon");
System.out.println("Good Night");
}
}执行结果：
java
Good Morning
Good Afternoon
Good Night
++++++++++++++++++++++++++++
Good Morning
Good Afternoon
Good Night程序示例：
java
public class method1 {
public static void main(String[] args) {
System.out.println("m");
method1();
System.out.println("n");
method2();
System.out.println("k");
}
public static void method1() {
System.out.println("a");
System.out.println("b");
method2();
System.out.println("u");
}
public static void method2() {
System.out.println("d");
System.out.println("c");
}
}执行结果：
m
a
b
d
c
u
n
d
c
k
程序示例：
java
public class method1 {
public static void main(String[] args) {
getSum();
}
public static void getSum() {
int a = 10;
int b = 20;
System.out.println(a + b);
}
}执行结果：
30
带参数的方法
形参：形式参数，是方法定义中所用参数。
实参：实际参数，是方法调用中所用参数。
程序示例：
java
public class method1 {
public static void main(String[] args) {
getSum(10, 20);
}
public static void getSum(int a, int b) {
System.out.println(a + b);
}
}执行结果：
30
传递参数允许自动类型转换，例如下面的程序涉及将 float 转换为 double 以及将 int 转换为 double。
java
public class method1 {
public static void main(String[] args) {
System.out.println(getSum(10.0F, 20));
}
public static double getSum(double a, double b) {
return a + b;
}
}执行结果：
30.0
程序示例：
java
// 计算长方形的面积
import java.util.Scanner;
public class method1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("输入长方形的长：");
int length = sc.nextInt();
System.out.print("输入长方形的宽：");
int weight = sc.nextInt();
System.out.println("长方形的面积为" + getArea(length, weight));
}
public static int getArea(int a, int b) {
return a * b;
}
}执行结果：
输入长方形的长：3
输入长方形的宽：4
长方形的面积为12
带返回值的方法
直接调用，不对返回值做任何处理：
java
方法名(实参);赋值调用：
java
数据类型 变量 = 方法名(实参);输出调用：
java
System.out.println(方法名(实参));程序示例：
java
public class method1 {
public static void main(String[] args) {
System.out.println(getSum(10, 20));
}
public static int getSum(int a, int b) {
return a + b;
}
}执行结果：
30
方法返回类型和实际 return 的计算结果的类型不同时，允许自动类型转换，即 return 的结果自动类型转换到方法定义中的指定类型，最终的返回值的类型以方法定义中指定的类型为准。
例如，下面的程序中，return 语句的结果为 int 类型，但是方法定义指定了返回类型为 double 类型，最终方法返回的类型为 double，因为将 int 自动转换为 double 了。
java
// 计算长方形的面积
import java.util.Scanner;
public class method1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("输入长方形的长：");
int length = sc.nextInt();
System.out.print("输入长方形的宽：");
int weight = sc.nextInt();
System.out.println("长方形的面积为" + getArea(length, weight));
}
public static double getArea(int a, int b) {
return a * b;
}
}执行结果：
输入长方形的长：3
输入长方形的宽：4
长方形的面积为12.0
方法的重载
方法的重载：在同一个类中，定义了多个同名的方法，功能都相同或类似，但是形参列表不同，可以是类型不同或者是个数不同或者顺序不同，只要有一个不同就可以。
方法的重载与返回值无关。
构成重载的方法必须是同一个类中的，不同的类中的同名方法不构成重载。
不建议书写仅有形参顺序不同的重载函数。
程序示例：
java
// 需求：使用方法重载的思想，设计比较两个整数是否相同的方法。
// 要求：兼容全整数类型（byte,short,int,long）
public class method1 {
public static void main(String[] args) {
byte m1 = 1, n1 = 2;
System.out.println(compare(m1, n1));
short m2 = 1, n2 = 2;
System.out.println(compare(m2, n2));
int m3 = 1, n3 = 2;
System.out.println(compare(m3, n3));
long m4 = 1, n4 = 2;
System.out.println(compare(m4, n4));
}
public static boolean compare(byte a, byte b) {
System.out.println("调用byte类型方法");
return a == b;
}
public static boolean compare(short a, short b) {
System.out.println("调用short类型方法");
return a == b;
}
public static boolean compare(int a, int b) {
System.out.println("调用int类型方法");
return a == b;
}
public static boolean compare(long a, long b) {
System.out.println("调用long类型方法");
return a == b;
}
}执行结果：
调用byte类型方法
false
调用short类型方法
false
调用int类型方法
false
调用long类型方法
false
程序示例：
java
// 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
public class Exercise1 {
public static void main(String[] args) {
int[] nums = {11, 22, 33, 44, 55};
traverse(nums);
}
public static void traverse(int[] strings) {
System.out.print("[");
for (int i = 0; i < strings.length; i++) {
if (i == strings.length - 1)
System.out.print(strings[i]);
else System.out.print(strings[i] + ", ");
}
System.out.println("]");
}
}执行结果：
[11, 22, 33, 44, 55]
程序示例：
java
// 需求：设计一个方法求数组的最大值，并将最大值返回
public class Exercise1 {
public static void main(String[] args) {
int[] nums = {11, 22, 33, 44, 55};
System.out.println("数组最大值为 " + getMax(nums));
}
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
max = max > arr[i] ? max : arr[i];
}
return max;
}
}执行结果：
数组最大值为 55
程序示例：
java
// 定义一个方法判断数组中的某一个数是否存在，将结果返回
import java.util.Scanner;
public class Exercise1 {
public static void main(String[] args) {
int[] nums = {11, 22, 33, 44, 55};
Scanner sc = new Scanner(System.in);
System.out.print("输入要寻找的数：");
int find = sc.nextInt();
System.out.println("要寻找的数的索引为：" + getIndex(nums, find));
}
public static int getIndex(int[] arr, int n) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == n)
return i;
}
return -1;
}
}执行结果：
输入要寻找的数：22
要寻找的数的索引为：1
程序示例：
java
// 需求：
// 功能：
// 定义一个方法 copyOfRange(int[] arr, int from, int to)
// 将数组 arr 中从索引 from（包含 from）开始，
// 到索引 to 结束（不包含to）的元素复制到新数组中，
// 将新数组返回。
import java.util.Scanner;
public class Exercise1 {
public static void main(String[] args) {
int[] nums = {0, 11, 22, 33, 44, 55, 66, 77, 88, 99};
Scanner sc = new Scanner(System.in);
System.out.print("输入要复制的起始索引：");
int start = sc.nextInt();
System.out.print("输入要复制的终止索引：");
int end = sc.nextInt();
int[] newNums = copyOfRange(nums, start, end);
System.out.println("复制出来的数组为：");
for (int i = 0; i < newNums.length; i++) {
System.out.print(newNums[i] + " ");
}
}
public static int[] copyOfRange(int[] arr, int from, int to) {
int[] newArr = new int[to - from];
for (int i = 0, j = from; i < newArr.length; i++, j++) {
newArr[i] = arr[j];
}
return newArr;
}
}执行结果：
输入要复制的起始索引：1
输入要复制的终止索引：6
复制出来的数组为：
11 22 33 44 55
方法占用的内存分析
每一个软件在运行时都要占用内存，JVM 也是如此，为了更好地利用内存，JVM 将内存进行分块。
方法刚开始执行时要进栈，执行完了后立刻出栈。栈的特点：先进后出。
引用数据类型的变量，存储的是地址值。引用指的是使用了其他空间的数据。
基本数据类型的值是存储在自己的空间当中的。
基本数据类型的变量都是在栈中，引用数据类型的变量的实际内容是在堆中。
传递基本数据类型时，传递的是真实的数据，形参的改变不会影响实参，除非用返回值的形式修改原来的值。
程序示例：
java
// 值传递
public class Exercise1 {
public static void main(String[] args) {
int number = 100;
System.out.println(number); // 100
change(number);
System.out.println(number); // 100
}
public static void change(int number) {
number = 200;
}
}传递引用数据类型时，传递的是地址值，形参的改变会影响实参的值。
程序示例：
java
// 引用传递
public class Exercise1 {
public static void main(String[] args) {
int[] number = {100, 200, 300};
System.out.println(number[0]); // 100
change(number);
System.out.println(number[0]); // 200
}
public static void change(int[] number) {
number[0] = 200;
}
}