概念
基本格式
方法名称命名规则:和变量一样,使用小驼峰。
方法体:也就是大括号当中可以包含任意条语句。
public static void 方法名称() {
方法体
}
注意事项
- 方法定义的先后顺序无所谓。
- 方法的定义不能产生嵌套包含关系。
- 方法定义好了之后,不会执行的。如果要想执行,一定要进行方法的调用。
调用方法格式
方法名称();
代码:
运行的不是HelloWorld.java 是HelloWorld.class
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello,World!!");
}
}
完整格式
修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
方法体
return 返回值;
}
参数
- 修饰符:现阶段固定写法:public static
- 返回值类型:也就是方法最终产生的数据结果是什么类型
- 方法名称:方法的名字,规则和变量一样,小驼峰
- 参数类型:进入方法的数据是什么类型 (参数其实就是个变量)
- 参数名称:进入方法的数据对应的变量名称
- 参数如果有多个,使用逗号进行分隔
- 方法体:方法需要做的事情,若干行代码
- return:两个作用,第一停止当前方法,第二将后面的返回值还给调用处
- 返回值:也就是方法执行后最终产生的数据结果
方法的三种调用
- 单独调用: 方法名称(参数);
- 打印调用
- 赋值调用
注意事项
- return后面的“返回值”,必须和方法名称前面的“返回值类型”,保持对应
/*
方法的定义格式
方法其实就是若干语句的功能集合
方法好比是一个工厂
蒙牛工厂 原料:奶牛、饲料、水
产出物:奶制品
钢铁工厂 原料:铁矿石、煤炭
产出物:钢铁建材
参数 (原料):就是进入方法的数据。
返回值(产出物): 就是从方法中出来的数据。
定义一个两个int数字相加的方法。三要素:
返回值类型:int
方法名称:sum
参数列表:int a, int b
*/
public class Demo02MethodDefine {
public static void main(String[] args) {
// 单独调用
sum(10,20);
// 打印调用
// 输出语句先去调用方法,把方法最终的返回值打印输出
System.out.println("两数和为:" + sum(50,40));
// 赋值调用
int num = sum(2,5);
num += 100;
System.out.println("两数和为:" + num);
}
public static int sum(int a, int b) {
System.out.println("方法执行啦!");
int result = a + b;
return result;
}
}
结果:
方法执行啦!
方法执行啦!
两数和为:90
方法执行啦!
两数和为:107
对比有参数和无参数
- 有参数:小括号当中有内容,当一个方法需要一些数据条件,才能完成任务的时候,就是有参数。
例如:两个数字相加,必须知道两个数字各是多少,才能相加。
-
无参数:小括号当中留空。一个方法不需要任何数据条件,自己就能独立完成任务,就是无参数.
例如:定义一个方法,打印固定10次HelloWorld。
public class Demo03MethodParam {
public static void main(String[] args) {
method1(10,20);
System.out.println("============");
method2();
}
// 有参数
public static void method1 (int a, int b) {
int result = a * b;
System.out.println("结果是:" + result);
}
// 无参数
public static void method2 () {
for (int i = 0; i < 10; i++) {
System.out.println("Hello,World!" + (i+1));
}
}
}
对比有返回值和无返回值
- 对于有返回值的方法,可以使用单独调用、打印调用和赋值调用。
- 无返回值的方法,只能使用单独调用。
package cn.luis.demo2;
/*
对比有返回值和无返回值
题目要求:定义一个方法,用来【求出】两个数字之和 (你帮我算,算完之后把结果告诉我)
题目变形:定义一个方法,用来【打印】两个数字之和 (你帮我算,算完之后自己显示结果,不用告诉我)
*/
public class Demo04MethodReturn {
public static void main(String[] args) {
// 有返回值
int num = getSum(10,20);
System.out.println("返回值是:" + num);
System.out.println(getSum(10,20)); // 正确写法
getSum(10,20); // 正确写法,但返回值没有用到
System.out.println("=============");
// 无返回值 (对于void没有返回值的方法,只能单独调用,不能打印或复制)
// 单独
printSum(10,20); // 正确写法 左面不能有变量来接收 因为没有返回值
/* // 打印
System.out.println(printSum(10,20)); // 错误写法! 返回值类型为void(什么也没有)
System.out.println(void);*/
/* // 赋值
int num2 = printSum(10,20);
int num3 = void;
void num4 = void;*/
}
// 我是一个方法,我负责两个数字相加。
// 我有返回值int,谁调用我,我就把计算结果告诉谁
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
// 我是一个方法,我负责两个数字相加。
// 我没有返回值,不会把结果告诉任何人,而是我自己进行打印输出。
public static void printSum(int a, int b) {
int result = a + b;
System.out.println("结果是:" + result);
}
}
案例:判断两个数字是否相同
题目:定义一个方法,用来判断两个数字是否相同。
/*
方法练习一:
题目:定义一个方法,用来判断两个数字是否相同。 ----> 是否:boolean!!!
思路:三要素
返回值类型: boolean
方法名称: isSame
参数列表: int a, int b
*/
public class Demo01MethodSame {
public static void main(String[] args) {
boolean same = isSame(3,5);
System.out.println("两个数字是否相同:" + same);
}
public static boolean isSame (int a, int b) {
/*if (a == b) {
return true;
} else {
return false;
}*/ //这样写不太好
// 第二种
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
/*// 第三种
same = a == b ? true : false; // 可以写成boolean same = a == b;
return same;
// 第四种
return a == b;*/
}
}
案例:求出1~100之间所有数字的和
/*
题目:定义一个方法,求出1~100之间所有数字的和。
思路:三要素
1. 返回值:有返回值,计算结果是一个int数字
2. 方法名称:getSum
3. 参数列表:数据范围已经确定,是固定的,所以不需要告诉我任何条件 不需要参数
*/
public class Demo02MethodSum {
public static void main(String[] args) {
System.out.println("结果是:" + getSum());
}
public static int getSum () {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
return sum;
}
}
案例:打印指定次数的HelloWorld
/*
题目:定义一个方法,用来打印指定次数的HelloWorld。
思路:三要素
返回值类型:只是打印操作,没有计算,也没有结果要告诉调用处
方法名称:printCount
参数列表:到底要打印多少次?? 次数:int
*/
public class Demo03MethodPrint {
public static void main(String[] args) {
// 单独调用
printCount(10);
System.out.println("===================");
// 打印调用
System.out.println(printCount(10L));
System.out.println("===================");
// 赋值调用
long num = printCount(10L);
System.out.println("返回值是:" + num);
}
public static void printCount (int num) {
for (int i = 1; i <= num; i++) {
System.out.println("Hello,World!!" + i);
}
}
public static int printCount(long num) {
int count = 0;
for (int i = 1; i <= num; i++) {
count += i;
System.out.println("Bitch !" + i);
}
return count;
}
}
注意事项
- 对于一个void没有返回值的方法,不能return后面的返回值,只能写:return;
- 对于void方法当中的最后一行return可以省略不写。
- 一个方法当中可以有多个return语句,但是必须保证同时只会有一个被执行到。两个return不能连写
public class Demo04MethodNotice {
// 5
public static int method1() {
return 10;
}
// 6
public static void method2() {
// return 10; // error!!
return; // 没有返回值,只是结束方法的执行而已。
}
// 7
public static void method3() {
System.out.println("AAA");
System.out.println("AAA");
System.out.println("AAA");
return; //void方法 最后一行的return可以不写
}
// 8
public static int getMax(int a, int b) {
/* int max;
if(a > b) {
max = a;
} else {
max = b;
}
return max;*/
if(a > b) {
return a;
} else {
return b;
}
}
}
方法的重载
方法的重载(Overload):多个方法的名称一样,但是参数列表不一样。
对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的方法名称,太麻烦。
好处:只需要记住唯一一个方法名称,就可以实现类似的多个功能
与下列因素相关
- 参数个数不同
- 参数类型不同
- 参数的多类型顺序不同
与下列因素无关
- 与参数名称无关
- 与方法的返回值类型无关
public class Demo01MethodOverload {
public static void main(String[] args) {
/*System.out.println(sumTwo(10,20)); // 30
System.out.println(sumThree(10,20,30)); // 60
System.out.println(sumFour(10,20,30,40)); // 100*/
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
}
public static int sum(int a, int b) {
System.out.println("有2个参数的方法执行啦!");
return a + b;
}
public static int sum(int a, int b, int c) {
System.out.println("有3个参数的方法执行啦!");
return a + b + c;
}
public static int sum(int a, int b, int c, int d) {
System.out.println("有4个参数的方法执行啦!");
return a + b + c + d;
}
//2. 参数类型不同
public static int sum(double a, double b) {
return (int) (a + b); // 必须强转
}
// 3. 参数的多类型顺序不同
public static int sum(int a, double b) {
return (int) (a + b); // 必须强转
}
public static int sum(double a, int b) {
return (int) (a + b); // 必须强转
}
/* // 错误写法!与参数名称无关
public static int sum(int x, int y) {
System.out.println("有2个参数的方法执行啦!");
return x + y;
}*/
/* // 错误写法!与返回值类型无关
public static double sum(int a, int b) {
System.out.println("有2个参数的方法执行啦!");
return a + b + 0.0;
}*/
}
案例: 比较两个数据是否相等
/*
题目:比较两个数据是否相等。
参数类型分别为两个byte类型,两个short、两个int、和两个long类型
并在main方法中进行测试。
*/
public class Demo02MethodOverloadSame {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
System.out.println(isSame(a,b));
System.out.println(isSame((short)20,(short)20));
System.out.println(isSame(11,12));
System.out.println(isSame(10L,12L));
}
public static boolean isSame(byte a, byte b) {
System.out.println("两个byte参数的方法执行啦!");
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
}
public static boolean isSame(short a, short b) {
System.out.println("两个short参数的方法执行啦!");
boolean same = a == b ? true : false;
return same;
}
public static boolean isSame(int a, int b) {
System.out.println("两个int参数的方法执行啦!");
boolean same;
return a == b;
}
public static boolean isSame(long a, long b) {
System.out.println("两个long参数的方法执行啦!");
if (a == b) {
return true;
} else {
return false;
}
}
}
案例:判新哪些方法是重载关系
package cn.luis.demo4;
/*
判新哪些方法是重载关系。
*/
public class Demo03OverloadJudge {
public static void open() {} // 正确重载
public static void open(int a) {} // 正确重载
static void open(int a,int b) {} // 代码错误:和第8行冲突
public static void open(double a,int b){} // 正确重载
public static void open(int a,double b) {} // 代码错误:和第6行冲突
public void open(int i,double d) {} // 代码错误:和第5行冲突
public static void OPEN() {} // 代码正确不会报错,但是并不是有效重|
public static void open(int i,int j) {} // 代码错误:和第3行冲突
}
实现重载的println
方法
在调用输出语句的时候,println
方法其实就是进行了多种类型的重载形式。
否则就得叫printShortln、printIntln
等等 很麻烦
package cn.luis.demo4;
public class Demo04OverloadPrint {
public static void main(String[] args) {
myPrint(100);
myPrint("我");
}
public static void myPrint(byte num) {
System.out.println(num);
}
public static void myPrint(short num) {
System.out.println(num);
}
public static void myPrint(int num) {
System.out.println(num);
}
public static void myPrint(long num) {
System.out.println(num);
}
public static void myPrint(float num) {
System.out.println(num);
}
public static void myPrint(double num) {
System.out.println(num);
}
public static void myPrint(char zifu) {
System.out.println(zifu);
}
public static void myPrint(boolean is) {
System.out.println(is);
}
public static void myPrint(String str) {
System.out.println(str);
}
}