Java ee 从入门到放弃 day05_java设计一个getmax方法用于打印两个整数中较小的数-CSDN博客

本文链接：https://blog.csdn.net/nickname_million/article/details/103149167

方法

方法定义和调用

package cn.wang.method;
/*
方法（method）：
    是将具有独立功能的代码块组织成为一个整体，让它变成具有特殊功能的代码集

PS：
    方法必须先创建才能使用
    方法的创建后并不是直接运行的，需要进行方法调用

定义格式：
    public static void 方法名(){
        //方法体
    }
范例：
    public static void methodDefine(){
        //方法体
    }

方法调用
    格式：方法名();
    范例：methodDefine();
 */
public class MethodDefine {
    public static void main(String[] args) {
        //方法调用
        methodDefine();
    }
    //定义一个名叫methodDefine的方法
    public static void methodDefine(){
        int number = 10;
        //判断number是否是偶数
        if (number % 2 == 0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    }
}

方法练习

package cn.wang.method;
/*
设计一个方法用于打印两个数中的较大数
 */
public class MethodGetMax {
    public static void main(String[] args) {
        //调用方法
        getMax();
    }
    //定义一个名叫getMax的方法
    public static void getMax(){
        int a = 10;
        int b = 9;
        //利用三元运算符进行比较取得最大值
        int max = a > b ? a : b;
        System.out.println("Max：" + max);
    }
}

带参方法定义和调用

package cn.wang.method;
/*
带参方法定义
    格式：public static void 方法名(参数){
        ......
    }
    格式(单个参数)：public static void 方法名(数据类型 变量名){
        ......
    }
    格式(多个参数)：public static void 方法名(数据类型 变量名,数据类型 变量名，...){
        ......
    }
    PS：方法定义时，参数中的数据类型和变量名都不能少，缺少就会报错
    方法定义时，多个参数之间用逗号隔开

带参方法调用
    格式：方法名(参数);
    格式(单个参数)：方法名(数据类型 变量值)
    格式(多个参数)：方法名(数据类型 变量值,数据类型 变量值，...)

形参和实参
    形参：方法定义中的参数
    实参：方法调用中的参数
*/
public class MethodParam {
    public static void main(String[] args) {
        //methodParam方法调用
        methodParam(10);//10就是实参
        //methodParamTwo方法调用
        methodParamTwo(10,20);//10 20就是实参
    }
    //定义一个名叫methodParam的(单个参数)的方法，int number就是形参
    public static void methodParam(int number){
        System.out.println(number);//10
        System.out.println("=========");
    }
    //定义一个名叫methodParamTwo的(多个参数)的方法，int a 和 int b就是形参
    public static void methodParamTwo(int a,int b){
        System.out.println(a + "," + b);//10,20
    }
}

带参方法的练习

package cn.wang.method;
/*
设计一个方法用于打印两个数中较大的数，数据来自方法参数
 */
public class ParamGetMax {
    public static void main(String[] args) {
        //调用方法时，形参的个数和类型，要和实参一一对应，不然会报错
        getMax(10,20);
        //使用变量调用方法
        int a = 10;
        int b = 20;
        getMax(a,b);
    }
    //定义一个名叫getMax的方法
    public static void getMax(int a,int b){
        int max = a > b ? a : b;
        System.out.println("Max:" + max);//20
    }
}

带返回值方法定义和调用

package cn.wang.method;
/*
带返回值方法定义
    格式：public statc 数据类型 方法名(参数){
        return 数据;
    }return后面的返回值与方法定义上的数据类型要匹配
带返回值方法调用
    格式1：方法名(参数);
    格式2：数据类型 变量名 = 方法名(参数);
    方法的返回值通常会用变量接收，否则该返回值将毫无意义
 */
public class MethodReturn {
    public static void main(String[] args) {
        methodReyurn(10,20);

        int number = methodReyurn(10,20);
        System.out.println(number);
    }
    //定义一个返回值为int类型的方法
    public static int methodReyurn(int a,int b){
        return a + b;
    }
}

带返回值方法练习

package cn.wang.method;

import java.sql.SQLOutput;

/*
设计一个方法可以获取两个数的较大值，数据来源参数
 */
public class RetuenGetMax {
    public static void main(String[] args) {
        int result = getMax(10,20);
        System.out.println("Max:" + result);
        System.out.println("Max:" +getMax(20,30));
    }
    public static int getMax(int a,int b){
        int max = a > b ? a : b;
        return max;
    }
}

方法的注意事项

package cn.wang.method;
/*
方法注意事项：
    方法不能嵌套定义
    void表示没有返回值，可以省略return，也可以单独的书写return，后面不加数据

 */
public class MethodProblem {
}

方法重载

package cn.wang.method;
/*
方法重载
    方法重载指同一个类中定义的多个方法之间的关系，满足下条件即可构成重载
       1.多个方法在同一各类中
       2.多个方法具有相同的方法名
       3.多个方法的参数不相同，类型不同或者数量不同
    方法重载特点
        1.重载仅对应方法的定义，与方法调用无关
        2.重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，不能通过返回值
        来判断两个方法是否构成重载
 */
public class MethodOverload {
    public static void main(String[] args) {
        System.out.println(sum(10,20));//调用时，Java虚拟机会通过参数不同来区分同名方法
        System.out.println(sum(10,20,30));
        System.out.println(sum(1.1,1.2));
    }
    public static int sum(int a,int b){
        return a + b;
    }
    public static int sum(int a,int b,int c){
        return a + b + c;
    }
    public static double sum(double a,double b){
        return a + b;
    }
}

方法重载练习

package cn.wang.method;
/*
使用方法重载，设计比较两个整数是否相等的方法，兼容全整数类型（byte,short,int,long）
 */
public class OverloadEquals {
    public static void main(String[] args) {
        //调用方法
        System.out.println(overloadEquals((byte) 10,(byte) 20));
        System.out.println(overloadEquals((short) 20,(short) 20));
        System.out.println(overloadEquals( 10,20));
        System.out.println(overloadEquals( 20L,20L));
    }
    //定义方法
    public static boolean overloadEquals(byte a,byte b){
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
    public static boolean overloadEquals(short a,short b){
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
    public static boolean overloadEquals(int a,int b){
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
    public static boolean overloadEquals(long a,long b){
        if (a == b){
            return true;
        }else {
            return false;
        }
    }
}

方法参数传递基本、引用类型

package cn.wang.method;
/*
方法参数传递
    对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
    对于引用数据类型的参数，形式参数的改变，会影响实际参数的值

 */
public class ArgsMethod {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);//100
        change(number);
        System.out.println("调用change方法后：" + number);//100
        int arr[] = {100,20,30};
        System.out.println("调用change方法前：" + arr[0]);//100
        change2(arr);
        System.out.println("调用change方法后：" + arr[0]);//200
    }
    public static void change(int number){
        number = 200;
    }
    public static void change2(int[] arr){
        arr[0] = 200;
    }
}

数组遍历

package cn.wang.method;
/*
设计一个方法用于数组遍历，要求便利的结果是一行上的，例如：[11,22,33,44,55]
 */
public class MethodTraversal {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        //调用方法
        methodTraversal(arr);
    }
    //创建方法
    public static void methodTraversal(int[] arr){
        //遍历数组，并按要求打印
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                System.out.println(arr[i] + "]");
            }else if(i == 0){
                System.out.print("[" + arr[i] + ",");
            }else {
                System.out.print(arr[i] +",");
            }
        }
    }

}

