Java基本语法详解

1数据类型与运算符

1.1变量

变量类型总览

1.1.1整数型变量

整数类型： byte、 short、 int、 long

基本语法格式：
数据类型 变量名 = 初始值;
代码示例：

int  num1 = 10;//定义一个整型变量
System.out.println(num1);
long  num2  = 10L;//定义一个长整型变量,初始值可以为大写的字母L
System.out.println(num2);//也可写为小写的l(不是数字1)

如果运算的结果超出了 int 的最大范围，就会出现溢出的情况

int maxValue = Integer.MAX_VALUE;//int的最大值
System.out.println(maxValue+1);//输出结果为：int 的最小值
int mINValue = Integer.MIN_VALUE;//int的最小值
System.out.println(minValue-1);//输出结果为：int的最大值

注意：

1. java的整型常量默认为 int 型，声明long型常量须后加小写字母‘l’或大写‘L’
2. java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

1.1.2浮点型变量

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。

基本语法格式：
变量类型 变量名 = 初始值;
代码示例：

double num3 = 1.0;//定义一个双精度变量
System.out.println(num3);
float  num4 = 1.0f;//定义一个单精度变量
System.out.println(num4);

注意：

1.Java 的浮点型常量默认为double型， 声明float型常量，须后加‘f’或‘F’。
2.小数本身是没有一个精确的数字的，只能精确到几位

1.1.3字符型与布尔类型变量

字符型
char 型数据用来表示通常意义上“字符”(2字节)

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字
母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符。
例如：

  char c1 = 'a';
   char c2= '中'; 
   char c3 = '9';

Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：

 char c3 = ‘\n’; // '\n'表示换行符

直接使用 Unicode 值来表示字符型常量：
‘\uXXXX’。其中， XXXX代表一个十六进制整数。如： \u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

布尔型
boolean 类型用来判断逻辑条件，一般用于程序流程控制：

if条件控制语句；

while循环控制语句；

do-while循环控制语句；

for循环控制语句；

注意事项：

1.boolean类型数据只允许取值true和false，无null。

2.Java中的boolean类型和int不能相互转换，不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

3.boolean类型数据有些 JVM 的实现是只占一个字节，有些是占一个比特位，这个没有明确规定。

Java虚拟机中没有任何供boolean值专用的字节码指令， Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替： true用1表示， false用0表示 ———《java虚拟机规范 8版》

1.1.4字符串类型变量

String不是基本数据类型，属于引用数据类型

基本语法格式：
String 变量名 = “初始值”

字符串中一些特定的不太方便直接表示的字符需要进行转义。
转义字符示例：

//创建一个字符串 My name is "超人"
String name = "My name is \"超人\"";

//使用方式与基本数据类型一致。
//例如：
 String str = “abcd”;
 //一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。
// 例如：
str = str + “xyz” ;//字符串与字符串
int n = 100;//字符串与整数

以上代码说明，当一个 + 表达式中存在字符串的时候，都是执行字符串的拼接行为。

同时打印多个字符串或数字

int a = 10;
int b = 20;
System.out.println("a = "+a+"b = "+b);

1.1.5变量的作用域

也就是该变量生效的范围，一般是变量定义所在的代码块（大括号）
代码示例：

class Test{
    public static void main(String[] args){
    {
        int x = 10;
        System.out.println(x);//编译通过
    }
    System.out.println(x);//编译失败，找不到变量x 
    }
}

1.1.6变量的命名规范

硬性指标：

1.一个变量名只能包含数字，字母，下划线（$可以，不推荐使用）
2.数字不能开头
3.变量名是大小写敏感的，num 和 Num 是两个不同的变量

软性指标：

1.具有描述性，见名知意
2.不宜使用拼音（不绝对）
3.词性推荐使用名词
4.推荐小驼峰命名法，当一个变量有多个单词构成时，除了第一个单词之外，其他单词首字母都大写

小驼峰命名示例：

int maxValue = 100;
String studentName = "超人";

1.2基本数据类型间的转换

1.2.1常量

常量是指在运行时类型不能发生改变，并且常量在编译时就已经确定

1.字面值常量

10 // int 字面值常量(十进制) 
010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8 
0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16 
10L // long 字面值常量. 也可以写作 10l (小写的L) 
1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D 
1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2 
1.0f // float 字面值常量, 也可以写作 1.0F 
true // boolen 字面值常量, 同样的还有 false 
'a' // char 字面值常量, 单引号中只能有一个字符
"abc" // String 字面值常量, 双引号中可以有多个字符.

