Java基础语法 第2节 Java语言基本语法

一、标识符和关键字

　　1.标识符　　

1）java中标识符用来为程序的白能量、常量、方法、类、接口和包名命名，标识符由字母、数字、下划线、美元符号组成，且第一个字符不能是数字；

2）标志符命名规则：见名知意原则和驼峰命名法；

　　 2.关键字：被Java语言赋予了特殊含义，用作专门用途的字符串（单词），关键字中所有字母都为小写

　　 3.Java中的名称命名规范

1）包名：多单词组成时，所有字母都小写：xxxyyyzzz

2）类名接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

3）变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

4）常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

二、注释和标签

1. 单行注释：// ，多行注释：/*...*/
2. 文档注释：/**
   　　          *文档注释（以@为前缀）
   　　          */
3. @author：作者名，@version：版本，@parameter：参数及其意义，@since：最早使用该方法、类的JDK版本，@return：返回值，@throws：异常类机器抛出条件

三、变量和数据类型

　　1.进制数

十进制（D）	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
二进制（B）	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111
八进制（O）	0	1	2	3	4	5	6	7	10	11	12	13	14	15	16	17
十六进制（H）	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F

　　注：八进制必须以0开头，例：0123；十六进制必须以0X开头，例：0X25

　　2.各进制数转换

　　　　1）其他类型---->十进制：各位数字分别乘以各自基数（二进制：2，八进制：8，十六进制：16）的（N-1）次方，并相加求和，其中N是数字位数（按权相加法）

　　　　　　例如：（1001）₂=（9）₁₀：1×23+0×22+0×21+1×20=9；（11）₈=（9）₁₀：1×81+1×80=9；（25）₁₆=（37）₁₀：2×16¹+5×16⁰=37；

　　　　2）十进制--->其他类型：整数部分（除基取余法↑），小数部分（乘基取余法↓），再拼接　

　　　　3）二进制---->八进制：←整数部分.小数部分→，即整数部分向左每三位转换成二进制数，位数不够则补0；小数部分向右每三位转换成二进制数，位数不够则补0

　　　　4）八进制---->二进制：与二进制-转八进制相反

　　　　5）二进制----->十六进制：←整数部分.小数部分→，即整数部分向左每四位转换成二进制数，位数不够则补0；小数部分向右每四位转换成二进制数，位数不够则补0

　　　　6）十六进制----->二进制：与二进制转十六进制相反

　　　　7）八进制<----->十六进制：八进制<--->二进制<------>十六进制

　　　　　　　 

　　3.数据类型：

　　

　　3. 默认值：数值变量：0；字符变量：‘\0’；布尔变量：false；引用数据类型：null；'\n':换行；'\t'：Tab键；'\r'：回车

　　4. 不同数据类型之间的转换（自动转换：如下图；强制转换：int a = （int）45.3）

　　

注：对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。如下图，底数2，0或1表示正或负

　　

　　5.变量：

　　　　1）常量：程序执行过程中值不能被改变的量，通常用大写字母表示

　　　　2）变量：程序执行过程中值能被改变的量

　　　　3）定义变量：[访问修饰符]变量类型   变量名 [= 初始值]，final 数据类型  常量名称 [=初始值]

　　　　4）当定义的final变量属于成员变量时，必须定义时赋初始值

　　　　5）变量的有效范围：

　　　　　　◊成员变量：类体中定义，整个类中有效

　　　　　　　　实例变量：int x = 5;

　　　　　　　　静态变量（类变量）：有效范围内可以”跨类“，甚至达到整个程序之内。使用方法：1.本类中直接存取；2.其他类中以"类名.静态变量"调用

　　　　　　◊局部变量：方法体中定义，只在当前代码块有效（{变量作用范围}），包括方法的参数。局部变量的使用高于成员变量，若同名则成员变量展示隐藏

三、运算符与表达式

　　1. 算术运算符

　　

　　◊算数运算符的注意问题：

　　　1）取余（模）：余数正负与”%左边“的数保持一致。例：-1%5 = -1（商0），1%-5 = 1

　　　2）“+”除字符串相加功能外，还能把非字符串转换成字符串。例：System.out.println("5+5="+5+5); //打印结果是"5+5=10"

　　　3）++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果不同

　　

　　

