# 【方法】
##### 今日复习指南
~~~
1.有参数无返回值方法的定义和调用(0.5个小时内完成,多写几遍)
itheima03包中Demo01PrintMax.java 打印两个int数字的最大值
itheima03包中Demo02PrintOu.java 打印一个int数字是否是偶数
2.有参数有返回值方法的定义和调用(1.5个小时内完成,多写几遍)
itheima04包中Demo01GetMax.java 获取两个int数字的最大值
itheima04包中Demo02GetOu.java 获取一个int数字是否是偶数
3.其它知识
(1)方法的调用方式
(2)形参和实参的区别
~~~
##### 今日内容
~~~
方法的概念【重要】
无参数无返回值方法的定义和调用【重要】
有参数无返回值方法的定义和调用【重要】
有参数有返回值方法的定义和调用【重要重要重要重要重要】
~~~
### 第一章 方法入门【理解】
##### 1.1 方法引入
~~~
/*
代码功能:模拟游戏中打怪物的场景
发现问题:
打怪物的代码是相同的,打了3次怪物,写了3次相同的代码,导致程序代码冗余,阅读性差
怎么解决问题呢?
1.能否将发射炮弹的代码,做成一个方法/功能
2.使用的时候直接调用即可
========================================================================
这个代码大家不用写,直接拷贝
========================================================================
*/
public class Demo01NoMethod {
/*
main是一个主方法,由JVM调用,是程序的入口
1.public static:修饰符,目前固定写法
2.void:返回值类型,表示方法内部的代码执行完毕,没有最终的结果,返回给调用者
3.main:方法名称:固定写法
4.String[] args:方法的参数
*/
public static void main(String[] args) {
System.out.println("游戏开始...");
System.out.println("看到了一个怪物...血牙野猪...");
System.out.println("准备发射5发炮弹");
System.out.println("发射第1发炮弹* * * *");
System.out.println("发射第2发炮弹* * * *");
System.out.println("发射第3发炮弹* * * *");
System.out.println("发射第4发炮弹* * * *");
System.out.println("发射第5发炮弹* * * *");
System.out.println("发射5发炮弹结束");
System.out.println("...血牙野猪被打倒...");
System.out.println("...走啊走啊走啊走...");
System.out.println("看到了一个怪物...黄金虎鲨...");
System.out.println("准备发射5发炮弹");
System.out.println("发射第1发炮弹* * * *");
System.out.println("发射第2发炮弹* * * *");
System.out.println("发射第3发炮弹* * * *");
System.out.println("发射第4发炮弹* * * *");
System.out.println("发射第5发炮弹* * * *");
System.out.println("发射5发炮弹结束");
System.out.println("...黄金虎鲨被打倒...");
System.out.println("...走啊走啊走啊走...");
System.out.println("看到了一个怪物...吞天巨狼...");
System.out.println("准备发射5发炮弹");
System.out.println("发射第1发炮弹* * * *");
System.out.println("发射第2发炮弹* * * *");
System.out.println("发射第3发炮弹* * * *");
System.out.println("发射第4发炮弹* * * *");
System.out.println("发射第5发炮弹* * * *");
System.out.println("发射5发炮弹结束");
System.out.println("...吞天巨狼被打倒...");
System.out.println("...走啊走啊走啊走...");
System.out.println("游戏结束...");
}
}
~~~
~~~
package com.itheima01;
/*
代码功能:模拟游戏中打怪物的场景
发现问题:
打怪物的代码是相同的,打了3次怪物,写了3次相同的代码,导致程序代码冗余,阅读性差
怎么解决问题呢?
1.能否将发射炮弹的代码,做成一个方法/功能
2.使用的时候直接调用即可
========================================================================
这个代码大家不用写,直接拷贝
========================================================================
注意:
1.方法定义完毕后,不调用不执行
2.方法的调用格式:
方法名称(...);
3.方法定义完毕后,可以调用任意多次
*/
public class Demo02Method {
/*
main是一个主方法,由JVM调用,是程序的入口
1.public static:修饰符,目前固定写法
2.void:返回值类型,表示方法内部的代码执行完毕,没有最终的结果,返回给调用者
3.main:方法名称:固定写法
4.String[] args:方法的参数
*/
public static void main(String[] args) {
System.out.println("游戏开始...");
System.out.println("看到了一个怪物...血牙野猪...");
//调用方法,发射5发炮弹
fire();
System.out.println("...血牙野猪被打倒...");
System.out.println("...走啊走啊走啊走...");
System.out.println("看到了一个怪物...黄金虎鲨...");
//调用方法,发射5发炮弹
fire();
System.out.println("...黄金虎鲨被打倒...");
System.out.println("--------------------------------");
System.out.println("...走啊走啊走啊走...");
System.out.println("看到了一个怪物...吞天巨狼...");
//调用方法,发射5发炮弹
fire();
System.out.println("...吞天巨狼被打倒...");
System.out.println("...走啊走啊走啊走...");
System.out.println("游戏结束...");
}
//模拟main方法,定义发射炮弹的方法fire
public static void fire() {
System.out.println("准备发射5发炮弹");
for (int i = 1; i <= 5; i++) {
System.out.println("发射第"+i+"发炮弹* * * *");
}
return ;//结束方法的执行,返回方法的调用处
}
}
~~~
图解:
##### 1.2 方法的概念和格式
~~~
1.方法的概念:
就是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
将具有特殊功能的一段代码,使用{}括起来,添加一些必要的修饰符等,起个名字,方便使用
2.方法的格式:
修饰符 返回值类型 方法名称(参数列表...) {
方法功能代码;
return ; 或者 return 结果数据/返回值数据;
}
3.格式解释:
(1)修饰符: public static 目前固定写法,先记住
(2)返回值类型: 方法的功能代码执行完毕后,产生的返还给方法调用者的结果数据的类型
目前定义的方法内部没有结果数据返回给调用者,返回值类型固定写为void
目前定义的方法是没有返回值的,返回值类型固定写为void
(3)方法名称: 给方法起个名字(标识符: 符合命名规范(小驼峰规则)),方便后期调用
(4)参数列表:目前定义的方法没有参数,不需要写参数列表,但是必须保留()
(5)方法功能代码: 一行/多行语句
(6)return ; 结束方法,返回到方法的调用处,建议省略
~~~
##### 1.3 无返回值无参数方法的定义和调用
~~~
1.练习:
定义方法method,方法内部输出一句话"我是一个方法"
/*
无返回值无参数方法的定义和调用
1.无返回值:
方法内部没有结果数据返回给调用者,返回值类型固定写为void
方法是没有返回值的,返回值类型固定写为void
2.无参数:
方法没有参数,不需要写参数列表,但是必须保留()
3.练习:
定义方法method,方法内部输出一句话"我是一个方法"
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
*/
public class Demo01Method {
public static void main(String[] args) {
System.out.println("main...start...");
//调用method方法
method();
System.out.println("main...end...");
}
//定义方法method,方法内部输出一句话"我是一个方法"
public static void method() {
System.out.println("我是一个方法");
return ;//结束方法返回到方法的调用处
}
}
~~~
##### 1.4 无返回值无参数方法的调用图解
##### 1.5 无参数无返回值的方法练习-打印最大值
~~~
需求:
定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
/*
无参数无返回值的方法练习-打印最大值
1.无返回值:
方法内部没有结果数据返回给调用者,返回值类型固定写为void
方法是没有返回值的,返回值类型固定写为void
2.无参数:
方法没有参数,不需要写参数列表,但是必须保留()
3.练习:
定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
*/
public class Demo02PrintMax {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法printMax
printMax();
System.out.println("main...end...");
}
//定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
public static void printMax() {
int a = 10;
int b = 20;
int max = (a > b) ? a : b;
System.out.println("最大值: "+max);
return ;//结束方法,返回到方法的调用处
}
}
~~~
图解:
##### 1.6 无参数无返回值的方法练习-打印数字是否是偶数
~~~
需求:
定义一个方法，打印输出该方法内部的数据(方法内部定义的变量)是否是偶数
/*
无参数无返回值的方法练习-打印数字是否是偶数
1.无返回值:
方法内部没有结果数据返回给调用者,返回值类型固定写为void
方法是没有返回值的,返回值类型固定写为void
2.无参数:
方法没有参数,不需要写参数列表,但是必须保留()
3.练习:
定义一个方法，打印输出该方法内部的数据(方法内部定义的变量)是否是偶数
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
*/
public class Demo03PrintOu {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法printOu
printOu();
System.out.println("main...end...");
}
//定义一个方法，打印输出该方法内部的数据(方法内部定义的变量)是否是偶数
public static void printOu() {
int num = 11;
boolean result = (num%2==0) ? true : false;
System.out.println(num+"是偶数吗? "+result);
return ;//结束方法,返回到方法的调用处
}
}
~~~
### 第二章 方法详解【理解】
##### 2.1 方法的格式详解
~~~
1.方法的概念:
就是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
将具有特殊功能的一段代码,使用{}括起来,添加一些必要的修饰符等,起个名字,方便使用
2.方法的格式:
修饰符 返回值类型 方法名称(数据类型1 变量名称1,数据类型2 变量名称2 ...) {
方法功能代码;
return 结果数据/返回值数据;
}
3.格式解释:
(1)修饰符: public static 目前固定写法,先记住
(2)返回值类型: 你调用我的方法后,我方法内部会返还你一个什么样子的数据
方法的功能代码执行完毕后,产生的返还给方法调用者的结果数据的类型
举例:
方法内部如果返回数字100: 返回值类型 int
方法内部如果返回数字6.6: 返回值类型 double
方法内部如果返回true/false: 返回值类型 boolean
(3)方法名称: 给方法起个名字(标识符: 符合命名规范(小驼峰规则)),方便后期调用
(4)参数列表: 你调用我的这个方法时,需要传递给我几个什么样子的数据
参数列表...的本质: 就是在定义一个/多个变量,可以接收调用者调用方法时,传递的数据
举例:
定义方法时(): 调用方法时,必须什么都不传递
定义方法时(int a): 调用方法时,必须传递一个int类型的数据
定义方法时(int a,int b): 调用方法时,必须传递两个int类型的数据
定义方法时(int a,int b,double c): 调用方法时,必须传递两个int类型的数据和一个double类型的数据 而且顺序不能错误
(5)方法功能代码: 一行/多行语句
(6)return 结果数据/返回值数据;
a.结束方法
b.把return后面的结果数据/返回值数据 返还给方法的调用者
4.方法的理解: 可以理解为工厂/机器
生产汽车的工厂:
原材料: 发动机,变速箱,车架 ...
产出物: BMW750Li,S600,ZT700 ...
榨汁机:
原材料: 水果,水...
产出物: 果汁
原材料是进入工厂/机器的东西,相当于调用方法是,传递给方法的参数 进入方法的东西 参数列表
产出物是从工厂/机器里面出来的东西,相当于调用方法后返回的数据 从方法中出来的东西 返回值--返回值类型
5.定义方法的三要素:
(1)方法名称:
(2)参数列表:
(3)返回值类型:
~~~
##### 2.2 无返回值有参数的方法练习-打印最大值
~~~
需求:
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
/*
无返回值有参数的方法练习-打印最大值
1.无返回值:
分享经验: 当在需求中明确看到打印/输出二字,说明该方法内部不需要返回结果,返回值类型固定写为void
2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数
3.练习:
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
5.定义方法的三要素:
(1)方法名称: printMax
(2)参数列表: int a,int b
(3)返回值类型: void
*/
public class Demo01PrintMax {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法printMax: 传递常量
printMax( 10 , 20 );
System.out.println("main...end...");
}
//定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
public static void printMax(int a , int b ) {
int max = (a>b) ? a : b;
System.out.println("最大值: "+max);
return ;//结束方法,返回到方法的调用处
}
}
~~~
图解:
##### 2.3 无返回值有参数的方法练习-打印数字是否是偶数
~~~
需求:
定义一个方法，该方法接收一个int参数，方法内部打印输出该数据是否是偶数
/*
无返回值有参数的方法练习-打印数字是否是偶数
1.无返回值:
分享经验: 当在需求中明确看到打印/输出二字,说明该方法内部不需要返回结果,返回值类型固定写为void
2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数
3.练习:
定义一个方法，该方法接收一个int参数，方法内部打印输出该数据是否是偶数
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
5.定义方法的三要素:
(1)方法名称: printOu
(2)参数列表: int num
(3)返回值类型: void
*/
public class Demo02PrintOu {
public static void main(String[] args) {
System.out.println("main...start...");
//调用printOu方法
printOu(10 );
System.out.println("main...end...");
}
//定义一个方法，该方法接收一个int参数，方法内部打印输出该数据是否是偶数
public static void printOu(int num) {
boolean result = (num % 2 == 0) ? true : false;
System.out.println(num+"是偶数吗? "+result);
return ;//结束方法,返回到方法的调用处
}
}
~~~
##### 2.4 有返回值有参数的方法练习-获取最大值
~~~
需求:
设计一个方法可以获取两个int数的较大值，数据来自于参数
/*
有返回值有参数的方法练习-获取最大值
1.有返回值:
分享经验: 当在需求中明确看到获取/判断/返回二字,说明该方法内部需要返回结果,必须定义返回值类型
2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数
3.练习:
设计一个方法可以获取两个int数的较大值，数据来自于参数
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
5.定义方法的三要素:
(1)方法名称: getMax
(2)参数列表: int a,int b
(3)返回值类型: int
*/
public class Demo01GetMax {
public static void main(String[] args) {
System.out.println("main...start...");
//调用getMax方法,传递10和20,把方法返回的结果赋值给int变量result
int result = getMax(10 ,20 );
System.out.println("最大值: "+result);
System.out.println("main...end...");
}
//设计一个方法可以获取两个int数的较大值，数据来自于参数
/*
你调用我的方法printMax时,必须给我传递2个int数据,
我方法内部代码执行完毕后,返回给你一个int数据
你: 方法的调用者
我: 方法本身
有进有出
*/
public static int getMax(int a , int b ) {
int max = (a > b) ? a : b;
return max;//结束方法,把max中的数据返还给方法的调用处/者
}
}
~~~
##### 图解分析:
##### 2.5 有返回值有参数的方法练习-获取数字是否是偶数
~~~
需求:
定义一个方法，该方法接收一个int参数，判断该数据是否是偶数，并返回真假值
/*
有返回值有参数的方法练习-获取数字是否是偶数
1.有返回值:
分享经验: 当在需求中明确看到获取/判断/返回二字,说明该方法内部需要返回结果,必须定义返回值类型
2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数
3.练习:
定义一个方法，该方法接收一个int参数，判断该数据是否是偶数，并返回真假值
4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(...);
(3)方法定义完毕后,可以调用任意多次
5.定义方法的三要素:
(1)方法名称: getOu
(2)参数列表: int a
(3)返回值类型: boolean
*/
public class Demo02GetOu {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法getOu,传递常量数字10,把结果数据赋值给boolean变量flag
boolean flag = getOu(10);
System.out.println("10 是否是偶数呢? " + flag );
int num = 11;
//调用方法getOu,传递变量num,把结果数据赋值给boolean变量flag2
boolean flag2 = getOu( num );
System.out.println(num+" 是否是偶数呢? " + flag2 );
System.out.println("main...end...");
}
//定义一个方法，该方法接收一个int参数，判断该数据是否是偶数，并返回真假值
/*
你调用我的方法getOu时,必须给我传递1个int数据,
我方法内部代码执行完毕后,返回给你一个boolean数据
你: 方法的调用者
我: 方法本身
有进有出
*/
public static boolean getOu(int a ) {
boolean result = (a%2==0) ? true : false;
return result;//结束方法,把result中的数据返还给方法的调用处/者
}
}
~~~
##### 图解分析:
##### 2.6 方法的注意事项
~~~
package com.itheima05;
import java.util.Scanner;
/*
方法的注意事项一
1.方法不能嵌套定义(在定义方法的内部又定义了其它方法),可以调用其它方法
2.方法可以嵌套调用
3.定义方法时参数列表根据需求确定(可以有0个/1个/2个/3个...)
4.定义方法时返回值类型根据需求确定
如果没有返回值,返回值类型固定写为void
5.如果方法需要参数列表,参数列表中定义的变量的类型根据需求确定
可以是基本类型/引用类型
6.如果分析后发现方法需要返回值类型,那么返回值类型也可以是基本类型/引用类型
*/
public class Demo01MethodNotice {
public static void main(String[] args) {
method();
//调用方法获取一个int数字保存到int变量a中
int a = getNum();
//调用方法打印一个int数字
printNum(a);
System.out.println("-----------");
printNum( getNum() );
}
//定义打印一个int数字的方法
public static void printNum(int num) {
System.out.println(num);
}
//定义方法获取一个int数字
public static int getNum() {
return 100;
}
//定义无参数无返回值方法
public static void method() {
System.out.println("method...");
//错误: 定义方法时,该方法内部不能在定义其它方法
/*public static void fun() {
System.out.println("fun...");
}*/
//正确的: 定义方法时,该方法内部可以调用其它方法
show();
}
//定义无参数无返回值方法
public static void show() {
System.out.println("show....");
}
}
~~~
~~~
package com.itheima05;
/*
方法的注意事项二
1.返回值类型，必须要和 return 语句返回的数据的类型要匹配，否则编译失败 。
2.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
3.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据 return ;
4.如果定义的方法需要返回值,那么只能返回一个数据,不能返回2个及以上的数据
而且可以返回基本类型也可以返回引用类型(根据需求确定)
如果非得返回多个数据,可以把多个数据放在数组中,返回一个数组
*/
public class Demo02MethodNotice {
public static void main(String[] args) {
byte b = 100;
//float a = 6.6;
double d = 'a';
}
public static int getNum2() {
//return 100,200;//return 后面只能写一个数据
return 100;
}
public static int[] getArray() {
return new int[]{100,200,300};
}
//1.返回值类型，必须要和 return 语句返回的数据的类型要匹配，否则编译失败 。
public static boolean getNum() {
//return 100;//100是int类型,返回值类型写为int
//return 6.6;//6.6是double类型,返回值类型写为double
//return 'a';//'a'是char类型,返回值类型写为char
return true;//true是boolean类型,返回值类型写为boolean
}
//2.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
public static int getMax(int a, int b) {
if(a>b) {
return a;
//System.out.println(".....");//无效代码
} else {
return b;
//System.out.println(".....");//无效代码
}
//System.out.println(".....");//无效代码
}
}
~~~
##### 2.7 有返回值的方法调用方式
~~~
package com.itheima06;
/*
有返回值的方法调用方式 可以赋值/打印/单独调用
1.赋值调用: 把调用有返回值的方法返回的结果数据保存到左侧的变量中 ---推荐使用---
数据类型 变量名称 = 方法名称(参数列表...);
2.打印/输出调用: 把调用有返回值的方法返回的结果数据直接交给输出语句进行输出
System.out.println(方法名称(参数列表...));
3.单独调用: 把调用有返回值的方法返回的结果数据 既没有赋值给变量也没有交给输出语句 ---不推荐使用---
此时把结果数据丢了,这种调用方式意义不大,但是代码没错哈
方法名称(参数列表...)
*/
public class Demo01InvokeMethod {
public static void main(String[] args) {
System.out.println("main...start...");
//1.赋值调用: 把调用有返回值的方法返回的结果数据保存到左侧的变量中
int result = getSum(10,20);
System.out.println("和: "+result);
System.out.println("和: "+(result*10));
//2.打印/输出调用: 把调用有返回值的方法返回的结果数据直接交给输出语句进行输出
System.out.println(getSum(100,200));
//3.单独调用: 把调用有返回值的方法返回的结果数据 既没有赋值给变量也没有交给输出语句
getSum(1000,2000);
System.out.println("main...end...");
}
//定义方法,获取2个int数据之和
public static int getSum(int a , int b ) {
int sum = a + b;
return sum;
}
}
~~~
##### 2.8 无返回值的方法调用方式
~~~
package com.itheima06;
/*
没有返回值的方法调用方式 只能采用单独调用,不能使用赋值和打印调用
1.单独调用: ---只能使用---
方法名称(参数列表...)
2.赋值调用: 错误
2.打印/输出调用: 错误
*/
public class Demo02InvokeMethod {
public static void main(String[] args) {
System.out.println("main...start...");
//1.单独调用: ---只能使用---
printSum(10,20);
//2.赋值调用: 错误
//int result = printSum(100,200);//错误: int变量只能保存int数据,但是该方法没有返回int数据
//void v = printSum(100,200);//错误: void根本不是数据类型
//3.打印/输出调用: 错误
//System.out.println(printSum(1000,2000));//错误: 因为printSum方法没有任何数据返回
System.out.println("main...end...");
}
//定义方法,打印2个int数据之和
public static void printSum(int a , int b ) {
int sum = a + b;
System.out.println("和: "+sum);
return ;
}
}
~~~
##### 2.9 形式参数和实际参数的区别
~~~
package com.itheima06;
/*
形式参数和实际参数的区别?
形式参数:
1.概念: 定义方法时,小括号()中定义的参数(变量),给它起个名字,叫做形式参数
2.特点:
(1)在定义时,指定的
(2)是没有值的,定义时是不能赋值的
(3)当调用方法时,使用调用时传递的参数进行赋值
实际参数:
1.概念: 在调用方法时,小括号()中给出的数据常量/变量,,给它起个名字,叫做实际参数
2.特点:
(1)在调用方法时,指定的
(2)实际参数,是在调用方法时使用的,必须要有值,没有值报错
注意:
实参和形参 名字是可以相同的,互不影响
*/
public class Demo03MethodParam {
public static void main(String[] args) {
System.out.println("main...start...");
/*
实际参数:
1.概念: 在调用方法时,小括号()中给出的数据常量/变量,,给它起个名字,叫做实际参数
2.特点:
(1)在调用方法时,指定的
(2)实际参数,是在调用方法时使用的,必须要有值,没有值报错
*/
//调用printSum方法: 传递常量
printSum(100,200);//100和200 叫做实际参数
//调用printSum方法: 传递变量
int m = 100,n = 200;
printSum( m , n );//m和n 叫做实际参数
//调用printSum方法: 传递变量
int a = 1000, b = 2000;
printSum( a , b );//调用方法时,传递的a和b: 叫做实际参数
System.out.println("main...end...");
}
//定义方法,打印2个int数据之和
/*
形式参数:
1.概念: 定义方法时,小括号()中定义的参数(变量),给它起个名字,叫做形式参数
2.特点:
(1)在定义时,指定的
(2)是没有值的,定义时是不能赋值的
(3)当调用方法时,使用调用时传递的参数进行赋值
*/
public static void printSum(int a , int b ) {//a和b 叫做形式参数
int sum = a + b;
System.out.println("和: "+sum);
return ;
}
}
~~~
##### 总结
~~~
能够知道方法定义的通用格式
public static 返回值类型 方法名称(参数列表...){
方法体;
return 返回值;
}
能够知道形参和实参的区别
1.形参:
(1)概念: 在定义方法时,()中定义的变量,叫做形参
(2)特点:
a.是在定义方法时,指定的
b.定义时,是没有值的,只有被调用时,才会有值
2.实参:
(1)概念: 是在调用方法时,()中指定的数据 常量/变量,叫做实参
(2)特点:
a.是在调用方法时,给出的
b.实参是必须有值的,没有值就是错误
能够使用方法完成两个较大数的获取并调用方法
//1.赋值调用
int max = getMax(10,20);
sout(max);
//2.打印调用
sout(getMax(100,200));
//3.直接/单独调用 代码没有错误,但是没有意义
getMax(1000,2000);
//获取两个int数据的较大值
public static int getMax(int a,int b) {
if(a>b) {
return a;
} else {
return b;
}
}
~~~