2.final 关键字修饰的常量

final int a = 10;
a = 20;//编译出错，提示无法为最终变量a 分配值

1.2.2理解类型转换

Java作为一个强类型的编程语言，当不同类型的变量相互赋值时会有严格的校验
int 和 long / double 相互赋值

int a = 10; 
long b = 20; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 
//long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.
int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a;
//double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int

结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行.

int 和 boolean 相互赋值

int a = 10; 
boolean b = true; 
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

结论: int 和 boolean 是毫不相干的两种类型, 不能相互赋值

int 字面值常量给byte

byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失
//注意: byte 表示的数据范围是 -128 -> +127, 256已经超过范围，而100还在范围之内

结论: 使用字面值常量赋值的时候, Java 会自动进行一些校验，判定赋值是否合理
小结：
1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查.

1.2.3理解数值提升

int 和 long 混合运算

int a = 10; 
long b = 20; 
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过.

结论: 当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换.

byte 与 byte 的运算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 
// 编译报错
//Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
// byte c = a + b; 

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算.

正确的写法：

byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c)；

类型提升小结：
1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算

1.2.4 String 和 int 之间的相互转换

int 转成 String

int num = 10; 
// 方法1 
String str1 = num + ""; 
// 方法2 
String str2 = String.valueOf(num); 

String 转成 int

String str = "100"; 
int num = Integer.parseInt(str);

1.2.5基本数据类型的转换（重点）

自动类型转换：
容量小的类型自动转换为容量大的数据类型。
数据类型按容量大小排序为：

总结：
1.有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2.byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
3.boolean类型不能与其它数据类型运算。
4.当把任何基本数据类型的值和字符串(String)进行连接运算时(+)， 基本数据类型的值将自动转化为字符串(String)类型。

1.3运算符

1.3.1算术运算符

算术运算符总览：

除法中需要注意的几点：
1.int / int 结果还是 int,需要用double来计算

int a = 1;
int b = 2;
System.out.println(a / b);
//结果为0

2. 0不能作为除数

3. %表示取余，不仅可以对 int 求模，也能对double求模

System.out.println(11.5%2.0);
//运行结果
1.5

1.3.2关系运算符

关系运算符总览：

注意：
1.关系运算符的结果都是boolean型，也就是要么是true，要么是false。
2.关系运算符“==”不能误写成“=” 。

1.3.3逻辑运算符

逻辑运算符主要有3个：

&&  //两个操作数都为ture,结果为ture，否则为false
||  //都为false结果为false,否则为true
！  //逻辑反操作

注意：
逻辑运算符的运算结果和返回值都是 boolean.

短路求值

&& 和 || 遵循短路求值规则。

System.out.println(10 > 20 && 10 / 0 == 0);//打印false
System.out.println(10 < 20 || 10 / 0 == 0);//打印ture
//计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行,
// 说明 10 / 0 并没有真正被求值.

结论：
1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式.
2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式.
3. & 和 | 不建议使用，不支持短路求值

1.3.4位运算符

位运算符总览：

位操作表示按二进制位计算

注意：

1. 0x 前缀的数字为16进制数字，16进制可以看成二进制的简化形式，一个16进制对应4个二进制位。
2. 0xf表示16进制中的15，也就是二进制的1111
3. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
4. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
5. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
6. 移动负数位或者移位位数过大都没有意义

1.3.5条件运算符

条件运算符也叫三目运算符

语法格式：

表达式1？表达式2：表达式3

当表达式1的值为 ture 时，整个表达式的值为表达式2的值；若为 false ,整个表达式的值为表达式3的值。

//求两个数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

2程序流程控制

1.顺序结构

顺序结构，即按照代码书写的顺序一行一行执行

System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");
//运行结果
aaa
bbb
ccc

2.分支结构

2.1.1 if 语句

基本语法形式1

if (布尔表达式){//只能是布尔表达式，不同于C语言
    //条件满足时执行的代码
}

基本语法形式2

if(布尔表达式){
    //条件满足时执行的代码
}else{
    //条件不满足时执行的代码
}

基本语法形式3

if(布尔表达式){
    //条件满足时执行代码
}else if(布尔表达式){
    //条件满足时执行代码
}else{
    //条件都不满足时执行代码
}

