欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2024-03-25 23:59:52
...

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);
    }
}