1 标识符与关键字

Java 基础语法 | 菜鸟教程 (runoob.com)

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary
• 类的名字：首字母大写

2 基本数据类型

Java 基本数据类型 | 菜鸟教程 (runoob.com)

2.1 基本数据类型

• 8+1种基本类型:byte,short,int,long,float,double,boolean,char,void

• byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

  int decimal = 100;
  int octal = 0144;
  int hexa =  0x64;
  

• 字符串常量和字符变量都可以包含任何 Unicode 字符。例如：

  char a = '\u0001';
  String a = "\u0001";
  

• 转义字符:

\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
\"	双引号
\'	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

• 所有类型的二进制位数、最大值、最小值可直接调用：

  // int  
  System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
  System.out.println("包装类：java.lang.Integer");  
  System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
  System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
  System.out.println();
  // 【输出】
  // 基本类型：int 二进制位数：32
  // 包装类：java.lang.Integer
  // 最小值：Integer.MIN_VALUE=-2147483648
  // 最大值：Integer.MAX_VALUE=2147483647
  

byte	-128	-2^7
8位	127	2^7-1
short	-32768	-2^15
16	32767	2^15 - 1
int	-2,147,483,648	-2^31
32	2,147,483,647	2^31 - 1
long	-9,223,372,036,854,775,808	-2^63
64	9,223,372,036,854,775,807	2^63 -1
float
32
double
64
boolean	true
	false
char	\u0000	十进制等效值为 0
16	\uffff	十进制等效值为 65535

2.2 常量

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

3 类型转换运算

Java 基本数据类型 | 菜鸟教程 (runoob.com)

3.1 自动类型转换

• 转换从低级到高级。

  低  ------------------------------------>  高
  byte, short, char —> int —> long —> float —> double 
  

• 规则：

  • 不能对boolean类型进行类型转换。

  • 不能把对象类型转换成不相关类的对象。

  • 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

  • 转换过程中可能导致溢出或损失精度，例如：

    int i =128;
    byte b = (byte)i;
    System.out.println(b);
    // 【输出】
    // -128
    

  • 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

    (int)23.7 == 23;        
    (int)-45.89f == -45
    

• 例：

  public class ZiDongLeiZhuan{
      public static void main(String[] args){
          char c1='a';//定义一个char类型
          int i1 = c1;//char自动类型转换为int
          System.out.println("char自动类型转换为int后的值等于"+i1);
          char c2 = 'A';//定义一个char类型
          int i2 = c2+1;//char 类型和 int 类型计算
          System.out.println("char类型和int计算后的值等于"+i2);
      }
  }
  
  // 【输出】
  // char自动类型转换为int后的值等于97
  // char类型和int计算后的值等于66
  

3.2 强制类型转换

public class ForceTransform {
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

// 【输出】
// int强制类型转换为byte后的值等于123

4 数组

Java 数组 | 菜鸟教程 (runoob.com)

Java 测验四（数组） | 菜鸟工具 (jyshare.com)

4.1 声明数组变量

• 语法

  dataType[] arrayRefVar;   // 首选的方法
  dataType arrayRefVar[];  // 效果相同，但不是首选方法
  

• 例子

  double[] myList;         // 首选的方法
  double myList[];         //  效果相同，但不是首选方法
  

4.2 创建数组

• 语法

  arrayRefVar = new dataType[arraySize];
  dataType[] arrayRefVar = new dataType[arraySize];	// 声明变量+创建数组
  dataType[] arrayRefVar = {value0, value1, ..., valuek};		// 声明变量+创建数组
  

• 例子

  public class TestArray {
     public static void main(String[] args) {
        // 数组大小
        int size = 10;
        // 定义数组
        double[] myList = new double[size];
        myList[0] = 5.6;
        myList[1] = 4.5;
        myList[2] = 3.3;
        myList[3] = 13.2;
        myList[4] = 4.0;
        myList[5] = 34.33;
        myList[6] = 34.0;
        myList[7] = 45.45;
        myList[8] = 99.993;
        myList[9] = 11123;
        // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < size; i++) {
           total += myList[i];
        }
        System.out.println("总和为： " + total);
     }
  }
  

4.3 处理数组

4.3.1 for循环

double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
    System.out.println(myList[i] + " ");
}

4.3.2 For-Each循环

• 语法

  for(type element: array){
      System.out.println(element);
  }
  

• 例子

  public class TestArray {
     public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};
   
        // 打印所有数组元素
        for (double element: myList) {
           System.out.println(element);
        }
     }
  }
  

4.3.3 数组作为函数的参数

• 是引用传递，此时传过去的是数组的地址。引用传递传递的是引用数据在堆中的地址，因此可以通过引用传递修改引用数据类型在堆中的值，但是引用传递并不能修改原来的引用的值。
  例题：
  
  

4.3.4 数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

4.4 多维数组

1. 多维数组的初始化

• 直接为每一维分配空间

  • 语法

    type[][] typeName = new type[typeLength1][typeLength2];
    

  • 例子

    int[][] a = new int[2][3];
    

• 从最高维开始，分别为每一维分配空间

  • 例子：

    String[][] s = new String[2][];
    s[0] = new String[2];
    s[1] = new String[3];
    s[0][0] = new String("Good");
    s[0][1] = new String("Luck");
    s[1][0] = new String("to");
    s[1][1] = new String("you");
    s[1][2] = new String("!");
    

  • 解析：s[0]=new String[2]和s[1]=new String[3]是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间s0=new String("Good")等操作。