代码示例：

//判定一个数字是奇数还是偶数
int num = 10;
if(num % 2 == 0){
    System.out.println("num 是偶数");
}else{
     System.out.println("num 是奇数");
}

注意：悬垂 else 问题

int x = 10;
int y = 10;
if (x == 10) 
     if (y == 10)
         System.out.println("aaa");
else
     System.out.println("bbb");

if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配.
但是实际开发中我们 不建议 这么写，最好加上大括号。

2.1.2 switch 语句

基本语法：

switch(整数|枚举|字符|字符串){
     case 内容1 : {
         内容满足时执行语句;
         break;
         }
     case 内容2 : {
         内容满足时执行语句;
         break;
         }
     ...
     default:{
         内容都不满足时执行语句;
         break;
         } 
}

注意事项：

1. break 不要遗漏，否则会失去“多分支选择”的效果
2. switch 中的值只能是 整数 | 枚举 | 字符 | 字符串
3. 不能做 switch 的参数的数据类型有：long ,float, double, boolean

3.循环结构

2.3.1 while 循环

基本语法格式：

while(循环条件){//循环条件为布尔表达式，ture 执行语句，否则结束循环。
    循环语句；
}

示例代码1：计算1-100的和

int n = 1; 
int result = 0; 
while (n <= 100) { 
    result += n; 
    n++; 
} 
System.out.println(num); 
// 执行结果
5050

注意：
while 下面的语句可以不写{ }，但不写时只能支持一条语句。

2.3.2 break 和 continue

break 的功能是让循环提前结束

代码示例：找到100-200中第一个3的倍数

int num = 100; 
while (num <= 200) { 
    if (num % 3 == 0) { 
    System.out.println("找到了 3 的倍数, 为:" + num); 
    break; 
    } 
    num++; 
} 
// 执行结果
找到了3的倍数，为：102

continue 的功能是跳过本次循环，其以下代码不再运行

代码示例：找到100-200中所有3的倍数

int num = 100; 
while (num <= 200) { 
    if (num % 3 != 0) { 
    num++; // 这里的 ++ 不要忘记! 否则会死循环. 
    continue; 
    } 
    System.out.println("找到了 3 的倍数, 为:" + num); 
    num++; 
}

2.3.3 for 循环

基本语法：

for(表达式1；表达式2；表达式3){
    循环体；
}

表达式1：用于初始化循环变量
表达式2：循环条件
表达式3：更新循环变量

示例代码：计算1！+ 2！+3！+4！+5！

int sum = 0; 
for (int i = 1; i <= 5; i++) { 
    int tmp = 1; 
    for (int j = 1; j <= i; j++) { 
    tmp *= j; 
    }  
    sum += tmp; 
} 
System.out.println("sum = " + sum);

4.输入输出

2.4.1输出到控制台

基本书法：

System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

println 输出的内容自带 \n, print 不带 \n
printf 的格式化输出方式和 C 语言的 printf 是基本一致的

2.4.2从键盘输入

使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner; // 需要导入 util 包
Scanner sc = new Scanner(System.in); 
System.out.println("请输入你的姓名："); 
String name = sc.nextLine(); 
System.out.println("请输入你的年龄："); 
int age = sc.nextInt(); 
System.out.println("请输入你的月薪："); 
float salary = sc.nextFloat(); 
System.out.println("你的信息如下："); 
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary); 
sc.close(); // 注意, 要记得调用关闭方法
// 执行结果
请输入你的姓名：
超人
请输入你的年龄：
19
请输入你的月薪：
25000 
你的信息如下：
姓名: 超人
年龄：19
工资：25000

使用 Scanner 循环读取N 个数字

Scanner sc = new Scanner(System.in); 
double sum = 0.0; 
int num = 0; 
while (sc.hasNextDouble()) { 
    double tmp = sc.nextDouble(); 
    sum += tmp; 
    num++; 
} 
System.out.println("sum = " + sum); 
System.out.println("avg = " + sum / num); 
sc.close(); 
// 执行结果
10 
40.0 
50.5 
^Z 
sum = 150.5 
avg = 30.1

注意：当循环输入多个数据时，使用ctrl+z来结束输入，IDEA上是ctrl+D

Java语法知识点补充

Java中的名称命名规范

Java中的名称命名规范：

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

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

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个
单词首字母大写： xxxYyyZzz

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

Java中的关键字