语言：人与人交流沟通的表达方式
计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言
Java之父：詹姆斯·高斯林（James Gosling）
2009年，Sun公司被甲骨文公司收购


JDK  java开发工具包
        JRE  java运行环境
        JVM  java虚拟机

        JDK > JRE > JVM

         编写源代码
                        结尾：.java
         编译代码
                  命令： javac 代码.java
                  编译会生成一个代码.class的二进制文件
         运行代码
                  命令： java  代码
                  
java基础语法****                  
                  
        注释： 解释说明代码的功能  不参加运行

                        单行注释：  //
                        多行注释： /*多行注释*/


        关键字：
       
                 被java赋予特殊含义的单词
                 特点： 都是小写字母
                 注意：以及被java使用了 我们不能定义成其他的内容了
                 
                 
        常量： 在运行期间 值不能发生改变的量       
          
                字符串常量  "双引号括起来的内容 称之为字符串"  
                 
                整数常量： 1 2 35555  666666    9999999
                 
                小数常量： 3.14  
               
                字符常量： '1'  'A'  '3'
               
                布尔常量： true  false
               
                空常量： null
                 
        数据类型:
       
        字符串

      整数：    byte   short   int   long
      浮点数：  float   double
      字符型：  char
      布尔型：        boolean
       
            byte 范围： -128~127
                int  范围： 2的31次方 大概值 21亿
                char 范围： 65535
       
            整数默认类型是 int
                浮点数默认的类型是 double
               
    变量：
       
       定义格式：
          
                  数据类型        变量名 = 数据值;   int num = 98;
                          数据类型 变量名; 变量名 = 数据值; int  num; num = 60;  
                          
           变量使用的注意事项：
             1.变量名不能重复
                 2.变量要给初始值否则不能使用
                 3.long类型定义的时候 值加上 L （默认类型 int）
                 4.float类型 默认的类型是 double 类型 后面加上F 表示float
                 
        标识符：见名知意
       
       组成：数字 字母        下划线 _ [美元符 $ 能不用则不用]
                         不能以数字开头
                         不能是关键字
                       
          小驼峰命名： 首字母小写其他每个单词的首字母大写  firstName 主要用在 方法名  变量名
          大驼峰命名： 每个单词的首字母大写   FirstName     类
          
        数据类型转换：

      自动类型转换：从数据范围小的数据类型转换成数据范围大的数据类型  不需要我们操作

             强制类型转换：从数据范围大的数据类型转换成数据范围小的数据类型
                       出现问题： 精度丢失  数据溢出
                   
            算数运算符：
     + - *
         
         '/'  整除 使用的两个整数相除 结果还是整数  
         
         %  取模（取余数） 一般只针对整数才有效果
         
         两个数据类型进行运算 结果类型是数据范围较大的一方
         
          +操作：
         
          byte short char 进行运算的时候 把提升成int类型 再进行计算
    错误的案例：
         /* byte num1 = 3;
            short num2= 30;
            short num3 = num1 + num2;

          */
          
          字符串的+操作：
             字符串的拼接 （字符串可以使用+号拼接任意类型的数据）
                 注意：拼接顺序从左到右   
                 8+80+"hehe"+1
                 "hehe"+80+90
               
        赋值运算符：
            int num = 10;  num += 10; ==> num = num +10;
               
                byte num1 = 2;
                byte num1 = num1+1;//出现问题 最终的结果是int类型
                byte num1 +=1; //相当于 byte num1 = (byte)(num1+1);
               
                 int num = 10;  num %= 2; ==>num = num%2;
               
        /*        int a = 10;  //雪碧
        int b = 20;  //可乐
        System.out.println("a:" + a);
        System.out.println("b:" + b);

       int temp = a;//空杯子
        a = b;
        b = temp;
        System.out.println("a:" + a);
        System.out.println("b:" + b);*/
               
        自增自减：
       最多的用的地方 单独使用：前++ 和后++ 效果一样       
           如果不是单独使用：
               ++前  先加1 再进行运算
                   后++  先使用 再加1
               
        关系运算符：
        得到的结果都是布尔类型的；
        > <  >=  <=         ==  !=
        符号都是英文状态下
        >= ,<=        满足任意一个条件 > 或者是 等于 返回值为 true       
                != 返回值 只有在不相等的情况下返回 true
               
        逻辑运算符：
       
       &  逻辑与 只有全部为 true 结果才为 true 其他为 false
       |  逻辑或 只有全部为 false 结果才为 false 其他都为 true
           ^  逻辑异或 相同为 false 不同为 true  
           !  逻辑非  true  !true  ==> false
                 
               
       && 短路与  遇到第一个为 false 的值之后将不在执行后面的内容               
           || 短路或  遇到第一个为 true 的值之后将不在执行后面的内容  
               
                /*
                  int i1 = 5;
        boolean result = (i1++ > 5) && (++i1 > 4);
        System.out.println(result);//false
        System.out.println(i1); // 6
               
                int i2 = 5;
        boolean result = (i2++ > 5) || (++i2 > 4);
        System.out.println(result);//true
        System.out.println(i2); //7
                */
               
        三元运算符：
             
                 关系表达式 ? 表达式1:表达式2;
                 
                 执行流程： 执行关系表达式返回值 true 执行 表达式1 否则 执行 表达式2
                 int a=10;
                 int b =20;
                  a > b ? a:b;
               
        键盘输入：
           导包：            import java.util.Scanner;
                   创建对象：  Scanner scanner = new Scanner(System.in);
                   接受数据：  int x = sc.nextInt();
               
               
         流程控制语句：

          顺序结构：从上往下依次执行；
          分支结构： if        语句
                     if(关系表达式){
                                语句体;
                         }
                     关系表达式结果如果是 true 语句体执行 否则不执行
                         
                 if语句的标准格式：
                         if(关系表达式){
                                语句体1;
                         }else{
                                语句体2;
                         }
                        先执行关系表达式，如果表达式结果为 true 执行语句体1 否则执行语句体2
                       
                        转换成三元运算符
                       
                if语句的扩展格式：
                     if(关系表达式1){
                                语句体1;
                         }else if(关系表达式2){
                                语句体2;
                          ...
                                 
                         }else{
                                语句体n;
                         }
                         
                 先执行关系表达式 执行到第一个符合条件的表达式 执行其对应的方法体
                  多者选其一
                  
                  输入一个数据：
                   判断 属于大写字母 ，小写字母，数字
                  
                  switch 语句：

    switch(表达式){
                case 值1:
                 语句体1;
                 // break;
                case 值2:
                 语句体2;
                  break;
                case 值3:
                 语句体3;
                  break;
                  ...
                  
                default:
                  语句体;
                  break;
               
        }
       
        switch语句的注意点：
          1.表达式的内容： byte short int char  枚举  String
          2.case 穿透 如果case语句后面没有跟 break 会继续执行下一个选项的内容 直到遇到第一个 break为止
          3.case语句 顺序没有要求 default 可以任意放置 但是 写上 break ；
          4.case 值 不能重复
          
        switch 语句 和 if..else 扩展格式 区别：
       最大的区别：  switch 效率高 占内存   if...else 效率低 灵活性高        
          
