java入门04

java入门04

break 和 continue

break 和 continue 再循环中的作用

break作用 跳出(结束)循环

//注意：break跳出循环 在break对的后面写任何代码
        //都不会执行 所以没有意义  报错
        //如果break 在分支语句当中 那么break的后面可以写代码
        //因为这个分支语句 有可能不被执行
        // continue作用
        // 立即结束本次循环 继续执行下次循环
        /*
        for(int i=0;i<10;i++)
        {
            if (i==8) {
                continue;

            }
            System.out.println(i);



        }*/

continue 和 break的区别

举例

//打印[0, 100]中是7的倍数中的值最大那个数
        // 反着输出100-0
        // 这是可以直接停止循环
        // 
        int max=0;
        for (int i = 100; i>=0; i--) {
            if(i%7==0)
            { 
                max=i;
                System.out.println(max);
                break;
            }

        }

//班级11个人和每个人打招呼 讨厌的人不打招呼
        //我讨厌的 3 号 5号 9号
        for (int i = 1; i <=11; i++) {
            if(i==3||i==5||i==9)
            {
                continue;
            }
            System.out.println(i+"号你好");


        }

在嵌套for循环中break 和 continue的作用是啥？

// break在嵌套中作用:结束(跳出)当前(本层)的循环
        for (int i = 0; i <10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==2)
                {
                    break;
                }
                System.out.print(j);
            }
            System.out.println("----------------");
        }

// continue嵌套中的作用:跳出本次循环 继续执行下一次循环
        for (int i = 0; i <10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==2)
                {
                    continue;
                }
                System.out.print(j);
            }
            System.out.println("----------------");
        }

for的死循环怎么表示？

for(;;) {
            System.out.println("1");
        }

随机数

math 的随机数

[0,1)的数

公式

Math.random()*(最大值 -最小值 +1)+最小值

举例：

// 随机[15,200]得整数 10个  找出最大值

      int max=0;
      for (int i = 0; i < 10; i++) {
          //注意 :你要知道 循环体中些什么内容
          int num= (int)(Math.random()*(200-15+1)+15);
          System.out.println(num);

          if(num>max)
          {
              max=num;
          }

    }
         System.out.println("max="+max);
   }
}

函数

函数(方法 功能)
* 函数的定义：封装的 特定功能 代码块
*
* 函数的好处：方便使用提高了写代码的效率
* 减少了大量重复代码的编写
*
* 函数的结构：
* 关键字 函数的返回值类型 函数名(参数类型 参数1，参数类型 参数2，…) 参数列表
* {
* 函数中的语句
* return 返回值；
* }
*
* 函数的书写位置 :
* 注意 ：一定要写在类中(只有类中 才能写函数)
* 思考: 函数中 能不能 写函数？ 不能

• 注意:函数写不写 返回值 是根据你的需求 如果 调用玩 函数 你要对返回的结果进行操作
• 可以使用带返回值的函数

• 如果仅仅是打印结果 那么可以写不带返回值的参数

• 函数的分类；

• 1.有参数 又返回值
• 2.有参数 没返回值
• 3.没参数 有返回值

• 4.没参数 没返回值

• 函数编写的步骤；

• 1.确定编写的函数 有没有 返回值 返回值的类型是什么

• 2.确定编写的函数 有没有参数 参数是几个

• 思考同一个类中 函数可不可以同名？可以

举例：

需求编写一个 求两个数的 和的函数

public static int sum(int a,int b) {
        int rel =a+b;
        System.out.println(rel);
        return rel;

    }
public static void main(String[] args) {
        //函数的调用

        sum(5,8);
    }

打印一个3行4列的矩形的函数

public static void rectangle(int x,int y) {
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                System.out.print("*");
            }
            System.out.println();

        }
public static void main(String[] args)
{
    //函数的调用
    rectangle();
}

函数的承载

函数重载：参数名相同 参数不能相同

注意：函数是不是重载 只跟函数的 参数 有关

（跟参数个数 参数类型 参数顺序 有关 跟 参数名 无关 跟 返回值 无关）

把相同的功能 但是 参数 和 内部实现不同的 函数 起相同的名字 的函数

是函数的的重载

原函数

public static void fun(int a,char b,double c){}

不是函数的重载 跟参数名无关

不是

public static void fun(int x,char y,double z){}

是

public static void fun(int x,char y){}

需求： 定义函数

1.计算两个数的最大值

2.计算3个数的最大值

3.计算4个数的最大值

// 计算两个数的最大值
public static int max(int a, int b)
{
    int max=(a>b)? a:b;
    return max;
}
// 计算三个数的最大值
public static int max(int a, int b，int c）
{
    int max=(max(a,b)>c)? max(a,b):c;

    return max;
}
// 计算四个数的最大值
public static int max(int a, int b, int c, int d)
{
    int max=(ma(a,b,c)>d)? max(a,b,c):d;
    return max;
}

递归函数

递归函数(不要求你掌握)

在函数内部 调用一个 跟自己功能一样的函数(自己调自己)

注意 递归 函数 必须要有出口 否则无法停掉程序

例题：
计算 4的阶乘 1 * 2 * 3 *4

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

数组

数组的定义:数组相当于 一个容器 存放可一组 相同类型 的数据

数组存放的规则:是以 下标(角标)来存放的 并且下标从0开始

变量的声明:

数据类型 变量名 =初值;

数组声明的规范:

数据类型[] 数据名 =初值；

这个数据类型指的是数据中存放的数据 的类型

//声明了一个长度为5 的整型数组
        //注意：数组的长度 一但声明 就不能改变
        // 数组实在堆内存中开辟了一块 连续的空间
        int[] array =new int[5];
        // 在数组中取出一个值 数组名[角标]
        // ArrayIndexOutOfBoundsException 数组下表越界
        array[3]=10;
        System.out.println(array[3]);
        // array 指向一个空的地方
        //array=null;
        //NullPointerException 空指针异常
        // 访问了一个可能不存在的区域
        System.out.println(array);

这里有张图帮助 理解数组

数组的遍历

注意 ：数组方面的问题都离不开遍历

//数组的声明方式二(语法糖)
        //直接声明 数组中保存的值
        int[] array =new int [] {1,2,3,4,5};
//打印数组中所有的值 -----便利数组
        // array.length 数组的长度

        for(int i =0;i<array.length;i++)
        {
            System.out.println(array[i]);
        }
// 将数组 转化成字符串来输出
        System.out.println(Arrays.toString(array));

例题：
随机10个数 随机的区间是[15,150]

1.把这个10个数放入数组中

2.打印最大值

        int []ss=new int[10];
        int max=0;
        for (int i = 0; i < ss.length; i++) {
            ss[i]=(int)(Math.random()*(150-15+1)+15);//把数据放入数组对应的位置中
            System.out.println(ss[i]);
        }
        for (int i = 0; i < ss.length; i++) {
            if(ss[i]>max) {
                max=ss[i];
            }

        }
        System.out.println("max="+max);