Java学习历程六《方法定义和调用》

Java中的方法

语法格式:

访问修饰符 返回类型 方法名(参数列表){
    方法逻辑
}
public static void main(String[] args){
    System.out.println("Hello word!")
}

public static 访问修饰符<静态方法>
void 返回类型<不返回任何类型>
main 方法名
String[] args 参数列表<字符串类型>

访问修饰符:当前方法被访问的权限范围

• public
• 什么都不写
• protected
• private

返回类型:

• void 无返回
• int
• …

方法命名规则和变量命名规则一样

• 一单词小写
• 多单词,第一个单词小写,剩余单词首字母大写

参数:

• 可无参数
• 有参数类型个参数名组成
• 多类型参数可以用,隔开

没有参数和返回值的方法的定义和使用

import java.util.Scanner;

public class NoParametersNoReturn {
    public static void main(String[] args) {
        /*  在NoParametersNoReturn类中定义了方pringStar()
            如果想要怕使用这个方法,
            1.NoParametersNoReturn npnr = new NoParametersNoReturn(); 实例化对象npnr
            2.npnr.printStar() 实例对象去调用方法
         * */
        String t;
        Scanner sc = new Scanner(System.in);
        NoParametersNoReturn npnr = new NoParametersNoReturn();
        System.out.println("输入内容:");
        t = sc.next();
        npnr.printStar();
        System.out.println(t);
        npnr.printStar();
    }

    public void printStar() {
        System.out.println("***********");
    }
}

无参数有返回值的方法

public class NoParametersHaveReturn {
    public int rectangularArea() {
        // 求矩形的面积
        int length = 10;
        int width = 5;
        return length * width;

    }
    public static void main(String[] args) {
        //
        NoParametersHaveReturn nphr = new NoParametersHaveReturn();
        System.out.println("矩形面积:" + nphr.rectangularArea());
    }
}

有参数无返回值的方法

public class HaveParametersNoReturn {
    public void floatMax(float a, float b) {
        if (a > b) {
            System.out.println("最大值" + a);
        } else if (a < b) {
            System.out.println("最大值" + b);

        } else {
            System.out.println("相等");
        }
    }

    public static void main(String[] args) {
        //
        HaveParametersNoReturn hpnr = new HaveParametersNoReturn();
        float a = 10.0f;
        float b = 10.1f;
        hpnr.floatMax(a, b);
    }
}

有参数有返回值的方法

public class HaveParametersHaveReturn {
    public int factorial(int n) {
        // n 的阶乘
        int item = 1;
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else {
            for (int i = 1; i <= n; i++) {
                item *= i;
            }
            return item;
        }

    }

    public static void main(String[] args) {
        //
        HaveParametersHaveReturn hphr = new HaveParametersHaveReturn();
        int n = 4;
        System.out.println(hphr.factorial(n));
    }
}

方法重载

特点:方法名相同,当时参数[类型][数量]不同

public class MethodOverload {
    public int plus(int x, int y) {
        return x + y;
    }

    public double plus(double x, double y) {
        return x + y;
    }

    public int plus(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        //
        int x = 5, y = 10;
        int[] a = {1, 2, 3, 4, 5};
        MethodOverload md = new MethodOverload();
        System.out.println("int类型的和:" + md.plus(x, y));
        System.out.println("double类型的和:" + md.plus(5.6, 4.4));
        System.out.println("数组元素累加和:" + md.plus(a));

    }
}

方法调用的值传递

public class ExchangeDemo {
    public void swap(int a,int b){
        int tmp;
        System.out.println("交换前-a="+a+"  b="+b);
        tmp = a;
        a = b;
        b = tmp;
        System.out.println("交换后-a="+a+"  b="+b);
    }
    public void doSwap(){
        /*
        除了主方法需要实例对象去调用其他方法外
        其他方法与其他方法之间可以直接调用
        * */ 
        int a = 4,b = 5;
        System.out.println("调用方法前-a="+a+"  b="+b);
        swap(a,b);
        System.out.println("调用方法后-a="+a+"  b="+b);
    }
    public static void main(String[] args) {
        // 主方法调用其他方法,需要实例对象
        ExchangeDemo ed = new ExchangeDemo();
        ed.doSwap();

    }
}

结果为:

调用方法前-a=4  b=5
交换前-a=4  b=5
交换后-a=5  b=4
调用方法后-a=4  b=5

调用方法的时候,传递的数据只是a,b的值作为参数,值传递的方法中后,会在方法中
形成新的a,b对象,这个新对象是局部变量,不影响外部的a,b;所以最终的结果是,调用
方法后,对外部a,b的数据没有影响.

数组传值的结果有点不同:

public class ArrayDemo {
    public void updateArray(int[] b) {
        // 修改数组中某个元素的方法
        b[3] = 0;
        System.out.println("方法内,数组b的元素为:");
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        //
        int[] a = {1,2,3,4,5};
        ArrayDemo ad = new  ArrayDemo();
        System.out.println("调用前,数组a的元素为:");
        for (int i : a){
            System.out.print(i+" ");
        }
        System.out.println();
        ad.updateArray(a);
        System.out.println("调用后,数组a的元素为:");
        for (int i : a){
            System.out.print(i+" ");
        }
        System.out.println();

    }
}

结果为:

调用前,数组a的元素为:
1 2 3 4 5 
方法内,数组b的元素为:
1 2 3 0 5 
调用后,数组a的元素为:
1 2 3 0 5 

数组是引用数据类型,结果不同:
对方法外部的数组产生了影响,调用方法前,数组a指向数组的内存空间,调用方法,
方法中的b也指向了这片内存空间,也就是当前数组的内存空间被两个数组名a,b指向
同一个数组的内存空间,在方法内进行修改的时候会对共同的内存空间产生影响,所以
影响了主方法中的数组的元素;

可变参数列表

参数的类型可以确定,但是个数不能被确定

• int... n 表示参数n是个参数列表,但是不知道一共有几个元素

public class DoAddDemo {
    public void sum(int... n) {
        int sum = 0;
        for (int i : n) {
            sum += i;
        }
        System.out.println("结果为:" + sum);
    }

    public static void main(String[] args) {
        //
        DoAddDemo dad = new DoAddDemo();
        dad.sum(1,2,3,4,5);
    }
}

既有可变参数列表,又有固定参数:

需要注意的是,可变参数放在不可变参数的后面

public class DoAddDemo {
    public void search(int n, int... a) {
        boolean flag = false;
        for (int i : a) {
            if (n == i) {
                flag = true;
                break;
            }
        }
        if (flag) {
            System.out.println("找到:" + n);
        } else {
            System.out.println("没找到:" + n);
        }
    }

    public static void main(String[] args) {
        //
        DoAddDemo dad = new DoAddDemo();
        dad.search(5, 1, 2, 3, 4, 5, 6);
    }
}