for 循环：

    ①初始化语句     在程序开始的时候会执行一次  
        ②条件判断语句
        ③ 循环体
        ④ 步进语句
         
         格式：
             for (①初始化语句;②条件判断语句;④ 步进语句  ){
                             ③ 循环体;
                   }
                  
                   ①->②->③->④->②->③->④->②...
       
            结束：②条件判断语句 返回值为false 停止循环
       
       
        逢7过 （统计过的个数）代码：
       /*   
        int count = 0;

        for (int i = 1; i < 100; i++) {
            // 是7的 倍数
            //个位或者是十位 为7
            int ge = i % 10;
            int shi = i / 10;

            if (i % 7 == 0 || (ge == 7 || shi == 7)) {

                System.out.println(i);
                count++;      
            }
        }
        System.out.println("count:" + count);                  
          */
          
          
while 循环格式：


                 ①初始化语句
                 while(②条件判断语句){
                           ③ 循环体
                           ④ 步进语句
                 }          
         
           ①->②->③->④->②->③->④->②...
          
          结束：②条件判断语句 返回值为false 停止循环
          
          
do .. while 循环：
          
             ①初始化语句
          do {
                 ③ 循环体
                 ④ 步进语句   
          }while(②条件判断语句);
          
          ①->③->④->②->③->④->②...
         
         结束：②条件判断语句 返回值为false 停止循环
         特点：第一次执行 无论条件判断为true或者false 都会先执行一次
          
        三种循环的区别：

     do...while 无论条件是否成立 都会执行一次
     for 循环 使用 明确循环次数
         while 循环 不明确循环次数
         
         如果死循环 用 while(true){ 循环体}
         
        continue 作用 跳过某一次循环 后面的内容继续执行
       
        break 为终止当前的循环 后面的内容不再继续执行
          
          
         Random random = new Random();
          int i =random.nextInt(10);// 随机出 0-10之间的数据  包括0 不包括10
          
          获取指定范围的数据  90-100 包含90和100   random.nextInt(100-90+1)+ 90;
          
