java基础学习第六天

方法

方法的调用

常量调用和变量调用

package com.itheima;
/*
调用格式：
    方法名（参数）
 */
public class MethodDemo04 {
    public static void main(String[] args) {
        //常量值的调用
        isEvenNumber(10);
        //变量的调用
        int number =10;
        isEvenNumber(number);
    }
    public static void isEvenNumber(int number){
        if(number%2==0){
            System.out.println(true);
        }else {
            System.out.println(false);
        }
    }
}

/*
            需求：
                设计一个方法用于打印两个数中的较大值，数据来自于方法参数
            思路：
                1.定义一个方法，用于打印两个数的较大值，例如getMax()
                2.为方法定义两个参数，用于接收两个数字
                3.使用分支语句分两种情况对两个数字的大小关系进行处理
                4.在main()方法中调用定义好的方法（使用常量）
                5.在main()方法中调用定义好的方法（使用变量）
         */
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);
        //在main()方法中调用定义好的方法（使用变量）
        int a=10;
        int b=20;
        getMax(a,b);
public static void getMax(int a,int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if (a>b){
            System.out.println(a);
        }else {
            System.out.println(b);
        }
    }
```java
/*
    需求：
        自定义一个方法，这个方法可以接受三个小数，然后在方法中，从大到小打印出3个小数
    分析：
 */

public class MethodDemo05 {
    public static void main(String[] args) {
        paiXu(2.1,2.2,1.2);//常量调用
        double a=10.5;
        double b=18.5;
        double c=1.5;
        paiXu(a,b,c);//变量调用
    }

    public static void paiXu(double a,double b,double c) {
        //1.先比较前两个数字，比较后，保证a>b
        if(a<b){
            //交换a b
            double d=a;//使用a的值覆盖d的值；（将a保存到d中）
            a=b;//将b的值，赋值给c,(此时c的值就变成了b)
            b=d;//将a的值修改为d,(d保存的就是原来a的值)
        }
        //一旦代码执行到这，此时的a一定不小于b
        //2.使用b和c比，保证b>c c此时一定是最小值
        if (b<c){
            //交换 b c
            double d=b;//使用b的值覆盖d的值；（将b保存到d中）
            b=c;//将b的值，赋值给c,(此时c的值就变成了b)
            c=d;//将b的值修改为d,(d保存的就是原来b的值)
        }
        //此时 大小顺序就排好了 a>b>c
        System.out.println("三个数的大到小顺序是"+a+","+b+","+c);
    }
}

package com.itheima;

public class MethodDemo06 {
    public static void main(String[] args) {
        //1.方法名（参数）；
        //isEvenNumber(10);
        //true;
        //2.数据类型 变量名 =方法名（参数）；
        boolean flag = isEvenNumber(10);
//        boolean flog =true;
        System.out.println(flag);
    }

    private static boolean isEvenNumber(int i) {
        if (i%2==0){
            return true;
        }else {
            return false;
        }
    }
}

package com.itheima;
/*
    需求：
        设计一个方法可以获取两个数的较大值，根据来自于参数
    思路：
        1.定义一个方法，用于获取两个数中的较大值
        2.使用分支语句分两种情况对两个数字的大小关系进行处理
        3.根据题设分别设置两种情况下对应的返回结果
        4.在main（）方法中调用定义好的方法并使用变量保存
        5.在main（）方法中调用定义好的方法并直接打印结果
 */
public class MethodDemo07 {
    public static void main(String[] args) {
    //在main（）方法中调用定义好的方法并使用变量保存
        int result =getMax(10,20);//赋值调用
        System.out.println(result);
    //在main（）方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(10,20));
    }

    private static int getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        //根据题设分别设置；两种情况下对应的返回结果
        if (a>b){
            return a;
        }else {
            return b;
        }
    }
}

方法重载

package com.itheima;
/*
    方法重载：
    多个方法在同一个类中
        多个方法具有相同的方法名
        多个方法的参数不相同，类型不同或者数量不同
 */
public class MethodDemo08 {
    public static void main(String[] args) {
        //调用方法
        int result =sum(10,20);
        System.out.println(result);
        double result1=sum(10.0,20.0);
        System.out.println(result1);
        int result2=sum(10,20,30);
        System.out.println(result2);
    }
    //需求一：求两个int类型的数据和的方法
    private static int sum(int a, int b) {
        return a+b;
    }
    //需求二：求两个double类型的数据和的方法
    private static double sum(double a, double b) {
        return a+b;
    }
    //需求三：求三个int类型的数据和的方法
    private static int sum(int a, int b, int c) {
        return a+b+c;
    }

}

package com.itheima;
public class MethodDemo09 {
    public static void main(String[] args) {
      //调用方法
        System.out.println(ssr(10,20));
        System.out.println(ssr((byte)10,(byte)20));
        System.out.println(ssr((short)10,(short)20));
        System.out.println(ssr(10L,20L));
    }
    //byte
    private static boolean ssr(byte a, byte b) {
        System.out.println("byte");
        return  a==b;
    }
    //int
    private static boolean ssr(int a, int b) {
        System.out.println("int");
        return  a==b;

    }
    //short
    private static boolean ssr(short a, short b) {
        System.out.println("short");
        return  a==b;
    }
    //long
    private static boolean ssr(long a, long b) {
        System.out.println("long");
        return  a==b;
    }
}

package com.itheima;
/*
    对于基础数据类型的参数，形式参数的改变，不影响实际参数的值
    对于引用数据类型的参数，形式参数的改变，影响实际参数的值

 */
public class MethodDemo10 {
    public static void main(String[] args) {
        int number =100;
        System.out.println("执行方法前："+number);
        isNumber(number);
        System.out.println("执行方法后："+number);
        int [] arr={10,20,30};
        System.out.println("执行change方法前："+arr[1]);
        change(arr);
        System.out.println("执行change方法后："+arr[1]);

    }

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

遍历数组

package com.itheima;
public class MethodDemo11 {
    public static void main(String[] args) {
//        System.out.println("hello");
//        System.out.println("world");
//        System.out.print("hello");
//        System.out.print("world");
        //定义一个数组，用静态初始化完成数组元素初始化
        int [] arr ={11,12,13,50,60};
        printArray(arr);
    }
    private static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i ==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("]");
    }
}

数组最大值

package com.itheima;
/*
    数组最大值
 */
public class MethodDemo12 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int [] arr={12,45,98,73,68};
        //调用获取最大值的方法，用变量接受返回结果
        int max=getMax(arr);
        //把结果输出在控制台
        System.out.println("数组的最大值为："+max);
    }
    //定义一个方法，用来获取数组中的最大值
    /*
        明确：
            返回值类型， int
            参数，int [] arr
     */
    public static int getMax(int[] a) {
        int max=a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i]>max){
                max=a[i];
            }
        }
        return max;
    }
}