数组最大值

package cn.wang.method;
/*
设计一个方法用于获取数组中元素的最大值，调用方法并输出结果
 */
public class ArrayMax {
    public static void main(String[] args) {
        int[] arr = {15,56,23,72,1};
        int number = arrayMax(arr);
        //调用方法,并输出结果
        System.out.println("Max:" + number);
    }
    //创建方法
    public static int arrayMax(int[] arr){
        int max = arr[0];
        //遍历数组，取得数组中元素最大值
        for (int i = 1; i < arr.length; i++) {
            max = max > arr[i] ? max : arr[i];
        }
        return max;

    }
}

习题

第一题：分析以下需求，并用代码实现(每个小需求都需要封装成方法)

1.求两个整数之和
2.求两个小数之和
3.判断两个整数是否相等
4.判断两个小数是否相等
5.获取两个整数中较大的值
6.获取两个小数中较大的值
7.获取两个整数中较小的值
8.获取两个小数中较小的值
9.用一个方法获取两个整数中较大的值或较小的值

第二题：

1.定义方法public static boolean isSXH(int num)，
	功能:判断数字num是否是水仙花数,如果是返回true,如果不是返回false。
2.在main方法中调用该方法，传入数字，打印结果。(所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。)
	打印：传入数字153，结果为true，该数字是水仙花数。