快捷键  
    ALT + ENTER  遇到代码有问题 直接使用这个组合键
       
数组：
    变量  数据类型 变量名 = 值;
       
    存储多个 相同数据类型的 元素
       
         int[] arr;
         数据类型 [] 数组名;
       
        数组的动态初始化：只要有数组的长度和数据类型 就可以创建
           格式：
          
           数据类型 [] 数组名 =  new 数据类型[数组长度];
               int [] arr  =  new  int[10];
                 
                数组元素访问的格式：
                    数组名[索引];
                       
                        arr[0]; //第一个元素
                       
                        索引 元素在数组中的编号 从0开始
                       
                        系统默认的 根数据类型给相关的默认值
                       
                给数组元素赋值：

            数组名[索引] = 数据值;               
                       
        静态初始化：
         需要知道数组的内容

              数据类型 [] 数组名 =  new 数据类型[]{元素1,元素2,元素3,...};
           int [] arr = new int[]{1,3,6,7,8,9,0};       

        静态的省略格式：(进行操作的时候 也有new的这个步骤)
            数据类型 [] 数组名 =  {元素1,元素2,元素3,...};   
            int [] arr = {1,2,4,5,6};       

         基本数据类型  4类8种               
          引用数据类型默认值 就是 null                 
                       
        异常：

       NullPointerException  空指针异常  
               数组的值变成 null 要访问数组里面的元素
          
           ArrayIndexOutOfBoundsException  数组索引超出界限异常
              数组的索引超出了数组的范围

    遍历：
            如何求出数组的长度：
                        arr.length;
                               
                for(int i= 0;i<arr.length;i++){
                        System.out.println(arr[i]);
                }
方法：
    方法只有存在 才能使用
        方法创建好了 不会直接运行 需要手动调用才能运行
       
    基础方法的定义格式：
           public static void 方法名(){
                  
                   方法体;
           }
          
        基础方法的调用格式：
                方法名();
                       
        带参数的方法的定义格式：
       
           public static void 方法名(参数类型 参数名1,参数类型 参数名2,参数类型 参数名3,...){
                   方法体;
           }
       
        带参数的方法的定义格式：
               方法名(值1,值2,值3,值4.....);
                  
    参数对于方法来讲 增加了方法的灵活性
       
        形参  形式上的参数     方法定义时使用
        实参  实际传递的参数   方法调用的时候使用
       
        带参数带返回值的方法的定义格式：
          
             public static 返回值类型 方法名(参数列表){
                         
                         方法体;
                        [return 数据值;] //如果返回值是void 不需要这句
                 }
       
        返回值类型  void 表示什么都不返回
                    其他： 可以是任意的数据类型
                               
                    需要写上  return 数据值;
       
        方法的注意事项：
            1.方法不能嵌套定义
                2.返回值 void 不能写 return 值;  void后面可以跟 return; 但能return后面不能再写具体的值
                   return 表示返回 方法执行到此处后结束
                   如果不是 void  必须得写上 return 值;
            3.方法的调用 三种  单独调用  赋值调用（最常用的） 打印调用
                 CTRL + ALT + V 方法的返回值自动帮我们生成
       
        定义一个方法的要求：
       
            1.返回值类型 必须得明确
                2.参数列表 必须明确
               
                建议：写方法的时候 最好是能把方法的具体功能写上
               
