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;

              bytenum1 = 2;

              bytenum1 = num1+1;//出现问题 最终的结果是int类型

              bytenum1 +=1; //相当于 byte num1 = (byte)(num1+1);

               int num = 10; num %= 2; ==>num = num%2;

       自增自减：

      最多的用的地方 单独使用：前++ 和后++ 效果一样   

          如果不是单独使用：

              ++前  先加1 再进行运算

                 后++  先使用 再加1

       关系运算符：

       得到的结果都是布尔类型的；

       > <  >=  <=      ==  !=

       符号都是英文状态下

       >= ,<=   满足任意一个条件 > 或者是 等于 返回值为 true

              !=返回值 只有在不相等的情况下返回 true

       逻辑运算符：

      &  逻辑与 只有全部为 true 结果才为 true 其他为false

      |  逻辑或 只有全部为 false 结果才为 false 其他都为 true

          ^  逻辑异或相同为 false 不同为 true  

          !  逻辑非  true  !true ==> false  

      && 短路与 遇到第一个为 false 的值之后将不在执行后面的内容            

          || 短路或  遇到第一个为 true 的值之后将不在执行后面的内容  

       三元运算符：

               关系表达式 ? 表达式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语句的注意点：

         1.表达式的内容： byte shortint char  枚举  String

         2.case 穿透 如果case语句后面没有跟 break 会继续执行下一个选项的内容 直到遇到第一个 break为止

         3.case语句 顺序没有要求default 可以任意放置 但是 写上 break ；

         4.case 值 不能重复

       switch语句 和 if..else 扩展格式 区别：

      最大的区别： switch 效率高 占内存  if...else 效率低 灵活性高     

for 循环

    ①初始化语句     在程序开始的时候会执行一次  

       ②条件判断语句

       ③循环体

       ④步进语句

        格式：

            for (①初始化语句;②条件判断语句;④ 步进语句 ){

                          ③ 循环体;

                 }

                ①->②->③->④->②->③->④->②...

           结束：②条件判断语句 返回值为false 停止循环

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;

数组：

    变量  数据类型 变量名 = 值

    存储多个相同数据类型的 元素

        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(inti= 0;i<arr.length;i++){

                     System.out.println(arr);

              }

方法：

    方法只有存在才能使用

       方法创建好了不会直接运行 需要手动调用才能运行

    基础方法的定义格式：

          public static void 方法名(){

                 方法体;

          }

       基础方法的调用格式：

               方法名();

方法的注意事项：

           1.方法不能嵌套定义

              2.返回值 void 不能写 return 值;  void后面可以跟 return; 但能return后面不能再写具体的值

                 return 表示返回 方法执行到此处后结束

                 如果不是 void  必须得写上 return 值;

           3.方法的调用 三种  单独调用  赋值调用（最常用的） 打印调用

               CTRL + ALT + V 方法的返回值自动帮我们生成

       定义一个方法的要求：

           1.返回值类型 必须得明确

              2.参数列表必须明确

              建议：写方法的时候最好是能把方法的具体功能写上

方法重载：

       1.必须在同一个类中

       2.方法名要求必须相同 参列表不同  

                 参数列表不同  1.数据类型不同  2.参数数量不同 3.多个参数的先后顺序不一样   

        方法重载和什么没有关系：

               1.返回值类型无关

                        2.和参数名称无关                        

              基本数据类型作为方法的参数传递的是变量的值

              引用数据类型作为方法的参数传递的是地址值

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;

              bytenum1 = 2;

              bytenum1 = num1+1;//出现问题 最终的结果是int类型

              bytenum1 +=1; //相当于 byte num1 = (byte)(num1+1);

               int num = 10; num %= 2; ==>num = num%2;

       自增自减：

      最多的用的地方 单独使用：前++ 和后++ 效果一样   

          如果不是单独使用：

              ++前  先加1 再进行运算

                 后++  先使用 再加1

       关系运算符：

       得到的结果都是布尔类型的；

       > <  >=  <=      ==  !=

       符号都是英文状态下

       >= ,<=   满足任意一个条件 > 或者是 等于 返回值为 true

              !=返回值 只有在不相等的情况下返回 true

       逻辑运算符：

      &  逻辑与 只有全部为 true 结果才为 true 其他为false

      |  逻辑或 只有全部为 false 结果才为 false 其他都为 true

          ^  逻辑异或相同为 false 不同为 true  

          !  逻辑非  true  !true ==> false  

      && 短路与 遇到第一个为 false 的值之后将不在执行后面的内容            

          || 短路或  遇到第一个为 true 的值之后将不在执行后面的内容  

       三元运算符：

               关系表达式 ? 表达式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语句的注意点：

         1.表达式的内容： byte shortint char  枚举  String

         2.case 穿透 如果case语句后面没有跟 break 会继续执行下一个选项的内容 直到遇到第一个 break为止

         3.case语句 顺序没有要求default 可以任意放置 但是 写上 break ；

         4.case 值 不能重复

       switch语句 和 if..else 扩展格式 区别：

      最大的区别： switch 效率高 占内存  if...else 效率低 灵活性高     

for 循环

    ①初始化语句     在程序开始的时候会执行一次  

       ②条件判断语句

       ③循环体

       ④步进语句

        格式：

            for (①初始化语句;②条件判断语句;④ 步进语句 ){

                          ③ 循环体;

                 }

                ①->②->③->④->②->③->④->②...

           结束：②条件判断语句 返回值为false 停止循环

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;

数组：

    变量  数据类型 变量名 = 值

    存储多个相同数据类型的 元素

        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(inti= 0;i<arr.length;i++){

                     System.out.println(arr);

              }

方法：

    方法只有存在才能使用

       方法创建好了不会直接运行 需要手动调用才能运行

    基础方法的定义格式：

          public static void 方法名(){

                 方法体;

          }

       基础方法的调用格式：

               方法名();

方法的注意事项：

           1.方法不能嵌套定义

              2.返回值 void 不能写 return 值;  void后面可以跟 return; 但能return后面不能再写具体的值

                 return 表示返回 方法执行到此处后结束

                 如果不是 void  必须得写上 return 值;

           3.方法的调用 三种  单独调用  赋值调用（最常用的） 打印调用

               CTRL + ALT + V 方法的返回值自动帮我们生成

       定义一个方法的要求：

           1.返回值类型 必须得明确

              2.参数列表必须明确

              建议：写方法的时候最好是能把方法的具体功能写上

方法重载：

       1.必须在同一个类中

       2.方法名要求必须相同 参列表不同  

                 参数列表不同  1.数据类型不同  2.参数数量不同 3.多个参数的先后顺序不一样   

        方法重载和什么没有关系：

               1.返回值类型无关

                        2.和参数名称无关                        

              基本数据类型作为方法的参数传递的是变量的值

              引用数据类型作为方法的参数传递的是地址值