二、Java基础语法
1 . 注释
注释只是给程序的说明性文字 不会参与编译
单行注释
public class main{
public static void main(String[] args){
// System.out.println("Hello World!");
System.out.println("Hello World!");
}
}
运行结果 :
Hello World!
单行注释 // 双斜杠后面的内容会被注释
多行注释
public class main{
public static void main(String[] args){
/*
System.out.println("Hello World!");
System.out.println("Hello World!");
*/
System.out.println("Hello World!");
}
}
运行结果 :
Hello World!
*多行注释 以 / 开头 */ 结尾 中间的内容会被注释 **
文档注释
在程序中采用特定的注释格式进行注释,然后通过JDK提供的工具javadoc来解析,生成一套以网页文件形式体现的程序说明文档。
文档注释,一般用于注释类或方法。
暂时用不上 待补充
2 . 关键字
关键字就是被Java赋予特定含义的单词
关键字的特点
- 关键字的字母全部小写
- 常用的代码编辑器 对于关键字有特殊的高亮显示
Java中的部分关键字
assert const long public final continue goto static while strictfp
abstract default int extends class boolean break throws volatile ......
3 . 字面量
告诉程序员 : 数据在程序中的书格式
字面量类型
类型 | 关键字 | 说明 | 举例 | 默认值 | 内存大小 |
---|---|---|---|---|---|
整数类型 | int | 不带小数点的数字 | 123 456 | 0 | 4byte |
小数类型/浮点数类型 | float double | 带小数点的数字 | 123.456 | 0.0 | 8byte |
字符类型 | char | 单个字符 使用单引号括起来 | ‘a’ ‘0’ | ‘\0’ | 2byte |
字符串类型 | String | 一串字符 使用双引号括起来 | “Hello” | null | / |
布尔类型 | boolean | 只有值 真或假 | 真true 假false | false | 1byte || 4byte |
空类型 | / | 一个特殊的值 空值 | 值为 null | / | / |
4 . 数据类型
数据类型分为基本数据类型 和 引用数据类型
基本数据类型
数据类型 | 关键字 | 取值范围 | 内存占用 |
---|---|---|---|
整数 | byte | − 2 7 -2^7 −27 ~ 2 7 − 1 2^7-1 27−1 | 1 1 1 |
整数 | short | − 2 15 -2^{15} −215 ~ 2 15 − 1 2^{15}-1 215−1 | 2 2 2 |
整数 | int | − 2 31 -2^{31} −231 ~ 2 31 − 1 2^{31}-1 231−1 ≈ 2 e 9 \approx 2e9 ≈2e9 | 4 4 4 |
整数 | long | − 2 63 -2^{63} −263 ~ 2 63 − 1 2^{63}-1 263−1 ≈ 9 e 19 \approx 9e19 ≈9e19 | 8 8 8 |
浮点数 | float | − 3.401298 e − 38 -3.401298e-38 −3.401298e−38~ 3.402823 e + 38 3.402823e+38 3.402823e+38 | 4 4 4 |
浮点数 | double | − 4.9000000 e − 324 -4.9000000e-324 −4.9000000e−324~ 1.797693 e + 308 1.797693e+308 1.797693e+308 | 8 |
字符 | char | 0 0 0~ 65535 65535 65535 | 2 2 2 |
布尔 | boolean | t r u e , f a l s e true , false true,false | 1 1 1 |
在定义long类型时 需要在数字后面添加 ‘L’ 或者 ‘l’
在定义float类型时 需要在数字后面添加 ‘F’ 或者 ‘f’
取值范围大小关系
double > float > long > int > short > byte
5 . 变量
在程序运行过程中 其值有可能发生变换的量 (数据)
变量命名规则
- 名字中只能包含 字母 数字 下划线’_’ 美元符’$’
- 数字不能开头
- 变量名不能重复定义
- 不能与Java的关键字相重复
- 区分大小写
使用方法
[数据类型 | 字面量类型] [变量名] = [值];
定义变量
public class main{
public static void main(String[] args){
//定义了一个整数类型的变量 值为10
int a=10;
//定义了一个浮点数的变量 未赋值
double b;
//定义了三个char类型的变量
char c1='a',c2,c3;
//定义了一个long类型的变量
long d=12345L;
//定义了一个float类型的变量
float e=3.1415f;
}
}
输出打印
public class main{
public static void main(String[] args){
int a=10;
System.out.println(a);
// 输出结果为 10
}
}
参与计算
public class main{
public static void main(String[] args){
int a=10,b=20;
System.out.println(a+b);
// 输出结果为 30
}
}
修改数值
public class main{
public static void main(String[] args){
int a=10;
System.out.println(a);
// 输出结果为 10
a=30;
// 把变量 a 的值修改为30
System.out.println(a);
// 输出结果为 30
}
}
6 . 算数运算符
运算符和表达式
- 运算符
- 对字面量或者变量进行操作的符号
符号 | 作用 |
---|---|
+ | 加 |
- | 减 |
* | 乘 |
/ | 除 |
% | 取余 |
= | 赋值 a = b 把 a 的值给 b 赋值 a=b 把a的值给b 赋值a=b把a的值给b |
+= | a + = b 等于 a = a + b a+=b\ \ 等于\ \ a=a+b a+=b 等于 a=a+b |
-= | a − = b 等于 a = a − b a-=b\ \ 等于\ \ a=a-b a−=b 等于 a=a−b |
/= | a / = b 等于 a = a / b a/=b\ \ 等于\ \ a=a/b a/=b 等于 a=a/b |
*= | a ∗ = b 等于 a = a ∗ b a*=b\ \ 等于\ \ a=a*b a∗=b 等于 a=a∗b |
%= | a % = b 等于 a = a % b a\%=b\ \ 等于\ \ a=a\%b a%=b 等于 a=a%b |
++ | a + + 等于 a + = 1 a++ \ 等于\ a+=1 a++ 等于 a+=1 |
– | a − − 等于 a − = 1 a-- \ 等于\ a-=1 a−− 等于 a−=1 |
- 表达式
- 用运算符把字面量或者变量连接起来 符合Java语法的式子
int a=10;
int b=20;
// '+' 就是运算符
// a+b 是表达式
int c=a+b;
7 . 隐式转换和强制转换
隐式转换
- 取值范围小的和取值范围大的进行运算 小的会先提升为大的 再进行运算
public class main{
public static void main(String[] args){
int a=10;
double b=20;
//此时输出 a+b 的值为 30.0 double类型的 在计算 a+b 时 会自动把 a 提升为double类型
System.out.println(a+b);
}
}
- 内存占用不满 4byte 类型的会自动转化为 int 来进行计算
public class main{
public static void main(String[] args){
byte a=100,b=200;
//此时输出结果为 200 但是 byte 类型的最大值为127
System.out.println(a+b);
}
}
强制转换
- 强制转换是把占用内存大的类型转换为占用内存小的类型
- 强制转换之后可能会出现精度丢失的问题
书写格式
(数据类型)变量名
double a=12.3;
// 此时输出的为 12 丢失了小数部分
System.out.println((int)a);
精度丢失
public class main{
public static void main(String[] args){
int a=4987;
byte b=(byte)a;
//此时输出的 b 结果为123 就是出现了精度丢失
System.out.println(b);
}
}
/*
数字在内存中都是使用二进制进行存储的
int 占用4byte 32位
4987 的二进制为 1001101111011
byte 占用1byte 8个字节
a强制转换为byte之后只会保留后八位二进制 01111011
0 1 1 1 1 0 1 1
第一位为符号位 0表示正数 1表示负数
后七位为数据位 1111011转为十进制位123
所以 b 的值为123
*/
8 . 字符串的 ‘+’ 操作
- 当 ‘+’ 操作中出现字符串时 这个 ‘+’ 就不是算数运算符了 而是字符串连接符号
- ‘+’ 会将前后的数据进行拼接 产生一个新的字符串
public class main{
public static void main(String[] args){
int a=123;
// 输出结果为 123456 因为出现了字符串
System.out.println(a+"456");
}
}
public class main{
public static void main(String[] args){
int a=123;
int b=10;
// 输出结果为 133456
// 刚开始算 a+b 因为没出现字符串 所以计算的是值相加 结果为 133
// 再拿 a+b 的结果 133 去与 "456" 相加 因为 "456" 是字符串 所以结果是 133456
System.out.println(a+b+"456");
}
}
9 . 字符的 ‘+’ 操作
- 字符在计算机中是以ASCII码的形式存放的
- 字符的 + 操作就是ASCII码值的相加
public class main{
public static void main(String[] args){
char a='A';
//输出的值为 65 字符 'A' 的ASCII码值就为65
System.out.println((int)a);
}
}
10 . 关系运算符
符号 | 说明 |
---|---|
== | a = = b a==b a==b 判断 a 和 b 是否相等相等为 t r u e 不相等为 f a l s e 判断a和b是否相等 相等为\ true \ 不相等为\ false 判断a和b是否相等相等为 true 不相等为 false |
!= | a = = b a==b a==b 判断 a 和 b 是否不相等不相等为 t r u e 相等为 f a l s e 判断a和b是否不相等 不相等为\ true \ 相等为\ false 判断a和b是否不相等不相等为 true 相等为 false |
> | a > b a>b a>b 判断 a 是否大于 b 大于为 t r u e 不大于为 f a l s e 判断a是否大于b 大于为\ true \ 不大于为\ false 判断a是否大于b大于为 true 不大于为 false |
< | a < b a<b a<b 判断 a 是否小于 b 小于为 t r u e 不小于为 f a l s e 判断a是否小于b 小于为\ true \ 不小于为\ false 判断a是否小于b小于为 true 不小于为 false |
>= | a > = b a>=b a>=b 判断 a 是否大于等于 b 大于等于为 t r u e 小于为 f a l s e 判断a是否大于等于b 大于等于为\ true \ 小于为\ false 判断a是否大于等于b大于等于为 true 小于为 false |
<= | a < = b a<=b a<=b 判断 a 是否小于等于 b 小于等于为 t r u e 大于为 f a l s e 判断a是否小于等于b 小于等于为\ true \ 大于为\ false 判断a是否小于等于b小于等于为 true 大于为 false |
-
**关系运算符的结果都为 boolean 类型 要么是 t r u e true true 要么是 f a l s e false false **
-
不要把 = = == == 写成 = = =
11 . 逻辑运算符
符号 | 说明 |
---|---|
& & \&\& && | 并且的意思 两边都为真才为真 并且的意思\ \ 两边都为真才为真 并且的意思 两边都为真才为真 |
& \& & | 按位与 两边都为 1 才是 1 按位与\ \ 两边都为1才是1 按位与 两边都为1才是1 |
$ | |
$ | $ |
^ | 逻辑异或 不同为 t r u e 相同为 f a l s e 逻辑异或\ \ 不同为true\ \ 相同为false 逻辑异或 不同为true 相同为false |
! ! ! | 取反 0 遍 11 遍 0 取反\ \ 0遍1 1遍0 取反 0遍11遍0 |
12 . 三元运算符
# 基础语法
[表达式] ? (A语句) : (B语句);
# 如果表达式的值为 true 则执行 A语句 否则执行 B语句
// 求两个数的最大值
/*
int a=10,b=20;
int max= a>b?a:b;
*/
// 三元运算符的嵌套使用 求三个数的最大值
/*
int a=10,b=20,c=30;
int max= a>b?a>c?a:c:b>c?b:c;
*/
13 . 运算符的优先级
优先级 | 运算符 |
---|---|
1 1 1 | . ( ) { } . \ \ () \ \ \{ \} . () {} |
2 2 2 | ! + + − − !\ \ ++\ \ -- ! ++ −− |
3 3 3 | ∗ / *\ \ /\ \ % ∗ / |
4 4 4 | + − +\ \ - + − |
5 5 5 | > > < < > > > >>\ \ <<\ \ >>> >> << >>> |
6 6 6 | < < = > > = <\ \ <=\ \ >\ \ >= < <= > >= |
7 7 7 | = = ! = ==\ \ != == != |
8 8 8 | & \& & |
9 9 9 | ^ |
10 10 10 | $ |
11 11 11 | & & \&\& && |
12 12 12 | $ |
13 13 13 | ? : ?: ?: |
14 14 14 | = + = − = ∗ = / = =\ \ +=\ \ -=\ \ *=\ \ /=\ \ %=\ \ & \= = += −= ∗= /= |
14 . 源码、反码、补码
- **源码 : 数字的二进制位 第一位为符号位 符号位为 0 表示正数 1为负数 **
正数在内存中的存储
# 正数的源码 = 反码 = 补码
# 13的源码
# 13的二进制位 1101
# 源码为 00001101
负数在内存中的存储
# 负数的源码 = 符号位为1 其他位与正数的源码一样
# 负数的反码 = 负数的源码除了符号位按位取反 1变0 0变1
# 负数的补码 = 负数的源码+1
# -13 的源码为 10001101 //第一位符号位位1 表示负数
# -13 的反码为 11110010 //除了符号位按位取反
# -13 的补码为 11110011 //反码+1
15 . 分支语句
if
// 使用方法
// 单个if 如果表达式的值为 true 则执行语句 A
/*
if(表达式){
// 语句 A
}
*/
// if - else
// 如果表达式的值为 true 则执行 语句A 否则执行 语句B
/*
if(表达式){
// 语句 A
}else{
// 语句 B
}
*/
// if -else 的嵌套
// 如果 表达式1 的值为 true 则执行 语句A 否则再判断表达式2 的值 如果表达式2为 true 则执行 语句B 否则执行语句C
/*
if(表达式1){
// 语句 A
}else if(表达式2){
// 语句 B
}else{
// 语句 C
}
*/
swith
// 使用方法
// 先计算表达式的值 如果表达式的值等于 值1 就执行 语句A ,如果表达式的值等于 值2 就执行语句B 如果都不匹配 则执行default里面的语句
// 值1 2 3等只能是常量
/*
switch(表达式){
case 值1 :
语句 A;
break;
case 值2 :
语句 B;
break;
case 值3 :
语句 C;
break;
case 值4 :
语句 D;
break;
default :
语句 E;
break;
}
*/
16 . 循环语句
while循环 与 do-while循环
// 使用方法
// 如果表达式的值为true 则一直执行语句A 否则跳出循环
/*
while(表达式){
语句A;
}
*/
// do-while 循环
// 先执行一次语句 A,再判断表达式的值 如果表达式为 true 则继续执行语句A 否则跳出循环
/*
do{
语句A;
}while(表达式);
*/
for 循环
// 使用方法
// 初始化语句只会执行一次 再判断表达式 表达式为true则执行语句A 执行完之后再执行语句B 再判断表达式的值是否为true 如果为true 则继续语句A
/*
for([初始化语句];[表达式];[语句B]){
语句A;
}
*/
// 输出数字 1-100
/*
for(int i=1;i<=100;i++){
System.out.println(i);
}
*/
continue 与 break
- continue : 结束当前循环 开始下一次循环
// 输出数字 1-10 ,遇到7的倍数则不输出
/*
for(int i=1;i<=10;i++){
if(i%7==0){
// 遇到 7 的倍数就结束此次循环 开启下一次循环
continue;
}
System.out.println(i);
}
// 运行结果 :
1 2 3 4 5 6 8 9 10
*/
- break : 退出循环
// 输出数字 1-100 遇到 7 的倍数则退出循环
/*
for(int i=1;i<=100;i++){
if(i%7==0){
// 直接退出循环
break;
}
System.out.println(i);
}
// 运行结果 :
1 2 3 4 5 6
*/
17 . 数组
- **数组就是能够存储一些相同元素的集合 **
数组的定义与初始化
//静态初始化
//(数据类型)[] 数组名 = new (数据类型)[]{值1,值2,值3};
//定义了一个int类型的数组 存储了五个整数
int[] array = new int[]{1,2,3,4,5};
//动态初始化
//(数据类型)[] 数组名 = new (数据类型)[数组大小];
//定义了一个长度为10的int类型数组
int[] val=new int[10];
数组的元素访问与修改
// 数组的元素可以通过下标来进行访问
// 下标从 0 开始 下标的取值范围为 0 ~ 数组长度-1
// 格式
// 数组名[下标]
int[] array = new int[]{1,2,3,4,5};
//输出下标 2
System.out.println(array[2]);
//修改array数组中下标 3 的值为 100
array[3]=100;
//遍历数组 array.length为数组的长度
for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
数组在内存中的存储
- Java new 出来的内存都存储在堆空间中
- 数组名存储的仅仅只是堆空间中的地址值
int[] a=new int[]{1,2,3};
int[] b=a;
System.out.println(a[2]);
//输出的值为 3
b[2]=5;
System.out.println(a[2]);
//输出的值为 5
int[] b=a 只是把变量 a中存储的地址值赋值给 b ,此时变量 b 指向的的与a是同一块内存 修改b的值 a的值也会跟着修改