Java基础2--进制--变量--运算符

2-1，关键字

1，Java语言基础组成：关键字，标识符，注释，常量和变量，运算符，语句，函数，数组，这与其他的语言的基本组成差不多。只是表现形式不同。

2，掌握两点：表现形式和什么时候使用。

3，关键字：被赋予了特殊Java含义的单词。
如class,public,static,void
特点：关键字中所有的字母都是小写。

2-2，标识符

1，用于标识一些东西的符号。
用途：在程序中自定义的一些名称。
组成：由26个英文字母大小写，数字0-9，_，$组成。
定义合法标识符的规则：
(1)数字不可以开头。
(2)不可以使用关键字。

2，Java中严格区分大小写。
注意：在起名字时，为了提高阅读性，要尽量有含义。

2-3，注释

1，作用：用于注释说明解释程序的文字就是注释，提高了代码的阅读性。

2，其中两种方式：
(1)//内容 用于注释单行文字
(2)/*

内容
*/
用于注释多行文字。
以上两种形式很多语言都通用。

3，Java的特有注释：
/**
内容
*/
文档注释。这种形式可以通过JDK中的javadoc工具进行提取，在计算机中单独形成一个说明的文档。是程序的说明书，生成的文档是给程序员看的。

4，单行注释可以嵌套单行注释，也可以嵌套多行注释。
多行注释可以嵌套单行注释，多行注释中不能有多行注释。

5，注释可以用于检查错误，如：注释掉其中几行，若不报错，则是注释的那几行有错误。

6，小细节：注释文字不会被写到字节码文件中，仅在.java文件中显示，因为注释是给程序员看的。

2-4，注释的应用。

1，实际开发是必须要写注释，这是规范。

2，写代码是，要先有思想，先用注释将整个模块的思路写下来，再写代码，没思想没代码。

2-5，常量与变量

1，常量表示不能改变的数值。

2，Java中常量的分类。
(1)整数常量，所有整数。
(2)小数常量，所有小数。
(3)布尔(boolean)常量，有两个值，true和false。
(4)字符常量，用单引('')标识。
(5)字符串常量，用双引("")标识。
(6)null常量，只有一个值null。

3，对于整数：有四种表现形式：
二进制：0,1，满二进一。
八进制：0-7，满8进1，用0开头表示。
十进制：0-9，满10进1.
十六进制：0-9，A-F，满16进1，用0X开头表示。

2-6，进制的由来。

1，进制，就是一种计数方式。
如：十进制就是十个为一组，然后从1开始数。
二进制就是两个为一组，然后从1开始数。

2，由来：二进制早期是由电信号产生的，电信号有两种状态，要么开，要么关，1表示关，0表示开。计算机将8个01封装成1组，即：byte(字节)=8个2进制位,(8个bit)。计算机中最小的单位是字节。

3，1K=1024byte。很多厂商为了计算方便就按1000计算。
买了硬盘以后，比如买了一个500G的，但回家发现不够500G，是因为出厂时是按1000计算的，也就是说厂商按1000M为1G，在计算机中按1024M为1G，所以不足500G。
二进制表示起来很麻烦，就将二进制3个为一组，或四个为一组分割，三个为一组的就是八进制，四个为一组的就是十六进制。

2-7，进制转换

1，十进制：752 = 2*100+5*101+7*102 = 752.

二进制：1011 = 1*20+1*21+0*22+1*23= 64 .

八进制：1011 = 1*80+1*81+0*82+1*83= 521.

2，二进制的111对应10进制的7，代表八进制最大为7.
二进制的1111对应10进制的15，代表十六进制最大为15.
所以以三个二进制位为一组切一组二进制数，能表示所有的八进制数。以四个二进制位为一组切一组二进制数，能表示所有的十六进制数。

3,1010 1110的八进制表示为
010101 110
2 5 6 所以八进制表示为0256
十六进制表示为：
10101110
A E 十六进制表示为0XAE
技巧：十进制变为其他进制的方法：先将十进制数转成二进制数，再按上面方法获取其他进制。
二进制和十六进制常用，其他进制不常用。