　　2.赋值运算符

　　

　　3. 关系运算符
　　

　　4. 逻辑运算符

　　

　　注：a&&b若a为false则不会判断条件b，a||b若a为true则不会判断条件b，

　　6. 位运算符

运算符	名称	举例	运算规则	结果
&	“与”、“位与”	5&4	如果两个数的二进制，相同位的数都是1，则该位结果是1，否则是0	5的二进制是  0000 0000 0000 0101，4的二进制是  0000 0000 0000 0100，则结果是 0000 0000 0000 0100  转为十进制是4
|	“或”、“位或”	5 | 4	如果两个数的二进制，相同位的数有一个是1，则该位结果是1，否则是0	结果是  0000 0000 0000 0101  转为十进制是5
^	“异或、“位异或”	5 ^ 4	如果两个数的二进制，相同位的数只有一个是1，则该位结果是1，否则是0	结果是        0000 0000 0000 0001 转为十进制是1
~	“非”、“位非”	~5	属于一元操作符，只对一个操作数进行操作，（其他按位操作符是二元操作符）。按位“非”生成与输入位相反的值，——若输入0，则输出1，若输入1，则输出0	5的二进制是  0000 0000 0000 0101，则~5是 1111 1111 1111 1010  转为十进制是 -6
>>	右移位	5>>2	按照操作符右侧指定的位数将操作符左边的操作数向右移。“有符号”右移位操作符使用“符号扩展”；若符号位正，则在高位插入0；若符号位负。则在高位插入1	5的二进制是   0000 0000 0000 0101 右移两位  0000 0000 0000 0001
<<	左移位	5<<2	按照操作符右侧指定的位数将操作符左边的操作数向左移动（在低位补0）	5的二进制是   0000 0000 0000 0101 左移两位  0000 0000 0001 0100
>>>	“无符号”右移位	5>>>2	使用“零扩展”；无论正负，都在高位插入0	5的二进制是   0000 0000 0000 0101 无符号右移两位  0000 0000 0000 0001
	负数的二进制转化，计算机计算是用的补码	-5	1、首先取出这个数的原码的二进制 2、然后再求出反码 3、最后求出补码	-5的原码是              1000 0000 0000 0101 求出反码的是            1111 1111 1111 1010 求出补码是               1111 1111 1111 1011

　　注：移位操作符只可用来处理整数类型；　　　

　　7. 三元运算符

语法形式：布尔表达式 ？ 表达式1 ：表达式2

四、数组：用于存储一组同一数据类型数据的容器

　　1. 一维数组

　　　　定义：数据类型[ ] 数组名 = new 数据类型[ ]{元素1，元素2……}  或   数据类型[ ] 数组名 = {元素1，元素2……}

　　2. 二维数组：二维数组的每一个元素是一个一维数组

　　　　定义：数据类型[ ][ ] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][每个一维数组的长度];

 　　　　　　   数据类型[ ][ ] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][ ];

　　　　　　　数据类型[][] 数组名 = {{元素},{元素1， 元素2},……};

　　3.数组在内存中的存储过程

　　　　内存：栈内存、堆内存、方法区、本地方法栈（和其他语言交互）、寄存器（汇编）

　　　　栈内存：可以用于存储变量，栈内存对存入其中的变量不会自动赋值，变量在使用完成之后会立即移出栈内存释放空间

　　　　堆内存：用于存储对象的，堆内存对于存入其中的元素会自动的赋予初始值（byte/short/int：0,long：0L;float：0.0f,double：0.0,char：‘\u0000’,boolean：false）,引用数据类型的默认值都是null，对象使用完成之后不会立即移出堆内存，而是在不定的某个时刻被回收

　　4.数组应用

　　1）常用方法

