一、介绍
1、定义
方法就是用来解决一类问题的代码的有序组合，是一个功能模块。
1）举例
Scanner sc = new Scanner(System.in); sc.nextInt(); sc.next(); System.out.println();
2）解释：
其中sc为Scanner的对象；
sc.nextInt()是从键盘上获取整型值的方法;
sc.next()是从键盘上获取字符型值的方法;
2、方法的声明和调用
1）语法格式：
访问修饰符 返回类型 方法名（参数列表）{
方法体
}
public static void main(String[] args){ System.out.println("Hello,Imooc!"); }
2）访问修饰符：
方法允许被访问的权限范围
举例：public, 可以不写, protected,private
3）返回类型：void--无返回值，也可以是其他类型 基本数据类型，对象等
4）方法名：命名规则和变量一样，第一个单词小写
5）参数列表：可以省略，可以有多个，用逗号分开，是由参数类型、参数名 组成的
6）方法分类：根据方法是否带参数、是否返回值：
-无参无返回值方法
-无参带返回值
-带参无返回值
-带参带返回值
（下面我们根据这四个分类来介绍）
3.方法重载
二、方法分类（根据是否有参和返回值）
1、无参无返回值方法
举例：
一行打印输出一串星号
要实现的效果图：
************************
欢迎来到Java的世界！
************************
提示：对于重复操作的行为，归结为一个方法，之后调用
1）方法必须在类的内部定义。
2）方法调用：先声明对象，然后用“对象名.方法名()”的方式去调用方法。
package com.fiona.javaBasis.day8method; public class MethodDemo {//类名MethodDemo //打印输出星号的方法，一般写在主方法前面 public void printStar(){//无参无返回值，使用viod且括号是空的 System.out.println("************************"); } public static void main(String[] args) { //方法的声明：创建一个MethodDemo类的对象myMethedDemo MethodDemo myMethodDemo=new MethodDemo(); //方法的调用：使用对象名.方法名()去调用方法 myMethodDemo.printStar(); System.out.println("欢迎来到Java的世界！"); myMethodDemo.printStar(); } }
2、无参带返回值方法
1）方法在类的内部定义。
2）习惯把方法写到主方法的前面。
3）例如Scanner类
4）return（返回）的类型必须与方法类型一致，且名称可以一致
5）举例：
public class Two { //求长方形的面积 public int area() {//无参有返回值,返回值是int类型 int length=10; int width=5; int getArea=length*width; return getArea;//返回语句，变量名和方法名可以一致 } public static void main(String[] args) { Two rc=new Two(); //因为是有返回值的，所以需要有输出语句，不可以直接rc.area() System.out.println("长方形的面积为："+rc.area());
3、带参无返回值
1）调用方法前必须先创建对象，然后使用对象调用方法。
2）传参可以是变量也可以是字面值；传参类型与参数类型必须一致
3）举例：定义一个求两个float类型数据最大值的方法，在方法中将最大值打印输出
package com.fiona.javaBasis.day8method; //举例：定义一个求两个float类型数据最大值的方法，在方法中将最大值打印输出 public class MaxDemo { //求最大值的方法 public void max(float a,float b){//有两个参数的话用逗号分隔 float max; max=a>b?a:b; System.out.println("两个数"+a+"和"+b+"的最大值是："+max); } public static void main(String[] args) { MaxDemo maxDemo=new MaxDemo(); //创建一个对象 int a=5,b=3; maxDemo.max(a,b);//调用上面的方法 float m=5.6f,n=8.9f; maxDemo.max(m,n); maxDemo.max(9.8f,12.3f);//不定义变量，直接传值 } } //两个数5.0和3.0的最大值是：5.0 //两个数5. 6和8.9的最大值是：8.9 //两个数9.8和12.3的最大值是：12.3
4）练习题：根据商品总价，计算出对应的折扣
package com.fiona.javaBasis.day8method; /* 定义一个方法，根据商品总价，计算出对应的折扣并输出。折扣信息如下： 1） 总价<100，不打折 2） 总价在100到199之间，打9.5折 3） 总价在200以上，打8.5折 */ import java.util.Scanner; public class demo01 { //定义对象 //定义商品总价存放到变量中 public void zhehou(float a) { if(a<100){ System.out.println("折后商品总价为："+a); }else if (100<=a&a<=199){ System.out.println("折后商品总价为："+a*0.95); }else { System.out.println("折后商品总价为："+a*0.9); } } public static void main(String[] args) { demo01 ZongJia=new demo01(); //调用方法，输出折后商品总价 System.out.println("请输入商品价格："); Scanner sc= new Scanner(System.in); float b=sc.nextInt(); ZongJia.zhehou(b); // demo01 ZongJia=new demo01(); // float b=160f; // ZongJia.zhehou(b); } }
4、带参有返回值方法
1）方法不能嵌套定义，也就是不能在在主方法中再写一个方法
2）带有返回值的方法是为了参与进一步的运算
3）下面的举例求阶乘，可以用嵌套for循环，也可以用有参有返回值的方法，我们这里使用方法。
4）举例：定义一个求n！的方法，然后再求1！+2！+3！+4！+5！
package com.fiona.javaBasis.day8method; public class FacDemo { //方法不能嵌套定义，不能再主方法中再写一个方法 //1、求阶乘的方法 public int fac(int n){//带参有返回值 int s=1;//s存放阶乘的结果 for(int i=1;i<=n;i++){ s*=i;//s=s*i;求阶乘 } return s; } //2、主方法 public static void main(String[] args){ FacDemo facDemo=new FacDemo(); //计算单个数字的阶乘 int fac=facDemo.fac(3);//3传给上面方法的n System.out.println("3!="+fac); //使用循环计算累加阶乘 int sum=0; //求1!+2!+3!+4!+5! for(int i=1;i<=5;i++){ fac=facDemo.fac(i); sum=sum+fac; } System.out.println("1!+2!+3!+4!+5!="+sum); } }
三、数组作为方法参数
举例：打印输出数组元素的值
public class Five { //循环打印输出数组元素的值 public void printArry(int[] arr) { for(int i=0;i<arr.length;i++) {//可以用增强型for循环：for(int n:arr) System.out.print(arr[i]+" ");//System.out.print(n+ " "); } System.out.println(); } public static void main(String[] args) { int[] arr= {10,20,30,40,50,}; Five am=new Five(); am.printArry(arr); } }
练习：求数组元素的平均值
package com.fiona.javaBasis.day8method; //编写方法，求数组元素的平均值。 /* 1、定义一个方法，求数组的平均值 2、在主方法中定义对象，并初始化一个float类型的数组，调用方法求数组元素的平均值，并将平均值打印输出 提示： 当数组元素的内容为：78.5,98.5,65.5,32.5和 75.5时，可得到效果图所示的结果 */ public class arrAvg { public float arrAvg(float[] a) { float sum=0f,avg=1f; for(int i=0;i<a.length;i++){ sum+=a[i]; } avg=sum/a.length; return avg; } public static void main(String[] args) { //定义对象 arrAvg Arr=new arrAvg(); //创建float类型的数组并初始化 float[] a={78.5f,98.5f,65.5f,32.5f,75.5f}; //调用方法求平均值并打印输出 System.out.println("数组的平均数为："+Arr.arrAvg(a)); } }
举例：查找数组元素的值
提示
方法参数：数组、要查找的元素 返回值：Boolean类型
把查找的过程放到方法里，主方法只放业务代码
import java.util.Scanner; public class ArraySearch { //查找数组元素值的方法 public boolean search(int n,int[] a){ boolean flag=false;//设置默认值默认没找到 for(int i=0;i<a.length;i++){ if(a[i]==n){ flag=true;//找到了 break; } } return flag; } public static void main(String[] args) { int[] arr={10,20,30,40,50,60}; Scanner sc=new Scanner(System.in); System.out.println("请输入要查找的数据："); int n1=sc.nextInt(); ArraySearch as=new ArraySearch(); boolean flag=as.search(n1,arr); if(flag){ System.out.println("找到了"); } else{ System.out.println("没找到"); } } }
四、方法重载
1、定义：方法名相同，但是参数列表（数据类型or数量）不同，叫做方法重载
2、举例：求最大值的方法
//定义一个求两个float类型数据最大值的方法，在方法中将最大值打印输出 public class MaxDemo { //求最大值的方法 public void max(double a, double b) { } public void max(float a,float b){//有两个参数的话用逗号分隔 float max; max=a>b?a:b; System.out.println("两个数"+a+"和"+b+"的最大值是："+max); } public static void main(String[] args) { MaxDemo maxDemo=new MaxDemo(); //创建一个对象 int a=5,b=3; maxDemo.max(a,b);//调用上面的方法 float m=5.6f,n=8.9f; maxDemo.max(m,n); maxDemo.max(9.8f,12.3f);//不定义变量，直接传值 maxDemo.max(9.8,12.3);//添加上double方法后，这里double类型就不会报错了 } } //两个数5.0和3.0的最大值是：5.0 //两个数5. 6和8.9的最大值是：8.9 //两个数9.8和12.3的最大值是：12.3
3、选择题
注意：蓝框中的与红框的对比，是方法的重载，另外两个不是
4、举例：定义三个方法，实现int、double和数组类型和的问题
//定义三个方法，实现int、double和数组类型和的问题 public class MathDemo { //1、求两个int类型数的和 public int plus(int m,int n){ return m+n; } //2、求两个double类型数的和 public double plus(double m,double n){ return m+n; } //3、求数组元素的累加和 public int plus(int[] arr){ int sum=0;//求累加和，必须要定义 for(int i=0;i<arr.length;i++){ sum=sum+arr[i]; } return sum; } public static void main(String[] args) { int m=5,n=10; int[] arr={1,2,3,4,5,6}; MathDemo mathDemo=new MathDemo(); System.out.println("int类型的和："+mathDemo.plus(m,n)); System.out.println("double类型的和："+mathDemo.plus(5.6,7.8)); System.out.println("数组元素的和："+mathDemo.plus(arr)); } } //int类型的和：15 //double类型的和：13.399999999999999 //数组元素的和：21
5、练习：两个重载的方法，分别求圆和长方形的面积
/* 定义两个重载的方法，分别求圆和长方形的面积。 1、定义两个求面积的重载方法，圆周率可以用Math.PI表示 2、在主方法中调用方法并将结果输出。 注意：当圆的半径为4.5，长方形长和宽分别为8和5时，可得到如效果图所示的结果 */ public class AreaDemo { //求圆形面积 public double mj(double m){ double mianji=m*m*Math.PI; return mianji; } //求长方形面积 public double mj(double c,double k){ double mianji=c*k; return mianji; } public static void main(String[] args) { //定义对象 AreaDemo areaDemo=new AreaDemo(); //定义一个double类型的变量存放半径，并初始化 double r=4.5; //定义两个变量存放长和宽，并初始化 double c=8,k=5; //调用方法，求圆的面积并打印输出 System.out.println("圆的面积为："+areaDemo.mj(r)); //调用方法，求长方形面积并打印输出 System.out.println("长方形的面积是："+areaDemo.mj(c,k)); } } //圆的面积为：63.61725123519331 //方形的面积是：40.0
五、方法传值
1、基本数据类型的传值
1）方法中改变的值并不会对主方法中的变量值产生影响
2）主方法必须使用对象的名字调用，例如ex.swapTest();
3）普通方法直接用方法名字调用（在一个类里），例如swap(m,n);
4）举例
public class ExchangeDemo { //交换方法 public void swap(int a,int b){ int temp; System.out.println("交换前：a="+a+","+"b="+b); temp=a; a=b; b=temp; System.out.println("交换后：a="+a+","+"b="+b); } public void swapTest(){ //ExchangeDemo ex=new ExchangeDemo(); //普通方法调用方法不需要定义对象，直接调用即可 方法名（实参）； int m=4,n=5; System.out.println("交换前：m="+m+","+"n="+n); swap(m,n); System.out.println("交换后：m="+m+","+"n="+n); } public static void main(String[] args) { ExchangeDemo ex=new ExchangeDemo(); ex.swapTest(); /*int m=4,n=5; System.out.println("交换前：m="+m+","+"n="+n); ex.swap(m,n); System.out.println("交换后：m="+m+","+"n="+n);*/ } }
2、数组的传值
1）基本数据类型传值不会影响主方法中的值；
2）引用数据类型的传值会影响主方法中的值【数组、类、接口】。
3）个人观点：基本数据类型作为方法参数时传递的是其保存的值；引用数据类型作为方法参数时传递的是其数据存储地址。
4）举例：
public class Ten { //定义一个用于修改某个数组元素值的方法 public void updateArry(int[] a) { a[3]=15; System.out.println("数组a的元素为："); for(int n:a) { System.out.print(n+" "); } System.out.println(); } public static void main(String[] args) { Ten b=new Ten(); int[] a1= {1,2,3,4,5}; System.out.println("方法调用前数组a1元素为："); for(int n:a1) { System.out.print(n+" "); } System.out.println(); b.updateArry(a1); System.out.println("方法调用后数组a1元素为："); for(int n:a1) { System.out.print(n+" "); } } } //方法调用前数组a1元素为： // 1 2 3 4 5 // 数组a的元素为： // 1 2 3 15 5 // 方法调用后数组a1元素为： // 1 2 3 15 5
六、可变参数列表
1、定义
参数的数量是不确定，可随时变化,
例如：
public void sum(int... n){}
1）当方法的参数中有多个参数的时候，可变参数列表必须放在最后一个位置
2）当可变参数列表作为方法参数时，可以将数组传递给可变参数列表
3）数组作为参数时，是不能将多个值传递给数组的
4）在方法定义中，方法名相同，一个可变参数，一个数组，认为当前的两个search方法重复定义，而不是重载！
2、只有一个可变参数
3、参数列表中有两个参数
public class ArgsDemo1 { //查找 public void search(int n,int...a){//可变参数不能使用数组 boolean flag=false; for(int a1:a){ if(a1==n){ flag=true; break; } } if(flag){ System.out.println("找到了"+n); } else{ System.out.println("没找到"+n); } } public static void main(String[] args) { ArgsDemo1 ad1=new ArgsDemo1(); ad1.search(3,1,2,3,4,5); int[] a={1,2,3,4,5};//可以将数组传递给可变参数列表 ad1.search(3,a); } } //找到了3 //找到了3
4、可变参数列表作为方法参数的重载问题
可变参数列表所在的方法是最后被访问的。
5、文档注释
1）
/**
*关于可变参数列表和重载的问题
*@author fiona作者
*@version 1.0版本
*/
2）在控制台进入相关目录下后可以通过javadoc -d doc xxx.java 生成doc文档包，生成的文档名叫index.html。（xxx类名）
七、方法的调试
eclipse功能键：
F5单步跳入（进入方法内部执行）
F6单步执行
F7单步跳出（由方法内部跳回调用处）
F8运行完当前断点，一直执行到下一个断点
F11进入debug
八、总结
1、方法声明的语法格式
访问修饰符 返回类型 方法名(参数列表) {
方法体
}
1）访问修饰符：public、private、protected、默认(什么都不写)
2）返回类型：可以是void或者任何数据类型(基本数据类型、引用数据类型)
3）方法名：参数内容可以省略，可以是基本数据类型或者引用数据类型
2、方法调用：
用 类名创建对象：
类名 对象名=new 类名（）；//Demo d =new Demo(）；
然后用 对象名.方法名（）；进行调用。
3、方法的重载：只与方法名和参数 列表相关，只有方法名相同，参数列表不同才是重载。
4、可变参数列表:public void sum(int...n);
1）当有两个以上的参数，可变参数必须放在最后。
2）数组可以传递给可变参数的方法，反之不行。
3）在重载中，含有可变参数的方法是最后被调用的。
4）可变参数一定是 方法中最后一个参数；
5）数组可以传递给可变参数的方法，反之不行
5、方法的传值问题（基本数据类型传值，引用数据类型传值）
1）基本数据类型传值：方法中对参数的修改，不会对 主方法中传来的变量产生影响。
2）引用数据类型传值：方法中的改变，会影响主方法中传来的数组。
6.方法调试