【8】Java方法

一、介绍

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.方法调试