方法重载：

        1.必须在同一个类中
        2.方法名要求必须相同 参列表不同  
                 参数列表不同  1.数据类型不同  2.参数数量不同 3.多个参数的先后顺序不一样

         方法重载和什么没有关系：
               1.返回值类型无关
                           2.和参数名称无关
                          
            
                基本数据类型作为方法的参数 传递的是变量的值
                引用数据类型作为方法的参数 传递的是地址值
        Debug过程:
    1.打断点 鼠标左键 点击需要断点的位置
        2.以debug模式运行
        3.查看debug模式下 各个变量的值
        4.  step over 下一步   step into 进入方法里面
          
基础回顾:
     if
           单if语句  符合条件才会执行
           if..else 标准格式 两者选其一
           if..else if..else...  扩展格式  多者选其一
          
        switch:
            switch(表达式){
                        case 值1:
                          语句体;
                          //break;
                        case 值2:
                          语句体;
                          break;

                        default:
                         语句体;
                         break;               
                }
                表达式的类型: byte short int char  枚举enum  String
                 case后面值 不能重复
                 case 穿透: case语句后面的break丢失 会造成 继续执行下一个语句体
                 case 语句 先后顺序 是可以颠倒的
                 
                逢七过:改  要求把剩余的数据 按照每行5个进行排列打印出
                /*
                   public static void main(String[] args) {
                                        int count = 0;
                                        for (int x = 1; x <= 100; x++) {
                                                //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
                                                if (x % 10 == 7 || x / 10 % 10 == 7 || x % 7 == 0) {
                                                        continue;
                                                } else {
                                                        count++;
                                                        if (count % 5 == 0) {
                                                                System.out.println(x);

                                                        } else {
                                                                System.out.print(x + "\t");
                                                        }

                                                }
                                        }

                                        System.out.println("count:"+count);
                                }
                */
                判断一个数据是否是质数:
       /*
                          public static boolean isZhi(int num) {

                                        for (int i = 2; i <= num; i++) {
                                                if (i != num && num % i == 0) {
                                                        return false;
                                                } else if (i == num) {

                                                        return true;
                                                }

                                        }

                                        return false;
                                }          
                */                         
                 

  语言：人与人交流沟通的表达方式
计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言
Java之父：詹姆斯·高斯林（James Gosling）
2009年，Sun公司被甲骨文公司收购


JDK  java开发工具包
        JRE  java运行环境
        JVM  java虚拟机

        JDK > JRE > JVM

         编写源代码
                        结尾：.java
         编译代码
                  命令： javac 代码.java
                  编译会生成一个代码.class的二进制文件
         运行代码
                  命令： java  代码
                  
