一、数据类型

1.Java标志符

（1）标识符规则

• 标识符必须以字母、_、$开头
• 标识符其它部分可以是字母、_、$和数字的任意组合
• Java 标识符大小写敏感，且长度无限制
• 标识符不可以是Java的关键字

合法的标志符
int  a = 1;
int  _123 = 1;
int  $12aa = 1;
int  变量1 = 1;  //合法，但是不建议使用中文命名的标识符

不合法的标志符
int  1a = 1;   //不能用数字开头
int  a# = 1;   //不能包含#这样的特殊字符
int  int = 1;  //不能使用关键字

（2）标识符的使用规范

• 表示类名的标识符：每个单词的首字母大写，如Person, Car
• 表示方法和变量的标识符使用"驼峰命名法"，即第一个单词小写，从第二个单词开始首字母大写

（3）Java关键字/保留字

Java关键字/保留字.png

2.变量和常量

（1）变量的分类

变量的分类.png

（2）常量

常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等
在Java语言中，主要是利用关键字final来定义一个常量。 常量一旦被初始化后不能再更改其值。

final double PI = 3.14;
// PI = 3.15; //编译错误，不能再被赋值！

3.数据类型

（1）数据类型分类

数据类型分类.png

（2）基本数据类型

基本数据类型.png

（3）Java转义字符

Java转义字符.png

二、运算符

运算符.png

三、类型转换

（1）自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。

自动类型转换.png

实例一：byte 、short 、char 之间运算结果都是int

byte a = 1;
short b = 2;
char c = 'a';
int r1 = a + b; //3
int r2 = b * c; //194
int r3 = a + c; // 98

实例二：int和int运算结果还是int，结果转为double方式有两种

int a = 3;
int b = 20;
int r1 = b / a;
double r2 = b / a + 0.0;
double r3 = (double)b / a;
System.out.println(r1); //6
System.out.println(r2); //6.0
System.out.println(r3); //6.666666666666667

实例三：自动转换要小心数据溢出问题

int count = 100000000;
int price = 1999;
long totalPrice = count * price; //结果输出负数,两个 int*int=int, 但结果超出了 int 的代表范围
long totalPrice = (long) count * price; //输出正确结果

另外，向下转换时可以直接将 int 常量字面量赋值给 byte、short、char 等数据类型，而不需要强制转换，只要该常量值不超过该类型的表示范围都能自动转换。

（2）强制类型转换

实例一：强制类型转换用于显式的转换一个数值的类型，可能造成精度降低或溢出。

double x  = 3.99999;
int r1 = (int)x;
char c = 'a';
int d = c + 1;
System.out.println(r1); //3
System.out.println(d); //98
System.out.println((char)d); //b

实例二：当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。

int x = 300;
byte bx = (byte)x;    //值为44

四、流程控制

（1）选择结构

• if单选择结构
• if-else双选择结构
• if-else if-else多选择结构
• switch结构

（2）循环结构

• while
• do-while
• for

（3）break语句和continue语句

实例一：break

public void test(){
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++){
            if(j == 2){
                break;
            }
            System.out.print("(i="+i+",j="+j+")");
        }
    }
}
输出结果：j=1就跳出内层循环，j=2不再执行
(i=0,j=0) (i=1,j=0) (i=2,j=0)

实例二：continue

public void test(){
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++){
            if(j == 2){
                continue;
            }
            System.out.print("(i="+i+",j="+j+")");
        }
    }
}
输出结果：j=1就跳出本次内层循环，j=2继续执行
(i=0,j=0) (i=0,j=2) (i=1,j=0) (i=1,j=2) (i=2,j=0) (i=2,j=2) 

（4）带标签的break和continue

实例一：break

public void test(){
    label:for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++){
            if(j == 1){
                break label;
            }
            System.out.print("(i="+i+",j="+j+") ");
        }
    }
}
输出结果：当j=1时结束了外层循环
(i=0,j=0)

实例二：continue

public void test(){
    label:for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++){
            if(j == 1){
                continue label;
            }
            System.out.print("(i="+i+",j="+j+") ");
        }
    }
}
输出结果：当j=1时结束了外层当次循环，外层继续下一个循环
(i=0,j=0) (i=1,j=0) (i=2,j=0) 

（5）语句块

语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

public class Test{
    public static void main(String[] args) {
        int a;
        int b;
        {
            int i;
            int a; //编译错误：不能重复定义变量a
        } //变量i的作用域到此为止
    }