java基础回顾

保留字 const,goto
三个特殊值 true false null
关键字都是小写
Java共有50个关键字

标识符：凡是代码中需要自己”命名“的地方都是标识符
给变量、类、方法等命名的字符序列就是标识符
标识符有命名规范：（必须遵守，又称为硬规则，不遵守编译则会报错，或者运行出现问题）
1，只能使用26个英文字母大小写，数字0-9，下划线_,美元符号$
2，数字不能开头
3，不能直接使用关键字、保留字、特殊值
4，严格区分大小写
5，不能含有空格
标识符有命名规范（建议遵守，又称软规则，不遵守不报错，但是会被歧视，排外）
1，见名知意
2，类名 每一个单词的首字母大写
3，变量名、方法名 从第二个单词开始大写
4，包名所有单词都小写 单词之间使用.分割
5，常量名 所有单词都大写 单词之间使用下划线_

基本数据类型
byte1 short2 int4 long8 整数
float4 double8 浮点型 不精确
boolean(true,false) 布尔型 只有两种类型
char1 单字符

引用数据类型
数组
类 String类
接口
枚举
注解

常量值 代码写死的 规定不变的 一目了然的
整数常量值：1 1L/1l System.out.println（1）会被识别成int类型 System.out.println（1L）会被识别成long类型 数字后面可以加L或l
小数常量值：1.5 1.5F/1.5f System.out.println（1.5）会被识别成double类型 System.out.println（1.5f）会被识别成float类型,数字后面加F或f
单字符常量值：‘a’ System.out.println（‘a’） 识别为char类型，单引号
布尔类型：false,true System.out.println（true）System.out.println（false）识别为boolean类型
System.out.println(helloworld)会被识别成String类型 双引号
System.out.println(“1”) 会被识别成string类型 双引号 与 System.out.println(1) 输出结果都是1，但是第二个是分配4个字节

变量：程序在运行期间可以改变的量
如何声明变量
数据类型 变量名
变量名=变量值
变量使用的要求
1变量必须先声明后使用
2变量在使用之前必须先初始化
3变量值的类型必须与变量声明的类型一致或者兼容
一致：一样
int age = 18; 18是int类型的常量值 age也是int类型
兼容：可以装的下，<=
long bigNum = 18; 18是int类型的常量值，bigNum是long类型
int age = 18L; 错误 18L是long类型的常量值，age是int类型
long>int
4变量有作用域
5同一个作用域中不能重复声明

变量三要素：代表内存（jvm中的内存）中的一块存储区域
1数据类型：决定这块内存有多大，可以存什么数据
2变量名：给这块区域命名，就好比咱们这里叫做”xx科技园“
3变量值：这块内存中真正的值

特殊的变量，特殊的常量
通常称为最终变量或常量
如果某个变量的值，不允许修改，那么可以把变量声明为final

进制
生活中用的十进制 数字范围0-9 进位规则逢十进一
计算机中二进制 数字范围0-1 进位规则逢二进一
其他进制：
八进制和十六进制
八进制 数字范围0-7 进位规则逢八进一
十六进制 数字范围0-9 A-F(a-f) 逢十六进一

换算规则 25的二进制 直接除以2 余数倒过来 11001
二进制到十进制，从最右边开始依次用当前位的数字乘以2的n次方，最右边是0次，依次为1次，2次
二进制到八进制 3位二进制一组 从右边开始组合
011001 可以看作 011 001两组 011-3 001-1 -》31 OCT
二进制转十六进制 4位二进制一组，从右边开始组合
00011001 0001 1001 0001-1 1001-9 -》19 HEX
DEC 十进制

输出一个十进制的值是10
System.out.println(10);
输出一个二进制的值是10
System.out.println(0B10);
输出一个八进制的值是10
System.out.println(010);
输出一个十六进制的值是10
System.out.println(0X10);
10 2 8 16 显示结果都是10进制

整数换算规则：
十进制-》二进制：除2倒取余
二进制-》十进制：每一位的数字*2的n次方，然后相加
二进制-》八进制：每三位一组
八进制-》二进制：1位代表3位二进制
二进制-》十六位进制：每四位一组
十六进制-》二进制：1位代表4位二进制

计算机存储单位：
最小的单位是bit(位)
1位可以存储0或1
比如：boolean，可以用1位表示，0表示false，1表示true
最基本的单位是byte(字节)
1个字节=8位
1byte=8bit

1KB=1024byte
1MB=1024KB
1GB=1024MB
1TB=1024GB
1PB=1024TB