2. 多维数组的引用

• 语法

  arrayName[index1][index2]
  

• 例子

  num[1][0];
  

4.5 数组的操作

• fill赋值
  public static void fill(int[] a, int val)
  将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int, double等）。

• sort排序

  public static void sort(Object[] a)
  对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

• equals比较

  public static boolean equals(long[] a, long[] a2)
  如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

• binarySearch二分查找

  public static int binarySearch(Object[] a, Object key)
  用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

5 运算符

• 算术运算符

  + - * / % ++ --	// 全部同c语言
  

  如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

• 关系运算符（返回值为true或false）

  == != > < >= <=
  

• 位运算符

  &  |   ^    ~       <<     >>       >>>
  与 或 异或 按位取反 按位左移 按位右移 按位右移补零
  

• 逻辑运算符（返回值为true或false）

  && || !
  

  短路逻辑运算符：当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

• 赋值运算符

  = += -= *= /= %= <<=>>= &= ^= |=
  

• 条件运算符
  语法：

  variable x = (expression) ? value if true : value if false
  

  例子：

  public class Test {
     public static void main(String[] args){
        int a , b;
        a = 10;
        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println( "Value of b is : " +  b );
   
        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println( "Value of b is : " + b );
     }
  }
  
  // 【输出】
  // Value of b is : 30
  // Value of b is : 20
  

• instanceof运算符
  用于检查某个对象是否属于特定的类或其子类型的实例，或者实现某个特定的接口。
  语法：

  (Object reference variable) instanceof (class/interface type)
  

  例子：

  class Vehicle {}
   
  public class Car extends Vehicle {
     public static void main(String[] args){
         String name = "James";
         boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
  		Vehicle a = new Car();
  		boolean result =  a instanceof Car;
          System.out.println( result);
     }
  }
  

• 运算符优先级

  类别	操作符	关联性
  后缀	() [] . (点操作符)	左到右
  一元	expr++ expr--	从左到右
  一元	++expr --expr + - ～ ！	从右到左
  乘性	* /％	左到右
  加性	+ -	左到右
  移位	>> >>> <<	左到右
  关系	> >= < <=	左到右
  相等	== !=	左到右
  按位与	＆	左到右
  按位异或	^	左到右
  按位或	|	左到右
  逻辑与	&&	左到右
  逻辑或	| |	左到右
  条件	？：	从右到左
  赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
  逗号	，	左到右

6 表达式

Java中的语句有很多种形式，表达式就是其中一种形式。表达式由操作数与运算符所组成。

操作数可以是常量、变量，也可以是方法；运算符就是数学中的运算符号如“+”、“-”、“*”、“/”、“%”等。以表达式（z+100）为例，“z”与“100”都是操作数，而“+”就是运算符。

表达式的计算结果必须是一个值，如果表达式是一个条件，就会产生逻辑值结果，即真或假。在其他情况下，值通常为计算的结果。

7 语句

7.1 循环结构

7.1.1 while循环（同c语言）

while( 布尔表达式 ) {
  //循环内容
}

7.1.2 do...while循环（同c语言）

do{
       //代码语句
}while(布尔表达式);

7.1.3 for循环（同c语言）

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

7.1.4 For-Each循环

• 语法

  for(声明语句: 表达式){
     //代码句子
  }
  

• 例子

  public class Test {
     public static void main(String[] args){
        int [] numbers = {10, 20, 30, 40, 50};
   
        for(int x: numbers ){
           System.out.print( x );
           System.out.print(",");
        }
        System.out.print("\n");
        String [] names ={"James", "Larry", "Tom", "Lacy"};
        for( String name : names ) {
           System.out.print( name );
           System.out.print(",");
        }
     }
  }
  

7.2 条件语句

if... else if...else

7.3 switch case

• 语法

  switch(expression){
      case value :
         //语句
         break; //可选
      case value :
         //语句
         break; //可选
      //你可以有任意数量的case语句
      default : //可选
         //语句
  }
  

• 例子

  public class Test {
     public static void main(String args[]){
        //char grade = args[0].charAt(0);
        char grade = 'C';
   
        switch(grade)
        {
           case 'A' :
              System.out.println("优秀"); 
              break;
           case 'B' :
           case 'C' :
              System.out.println("良好");
              break;
           case 'D' :
              System.out.println("及格");
              break;
           case 'F' :
              System.out.println("你需要再努力努力");
              break;
           default :
              System.out.println("未知等级");
        }
        System.out.println("你的等级是 " + grade);
     }
  }
  

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

8 输入输出

System.out.println("Hello World");
Scanner in = new Scanner(System.in);
System.out.println("echo:" + in.nextLine());
System.out.println("2+3="+2+3);
System.out.println("2+3="+(2+3));
System.out.println(2+3+"=2+3="+(2+3));

【输入】good morning

【输出】
Hello World
echo:good morning
2+3=23
2+3=5
5=2+3=5

Scanner in = new Scanner(System.in);
int price = in.nextInt();
System.out.println("100-"+price+'='+(100-price));

【输入】30

【输出】100-30=70