Java方法（二）

目录

  • Java方法（二）
  • 方法的重载
  • 命令行传参
  • 可变参数

方法的重载

  1. 什么是重载：
    重载就是在一个类中，有相同的函数名称，但形参不同的函数
    这里的不同包括数量不同、类型不同等等
  2. 重载的规则：
  • 方法名称必须相同
  • 参数列表必须不同（个数不同或类型不同或参数排列顺序不同等等）
  • 方法的返回类型可以相同也可以不同
  • 仅仅返回类型不同不足以成为方法的重载（只是返回类型不同的话编辑会报错）
  1. 重载在编辑器中如何运行：
    当方法名称相同时，编辑器会根据方法的参数个数、参数类型、参数排列顺序等去逐个匹配，用来选择对应的方法。
    如果找不到对应的方法，就会报错。
  2. 举例：
//在CDemo02里写上相同名字的重载方法
public class CDemo02 {
    public static int abc(int a){
        return a*3;
    }
    //个数不同
    public static int abc(int a,int b){
        return a+b;
    }
    //和上面的类型不同
    public static int abc(char a,int b){
        System.out.println(a);
        return b;
    }
    //和上面的顺序不同
    public static int abc(int a,char b){
        System.out.println(b);
        return a;
    }
    //个数和返回值不同（只有返回值不同不行）
    public static void abc(int a,int b,int c){
        System.out.println("a="+a+",b="+b+",c="+c);
    }
}
//在CDemo01里使用CDemo02里的方法
public class CDemo01 {
    public static void main(String[] args) {
        int a=3,b=4,c=5;
        int x1=0,x2=1;
        //调用abc(int a)方法
        System.out.println(CDemo02.abc(a));
        //调用abc(int a,int b)方法
        System.out.println(CDemo02.abc(a,b));
        //调用abc(char a,int b)方法
        x1=CDemo02.abc('s',a);
        System.out.println("x1="+x1);
        //调用abc(int a,char b)方法
        x2=CDemo02.abc(b,'t');
        System.out.println("x2="+x2);
        //调用abc(int a,int b,int c)方法
        CDemo02.abc(a,b,c);
    }
}
//输出：
9
7
s
x1=3
t
x2=4
a=3,b=4,c=5

命令行传参

  1. 需要运行一个程序时再传递给它消息，需要传递命令行参数给main()函数实现
  2. 先在Demo01文件里写出以下代码
package com.sxw;
public class Demo01 {
    public static void main(String[] args) {
        for(int i=0;i<args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
  1. 在cmd下执行某个java文件：
  • 在src文件夹下启动cmd，输入java com.sxw.Demo01（Demo01是文件名，com和sxp是所在包）（失败的话先用javac生成class文件）
  • 之后输入字符串就能实现对main函数传参

可变参数

  1. 从 java1.5开始支持可变参数
  2. 在方法声明中，在指定参数类型后加一个省略号（...）
  3. 可变参数指可以往一个变量里输入多个（不限量）数据形成数组
  4. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数都必须在它之前声明
  5. 举例一：
public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        //因为i为可变数据，所以可以随意输入int类型的元素个数，最终都会存在i数组中
        demo02.abc(1,2,3,4,5);
        demo02.abc(1,2);
        demo02.abc(1,1,1,1,1,1,1,1,1,1,1,1);
    }
    //将i定义为int的可变参数，则i中的数据为int数组，要通过数组的方式输出
    public void abc(int ... i){
        //由于每次输入的元素个数不同所以不知道每次i数组的长度（元素个数）
        //所以调用i数组的length()方法来得到i每次的长度，通过for循环输出i数组中的所有元素
        for (int j=0;j<i.length;j++){
            System.out.print(i[j]+" ");
        }
        System.out.println("");
    }
}
//输出：
1 2 3 4 5 
1 2 
1 1 1 1 1 1 1 1 1 1 1 1

举例二：

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.abc2('A',2,4,2,5);
        demo03.abc2('B',1,2,3,4);
    }
    //一个方法里可变参数只能有一个
    //可变参数，它必须是方法的最后一个参数
    //例如abc2方法的可变参数i必须放在最后，不能放在char a之前
    public void abc2(char a,int ... i){
        System.out.print(a+" ");
        for (int j=0;j<i.length;j++){
            System.out.print(i[j]+" ");
        }
        System.out.println("");
    }
}
//输出：
A 2 4 2 5 
B 1 2 3 4