关键字的使用限制 数字之间的进制转换 java如何注释

2.1 关键字
关键字是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。好比是汉
语当中的一些专有名词：北京，天安门，兵马俑。不能乱用。
用于定义数据类型的关键字：byte short int long float double char boolean void class interface
用于定义数据类型值的关键字：true false null
用于定义流程控制语句的关键字：if else switch case default while do for break continue return
用于定义访问权限修饰符的关键字：public protected private
用于定义继承关系的关键字：extends implements
用于定义实例对象的关键字：new this super instanceof
用于定义函数类型的关键字：static final abstract synchronized
用于处理异常的关键字：try catch finally throw throws
用于包的关键字：package import
其他的一些修饰关键字：native assert volatile transient

2.2 标识符
标识符指的是我们在程序中对变量、函数、类、接口、常量所定义的名称，也就是说这些名称是我
们自定义的。
标识符必须满足以下组成规则：
标识符可以由数字、字母、下划线 _ 、美元符 $ 组成
标识符不能以数字开头，当然下划线和美元符其实是可以开头的，但不推荐
标识符不能是关键字
标识符也不能是Java内置类的名称
标识符可以为任意长度，但必须是一个连续的词
标识符严格区分大小写
标识符是为那些抽象的数据进行的自定义起名，为了方便程序的阅读和理解，起名尽量要有
含义，不要通篇都是a b c d e f g…。在一些特殊的情况下（循环里 特殊数学符号），可以使用i j k
m n 之类的。
标识符命名的规范：
大驼峰式：主要针对类名，接口名。所有单词的首字母大写
小驼峰是：主要针对于变量名，函数名。除了第一个单词之外，其他单词首字母大写
常量规范：所有单词字母大写，单词与单词之间用下划线分隔
包名规范：所有单词字母小写，单词与单词之间用句号 . 分隔

2.3 注释
注释是用于注解和说明程序的一些程序中的内置文本信息的，但这些内置文本不属于代码的范畴。
所以在对含有注释的源代码进行编译时，所生成的字节码中不含有注释。注释给人看的！
注释主要有三种：
单行注释 //注释内容 直到换行为止
多行注释 /* 注释内容 内部可以进行换行 /
文档注释 /* 注释内容 内部可以进行换行 */ ：文档注释可以被编译器识别，并生成相应
的程序说明书。对某一个类进行文档生成时，该类必须是public型
myAge 变量名
getMax() 函数名
MyMoney 类名 接口名
MAX_VALUE 常量名
com.oupeng.java 包名
param args 在运行主函数是 所传入的一些指令的
return 该主函数没有返回值
注：除了有解释说明程序的功能之外，还可以用来调试程序。
多行注释中，不能再出现多行注释
今后，在写代码时，一定要先写注释，并且，注释最好详细一些

2.4 常量与进制
常量就是指在程序中直接出现的一些数据，也叫字面量
常量都有哪些：
整数常量
小数常量
字符常量：由一个字母、数字、符号被单引号( ‘’ )标识的数据
字符串常量：由若干个字母、数字、符号被双引号( “” )标识的数据
布尔类型常量
null常量