java基础语法****                  
                  
        注释： 解释说明代码的功能  不参加运行

                        单行注释：  //
                        多行注释： /*多行注释*/


        关键字：
       
                 被java赋予特殊含义的单词
                 特点： 都是小写字母
                 注意：以及被java使用了 我们不能定义成其他的内容了
                 
                 
        常量： 在运行期间 值不能发生改变的量       
          
                字符串常量  "双引号括起来的内容 称之为字符串"  
                 
                整数常量： 1 2 35555  666666    9999999
                 
                小数常量： 3.14  
               
                字符常量： '1'  'A'  '3'
               
                布尔常量： true  false
               
                空常量： null
                 
        数据类型:
       
        字符串

      整数：    byte   short   int   long
      浮点数：  float   double
      字符型：  char
      布尔型：        boolean
       
            byte 范围： -128~127
                int  范围： 2的31次方 大概值 21亿
                char 范围： 65535
       
            整数默认类型是 int
                浮点数默认的类型是 double
               
    变量：
       
       定义格式：
          
                  数据类型        变量名 = 数据值;   int num = 98;
                          数据类型 变量名; 变量名 = 数据值; int  num; num = 60;  
                          
           变量使用的注意事项：
             1.变量名不能重复
                 2.变量要给初始值否则不能使用
                 3.long类型定义的时候 值加上 L （默认类型 int）
                 4.float类型 默认的类型是 double 类型 后面加上F 表示float
                 
        标识符：见名知意
       
       组成：数字 字母        下划线 _ [美元符 $ 能不用则不用]
                         不能以数字开头
                         不能是关键字
                       
          小驼峰命名： 首字母小写其他每个单词的首字母大写  firstName 主要用在 方法名  变量名
          大驼峰命名： 每个单词的首字母大写   FirstName     类
          
        数据类型转换：

      自动类型转换：从数据范围小的数据类型转换成数据范围大的数据类型  不需要我们操作

             强制类型转换：从数据范围大的数据类型转换成数据范围小的数据类型
                       出现问题： 精度丢失  数据溢出
                   
            算数运算符：
     + - *
         
         '/'  整除 使用的两个整数相除 结果还是整数  
         
         %  取模（取余数） 一般只针对整数才有效果
         
         两个数据类型进行运算 结果类型是数据范围较大的一方
         
          +操作：
         
          byte short char 进行运算的时候 把提升成int类型 再进行计算
    错误的案例：
         /* byte num1 = 3;
            short num2= 30;
            short num3 = num1 + num2;

          */
          
          字符串的+操作：
             字符串的拼接 （字符串可以使用+号拼接任意类型的数据）
                 注意：拼接顺序从左到右   
                 8+80+"hehe"+1
                 "hehe"+80+90
               
        赋值运算符：
            int num = 10;  num += 10; ==> num = num +10;
               
                byte num1 = 2;
                byte num1 = num1+1;//出现问题 最终的结果是int类型
                byte num1 +=1; //相当于 byte num1 = (byte)(num1+1);
               
                 int num = 10;  num %= 2; ==>num = num%2;
               
        /*        int a = 10;  //雪碧
        int b = 20;  //可乐
        System.out.println("a:" + a);
        System.out.println("b:" + b);

       int temp = a;//空杯子
        a = b;
        b = temp;
        System.out.println("a:" + a);
        System.out.println("b:" + b);*/
               
        自增自减：
       最多的用的地方 单独使用：前++ 和后++ 效果一样       
           如果不是单独使用：
               ++前  先加1 再进行运算
                   后++  先使用 再加1
               
        关系运算符：
        得到的结果都是布尔类型的；
        > <  >=  <=         ==  !=
        符号都是英文状态下
        >= ,<=        满足任意一个条件 > 或者是 等于 返回值为 true       
                != 返回值 只有在不相等的情况下返回 true
               
        逻辑运算符：
       
       &  逻辑与 只有全部为 true 结果才为 true 其他为 false
       |  逻辑或 只有全部为 false 结果才为 false 其他都为 true
           ^  逻辑异或 相同为 false 不同为 true  
           !  逻辑非  true  !true  ==> false
                 
               
       && 短路与  遇到第一个为 false 的值之后将不在执行后面的内容               
           || 短路或  遇到第一个为 true 的值之后将不在执行后面的内容  
               
                /*
                  int i1 = 5;
        boolean result = (i1++ > 5) && (++i1 > 4);
        System.out.println(result);//false
        System.out.println(i1); // 6
               
                int i2 = 5;
        boolean result = (i2++ > 5) || (++i2 > 4);
        System.out.println(result);//true
        System.out.println(i2); //7
                */
               
        三元运算符：
             
                 关系表达式 ? 表达式1:表达式2;
                 
                 执行流程： 执行关系表达式返回值 true 执行 表达式1 否则 执行 表达式2
                 int a=10;
                 int b =20;
                  a > b ? a:b;
               
        键盘输入：
           导包：            import java.util.Scanner;
                   创建对象：  Scanner scanner = new Scanner(System.in);
                   接受数据：  int x = sc.nextInt();
               
               
         流程控制语句：

          顺序结构：从上往下依次执行；
          分支结构： if        语句
                     if(关系表达式){
                                语句体;
                         }
                     关系表达式结果如果是 true 语句体执行 否则不执行
                         
                 if语句的标准格式：
                         if(关系表达式){
                                语句体1;
                         }else{
                                语句体2;
                         }
                        先执行关系表达式，如果表达式结果为 true 执行语句体1 否则执行语句体2
                       
                        转换成三元运算符
                       
                if语句的扩展格式：
                     if(关系表达式1){
                                语句体1;
                         }else if(关系表达式2){
                                语句体2;
                          ...
                                 
                         }else{
                                语句体n;
                         }
                         
                 先执行关系表达式 执行到第一个符合条件的表达式 执行其对应的方法体
                  多者选其一
                  
                  输入一个数据：
                   判断 属于大写字母 ，小写字母，数字
                  
                  switch 语句：

    switch(表达式){
                case 值1:
                 语句体1;
                 // break;
                case 值2:
                 语句体2;
                  break;
                case 值3:
                 语句体3;
                  break;
                  ...
                  
                default:
                  语句体;
                  break;
               
        }
       
        switch语句的注意点：
          1.表达式的内容： byte short int char  枚举  String
          2.case 穿透 如果case语句后面没有跟 break 会继续执行下一个选项的内容 直到遇到第一个 break为止
          3.case语句 顺序没有要求 default 可以任意放置 但是 写上 break ；
          4.case 值 不能重复
          
        switch 语句 和 if..else 扩展格式 区别：
       最大的区别：  switch 效率高 占内存   if...else 效率低 灵活性高        
          