100Mb b是bit 实际上还要除以8

1个字节可以存储多大数字？ -128~127 为什么？
计算机存储数字有一个规则：
1符号位 二进制的最高位，最左边的位，用0表示正、1表示负数
25： 00011001
-25：10011001
-25-25=10000000=-0=0(结果是错)
2底层用补码表示
正数：补码和它的原码、反码一致
负数：补码和它的原码、反码不一致

原码：十进制转二进制，并且最高位符号位处理好
25
原码：00011001
反码：00011001
补码：00011001
-25
原码：10011001
反码：11100110(符号位不动，其余位取反)
补码：11100111（在反码的基础上+1）

-25-25=11100111-00011001=11001110(补码)
11001110 补码
11001101 反码
10110010 原码 -》-50

一个字节可以表示的数字范围？
01111111-》127
00000001-》1

11111111(补码)-》11111110(反码)-》10000001(原码) -1
10000001(补码)-》10000000(反码)-》11111111(原码) -127

00000000-》0
10000000-》用它表示-0浪费，用它表示-128

为什么是-128？
10000001（是-127）-00000001（是1）=10000000（结果应该是-128）

小数如何存储？
float：4个字节
double:8个字节
如何存储的呢？
1-先把十进制的小数换算成二进制
整数部分：和单独的整数一样，除以2倒取余
小数部分：乘*取整数部分

例如8.25为例 转为二进制：
首先整数部分除以2倒取余 1000
其次小数部分乘以2取整数部分（乘以2一次没有整数就接着乘，得到整数后将整数反转）0.252=0.5 0.52 =1.0
所以8.5-》1000.01
2-把带小数点的二进制用”科学计数法“表示
十进制的科学计数法：
586472.564-》科学计数法 5.8647256410的5次
0.0000568-》科学计数法 5.6810的10的-5次
科学计数法：整数部分只能是1位，并且非0
1000.01-》科学计数法 1.000012的3次
0.00011-》科学计数法 1.12的-4次

最终所有二进制小数用科学计数法表示之后
它们的整数部分都是1，即小数点左边只有一个1，
所以不用存储这个1和小数点了
3-所有二进制小数只需要存储：
A：符号位，仍然用最高位来表示，0表示正数，1表示负数
B：小数点后面的尾数
C：小数点移动的位数，称为指数，指数值还需要转换位二进制
4规定
float:4个字节，一共32位
1位符号位，8位用来存储指数，剩下23位用来存尾数
double:8个字节，一共64位
1位符号位，11位用来存储指数，剩下52位用来存储尾数

结论：
1-double类型的指数位比较多，意味着它可以表示存储的数据范围更大
2-double类型的尾数位比较多，意味着它可以表示的数字精度更大
3-float类型虽然是4个字节，它的存储范围比long和int类型都大

单字符char类型的存储范围？
1、先把每一个字符用一个整数值表示
最早计算机能表示的所有字符只有128个。编码值范围0-127
把这张字符与整数对应的表称为ASCII表

计算机又流行到其他地方。不同的国家就动起了剩下的128个位置的念头
1个字节一共可以有256中值的情况
1-出现问题，无法在同一个文档中，表示不同国家的字符
2-计算机流行到亚洲系列，256是远远不够的
中国又开始研究自己的编码表，比如GB2312，GBK，Big5
3-为了解决上面问题，提出了万国码，Unicode编码表

2、Java选择使用Unicode编码表
char类型占两个字节
编码范围0-65535
同时Unicode编码表会兼容ASCII表（0-127）
‘a’->97
‘b’->98
…
‘A’->65
‘B’->66
…
‘0’->48
‘1’->49
…
空格->32
…

刚才说的ASCII表和Unicode编码表这些事处理数据在"内存"中的方式
这些是环境编码。当把字符等存储到硬盘文件中，或者网络中传输时，使用的编码。