昨日习题答案

第一题：分析以下需求并实现

1.看程序说结果，请不要提前运行

public class Test03_01 {
	public static void main(String[] args) {
		int[] arr1 = {1,2,3,4,5};
		int[] temp1 = arr1;
		int[] temp2 = arr1;
		System.out.println("通过temp1取出数组值: ");
		
		for(int i = 0;i<temp1.length;i++) {
			System.out.print(temp1[i]+" ");
		}
		//通过temp1取出数组值:
		//1 2 3 4 5
		System.out.println();//换行
		System.out.println("通过temp2取出数组值: ");
		for(int i = 0;i<temp2.length;i++) {
			System.out.print(temp2[i]+" ");
		}
		//通过temp2取出数组值:
		//1 2 3 4 5
		System.out.println();
		temp1[2] = 9;
		
		System.out.println("通过temp1取出数组值: ");
		for(int i = 0;i<temp1.length;i++) {
			System.out.print(temp1[i]+" ");
		}
		//通过temp1取出数组值:
		//1 2 9 4 5
		System.out.println();
		System.out.println("通过temp2取出数组值: ");
		for(int i = 0;i<temp2.length;i++) {
			System.out.print(temp2[i]+" ");
		}
		//通过temp2取出数组值:
		//1 2 9 4 5
		System.out.println();
		
	}
}

第二题：分析以下需求并实现

1.看程序说结果，请不要提前运行

public class Test03_02 {
		public static void main(String[] args) {
			int[] arr1 = {1,2,3,4,5};
			int[] arr2 = {5,6,7};
			int[] temp = arr1;
			
			System.out.println("通过temp取出arr1中的元素: ");
			
			for(int i = 0;i<temp.length;i++) {
				System.out.print(temp[i]+" ");
			}
			
			//1 2 3 4 5
			
			temp = arr2;
			
			System.out.println("通过temp取出arr2中的元素: ");
			
			for(int i = 0;i<temp.length;i++) {
				System.out.print(temp[i]+" ");
			}
			//5 6 7
		}
	}

第三题:

1.定义一个长度为10的int类型数组，元素值使用随机数生成（范围为50-80）
2.打印该数组中满足个位和十位不包含7的元素。

public class Test4 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int start = 50;
        int end = 80;

        Random r = new Random();
        int ge = 0;
        int shi = 0;
        for (int i = 0; i < arr.length; i++) {
            //给数组随机赋值
            arr[i] = r.nextInt(end - start + 1) + start;
            ge = arr[i] % 10;
            shi = arr[i] / 10;
            if (ge != 7 && shi != 7) {
                System.out.println(arr[i]);
            }
        }
    }
}

第四题：分析以下需求并实现

1.定义一个用于存放班级分数的数组 int[] score;数组长度为5，并使用随机数（范围为0-100）为数组赋值
2.求出班级不及格人数(分数低于60分的就是不及格)
3.求出班级的平均分
4.求出班级的总分数

public class Test5 {
    public static void main(String[] args) {
        int[] score = new int[5];
        Random r = new Random();
        double sum = 0;//记录总分数
        int count = 0;//记录不及格人数
        for (int i = 0; i < score.length; i++) {
            score[i] = r.nextInt(100) + 1;//保证有100
            if (score[i] < 60) {
                count++;
            }
            sum += score[i];
        }
        System.out.println("班级不及格人数：" + count);
        System.out.println("班级总分：" + sum);
        System.out.println("班级平均分：" + (sum / score.length));
    }
}