```java
public static void main(String[] args) {
}
}
C:\Users\HENG\Desktop\JavaDay02>javadoc Sample.java
public class Sample {
public static void main(String[] args) {
//整数常量
System.out.println(10); //十进制整数
System.out.println(0b1001); //二进制整数 打印出来是十进制
System.out.println(0123); //八进制整数
System.out.println(0xAF3); //十六进制整数
//小数常量
System.out.println(3.14);
System.out.println(5.234e3);
System.out.println(1.2e-3);
//字符常量
System.out.println('a');
//System.out.println('ab'); ERROR
System.out.println('9');
//System.out.println('12'); ERROR
System.out.println('我');
System.out.println(' ');
//System.out.println(''); ERROR
//System.out.println('''); ERROR
System.out.println('\''); //打印 '
System.out.println('\n'); //打印 换行
System.out.println('\t'); //打印 缩进
//字符串常量
System.out.println("abcd");
System.out.println("a");
System.out.println(""); //字符串空串 vs null真空
System.out.println("\"");
//布尔常量
System.out.println(true);
十进制 二进制数
0 0
1 1
2 10
3 11
4 100
5 101
6 110
7 111
8 1000
二进制转十进制
规律就是：1 1 1 1 1 1 1 1 - 128 64 32 16 8 4 2 1
10010101 十进制是 128 + 16 + 4 + 1 = 149
十进制149 = 9 * 10
0 + 4 * 10
1 + 1 * 10
2
二进制1011 = 1 * 2
0 + 1 * 2
1 + 0 * 2
2 + 1 * 2
3 = 1 + 2 + 0 + 8 = 11
一个二进制位称之为是一个比特 bit；八个比特称之为一个字节 byte；字节是计算机当中的最小计
数单元。
1 byte = 8 bit
1 kb = 1024 byte
1 mk = 1024 kb
1 gb = 1024 mb
1 tb = 1024 gb
十进制转二进制
53 ÷ 2 = 26 ~ 1
26 ÷ 2 = 13 ~ 0
13 ÷ 2 = 6 ~ 1
6 ÷ 2 = 3 ~ 0
3 ÷ 2 = 1 ~ 1
1 ÷ 2 = 0 ~ 1
余数从下到上 110101 = 1 + 4 + 16 + 32 = 53
二进制转八进制
10010101 => 010-010-101 => 0225 = 5 * 8
0 + 2 * 8
1 + 2 * 8
2 =5 + 16 + 128 = 149
二进制转十六进制
System.out.println(false);
}
}
10010101 => 1001-0101 => 0x95 = 5 * 16
0 + 9 ^ 16
1 = 5 + 144 = 149
二进制转六进制
10010101 => 149
149 ÷ 6 = 24 ~ 5
24 ÷ 6 = 4 ~ 0
4 ÷ 6 = 0 ~ 4
所以六进制为405 => 5 * 6
0 + 0 * 6
1 + 4 * 6
2 = 5 + 0 + 144 = 149
负数的二进制
-29的二进制 将正数部分的二进制先取反 再加1 即为负数的二进制
00011101 =>取反 11100010 =>加1 11100011
2.5 变量
指的是变化的量
变量的本质就是在内存中程序所处的进程中的一个临时存储区域
该区域的存储值有限制的
该区域值的变化必须是同类型的或向下兼容的
该区域有其自身的物理内存地址-指针
该区域中 存储值的限制 和 数据的变化类型 由 数据类型 来决定
该区域中 其空间的分配 和 空间的物理内存地址 由计算机底层来决定
2.6 数据类型
在Java当中，数据类型主要分为两大类：
基本数据类型：在变量的空间中存储数据
整型
byte 1字节 2^8 256 -128~127 -2^7 ~ 2^7 - 1
short 2字节 2^16 65536 -32768~32767 -2^15 ~ 2^15 - 1
int 4字节
long 8字节
浮点型
float 4字节
double 8字节
字符型
char 2字节
布尔型
boolean 不确定
在常量中，整型常量默认int类型，小数常量默认是double类型
布尔类型，如果是单一变量的话，在JVM中true被认为是1 false被认为是0 所以是4字节存
如果是布尔类型数组的话，在JVM中true和false被认为是byte类型 1字节
public class Sample {
public static void main(String[] args) {
//整型byte short int long
byte b1 = 3;
/*
00000000 00000000 00000000 00000011
00000000
*/
byte b2 = 6;
System.out.println(b1 + b2);
//byte b3 = 800; //error
/*
00000000 0000000 00000011 00100000
00000000
*/
/*
Sample.java:11: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte b3 = 800;
^
1 个错误
*/
byte b4 = (byte) 800;
/*
00000000 0000000 00000011 00100000
00000000
00100000 阉割
*/
System.out.println(b4);
byte b5 = (byte) 933;
System.out.println(b5);
/*
00000000 0000000 00000011 10100101
00000000
10100101 阉割
10100101 - 1 = 10100100 取反 01011011 = 91
-91
*/
byte b6 = 100;
byte b7 = 100;
//byte b8 = b6 + b7; //error
//System.out.println(b8);
/*
Sample.java:40: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte b8 = b6 + b7;
^
1 个错误
*/
//如果不存在long类型的话 其他整型的相加结果一律为int
//b6与b7都是变量，相加的值对于b8而言是不确定的，所以结果可能会超范围
short s1 = 9;
short s2 = 10;
//short s3 = s1 + s2; //error
/*
Sample.java:53: 错误: 不兼容的类型: 从int转换到short可能会有损失
short s3 = s1 + s2;
^
1 个错误
*/
int i1 = Integer.MAX_VALUE; //int的最大值
int i2 = 1;
int i3 = i1 + i2;
System.out.println(i3); //整形溢出
/*
01111111 11111111 11111111 11111111
+1
10000000 00000000 00000000 00000000
-1
01111111 11111111 11111111 11111111
取反
10000000 00000000 00000000 00000000
*/
//long l1 = 123123123123; error
/*
Sample.java:74: 错误: 过大的整数: 123123123123
引用数据类型：数据是在堆内存中存储，变量仅仅存放的是数据在堆内存中的地址
字符串
数组
对象
在Java中，但凡存储在堆内存中的数据，统称为对象
2.7 运算符
算术运算符
long l1 = 123123123123;
^
1 个错误
*/
long l2 = 123123123123L; //long类型的常量
//long l3 = 123123123123123123123L; //error 爆了long的表
//float f = 3.14; //error
/*
Sample.java:85: 错误: 不兼容的类型: 从double转换到float可能会有损失
float f = 3.14;
^
1 个错误
*/
float f = 3.14f;
double d1 = 3.14;
double d2 = 10;
double d3 = 3.14f;
double d4 = f;
double d5 = b1 + s1 + i2 + l2; //也会出现溢出的问题
//char类型而言 变量空间存的是ASCII编号
char c1 = 'a'; //将字符a的编号存到c1里
char c2 = 'A';
System.out.println(c1);
System.out.println(c2);
System.out.println(c1 + c2);
char c3 = 97;
char c4 = 65;
System.out.println(c3);
System.out.println(c4);
System.out.println((char) 98);
System.out.println((char)(c1 + 4));
System.out.println('0' + 0);
//'a'97 'A'65 '0'48
boolean bool1 = true;
boolean bool2 = false;
}
}
算数运算
符
含义 备注
+ 加法 1+2=3 如果加号左右有字符串 则加号为连接符
- 加法 3-2=1
* 乘法 3*2=6
/ 除法 3/2=1 3.0/2=1.5 如果除号两边都是整数 结果为整数；有小数 结果为小
数
% 取余 9%5=4 注意一点，如果前或后为负数怎办？
a++
后置自增
a自身加一，使用原来的值
++a
前置自增
a自身加一，使用加之后的值
a--
后置自减
a自身减一，使用原来的值
--a
前置自减
a自身减一，使用加之后的值
赋值运算符
public class Sample {
public static void main(String[] args) {
/*
a++
1.先开辟临时存储区 将a的值赋值进去
2.a自身加一
3.临时存储区的值等待被调用 输出 赋值 参与运算
*/
int i = 0;
i++;
System.out.println(i++); //1
System.out.println(i); //2
int j = i++;
System.out.println(i); //3
System.out.println(j); //2
i = i++;
System.out.println(i); //3
i = i++;
System.out.println(i); //3
int a = 1;
System.out.println(a++ + ++a + a++ + a++ + ++a);
// 1 3 3 4 6
}
}
赋值运算符 含义 备注
+= 加法赋值 a+=3 a=a+3 赋值运算符只能用在变量身上
-=
*=
/=
%=
比较运算符
运算的结果为布尔类型
> 大于
< 小于
>= 大于等于
<= 小于等于
!= 不等于
逻辑运算符
& 单与
| 单或
^ 异或
! 非
&& 双与
|| 双或
位运算符
& 位与
public class Sample {
public static void main(String[] args) {
int x = 0;
int y = 0;
System.out.println(x++ > 0 & y++ > 0);
System.out.println(x);
System.out.println(y);
x = 0;
y = 0;
System.out.println(x++ > 0 && y++ > 0);
System.out.println(x);
System.out.println(y);
//&& 如果左边为假 则右边不用执行
//|| 如果左边为真 则右边不用执行
//相同为假 不同为真
System.out.println(true ^ true);
System.out.println(true ^ false);
System.out.println(false ^ false);
System.out.println(false ^ true);
}
}
| 位或
^ 位异或
>> 右移
<< 左移
三目运算符
数据类型 变量名 = 布尔表达式?值1:值2;
int number = 10 % 2 == 0? 10 : 2;
变量的交换问题：
方法一：
public class Sample {
public static void main(String[] args) {
int x = 7;
int y = 12;
System.out.println(x & y);
/*
0111
1100 &
0100 4
*/
System.out.println(x | y);
/*
0111
1100 |
1111 15
*/
System.out.println(x ^ y);
/*
0111
1100 ^
1011 11
*/
System.out.println(x << 3);
/*
0111
0111000
x * 2^3
*/
System.out.println(56 >> 2);
/*
111000
1110
56 / 2^2
*/
}
}
数据类型 变量名 = 布尔表达式?值1:值2;
int number = 10 % 2 == 0? 10 : 2;
int a = 3;
int b = 7;
方法一：
int c = a;
a = b;
b = c;
System.out.println(a);
System.out.println(b);
方法二：
a = a + b;
b = a - b;
a = a - b;
System.out.println(a);
System.out.println(b);
方法三：
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println(a);
System.out.println(b);