4，IP地址是由4个字节组成的，每个字节有8个二进制位组成，所以每段最大为255.

5，十进制-->二进制
就是十进制数除以2求余的倒序排列。



倒叙后，结果是110，所以6的二进制是110.

2-8，负数的进制。

1，整数在电脑中用4个字节表示，即4个8位。

如6-->0000 0000 0000 0000 0000 0000 0000 0110

2，十进制数的负数的二进制表示。

就是这个数的正数的二进制取反，再+1.

如：-6，正数是6,6的二进制是0000 0110.取反是：1111 1001.

加1: 1111 1001

+0000 0001

1111 1010 = -6

规律：负数的二进制的最高位是1.

3，计算机内部是如何进行运算的呢？

如：11+6=17是将11和6转为二进制，再相加，得到另一个二进制，再转为10进制，就是结果。

1011 -->11

+0110 -->6

10001 -->17

2-9，变量

1，概念：是内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域数据可以在同一类型范围内不断变化。

计算机中的运算一般是在内存中运算，内存比硬盘快，为了运算方便，在内存中为变量开辟一块空间，用于存储变量的值。

2，Java是强类型语言，一片内存中只能存放指定类型的数据。

变量三要素：类型，名称，赋值。

3，为什么要顶一变量？

用来不断的存放同一类型的常量，并可以重复使用。

4，使用变量注意：

变量的作用范围：一对{ }之间有效。

要对变量初始化。

数据类型：

|--基本数据类型(8种)：

|--数值型

|--整数类型：byte,short,int,long

|--浮点类型：float,double

|--字符型

|--char

|--布尔型

|--boolean

|--引用数据类型

|--类(class)

|--接口(interface)

|--数组([ ])

整数默认int,小数默认double。

byte:在内存中占一个8位，取值:-128~127,-27~27-1

short:在内存中占两个8位，-215~215-1,-32768-32767
int:在内存中占四个8位，-231~231-1
long:在内存中占八个8位，-263~263-1，在数字结尾要加上一个”L”。
byte和int常用。

如果：把short型数据强制放到byte中，那么只能将前面的8位装入，而后面的8位将丢弃。（二进制中，右边是前面）

float:单精度，四个字节表示，在结尾要加上一个“f”。
double:双精度，八个字节表示。
char:两个字节，0~65535。

2-10，变量基本演示

1，定义变量的格式：
数据类型 变量名 = 初始化值;
注意：格式是固定的，记住格式，以不变应万变。
变量就如同数学中的未知数。

2，作用域

main(){
byte b = 3;
{
int a = 4;
Sop(a);	//正确
}
Sop(a);		//编译报错，a的作用域为里面的一对大括号之间，出了作用域，a所在的内
//存空间自动释放
}

2-11，类型提升和强制转换

1，运算两边必须是同类型才能运算，不同类型不能运算。但如果都是数值型的时候，是可以运算的。因为运算是变量做了自动类型提升，将两边变为相同类型，以占用内存大的那个类型为主。
例如：
int x = 3;
byte b = 5;
x = x + b;
因为int占用的内存空间较大，为4个字节，而b只占用一个字节，若将x变为byte可能丢失数据，故将b提升为int，再进行运算。

2，int x = 3;
x= x + 5; 的内存图解



进行x=x+5的时候，内存会开辟出一块运算区进行运算，再将结果返回给x内存区域。

3，byte b = 3;
b= b + 4; 报错的内存图解。



由于b为byte类型，只有一个字节的空间，而结果是4个字节，将四个字节的数据赋给一个字节的数据，所以可能造成数据的丢失，所以报错。
若要强制运算：可以b=(byte)(b+4);这时强制类型转换。强制将b+4转化为byte型，如：将int型转为byte型，则是将前三个字节丢弃，只保留最后一个字节，这样很容易造成数据的丢失，所以强制类型转换要慎用。
强制类型转换图解：
例如有个int型的变量a，其转为二进制是：

2-12，字符类型运算过程

1，float和int做运算结果还是小数。

