Java中的Math类(随机数)和函数

Java中的Math类(随机数)和函数及函数的重载

Math类(随机数)

    Math中,随机数的代码是:random.
    也就是 Math.random();
    这时一个 返回的是[0,1)double类型的值
    是一个伪随机数
    伪随机数就是按照一定规则去随机的数
    当需要打印多少范围到多少范围直接的随机整数时,会运用到一条公式
    公式:
    (最大值 - 最小值 +1 ) + 最小值
    
    例如:
    //打印[5-10]的随机整数
    int num = (int)(Math.random() * 6 + 5);
    //random本是double类型的,如果想打印整数类型(int)就需要将它强制转换成int类型
    //这里的步骤 就是强制转换
    
    //这里的* 6 + 5  是由 (10 - 5 + 1) + 5 这么来的
    //也就是套用公式
    
    System.out.println(num);
    
    //需求:随机20个[10-300]之间的数 打印最大值
		
	int max = 0;
	for (int i = 0; i < 20; i++) {
		int num =(int) (Math.random()*291 + 10);
			if (max < num) {
				max = num;
			}
		}
		System.out.println(max);

函数

    Java中的函数是 : 封装了特定功能的代码块
    Java中的函数大部分是已经配备各种功能的代码块,可以直接用,如果你要自己写函数,也是可以的.
    
    函数的优点:方便使用,减少你的重复代码书写
    
    函数的写法:
                                参数列表
    关键字 返回值类型 函数名(参数类型 参数1, 参数类型 参数2,...){
        函数中的语句1;
        语句2;...
        //return后面返回的 返回值 要跟函数的返回值类型 对应
        return
    }
    
    函数的书写位置:在类中书写
    
    函数的分类:
    1.无参数 无返回值 的 函数
    2.有参数 有返回值 的 函数
    3.无参数 有返回值 的 函数
    4.有参数 无返回值 的 函数
    
    例如:(无参数无返回值)
    //(  关键字  ) (返回值类型)   (函数名)
    public static       void     printHW(){
    //  (           函数中的语句       )
        System.out.println("HelloWorld")
    }
    
    函数的调用:
    使用 函数名(传入的参数);
    
    编写函数的步骤:
    1.确定函数有没有返回值
    (接下来 是否要使用这个返回值 根据实际情况考虑)
    (如果没有返回值 返回值类型 使用 viod)
    
    2.确定函数有没有参数 有的话 是几个 都什么类型
    
    例如:
    //需求: 编写 计算两个整数的和 的 函数
    public static void main(String[] args) {
	printHW();//调用
	//有返回值的函数 不接收返回值也行
	int a = sum(5, 10);//调用
	System.out.println(a);
	int i = sum(1, 2, 3);
	System.out.println(i);
	}
	
	public static int sum(int a, int b) {
		return a + b;
	}
	
	//需求 编写 计算三个整数的和 的函数
	public  static int sum(int x, int y, int z) {
		int i = x + y + z;
		return i;
	}
	
	当写完函数后 要在 main 还函数中 调用

函数的重载

    函数的重载有什么用?
    需要站在使用者的角度去考虑问题 可以让使用者使用的更方便
    
    函数的重载:实现相同的功能 但是函数的内部实现不同
    函数的重载 是 函数名字相同 并且只跟参数有关
    (参数的类型 参数的顺序 参数个数 有关)
    跟参数的返回值 无关
    
    参数的类型:
    public static int sum(int a, double b){
        
    }
    public static int sum(int a, char b){
        
    }
    参数的顺序:
    public static int sum(int a, double b){
        
    }
    public static int sum(int b, double a){
        
    }
    参数个数
    public static int sum(int a, double b){
        
    }
    public static int sum(int a){
        
    }
    
    这些都是函数的重载
    
    例如:
    /*编写下列函数  函数重载的练习
 *  计算两个数的最大值
 *  计算三个数的最大值
 *  计算四个数的最大值
 *  计算五个数的最大值
 */
	public static void main(String[] args) {
		System.out.println(sum(1, 2));
		System.out.println(sum(1, 2, 3));
		System.out.println(sum(1, 2, 3, 4));
		System.out.println(sum(1, 2, 3, 4, 5));
	}
	public static int sum(int a, int b) {
		int max = ( a > b ) ? a : b;		
		return max;
	}
	public static int sum(int a, int b, int c) {
		int max = sum(a, b);
		return (max > c) ? max : c;
	}
	public static int sum(int a, int b, int c, int d) {
		int max = sum(a, b, c);
		return (max > d ) ? max : d;
	}
	public static int sum(int a, int b, int c, int d, int e) {
		int max = sum(a, b, c, d);
		return (max > e ) ? max : e;
	}
    
    各个函数的函数名可以相同

递归函数

    递归函数就是调用一个和自己函数名相同的函数
    也就是自己调用自己
    
    例如:
    //编写 计算4的阶乘的函数
    
    public static void main(String[] args) {
	    fun(4); //调用函数
	    System.out.println(fun(4));
	}
	public static int fun(int i) {
		//递归出口(停止递归)
		//没有出口 相当于死循环
		if (i == 1 ) {
			return 1;
		}else {
			return i * fun(i - 1);//调用前一次自己的值 和这一次自己的值 相乘
		}
	}

                                                                  Day.4