.1 方法的概念（理解）
方法是一个具有独立功能的代码集,他可以独立的运行,我们需要先编写这个方法,在需要的时候去调用即可.调用的格式就是方法名();
方法我们自己定义的,方法名是我们自己起的,遵循小驼峰命名法.a.方法写在类中:就是class的大括号中.b.他与main函数是并列的关系.他们没有先后.main里面不能直接写方法,自定义方法里面也不能在写方法.
为什么要有方法:我们重复使用的具体独立的功能的代码,我们需要早在程序里编写很多次,造成代码的阅读性很差,我们想到了方法(函数),方法就把这些具体独立功能的代码封装起来,在你程序需要的时候,就可以调用,这个代码我们只需要写一次,很多可以一直的调用,调用的格式是方法名();
作用:减少代码的复用性.
- 注意：
- 具有独立的功能.这个是你自己定的,需要你编写
- 需要调用才会执行
2. 方法的定义和调用
2.1 无参数方法定义和调用（掌握）
- 定义格式：
public static void 方法名(){
方法体;
}
- 范例：
public class Demo {
public static void main(String[] args) {
zuoFang();
System.out.println("吃早饭");
System.out.println("睡觉");
zuoFang();
System.out.println("吃中午");
System.out.println("睡觉");
zuoFang();
System.out.println("吃晚饭");
}
public static void zuoFang(){
System.out.println("洗米");
System.out.println("起锅烧油");
System.out.println("炒菜");
}
}
- 调用格式：
方法名();
- 范例：
zuoFang();
- 注意：
方法必须先定义，后调用，否则程序将报错
2.2 方法调用过程图解（理解）
2.3 无参数方法的练习（应用）
- 需求：设计判断两个数最大值的方法
- 思路：
- ①我要定义一个方法,给他起个名字
- ②在这个方法里定义两个变量
- ③比较两个变量的最大值
- ④在主(mian)方法中调用
- 代码：
public class Demo1 {
public static void main(String[] args) {
getMax();
}
//public static void 方法名(){}
public static void getMax(){
int a = 10;
int b = 20;
if(a>b){
System.out.println(a+"是最大值");
}else{
System.out.println(b+"是最大值");
}
};
}
3. 带参数方法定义和调用
3.1 带参数方法定义和调用（掌握）
- 定义格式：
参数：参与运算的数
参数范例：
public static void 方法名(数据类型 变量名,数据类型 变量名,....){
方法体;
}
- 范例：
public static void isEvennumber(int a){
if(a%2==0){
System.out.println("是偶数");
}else{
System.out.println("是奇数");
}
}
- 注意：方法定义参数是int型的,你就传什么类型的.参数定义几个,或者是什么类型的需要你自己去定,别人调用你的时候,需要按照你参数列表中的顺序,类型都要一样的去给你.
- 调用格式：
方法名(变量/常量);
- 范例：
int b = 19;
isEvennumber(b);
- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
3.2 形参和实参（理解）
1. 形参：
我们定义一个方法的时候,首先你自己要知道你定义的方法是干什么用,此时你可以决定调用者调用你方法的时候,需要传递给你什么类型的数据,你得接收,你就在方法的参数列表(方法的小括号)位置定义变量,变量的定义格式就是数据类型,变量名,如果有多个,用逗号隔开.此时他没有实际的值,所以我们叫他形式上参与运算的值,也叫形参.
2.实参：
调用者调用你方法的时候,他会看到你的参数列表,需要调用者提供什么数值,调用者就需要把实际的值给你去参与运算,最后得到结果,格式是方法名(变量/常量);这个数是不是实实在在存在的,我们叫他实际参与运算的数也叫实参.
3.3 带参数方法练习（应用）
- 需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }
- 代码：
public class Demo3 {
public static void getMax(double a ,double b){
if(a>b){
System.out.println(a+"是较大的数");
}else{
System.out.println(b+"是较大的数");
}
}
public static void main(String[] args) {
System.out.println("开始");
getMax(3.14,2.0);
System.out.println("结束");
}
}
4. 带返回值方法的定义和调用
4.1 带返回值方法定义和调用（掌握）
- 定义格式
public static 数据类型 方法名(数据类型 变量名,数据类型 变量名....){
方法体;
return 返回值;
}
这是一个完整定义方法的格式:
public static:方法的修饰:现在只需要照抄main方法;
数据类型:因为方法是你写的,有没有返回值,你肯定知道,如果有返回值,这个返回值是什么类型,这个数据类型就是什么类型.如果你的方法你写完没有返回值,这里就写void.
方法名:你自己给这个方法起的名字,遵循小驼峰命令法
参数列表:你定义一个方法的时候,你要要求调用者给你传递什么数,我们这里的参数列表接收,调用者传递的实际参数与我的参数列表个数,顺序,以及数据类型都要一致,否则程序报错.
方法体:这个方法具体的功能代码,就是你以前写在main方法中的代码,你能写在main方法中的代码,这里都可以写.
return 返回值:你的程序执行完,你需要给调用者返回一个数,这个数和你方法定义上的数据类型保持一致,否则报错,如果你没有返回值,return可以省略,如果你定义了返回值类型,你没有return,程序也会报错.
return也可以表示结束方法的意思.
- 范例
public class Demo5 {
//定义一个主方法
public static void main(String[] args) {
//方法的调用
//int c = 10;
// int d = 20;
//让用户去输入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数");
int a = scanner.nextInt();
System.out.println("请输入第二个数");
int b = scanner.nextInt();
//int max = getMax(a,b);//有返回值的 你先写方法名(实际参数) ALT+Enter
System.out.println(getMax(a,b));
}
//定义一个方法去判断两个数的最大值
/* public static 数据类型 方法名(数据类型 变量名,数据类型 变量名....){
方法体;
return 返回值;
}*/
public static int getMax(int a , int b ){
//用if去判断两个数的大小,约定好谁大我就返回谁
if(a>b){
return a ;
}else{
return b ;
}
}
}
- 注意：
- 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
- 调用格式
getMax(a,b)
- 范例
public static int getMax(int a , int b ){
//用if去判断两个数的大小,约定好谁大我就返回谁
if(a>b){
return a ;
}else{
return fasle ;//报错
}
}
}
public static int getMax(int a , int b ){
//用if去判断两个数的大小,约定好谁大我就返回谁
if(a>b){
return a ;
}//也是报错
}
}
4.2 带返回值方法练习（应用）
- 需求：设计一个方法可以获取两个数的较大值，数据来自于参数
- 代码：
public static void main(String[] args) {
//方法的调用
//int c = 10;
// int d = 20;
//让用户去输入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数");
int a = scanner.nextInt();
System.out.println("请输入第二个数");
int b = scanner.nextInt();
//int max = getMax(a,b);//有返回值的 你先写方法名(实际参数) ALT+Enter
System.out.println(getMax(a,b));
}
5. 方法的注意事项
5.1 方法的注意事项（掌握）
- 方法不能嵌套定义
- 示例代码：
public class Demo6 {
public static void main(String[] args) {
public static void getMax(){
}
}
}
5.2 方法的通用格式（掌握）
- 格式：
public static 数据类型 方法名(数据类型 变量名,数据类型 变量名....){
方法体;
return 返回值;
}
- 解释：
return也可以表示结束方法的意思.
这是一个完整定义方法的格式:
public static:方法的修饰:现在只需要照抄main方法;
数据类型:因为方法是你写的,有没有返回值,你肯定知道,如果有返回值,这个返回值是什么类型,这个数据类型就是什么类型.如果你的方法你写完没有返回值,这里就写void.
方法名:你自己给这个方法起的名字,遵循小驼峰命令法
参数列表:你定义一个方法的时候,你要要求调用者给你传递什么数,我们这里的参数列表接收,调用者传递的实际参数与我的参数列表个数,顺序,以及数据类型都要一致,否则程序报错.
方法体:这个方法具体的功能代码,就是你以前写在main方法中的代码,你能写在main方法中的代码,这里都可以写.
return 返回值:你的程序执行完,你需要给调用者返回一个数,这个数和你方法定义上的数据类型保持一致,否则报错,如果你没有返回值,return可以省略,如果你定义了返回值类型,你没有return,程序也会报错.
- 定义方法时，要做到两个明确
返回值类型:别人调用你的方法,有没有返回值,是你定的.
参数列表:别人调用你的时候,需要给你传递什么参数,你就在参数列表中定义什么参数.
- 调用方法时的注意：
有返回值的方法,调用者一般要接受这个返回值.
6. 方法重载
6.1 方法重载（理解）
- 方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
方法重载:方法的重复载入
满足一下条件就是重载:
1.在同一个类中
2.方法名相同的
3.参数列表不同(a.个数不同,b.顺序不同,c.数据类型不同)
4.与返回值无关,你就不用看返回值了
- 正确范例：
public static void show(int a){
}
public static void show(int a,double b){
}
public static void show(float a,int b){
}
public static void show(double c,int f){
}
- 错误范例：
public static void show(double b,int a){
}
public static void show(float a,int b){
}
public static void show(double c,int f){
}
6.2 方法重载练习（掌握）
- 需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
- 思路：
- ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
- ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
- ③定义所有的重载方法，两个byte类型与两个short类型参数
- ④完成方法的调用，测试运行结果
- 代码：
public class Demo7 {
public static void main(String[] args) {
int sum = sum(2, 2,6);
System.out.println(sum);
}
public static int sum(int a,int b){
System.out.println(1);
return a+b;
}
public static double sum(double a,double b){
System.out.println(2);
return a+b;
}
public static long sum(long a,long b){
System.out.println(3);
return a+b;
}
public static double sum(double a,int b){
System.out.println(4);
return a+b;
}
public static double sum(int a,double b){
System.out.println(5);
return a+b;
}
public static int sum(int a,int b,int c){
System.out.println(6);
return a+b+c;
}
}
//方法的重复载入,方法你需要接受的参数,可能存在顺序,类型,个数不同的各种需求,我就用重载,别人只需要记一个方法名就可以了,然后传入对应的实际参数,程序自动的根据实际参数的顺序类型个数去匹配对应的方法.
7. 方法的参数传递
7.1 方法参数传递基本类型（理解）
- 测试代码：
public class ArgsDemo01 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number);
change(number);
System.out.println("调用change方法后：" + number);
}
public static void change(int number) {
number = 200;
}
}
- 结论：
- 基本数据类型的参数，形式参数的改变，不影响实际参数
- 结论依据：
- 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
7.2 方法参数传递引用类型（理解）
- 测试代码：
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调用change方法后：" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
- 结论：
- 对于引用类型的参数，形式参数的改变，影响实际参数的值
- 结论依据：
- 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果
7.3 数组遍历（应用）
- 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
- 思路：
1.首先打印[
2.遍历数组,如果可以判断他不是最后一个元素,如果不是,我打印数组名[i]+","如果是,我直接打印元素
3.我再打印]
- 代码：
public class Demo10 {
public static void main(String[] args) {
//数据类型 [] 数组名 = {12,15,16,17,20};
int [] arr1 = {12,15,16,17,20};
printArray(arr1);
}
//public static 返回值类型 方法名(参数列表){
// 方法体;
// return 返回值;
// }
//[12, 15, 16, 17, 20]
public static void printArray(int [] arr){
/*
* 1.首先打印[
2.遍历数组,如果可以判断他不是最后一个元素,如果不是,我打印数组名[i]+","
如果是,我直接打印元素
3.我再打印]
*
* */
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+", ");
}
}
System.out.print("]");
}
}
7.4 数组最大值（应用）
- 需求：设计一个方法用于获取数组中元素的最大值
- 思路：
1.在主方法有一个数组吧
2.我需要编写一个判断数组最大值的方法
3.调用这个方法
- 代码：
public static void main(String[] args) {
//数据类型 [] 数组名 = {12,15,16,17,20};
int [] arr1 = {12,15,16,17,20};
int max= getMax(arr1);
System.out.println(max);
}
//public static 返回值类型 方法名(参数列表){
// 方法体;
// return 返回值;
// 你要知道有没有返回值
// 你要接什么参数
// }
public static int getMax(int[] arr){
//定义一个变量保存最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
} |
|
收藏
淘帖
踩
