方法

方法:将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集 注意:方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用。方法名命名采用驼峰命名法 格式:public static void 方法名(){}

package ch1;

public class a3_1方法 {

    //方法调用:方法名()
    public static void main(String[] args) {
        //调用下面写好的方法
        isEvenNumber();
    }

    //需求:定义一个方法，在方法中定义一个变量，判断上面的数据是否是偶数
    public static void isEvenNumber() { //方法，不调用不执行
        //定义变量
        int number = 10;
        //判断该数据是否是偶数
        if (number % 2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
    //注意:方法必须先定义后调用，否则程序将报错
}

方法练习

public static void main(String[] args) {
    //在main方法中调用下面定义好的方法
    getMax();

}
//定义一个方法，用于打印两个数字中的较大数
public static void getMax(){
    //定义两个变量，用于保存两个数字
    int a = 10;
    int b = 20;
    //使用分支语句判断两个数字的大小
    if(a > b){
        System.out.println(a);
    } else{
        System.out.println(b);
    }
}

带参数的方法

形参:方法定义中的参数 实参:方法调用中的参数

带参数方法定义 格式:public static void 方法名(参数){} 格式(单个参数):public static void 方法名(数据类型 变量名){} 格式(多个参数):public static void 方法名(数据类型 变量名1,数据类型 变量名2,……){}

注意: 1、方法定义时，参数中的数据类型与变量名都不能缺少 2、方法定义时，多个参数之间使用逗号分隔

带参数方法调用 格式:方法名(参数) 格式(单个参数):方法名(变量名/常量值) 格式(多个参数):方法名(变量名1/常量值1,变量名2/常量值2,……)

注意:方法调用时，参数的数量与类型必须跟方法定义中的设置相匹配

public static void main(String[] args) {
    //调用。当参数是常量值时的调用
    isEvenNumber(11);//输出false
    //当参数是变量时的调用，需要自己再定义一个参数
    int num = 10;
    isEvenNumber(num);//输出true
}

//需求:定义一个方法，该方法接收一个参数，判断该数据是否是偶数
public static void isEvenNumber(int number){ //当写一个参数时
    //用if语句实现判断
    if(number%2 == 0){
        System.out.println(true);
    } else{
        System.out.println(false);
    }
}

带参数方法的练习

xxxxxxxxxx
//需求:设计一个方法用于打印两个数中的较大数，需要比较的数字来自于方法参数
public static void main(String[] args) {
    //调用
    getMax(10,20); //a:和b:是系统自动加上去的，我们只需要在括号里写10，20。输出20

    //或者可以这样写
    int n = 11;
    int m = 21;
    getMax(n,m);//输出21
}

//定义方法。getMax里面定义两个参数，用于接收两个数字
public static void getMax(int a,int b){
    //分支语句
    if(a > b){
        System.out.println(a);
    } else{
        System.out.println(b);
    }
}

带返回值的方法

带返回值方法定义 格式:public static 数据类型 方法名(参数){return 数据;} 注意:方法定义时return后面的返回值跟方法定义上的数据类型要匹配

带返回值方法调用 格式1:方法名(参数) 格式2:数据类型 变量名 = 方法名(参数) 推荐使用格式2 注意:方法的返回值通常会使用变量接收，否则该返回值将无意义，例如格式1

x
public static void main(String[] args) {
    //第一种调用的写法
    isEvenNumber(12);//不会有输出,没意义
    //第二种调用的写法
    boolean flag = isEvenNumber(22);
    System.out.println(flag);//输出true
}

//定义方法
public static boolean isEvenNumber(int number){ //布尔型
    //判断是否为偶数
    if(number%2 == 0){
        return true;
    } else{
        return false;
    }
}

带返回值的方法练习

xxxxxxxxxx
//需求:设计一个方法可以获取两个数的较大值，需要比较的数字来自参数
public static void main(String[] args) {
    //调用方法
    int res = getMax(10,20); //a:和b:是系统自动加上去的，我们只需要在括号里写10，20。输出20
    System.out.println(res);//输出20

    //或者直接调用输出
    System.out.println(getMax(10,20)); //这样也可以不使用变量接收
}

//定义方法
public static int getMax(int a,int b){
    if(a > b){
        return a;
    } else{
        return b;
    }
}

方法的注意事项

方法不能嵌套定义,即方法里面不能放方法,方法跟方法之间是同级的 return表示返回值,只要是return,不管return是带不带参数的,在同一个方法里面的return后面的代码都不执行 void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据。即'void'和'returnd带参数'不能同时存在

xxxxxxxxxx
//定义main方法
public static void main(String[] args) {

}

//定义方法
public static void methodOne(){

}

//定义方法
public static void methodTwo(){

}

//方法之间不能嵌套定义
public static void methodThree(){
    public static void methodfour(){ //报错

    }
}

//void和不带参数的return  不报错
public static void methodFive(){
    return;
    //System.out.println(100); //报错，报错原因是'不可到达的代码',即这一行不会被执行到
}

//void和带参数的return  报错
public static void methodFive(){
    return 10;
}

方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载 1、多个方法在同一个类中 2、多个方法具有相同的方法名 3、多个方法的参数不相同，类型不同或者数量不同

方法重载的特点 1、重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式 2、重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关， 3、换句话说不能通过返回值来判定两个方法是否相互构成重载

xxxxxxxxxx
public static void main(String[] args) {
    //调用需求1的方法
    int res = sum(10,20);
    System.out.println(res);
    //调用需求2的方法
    double res2 = sum(10.0,20.0);
    System.out.println(res2);
    //调用需求3的方法
    int res3 = sum(10,20,30);
    System.out.println(res3);
}

//需求1:求两个int类型数据和的方法
public static int sum(int a,int b){
    return a + b;
}

//需求2:求两个double类型数据和的方法
public static double sum(double a,double b){
    return a + b;
}

//需求3:求三个int类型数据和的方法
public  static  int sum(int a,int b,int c){
    return a + b + c;
}

方法重载的练习

xxxxxxxxxx
//需求:使用方法重载的思想，设计比较两个整数是否相同的方法，并且要求兼容全整数类型(byte,short,int,long)
public static void main(String[] args) {
    //调用
    System.out.println(compare(10,20));//方法调用的是下面的int
    //如何让上面那一行调用byte类型的方法。要对参数进行强制转换，如下
    System.out.println(compare((byte)10,(byte)20));//方法调用的是下面的byte
    //如何让上面那一行调用long类型的方法。给数字的末尾加一个L，如下
    System.out.println(compare(10L,20L));
}

//下面的是四个重载方法

//int
public static boolean compare(int a,int b){
    System.out.println("int");//为了直观看到上面调用的是四个重载方法里面哪个方法
    return a == b;
}

//byte
public static boolean compare(byte a,byte b){
    System.out.println("byte");
    return a == b;
}

//short
public static boolean compare(short a,short b){
    System.out.println("short");
    return a == b;
}

//long
public static boolean compare(long a,long b){
    System.out.println("long");
    return a == b;
}

方法的参数传递

方法参数传递(基本类型) 注意:形式参数的改变，不影响实际参数的值

public static void main(String[] args) {
    int number = 100;
    System.out.println("调用change方法前:" + number);
    change(number);
    System.out.println("调用change方法后:" + number);
}

public static void change(int number){
    number = 200;
}

方法参数传递(引用类型)。比如数组就是引用类型的 对于引用类型的参数，形式参数的改变，影响实际参数的值

public static void main(String[] args) {
    int[] arr = {12,20,30};
    System.out.println("调用change方法前:" + arr[1]);
    change(arr);
    System.out.println("调用change方法后:" + arr[1]);
}

public static void change(int[] arr){
    arr[1] = 200;
}