一、介绍
方法是一个汉语词汇，方法的含义较广泛，一般是指为获得某种东西或达到某种目的而采取的手段与行为方式。方法在哲学，科学及生活中有着不同的解释与定义。
软件编程语言中,如果将函数定义为类定义的一部分或者将它与某个对象绑定,则该函数称为方法；.
二、内容
1.1 方法概述
软件的本质是为我们提供了解决日常事务的许多功能。在Java当中通过方法的方式来完成这些功能。即Java中的某个方法提供了某种功能，供我们人类解决问题。
我们可以将一个完整功能的代码组织成一个方法，在再次完成相同的功能时，便可以直接以整体的方式调用该功能，而不需要再将具体实现过程完整重复编写一遍。
main方法就是一个特殊的方法。作为程序入口，供JVM调用。
我们将不同功能定义成不同方法。供其他方法调用。最先接触方法时，我们定义不同的方法，供main方法直接调用。
1.2 方法的定义及使用
方法是对现实功能的一个抽象，便于对功能的复用。在一个类中可以有多个方法，多个方法是平等关系。
在很多语言当中，相同的概念使用函数来命名。
1.2.1 方法定义格式
在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
………
return 返回值;
}
对于上面的语法格式中具体说明如下：
修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，这些修饰符在后面的学习过程中会逐步介绍。目前使用固定的public static修饰符
返回值类型：方法返回值的数据类型
参数类型：调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回返回值
返回值：被return语句返回的值，该值会返回给调用者
1.2.2 方法的使用格式
1.2.2.1 方法的使用：
所有的方法定义出来，都是为了让别的方法使用的。永远不被别人调用的方法，其定义是没有意义的。
使用格式
在前边讲解引用数据类型的简单使用时，我们已经使用过方法
使用格式即：对象名.方法名(对应参数)
当一个类中有多个方法，多个方法之间可以相互直接调用，无需创建对象
使用格式：方法名(参数);
注意
方法必须先定义再使用
方法的定义顺序跟调用无关
/*
方法:方法就是对功能的封装,可以提高代码的复用性
工厂:
制造钢铁:原料矿石
制造牛奶:原料奶牛
定义方法的格式:
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
………
return 返回值;
}
对于上面的语法格式中具体说明如下：
修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，
这些修饰符在后面的学习过程中会逐步介绍。目前使用固定的public static修饰符
返回值类型：方法返回值的数据类型
参数类型：调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回返回值
返回值：被return语句返回的值，该值会返回给调用者, 返回值的数据类型一定要与返回值类型统一
方法调用格式:
方法名(参数);
*/
public class Demo01Method{
public static void main(String[] args){
//调用方法
int c = add(3,4);//7
System.out.println("c = " + c);
}
//定义求两个整数和方法 3 4
public static int add(int a,int b){
System.out.println("求两个整数的和方法开始");
int sum = a + b;
System.out.println("求两个整数的和方法结束");
return sum;//7
}
}
1.2.2.2 调用方法介绍：求和方法编写
public class Demo01Method {
/*
* 写一个方法，用于求和。
* 两个明确： 返回值类型 int 参数列表int a,int b
*/
public static int sum(int a,int b){
/*int c = a + b;
return c;*/
return a + b;
}
}
求和方法的调用(有明确返回值)
使用格式：方法名(参数);
单独调用，没有意义
sum(10,20);
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
System.out.println(sum(10,20));
赋值调用，推荐方式
int s = sum(10, 20);
// s+=100;
System.out.println("s:"+s);
求和方法的调用图解
1.2.3 定义格式注意事项
a) 返回值类型
可以返回任意类型,包含基本数据类型与引用数据数据类型
如果没有返回值，则使用void
b) return
结束方法的同时如果定义的返回值类型不是void，则同时将结果返回给调用者。
当返回值类型为void时，return后可以不跟返回值
当返回值类型为void时，可以省略，Java会自动补齐
c) 返回值
该方法运算的数值结果，该结果会通过return返回给调用者
有时结果运行后没有返回值。（买东西与买服务）
返回值的数据类型一定要与返回值类型统一
d) 方法名
方法的名称，区分不同方法的依据之一
定义符合小驼峰式 wordWordWord
e) 形式参数
是形式参数的数据类型，在定义时没有赋值，在方法使用时一定有值，所以可以使用该变量完成逻辑
是一个变量，用于存储调用方法时传递给方法的实际数值
/*
定义方法的注意事项:
a)返回值类型
可以返回任意类型,包含基本数据类型与引用数据数据类型
如果没有返回值，则使用void
b)return
结束方法的同时如果定义的返回值类型不是void，则同时将结果返回给调用者。
当返回值类型为void时，return后可以不跟返回值
当返回值类型为void时，return可以省略，Java会自动补齐
c)返回值
该方法运算的数值结果，该结果会通过return返回给调用者
有时结果运行后没有返回值。（买东西与买服务）
返回值的数据类型一定要与返回值类型统一
d)方法名
方法的名称，区分不同方法的依据之一
定义符合小驼峰式 wordWordWord
e)形式参数
是形式参数的数据类型，在定义时没有赋值，在方法使用时一定有值，所以可以使用该变量完成逻辑
是一个变量，用于存储调用方法时传递给方法的实际数值
*/
public class Demo02Method{
public static void main(String[] args){
//调用唐僧生孩子方法
//String xingMing = shengHaiZi(36);
//System.out.println("名字是: " + xingMing);
//唐僧生一群孩子方法
String[] xingMings = shengYiQunHaiZi(108);
for(int i=0; i<xingMings.length; i++){
System.out.println("第"+(i+1)+"孩子的姓名是: " +xingMings[i]);
}
//坐月子的方法
zuoYueZi(1800);
}
//定义一个唐僧生孩子方法
public static String shengHaiZi(int month){
System.out.println("怀了"+month+"个月,终于生孩子了!");
String name = "糖三角";
return name;
}
//定义一个唐僧生一群孩子方法
public static String[] shengYiQunHaiZi(int month){
System.out.println("怀了"+month+"个月,终于生了一群孩子了!");
String[] names = {"孙悟空","猪八戒","沙师弟","白龙马"};
return names;
}
//定义一个坐月子的方法
public static void zuoYueZi(int day){
System.out.println("在床上躺了"+day+"天!");
//return;
}
}
1.2.4 定义格式void与参数详解：
1.2.4.1 Void修饰的方法
格式
修饰符 void 方法名(参数类型 参数名1，参数类型 参数名2…) {
方法体;
return 返回值;
}
没有明确返回值的函数调用:
其实就是void类型方法的调用
只能单独调用
案例
写一个方法，在控制台输出10次HelloWorld案例。
public class Demo01Method {
public static void main(String[] args) {
//单独调用
printHelloWorld();
}
//在控制台输出10次HelloWorld案例。
public static void printHelloWorld() {
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}
}
1.2.4.2 Void修饰方法练习
1.2.4.2.1 定义一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
public class Demo02Method {
public static void main(String[] args) {
printNumber(10);
System.out.println("-------------------");
printNumber(100);
}
//在控制台打印1到该数据n的值
public static void printNumber(int n) {
for(int x=1; x<=n; x++) {
System.out.println(x);
}
}
}
1.2.4.2.2定义一个方法，把所有的水仙花数打印在控制台
public class Demo03Method {
public static void main(String[] args) {
printFlower();
}
//把所有的水仙花数打印在控制台
public static void printFlower() {
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x){
System.out.println(x);
}
}
}
}
1.2.5 方法参数传递问题
1.2.5.1 参数传递概述
可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
在这里，定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数
1.2.5.2 参数是基本类型及图解
n 形式参数的改变不影响实际参数。
public class Demo01Args {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
change(a, b);
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
}
public static void change(int a, int b) { // a=10,b=20
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
a = b; // a=20;
b = a + b;// b=40;
System.out.println("a:" + a + ",b:" + b);// a:20,b:40
}
}
1.2.5.3 参数是引用类型及图解
public class Demo02Args {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };
// 遍历数组
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("----------------");
change(arr);
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
// 如果元素是偶数，值就变为以前的2倍
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
1.2.6 多个方法可以共同访问成员变量
当一个类中定义了多个方法时，在方法A中定义的局部变量无法在方法B中直接访问。此时可以将变量定义在成员位置(类中方法外)，供多个方法同时访问。
使用static修饰的方法只能访问被static修饰的成员变量。
/*
多个方法之间不可以使用各自的局部变量
多个方法都可以使用成员变量,但是现在的方法都是用static修饰的,所以要访问成员变量,成员变量也必须被static修饰
成员变量:类的里边,方法的外边
*/
public class Demo03Method{
//int x;//错误: 无法从静态上下文中引用非静态 变量 x
static int x;
public static void main(String[] args){
x = 100;
System.out.println("x = " + x);
//调用method2方法
method2();
}
//方法1
public static int method1(int a){
int b = 10;
System.out.println(a*b);
return a*b;
}
//方法2
public static void method2(){
//System.out.println(a*b);// 错误: 找不到符号 方法2不能使用方法1里边的变量
//x = 200;
System.out.println("x = " + x);
}
}
1.3 方法定义练习
分别定义如下方法：
1.3.1 无返回值无参数方法，如打印3*3的矩形
1.3.2 有返回值无参数方法，如键盘录入得到一个整数
1.3.3 无返回值有参数方法，如打印指定M*N的矩形
1.3.4 有返回值有参数方法，如求三个数的平均值
/*
定义方法的练习;
无返回值无参数方法，如用*打印3*3的矩形
无返回值有参数方法，如用*打印指定M*N的矩形
有返回值无参数方法，如键盘录入得到一个整数
有返回值有参数方法，如求三个数的平均值
*/
import java.util.Scanner;
public class Demo04Method{
public static void main(String[] args){
//调用打印矩形方法
//printJX();
//调用打印不同矩形方法
//printJuXing(9,9);
//printJuXing(7,6);
//调用获取整数的方法
int a = getNumber();
System.out.println("a = " + a);
//调用求3个小数平均数方法
double b = pingJun(3.0,4.0,5.0);
System.out.println("b = " + b);
}
/*
无返回值无参数方法，如用*打印3*3的矩形
返回值类型: void
方法名: printJX
参数列表: 空
*/
public static void printJX(){
/*
***
***
***
*/
for(int i=0; i<3; i++){//控制打印行数
for(int j=0; j<3; j++){//控制每行打印几个
System.out.print("*");
}
System.out.println();
}
}
/*
无返回值有参数方法，如用*打印指定M*N的矩形
返回值类型: void
方法名: printJuXing
参数列表: int m, int n
*/
public static void printJuXing(int m, int n){
for(int i=0; i<m; i++){//控制打印行数
for(int j=0; j<n; j++){//控制每行打印几个
System.out.print("*");
}
System.out.println();
}
}
/*
有返回值无参数方法，如键盘录入得到一个整数
返回值类型: int
方法名: getNumber
参数列表: 空
*/
public static int getNumber(){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数: ");
int number = sc.nextInt();
return number;
}
/*
有返回值有参数方法，如求三个小数的平均值
返回值类型: double
方法名: pingJun (avg)
参数列表: double a,double b,double c
*/
public static double pingJun(double a,double b,double c){
//double avg = (a + b + c)/3;
return (a + b + c)/3;
}
}
1.3.5 获取两个数据中的较大值
public class Demo03MethodTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int x = sc.nextInt();
System.out.println("请输入第二个数据：");
int y = sc.nextInt();
//调用方法
int max = getMax(x,y);
System.out.println("max:"+max);
}
// 返回两个数中的较大值
public static int getMax(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
}
1.3.6 比较两个数据是否相等
public class Demo04MethodTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();
System.out.println("请输入第二个数据:");
int b = sc.nextInt();
//调用方法
boolean flag = compare(a,b);
System.out.println("flag:"+flag);
}
//比较两个数是否相等
public static boolean compare(int a,int b){
if(a==b){
return true;
}else {
return false;
}
}
}
1.3.7 获取三个数据中的较大值
public class Demo05MethodTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
System.out.println("请输入第三个数据：");
int c = sc.nextInt();
//调用方法
int max = getMax(a,b,c);
System.out.println("max:"+max);
}
// 返回三个数中的最大值
public static int getMax(int a, int b, int c) {
if (a > b) {
if (a > c) {
return a;
} else {
return c;
}
} else {
if (b > c) {
return b;
} else {
return c;
}
}
}
}
1.4 方法重载
在同一个类中，不能出现两个完全一样的方法。但是如果有多个功能，而这些功能大致相同只是某些已知量不同时，可以将两个方法的名称定义成相同的，而参数不同。这些相同名称不同参数的方法之间是重载关系。
1.4.1 方法重载定义
在同一个类中，出现方法名相同而参数列表不同，这样定义方法叫做方法重载。
这样的设计优化了程序设计
如：求3个数，4个数的和
方法定义：与求两数逻辑类似，求3、4个数和的方法中中只有参数不同。方法名与求两数的方法名相同，三个方法互为重载关系
public static int add(int a,int b) {逻辑} //两个数加法
public static int add(int a,int b,int c) {逻辑} //三个数加法
public static int add(int a,int b,int c,int d) {逻辑} //四个数加法
方法使用：main方法中直接调用
/*
方法重载:在一个类中方法名相同,参数列表不同
*/
public class Demo05Overload{
public static void main(String[] args){
System.out.println(add(10,20,30,40));
}
//两个数加法
public static int add(int a,int b) {
System.out.println("调用两个数相加");
return a + b;
}
//三个数加法
public static int add(int a,int b,int c) {
System.out.println("调用三个数相加");
return a + b + c;
}
//四个数加法
public static int add(int a,int b,int c,int d) {
System.out.println("调用四个数相加");
return a + b + c + d;
}
}
1.4.2 重载的注意事项
a) 重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同
参数顺序不同，如method(int x,double y)与method(double x,int y)不同
b) 重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
c) 重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在
/*
重载的注意事项
a)重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同
参数顺序不同，如method(int x,double y)与method(double x,int y)不同
b)重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
c)重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在
*/
public class Demo06Overload{
public static void main(String[] args){
//求两个小数的和
//double sum = add(3.1,3.4);
//System.out.println("sum = " + sum);
//求两个整数的和
//System.out.println(add(100,200));
System.out.println(add(100,200.0));
System.out.println(add(3.14,200));
}
//两个数加法
public static int add(int a,double b) {
System.out.println("调用先int两个数相加");
return (int)(a + b);
}
//两个数加法
/*
c)重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在
public static int add(int x,double y) {
System.out.println("调用先int两个数相加");
return (int)(x + y);
}
*/
//两个数加法
public static double add1(int a,double b) {
System.out.println("调用先int两个数相加");
return (a + b);
}
//两个数加法
public static double add(double a,int b) {
System.out.println("调用先double两个数相加");
return a + b;
}
//两个数小数加法
public static double add(double a,double b) {
System.out.println("调用两个小数相加");
return a + b;
}
//三个数加法
public static int add(int a,int b,int c) {
System.out.println("调用三个数相加");
return a + b + c;
}
//四个数加法
public static int add(int a,int b,int c,int d) {
System.out.println("调用四个数相加");
return a + b + c + d;
}
}
1.4.3 练习
1.4.3.1 比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
public class Demo02MethodTest {
public static void main(String[] args) {
// 调用
System.out.println(compare(10, 20));//整数默认为int类型
System.out.println("-------------");
System.out.println(compare((byte)10, (byte)20));
System.out.println("-------------");
System.out.println(compare((short)10, (short)20));
System.out.println("-------------");
//System.out.println(compare((long)10, (long)20));
System.out.println(compare(10L, 20L));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
// 第一种写法
// boolean flag = a==b?true:false;
// return flag;
// 第二种写法
// boolean flag = a == b;
// return flag;
// 第三种写法
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