for 循环：

    ①初始化语句     在程序开始的时候会执行一次  
        ②条件判断语句
        ③ 循环体
        ④ 步进语句
         
         格式：
             for (①初始化语句;②条件判断语句;④ 步进语句  ){
                             ③ 循环体;
                   }
                  
                   ①->②->③->④->②->③->④->②...
       
            结束：②条件判断语句 返回值为false 停止循环
       
       
        逢7过 （统计过的个数）代码：
       /*   
        int count = 0;

        for (int i = 1; i < 100; i++) {
            // 是7的 倍数
            //个位或者是十位 为7
            int ge = i % 10;
            int shi = i / 10;

            if (i % 7 == 0 || (ge == 7 || shi == 7)) {

                System.out.println(i);
                count++;      
            }
        }
        System.out.println("count:" + count);                  
          */
          
          
while 循环格式：


                 ①初始化语句
                 while(②条件判断语句){
                           ③ 循环体
                           ④ 步进语句
                 }          
         
           ①->②->③->④->②->③->④->②...
          
          结束：②条件判断语句 返回值为false 停止循环
          
          
do .. while 循环：
          
             ①初始化语句
          do {
                 ③ 循环体
                 ④ 步进语句   
          }while(②条件判断语句);
          
          ①->③->④->②->③->④->②...
         
         结束：②条件判断语句 返回值为false 停止循环
         特点：第一次执行 无论条件判断为true或者false 都会先执行一次
          
        三种循环的区别：

     do...while 无论条件是否成立 都会执行一次
     for 循环 使用 明确循环次数
         while 循环 不明确循环次数
         
         如果死循环 用 while(true){ 循环体}
         
        continue 作用 跳过某一次循环 后面的内容继续执行
       
        break 为终止当前的循环 后面的内容不再继续执行
          
          
         Random random = new Random();
          int i =random.nextInt(10);// 随机出 0-10之间的数据  包括0 不包括10
          
          获取指定范围的数据  90-100 包含90和100   random.nextInt(100-90+1)+ 90;
          
快捷键  
    ALT + ENTER  遇到代码有问题 直接使用这个组合键
       
数组：
    变量  数据类型 变量名 = 值;
       
    存储多个 相同数据类型的 元素
       
         int[] arr;
         数据类型 [] 数组名;
       
        数组的动态初始化：只要有数组的长度和数据类型 就可以创建
           格式：
          
           数据类型 [] 数组名 =  new 数据类型[数组长度];
               int [] arr  =  new  int[10];
                 
                数组元素访问的格式：
                    数组名[索引];
                       
                        arr[0]; //第一个元素
                       
                        索引 元素在数组中的编号 从0开始
                       
                        系统默认的 根数据类型给相关的默认值
                       
                给数组元素赋值：

            数组名[索引] = 数据值;               
                       
        静态初始化：
         需要知道数组的内容

              数据类型 [] 数组名 =  new 数据类型[]{元素1,元素2,元素3,...};
           int [] arr = new int[]{1,3,6,7,8,9,0};       

        静态的省略格式：(进行操作的时候 也有new的这个步骤)
            数据类型 [] 数组名 =  {元素1,元素2,元素3,...};   
            int [] arr = {1,2,4,5,6};       

         基本数据类型  4类8种               
          引用数据类型默认值 就是 null                 
                       
        异常：

       NullPointerException  空指针异常  
               数组的值变成 null 要访问数组里面的元素
          
           ArrayIndexOutOfBoundsException  数组索引超出界限异常
              数组的索引超出了数组的范围

    遍历：
            如何求出数组的长度：
                        arr.length;
                               
                for(int i= 0;i<arr.length;i++){
                        System.out.println(arr[i]);
                }