public class Demo{
public static void main(String[] args){
int a = 1234;
int ge=a%10;
int shi=a/10%10;
int bai=a/100%10;
int qian=a/1000%10;

int i=1;
int j=i++;
(1)先取i的值，放入操作数栈
(2)i自增 i=2
(3)用操作数栈中的值1赋值给j
i=2 j=1;

int k = i++++j + ++ij++;
(1)i++ 先取i的值，放入操作数栈 紧接着i自增 i=3
(2)++j j先自增 j=2 放入操作数栈中
(3)算* 取除操作数栈中i=2 j=2的值 计算结果 = 4
这个4重新返回操作数栈

接着算后面一段 ++ij++
(1)++i i先自增 i=4 放入操作数栈中
(2)j++ 先取j的值，放入操作数栈中 紧接着j自增 j=3
(3)算 取除操作数栈中i=4 j=2的值 计算结果 = 8
这个8重新返回操作数栈

所以4+8=12

int i = 1；
int j = i++;
(1)先取出i的值1，放入操作数栈中，再自增i=2
(2)将操作数栈中的值赋值给j j=1
i=2 j=1

int k = i++ * ++j + --ij–;
(1)i++ 先把i的值放入操作数栈，再自增i=3
(2)++j j先自增，j=2 再放入操作数栈中
(3)算 取出操作数栈中的值 i=2 j=2 计算结果 4
(4)–i i先递减 i=2 放入操作数栈
(5)j-- 先把j的值放入操作数栈中 再递减j=1
(6)算* 取出操作数栈的值 i=2 j=2 计算结果 4

所以4+4=8

int i =1;
int j = ++i + i++ * ++i + i++;

sout(i)5
sout(j)14

(1)++i i先自增为2，再放入操作数栈中 i=2
i++++i
(2)i++ 先将i的值放入操作数栈中i=2，再自增i=3
(3)++i i先自增 i=4 再放入操作数栈中
24=8
++i + i++ * ++i =2+8=10
(4)i++ 先把i的值放入操作数栈，再自增i i=5
(5)++i + i++ * ++i + i++ = 10+4=14

int i = 0;
int result = ++i/–i;
sout(result);

(1)++i i先自增为 i=1 再放入操作数栈中
(2)–i i先递减为 0
1/0 报错 有异常

1-比较运算符计算的结果只有两种：true/false
所以比较表达式通常都是作为判断条件来使用
2-等于 ==是表示判断 =是表示赋值

逻辑运算符
特殊：
1-逻辑运算符的操作数必须是boolean
2-逻辑运算符的结果也是boolean值
int score = 100;
sout(0<=score<=100) 报错 第一个类型：boolean 第二个类型：int true<=100?不对的

& 只有两边都是true，结果才是true
| 只要一边是true 结果就为true
^ 只有两边不一样，一个是true，一个是false 结果才为true
短路与：&& 只有两边都是true，结果才是true 但是它如果左边为false，右边不看 这样好处就可以提高效率
短路或||：只要一边是true，结果就为true 但是它如果左边为true，那右边不看了 这样好处就可以提高效率

inte a = 1;
int b = 2;
int c = 0;
boolean flag = false;
if(flagtrue){ 条件不成立
c=a++ +b; 不执行
}
if(flagfalse){
c=++a -b; ++a a先自增 a=2 放入操作数栈 -b
}
sout(a) 2
sout(b) 2
sout© 0

}
}

boolean x = true;
boolean y = false;
short z = 42;
if((z++42)&&(ytrue)) z++;
(z++) 先取z的值放入操作数栈中，再自增 z=43 42=42 true 再看 ytrue？ false true/false false 不成立 不执行该if
if((x=false)||(++z45)) z++;
(x=false) 赋值 x=false (++z)先自增z z=44再放入操作数栈 44=45? 不等于 false/false false 不成立 不执行该if
sout(z) 44

如果变成
boolean x = true;
boolean y = false;
short z = 42;
if(y=true)
if((z++42)&&(ytrue)) z++;
if((x=false)||(++z==45)) z++;
sout(z) 46

位运算 左移<<
左移几位，相当于乘以2的几次方
如果左移的位数，超过当前数据类型的总位数，需要先减去总位数
例如：3<<34 等价于 3<<2 322=12(32的2次方)
byte,short类型再运算时会自动提升为int。
sout(3<<4)//48
sout(3<<34)//12
3的二进制补码 ：00000000 00000000 00000000 00000011
3<<4 00000000 00000000 00000000 00110000 48
32的4次方 = 3*16=48

sout(-3<<4)
-3的二进制原码 10000000 00000000 00000000 00000011
-3的二进制反码 11111111 11111111 11111111 11111100
-3的二进制补码 11111111 11111111 11111111 11111101
-3<<4 11111111 11111111 11111111 11010000 补码
11111111 11111111 11111111 11001111 反码
10000000 00000000 00000000 00110000 原码 -48

右移>>
右移几位就相当于除以2的几次方 结果会向下取整
sout(83>>4) 83/2的4次方 =83/16=5 整数和整数相除，结果还是整数
如果右移的位数，超过当前数据类型的总位数，需要先减去总位数
byte,short类型再运算时会自动提升为int。

