1、方法是什么?
方法是一种语法结构,它可以把一段代码封装成一个功能,一便重复使用
2、方法定义的完整格式
修饰符 返回值类型 方法名(形参列表){
方法体代码(需要执行的功能代码)
return 返回值;
}
例:public Static int add(int a,int b){
int c = a + b;
return c;
}
3、调用格式:方法名(...);
4、方法的常见问题
1、方法的编写顺序无所谓
2、方法和方法之间是平级关系,不能嵌套定义
3、方法的返回值类型为void(无返回值),方法内则不能使用return返回数据,
如果方法的返回值类型写了具体类型,方法内部则必须使用return返回对应类型的数据
4、return语句下面,不能编写代码,因为永远执行不到,属于无效代码
5、方法不调用就不执行,调用时必须严格匹配方法的参数情况
6、有返回值的方法调用时可以选择定义变量接收结果,或者直接输出调用,甚至直接调用;
无返回值的方法的调用只能直接调用一下
public class lianxi {
public static void main(String[] args) {
/*方法
使用方法的优点
1、可以提高代码的复用性和开发效率
2、让程序的逻辑更清晰
*/
int c1 = sum(10,12);
System.out.println(c1);
int c2 = sum(13,18);
System.out.println(c2);
}
public static int sum(int a,int b){
int c = a + b;
return c;
}
}
方法的案例
public class lianxi {
public static void main(String[] args) {
//使用方法计算1-n的和并返回
System.out.println(sum(100));//1-100的和
}
public static int sum(int n) {
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
}
public class lianxi {
public static void main(String[] args) {
//判断一个数是奇数还是偶数
check(12);
check(101);
}
public static void check(int number){
if (number % 2 ==0){
System.out.println(number+"是偶数");
}
else {
System.out.println(number+"是奇数");
}
}
}
public class lianxi {
public static void main(String[] args) {
//找出任意数组的最大值
int[] arr = {1, 56, 2, 78, 90, 45};
int max = arrMax(arr);//调用方法
System.out.println("最大值是:" + max);
}
public static int arrMax(int[] arr) {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
//方法的运行区域在栈内存
public class lianxi {
public static void main(String[] args) {
//理解方法在内存的运行机制
study();
}
public static void eat(){
System.out.println("吃饭");
}
public static void sleep(){
System.out.println("睡觉");
}
public static void study(){
eat();
System.out.println("学习");
sleep();
}
}
方法的参数传递机制
基本类型和引用类型的参数在传递的时候有什么不同
1、都是值传递
2、基本类型的参数传输存储的数据值
3、引用类型的参数传输存储的地址值
public class lianxi {
public static void main(String[] args) {
//理解基本类型的参数传递:值传递
int a = 10;
chang(a);
System.out.println(a);//10
}
public static void chang(int a){
System.out.println(a);//10
a=20;
System.out.println(a);//20
}
}
public class lianxi {
public static void main(String[] args) {
//理解引用类型的参数传递:值传递,区别其不同点
int[] arr = {10,20,30};
chang(arr);
System.out.println(arr[0]);//100
}
public static void chang(int[] arr){
System.out.println(arr[0]);//10
arr[0]=100;
System.out.println(arr[0]);//100
}
}
public class lianxi {
public static void main(String[] args) {
//打印任意整型数组的内容
int[] arr1 = {10, 20, 30, 40};
printArr(arr1);
System.out.println("-----------------");
int[] arr2 = {1, 5, 2, 8, 9};
printArr(arr2);
System.out.println("-----------------");
int[] arr3 = {};
printArr(arr3);
}
public static void printArr(int[] arr) {
System.out.print('[');
if (arr != null && arr.length > 0) {
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
}
}
System.out.println(']');
}
}
public class lianxi {
public static void main(String[] args) {
//从整型数组中查找某个元素的索引并返回,不存在的返回-1
//定义数组调用
int[] arr = {11, 22, 33, 44, 55, 67, 89};
int index1 = searchIndex(arr, 89);
System.out.println(index1);
System.out.println("------------");
int index2 = searchIndex(arr, 0);
System.out.println(index2);
}
public static int searchIndex(int[] arr, int data) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == data) {
return i;
}
}
return -1;
}
}
public class lianxi {
public static void main(String[] args) {
//比较两个数组的内容是否一样,一样则返回true,不一样则返回false
int[] arr1 = {11, 12, 13, 14, 15};
int[] arr2 = {11, 12, 13, 14, 15};
System.out.println(compare(arr1, arr2));
}
public static boolean compare(int[] arr1, int[] arr2) {
if (arr1.length == arr2.length) {
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
} else {
return false;
}
}
}
1、方法重载
同一个类中,多个方法的名称相同,形参列表不同
2、使用方法重载的好处?
对于相似功能的业务场景:可读性好,方法名称相同提示是同一类型的功能,
通过形参不同实现功能差异化的选择
3、方法重载的识别技巧
只要是同一个类中,方法名称相同、形参列表不同,那么就是重载的方法,其他都不用管
(如:修饰符、返回值类型都无所谓)
形参列表不同是指:个数、类型、顺序不同,与形参名称无关
public class lianxi {
public static void main(String[] args) {
//识别方法重载的形式,并理解其调用流程,知道使用方法重载的好处
fire();
fire("岛国");
fire("岛国", 100);
}
public static void fire() {
System.out.println("默认发送一枚武器给米国");
}
public static void fire(String country) {
System.out.println("默认发送一枚武器给" + country);
}
public static void fire(String country, int num) {
System.out.println("默认发送" + num + "枚武器给" + country);
}
}
改进
public class lianxi {
public static void main(String[] args) {
//识别方法重载的形式,并理解其调用流程,知道使用方法重载的好处
fire();
fire("岛国");
fire("岛国", 100);
}
public static void fire() {
fire("米国");
}
public static void fire(String country) {
fire(country, 1);
}
public static void fire(String country, int num) {
System.out.println("默认发送" + num + "枚武器给" + country);
}
}