方法：
    方法只有存在 才能使用
        方法创建好了 不会直接运行 需要手动调用才能运行
       
    基础方法的定义格式：
           public static void 方法名(){
                  
                   方法体;
           }
          
        基础方法的调用格式：
                方法名();
                       
        带参数的方法的定义格式：
       
           public static void 方法名(参数类型 参数名1,参数类型 参数名2,参数类型 参数名3,...){
                   方法体;
           }
       
        带参数的方法的定义格式：
               方法名(值1,值2,值3,值4.....);
                  
    参数对于方法来讲 增加了方法的灵活性
       
        形参  形式上的参数     方法定义时使用
        实参  实际传递的参数   方法调用的时候使用
       
        带参数带返回值的方法的定义格式：
          
             public static 返回值类型 方法名(参数列表){
                         
                         方法体;
                        [return 数据值;] //如果返回值是void 不需要这句
                 }
       
        返回值类型  void 表示什么都不返回
                    其他： 可以是任意的数据类型
                               
                    需要写上  return 数据值;
       
        方法的注意事项：
            1.方法不能嵌套定义
                2.返回值 void 不能写 return 值;  void后面可以跟 return; 但能return后面不能再写具体的值
                   return 表示返回 方法执行到此处后结束
                   如果不是 void  必须得写上 return 值;
            3.方法的调用 三种  单独调用  赋值调用（最常用的） 打印调用
                 CTRL + ALT + V 方法的返回值自动帮我们生成
       
        定义一个方法的要求：
       
            1.返回值类型 必须得明确
                2.参数列表 必须明确
               
                建议：写方法的时候 最好是能把方法的具体功能写上
               
方法重载：

        1.必须在同一个类中
        2.方法名要求必须相同 参列表不同  
                 参数列表不同  1.数据类型不同  2.参数数量不同 3.多个参数的先后顺序不一样

         方法重载和什么没有关系：
               1.返回值类型无关
                           2.和参数名称无关
                          
            
                基本数据类型作为方法的参数 传递的是变量的值
                引用数据类型作为方法的参数 传递的是地址值
        Debug过程:
    1.打断点 鼠标左键 点击需要断点的位置
        2.以debug模式运行
        3.查看debug模式下 各个变量的值
        4.  step over 下一步   step into 进入方法里面
          
基础回顾:
     if
           单if语句  符合条件才会执行
           if..else 标准格式 两者选其一
           if..else if..else...  扩展格式  多者选其一
          
        switch:
            switch(表达式){
                        case 值1:
                          语句体;
                          //break;
                        case 值2:
                          语句体;
                          break;

                        default:
                         语句体;
                         break;               
                }
                表达式的类型: byte short int char  枚举enum  String
                 case后面值 不能重复
                 case 穿透: case语句后面的break丢失 会造成 继续执行下一个语句体
                 case 语句 先后顺序 是可以颠倒的
                 
                逢七过:改  要求把剩余的数据 按照每行5个进行排列打印出
                /*
                   public static void main(String[] args) {
                                        int count = 0;
                                        for (int x = 1; x <= 100; x++) {
                                                //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
                                                if (x % 10 == 7 || x / 10 % 10 == 7 || x % 7 == 0) {
                                                        continue;
                                                } else {
                                                        count++;
                                                        if (count % 5 == 0) {
                                                                System.out.println(x);

                                                        } else {
                                                                System.out.print(x + "\t");
                                                        }

                                                }
                                        }

                                        System.out.println("count:"+count);
                                }
                */
                判断一个数据是否是质数:
       /*
                          public static boolean isZhi(int num) {

                                        for (int i = 2; i <= num; i++) {
                                                if (i != num && num % i == 0) {
                                                        return false;
                                                } else if (i == num) {

                                                        return true;
                                                }

                                        }

                                        return false;
                                }          
                */