无符号右移：>>>
无论最高位是1还是0，右移时左边都是补0
对于正数来说，和右移是一样的
对于负数来说，结果会不同
sout(-83>>4)
-83的二进制原码：10000000 00000000 00000000 01010011
-83的二进制反码：11111111 11111111 11111111 10101100
-83的二进制补码：11111111 11111111 11111111 10101101

-83>>4 11111111 11111111 11111111 11111010 补码
11111111 11111111 11111111 11111001 反码
10000000 00000000 00000000 00000110 原码 -6
sout(-83>>>4) 268435450
-83的二进制原码：10000000 00000000 00000000 01010011
-83的二进制反码：11111111 11111111 11111111 10101100
-83的二进制补码：11111111 11111111 11111111 10101101

-83>>>4 00001111 11111111 11111111 11111010

按位与：&
对应位，
1&1 结果还是1
1&0 结果是0
0&1 结果是0
0&0 结果是0

按位或：
对应位，
1|1 结果1
1|0 结果1
0|1 结果1
0|0 结果0

sout(3&4)0
3的二进制 24个0 00000011
4的二进制 24个0 00000100
3&4 24个0 00000000

sout(3|4)7
3的二进制 24个0 00000011
4的二进制 24个0 00000100
3&4 24个0 00000111

按位异或
1^1 结果0
1^0 结果1
0^1 结果1
0^0 结果0

sout(3^4)7
3的二进制 24个0 00000011
4的二进制 24个0 00000100
3^4 24个0 00000111

sout(6^4)2
6的二进制 24个0 00000110
4的二进制 24个0 00000100
6^4 24个0 00000010

按位取反：~
~1是0
~0是1

sout(~4)-5
4的二进制 24个0 00000100
~4 24个1 11111011 补码
~4 24个1 11111010 反码
~4 1 23个0 00000101 原码 -5

赋值运算符
基本赋值运算符：=
扩展赋值运算符：
+=
-=
*=
/=
%=
&=
|=
^=

=
<<=
注意
1-=左边必须是变量，不能是常量值，不能是表达式
2-=右边的值(常量、变量、表达式)的类型必须<=左边变量的类型
3-=永远是最后算的
4-扩展的赋值运算符，当最后的赋值结果类型大于左边的变量类型时，会自动发生强制类型转换
所以拓展的赋值运算可能发生溢出或损失精度

int a = 1;
int b = 2; a=b+1;正确 b+1=a错误 左边是一个值了不是变量(左边只能写变量)

byte b1 = 1;
byte b2 = 2;
//b1=b1+b2;//b1+b2会自动升级为int int>byte
b1+=b2;//相当于 b1 = b1+b2 此时会把int强制转换为byte

byte b3 = 127;
byte b4 = 2;
b1+=b2;
sout(b1)-127

a*=a+b a=a*(a+b)

运算符优先级
单目运算排第一
乘除余二加减三
移位四，关系五
等和不等排第六
位与、异或和位或
短路与和短路或
依次从七到十一
条件排在第十二
赋值一定是最后

小写字母与大写字母之间存在什么关系
‘a’=97 ‘A’=65 相差32
‘b’=98 ‘B’=66 相差32
实现大小写字母转换
Scanner sc = new Scanner(System.in)；
char letter = sc.nextLine();
System.out.println(letter);
System.out.println((char)(letter-32));小写变大写
System.out.println((char)(letter+32));大写转小写

计算9与7

1001 9
0111 7
按位与
0001 1

1001 9
0111 7
按位或
1111 15

1001 9
0111 7
按位异或
1110 14

psvm
int i = 1;
int j = 2;
i+=j++; =>i=i+j++ i+j++ = 1+2 = 3 j先放入操作数栈再自增 j= 3 i=3

j=i++/2 + ++ij-- i++先放入操作数栈再自增i = 4 3/2 整数运算得整数 1 ++i先自增 i=5再放入操作数栈 j–先放入操作数栈再自减2 ++ij–=15
1+15=16
sout(i);5
sout(j);16

判断一个整数是否是3的倍数或者以3结尾，是则打印true，否则打印false
num%30 || num%103

输入两个整数存入a,b 按照从小到大顺序输出
int max = a>b?a:b;
int min = a<b?a:b;

使用if if(a>b) else

使用中间值temp

System.out.printf(内容，变量列表)
内容中需要用占位符
%d：整数
%f：小数
%.nf：小数点留n位
%c：单字符
%s：字符串
%b：boolean

year保存年份
1-要么能被4整除，同时不能被100整除
2-要么能被400整除