2，为了与生活中的文字相关联就出现了编码表，美国的ASCII码表，用计算机中的二进制位表示。生活中的文字例如：0110 0001表示a，对应十进制为97，所以字符型数据可以和整数做运算。例如：’a’+1=98
ASCII:American Standard Code forInformation Interchange
美国信息交换标准代码。

‘a’+1 : ‘a’在内存中占两个字节，1(int型)占四个字节，所以’a’自动提升为四个字节，找到对应的二进制码，再做+1运算，因为被提升为int型，所以结果为98，若想的到字母的结果，强制转换(char)(‘a’+1)就会用98的二进制查对应的码表，得到字符。

3，中国码表：
GB2312,国标，有六七千文字符号。
GBK，国标扩展码，最常用。
GB18030
中文也能比大小，比的是码表对应的底层的数字。

4，几个常用字符对应的码：’a’:97,’A’:65,’0’:48。

5，Java内置码表为Unicode，国际标准码表，能识别全世界的文字。

2-13，类型运算细节

1，读程序，说出运行结果：

byte b = 4;
//b = 3 + 7;   //正确
byte b1 = 3;
byte b2 = 7;
b = b1 + b2;   //报错
Sop(b);

下面为什么报错？
答：byte b = 4;这一句中，4是int型，在赋给b的时候会判断这个数有没有超过byte的范围，若没有超过则赋值成功，b = 3 + 7;这一句同理。b = b1 + b2;这一句，b1，b2都是byte型，若b1现在取127，b2取2，则相加就会超出byte的范围，由于变量b1,b2在电脑看来是未知数，所以电脑会认为无法检查其是否超出范围，所以报错。

2，读程序，说出结果

int x;
int x1 = Integer.MAX_VALUE;
int x2 = 2;
x = x1 + x2;
Sop(x);

这时不报错。因为int是默认类型，x1+x2超过范围后向前进位，int最大为32位，很可能超到33位上，这时只保留32位，丢弃33位，最高位变为1，所以变成一个负数。

2-14，算术运算符

1，运算符分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三元运算符

2，算术运算符：+ - * / %(求余)+(连接符)
int x = 6370;
x = x / 1000; //结果为6，自动舍弃小数位

int x = 5;
x = x % 2; //结果为x=1，取余数

4%5=4,3%5=3，左边小于右边，结果就是左边。
涉及负数运算时，负号只参考被模数(前面的是被模数)

3，什么时候使用%
一个数%2，不是0就是1，可模拟开关运算，或判断奇偶

4，任何字符与字符串用”+”相连接都会变为一个新的字符串

2-15，算术运算符和赋值运算符

1，++(自增) --(自减)
++：在原有数据的基础上+1，再赋给原有的数据。

2，int a = 3;
a+ 1; //错误，没有任何赋值，不是一个语句
Sop(a);

3，int a = 3 , b;
b= a ++; 的内存图解。



过程：a++是先将a的值临时存储到一片区域中，再用自己本身的值进行+1运算，得到4，再将4赋给本身的值，然后再将临时区内的3赋给b，Java认为，原来的值要参与其他运算，所以进行了预留(临时存储)a=4,b=3。
注：若a不参与其他运算，如b=a++(有赋值运算)，则有没有临时存储没有什么差别。
b=++a就是先把++后的结果4赋给b，然后再进行a的自增。
一句话总结++a和a++的区别：
++a是先将自身+1，在进行运算；a++是先用a的原始值运算，运算完，再+1。

4，赋值运算符
= += -= *= /= %=
a+=2; 相当于 a = a + 2;

5，一道题
short s = 3;
s+=4;
s=s+4;
以上两句有什么区别？
答：第二句报错，第一句没错。
s=s+4，s进行自动类型提升，提升为int，s+4结果为int型，而左边的s为short型，可能造成精度丢失，所以报错，且在底层做了两次运算。
s+=4，是将s+4的值赋给s，只做一次运算，算完s+4后自动进行强转，即：s=(short)(s+4);不造成丢失，所以不会编译失败。