方法的格式，调用，重载，形参实参，传值

 方法

　　对重复且有效的代码进行提取，提取的形式-----方法

 

方法的书写格式

　　修饰符 返回值类型 方法名(参数类型 参数名，…){

　　　　方法体；

　　　　return 返回值；

　　}

　　修饰符： public static

　　返回值类型： 返回值是什么类型就用什么类型来接

　　如果没有返回值 -------- void

　　方法名： 标识符

　　参数列表： 参数类型，个数，顺序，共同作用

　　方法体： 重复的代码

　　return： 用于将返回值进行返回

 

方法的调用

　　1.单独调用----------方法名（参数值）

　　2.输出调用

　　3.赋值调用

 

注意：

　　1.方法调用才能执行

　　2.两个明确（返回值类型 参数列表）

　　3.return 适用于方法，用于结束方法，以及返回值

　　4.要保证所有的数据方法都有返回值

　　5.方法抽取的形式不固定，经验有关

public class MethodDemo1 {
    public static void main(String[] args) {
​
        //打印三行四列的星星
        printXing(3, 4);
        
        //两个整数求和，没有返回值的方法，不能输出赋值调用
        //输出调用
        System.out.println(sum(4,5));
        //赋值调用
        int sum=sum(4, 5);
        System.out.println(sum);
        
        System.out.println(isOdd(19));
    }
    
    
    //打印星星的方法
    public static void printXing(int a,int b){
        for(int i=0;i<a;i++){
            for(int j=0;j<b;j++){
                if(j==2)    
                    return;             //结束方法
                System.out.print("*");
            }
            System.out.println();
        }
        
    }
    
    
    //两个整数和的方法
    public static int sum(int a,int b){
        int sum = 0;
        sum = a+b;
        return sum;
        
    }
    
    //判断一个整数是否是奇数
    //明确返回值类型-----boolean 
    public static boolean  isOdd(int a){
        //不正常的范围
        if(a<=0){
            return false;
        }
        
        if((a&1)==1){
            return true;
        }
        
        return false;
    }
    
    
    //判断一个整数是否是质数
    public static boolean  isPrime(int a){
        //不正常范围
        if(a<2){
            return false;
        }
        
        for(int i=2;i<=a/2;i++){
            if(a%i==0){
                return true;
            }
        }
        return false;
        
    }
    
    public static void isPrime1(int a){
        if(a<2){
            System.out.println("不是质数");;
        }
        
        for(int i=2;i<=a/2;i++){
            if(a%i==0){
                System.out.println("是质数");
            }
        }
        System.out.println("不是质数");
        
    }
}
​

 

方法的重载

　　在一个类中，出现了方法名一致，参数列表不一致的情况，叫做方法的重载

　　如果重载方法提供了精确匹配的方法------精确匹配

　　如果重载方法没有提供精确匹配的方法，就要进行相对精确的方法

　　如果重载方法提供了多个相对精确的方法就会报错

//方法的调用由方法名和参数列表共同组成------方法签名
public class MethodDemo2 {
    public static void main(String[] args) {
        
        //重载方法提供了精确匹配的方法------精确匹配
        //如果重载方法没有提供精确匹配的方法，就要进行相对精确的方法
        System.out.println(sum(1, 4.0));
    }
    //求和方法
    
    //sum(int,int)
    public static int sum(int a,int b){
        System.out.println("1");
        return a+b;
    }
    
    //sum(int,double)
    public static double sum(int a,double b){   //int和double不存在先后，所以不能再写sum（double a，int b）
        System.out.println("2");
        return a+b;
    }
    
    //sum(double,double)
    public static double  sum(double a,double b){
        System.out.println("3");
        return a+b;
    }
    
}

实参形参，易错点

　　方法的传值

　　　　如果实参是基本数据类型，传递的就是值的拷贝

　　　　如果实参是引用数据类型，传递的参数是地址值的拷贝

　　　　如果拿到这个拷贝的地址找到了原堆内存改变了元素，就会影响结果

　　　　如果拿到这个拷贝的地址值

public class MethodDemo3 {
    //方法的执行在栈中
    public static void main(String[] args) {
        
        
        int i = 2;
        //实参
        //如果实参是基本数据类型，传递的就是值的拷贝
        m(i);
        
        System.out.println(i);//输出为2
        
        
        
        int[] arr={1,2,3};
        //如果实参是引用数据类型，传递的参数是地址值的拷贝
        n(arr);
        System.out.println(arr[0]);
        
        
        int[] arr1={1,2,3};
        mn(arr1);
        System.out.println(arr[1]);
    }
    
    //形参
    public static void m(int i){
        i++;
    }
    
    public static void n(int[] arr){
        arr[0]=10;
    }
    
    public static void mn(int[] arr){
        //此处在堆中创建了一个新的空间，形参arr指向新的空间
        arr=new int[4];         
        arr[0]=10;
        
    }
}

 

​