•  Arrays.fill(数组名，值）：将数组中每个元素赋予相同的值。

• Arrays.asList(数组)：将数组转化为集合（set，list）。

  String s[] = {"wyy", "wzz", "wxx"};
  List<String> list = new ArrayList<>(Arrays.asList(s));
  list.add("whh");
  System.out.println("ArrayList是否包含:" + list.contains("whh"));

  Set<String> set = new HashSet<>(Arrays.asList(s));
  System.out.println("集合set是否包含:" + set.contains("wyy"));

• Arrays.toString(数组).contains（xxx）：数组是否包含某个元素

• ArrayUtils.addAll(array, array2) ：连接两个数组

• arr.join( ", ")：根据分隔符拼接数组元素

• ArrayUtils.reverse(array)：反转数组

• Arrays.equals(score1,score2)：比较两个数组是否相等

• Arrays.fill(array,value)：数组填充

• binarySearch(Object[] a,int fromIndex,int toIndex,Object key)：在指定的范围内查找某一元素，在进行数组查询之前，必须对数组进行排序（可以使用 sort() 方法），如果 key 包含在数组中，则返回搜索值的索引；否则返回 -1 或“-插入点”

  public static void main(String[] args)
  {
      double[] score={99.5,100,98,97.5,100,95,85.5,100};
      Arrays.sort(score);
      int index1=Arrays.binarySearch(score,100);
      int index2=Arrays.binarySearch(score,60);
      System.out.println("查找到 100 的位置是："+index1);
      System.out.println("查找到 60 的位置是："+index2);
  }

• Arrays.copyOf(dataType[] srcArray,int length)：默认从源数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。若目标数组如果已经存在，将会被重构。

• Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)：其中，srcArray 表示源数组；startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，若目标数组如果已经存在，将会被重构。

• System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)：方法位于 java.lang.System 类中，srcArray 表示源数组；srcIndex 表示源数组中的起始索引；destArray 表示目标数组；destIndex 表示目标数组中的起始索引；length 表示要复制的数组长度。目标数组必须已经存在，且不会被重构，相当于替换目标数组中的部分元素。

• array_name.clone()：clone() 方法的返回值是 Object 类型，要使用强制类型转换为适当的类型。例：int[] targetArray=(int[])sourceArray.clone();目标数组如果已经存在，将会被重构。

• Arrays.sort(数组) ：
  1. 导入 java.util.Arrays 包。
  2. 使用 Armys.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。

　　2）数组元素排序

• 冒泡排序：在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

  public voidarrSort(score){  //score是要排序的数组
  System.out.println("通过冒泡排序方法对数组进行排序：");
  for(int i=0;i<score.length-1;i++)
  {
      //比较相邻两个元素，较大的数往后冒泡
      for (int j=0;j<score.length-1-i;j++)
      {
          if(score[j]>score[j+1])
          {
              double temp=score[j+1];    //把第一个元素值保存到临时变量中
              score[j+1]=score[j];    //把第二个元素值转移到第一个元素变量中
              score[j]=temp;    //把临时变量（第一个元素的原值）保存到第二个元素中
          }
          System.out.print(score[j]+ " ");    //对排序后的数组元素进行输出
      }
      System.out.print("【");
      for(int j=score.length-1-i;j<score.length;j++)
      {
          System.out.print(score[j]+" ");
      }
      System.out.println("】");
  }
  }

• 选择排序：每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完

  int[] number={13,15,24,99,4,1};
  String end="\n";
  int index;
  for(int i=1;i<number.length;i++)
  {
      index=0;
      for(int j=1;j<=number.length-i;j++)
      {
          if(number[j]>number[index])
          {
              index=j;    //查找最大值
          }
      }
      end=number[index]+" "+end;    //定位已排好的数组元素
      int temp=number[number.length-i];
      number[number.length-1]=number[index];
      number[index]=temp;
      System.out.print("【");
      for(int j=0;j<number.length-i;j++)
      {
          System.out.print(number[j]+" ");
      }
      System.out.print("】"+end);
  }

五、流程控制语句（if,switch,for,while,do...while）

　　

　　2. 循环语句

　　

　　3.return 语句：用于终止函数的执行或退出类的方法，并把控制权返回该方法的调用者。如果这个方法带有返回类型，return 语句就必须返回这个类型的值；如果这个方法没有返回值，可以使用没有表达式的 return 语句。

　　4.break 语句：有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能。

　　5.continue 语句：是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。

　　注：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。

　　6.标签功能：跳出外层循环

标签名：循环体{　　　　　　
　　　　　　break 标签名；　　　　
　　　　}

Loop:for(int i=0;i<3;i++){
    for(int j=0;j<3;j++){
        if(j==4){
　　　　　break Loop;　//此处也可以用continue：跳过外层本次循环，执行外层下一次循环　　　　　　　
        }
    }
}