java 函数

1,  break  continue

break在嵌套中的作用结束本层循环
continue在嵌套中作用跳出本次循环执行下次循环

for (int i=0 ;i< 10;i++){

     if(i==8){

         continue;     //break;

}System.out.println("");

}

    反着输出100-0,第一进来的分支语句值即max可停止循环

int max1=1;
        for (int i=100;i>0;i--) {
            if (i % 7 == 0) {
                max1 = i;
                break;
            }
            
        }System.out.println(max1);

2 随机数

Math   [0,1)随机小数;

公式: *(最大值-最小值+1)+最小值

如[5,10)随机数

Math.random()*5+5

[5,10]随机整数

(int)(Math.random()*(10-5+1)+5)

生成{0,1)随机小数

double number = Math.random();
        System.out.println(number);

输出[55,100]10个随机整数,打印最大值

int num =(int) (Math.random()*(10-8+1)+8);
            System.out.println(num);
            int mux = 1;
            for (int i = 0; i < 10; i++) {
                int number = (int)(Math.random()*(100-55+1)+55);
                System.out.println(number);
                if(mux < number) {
                    mux = number;
                }
            }System.out.println("max是"+mux);

函数

函数的定义:封装了特定功能的代码块

函数的好处:方便实用,节约效率,减少大量code重复编辑时间

函数结构:  函数返回值类型 函数名(参数类型 参数1,参数类型 参数2,~~~){

                              函数语句;

                               return 返回值;

}

函数书写在类中,在函数中只能调用其它函数,但不可以定义其它函数

函数中的返回值是否需要根据需求来定

如调用函数后要对返回结果进行操作,需要待返回值的函数

如果仅是打印结果则不需要返回值

函数编写的步骤

1,确定编写的函数有误返回值

2,确定编写的函数有无参数

同一个类中的函数是可以重名的

函数的重载

函数是不是重载,只跟函数的参数有关(参数的个数,参数类型,参数顺序)

与参数名和返回值无关

定义求和sum函数

public static int sum(int a , int b) {
        int rel = a + b;
        return rel;

主函数调用sum求和

public static void main(String[] args) {
        //函数的调用
        int rel = sum(4, 6);
        System.out.println(rel );
        
    }

函数重载练习

计算2,3,4,5个数的最大值

public class Demo04 {
    public static int max (int a ,int b) {
           if (a<b) {
            a = b;
        }
        return a;
        
    }
    public static int max(int a ,int b, int c
            ) {int number= max(a, b);
        return (number>c)? number:c;
        }
    
    //遇到新功能
    public static int max(int a, int b ,int c ,int d) {
        int number = max(a, b, c);
        return (number >d)?number :d;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        int kk= max(1 , 2, 3, 4);
        System.out.println(kk);
        

    }

}

递归

在函数内部,调用一个与自己功能一样函数
     * 注意递归函数必须要有出口,否则无法停掉程序

public static int fun (int a) {
        if(a==1) {
            return 1;
        }
        return a*fun(--a);
    }
    
    public static void main(String[] args) {
        int a = 1;
        for (int i = 1; i <= 4; i++) {
            a = a* i;
        }System.out.println(a);
        int sk=fun(4);
        System.out.println(sk);
        

    }

}

数组

数组的定义:相当于容器,存放了一组相同类型的数;

数组声明规范    int[] array = new int [5];

//int [] array = new int[5];
        //数组的声明方式2
        //直接声明数组中保存的值
        //打印数组中所有值,遍历数组
        //array.length 数组的长度
        //Arrays.toString(array)将数组转化成字符传输出
        /*int [] array = new int[] {1,3,5,7,9};
        System.out.println(array[1]);
        //打印数组中所有的值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println(Arrays.toString(array));*/

//声明长度为5的整形数组
        //数组的长度一旦声明,就不能改变
        //执行完毕,立即释放(系统释放,不用人处理)\
        //int[] array = new int [5];
        //new代表在堆内存中开辟空间,数组实在堆内存中开了一片连续的空间
        //堆内存特点:1,有初始值 2,有内存地址3堆内存的垃圾回收机制
        //数组中取出一个值,     数组名 [角标]
        //int[array]保存的首地址
        //array=null;//array指向一个空的地方
            //NullpointerException空指针异常访问了一个可能不存在的区

//随机10个数随机区间[15,150]
        //1,十个数放入数组中 2打印最大值
        //注意:数组方面的问题都和遍历有关
        int[] array = new int[10];
        for (int i = 0; i < array.length; i++) {
            int num = (int)(Math.random()*(150-15+1)+15);
            array[i]=num;
        }System.out.println(Arrays.toString(array));
        int max=0;
        for (int i = 0; i < array.length; i++) {
            if (max<array[i]) {
                max=array[i];
            }
        }
        System.out.println("max"+max);