Java菜鸟学习之路之基础编程---关键字、标识符、基本数据类型和引用数据类型、类型转换机制、原码反码补码详解(二)
1.关键字与保留字
关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊含义，用作专门用途的字符串(单词)
特点：关键字中的所有字母都为小写
注意：严格意义来讲，true和false和null不算是关键字，但是可以被当作关键字来使用。
可以这样理解，我们需要特定的玻璃杯来盛水，但是我们没玻璃杯的话，我们是不是也可以用塑料杯来盛水，塑料杯有玻璃杯的作用，但它终究不是玻璃杯的范畴。
- 保留字
Java保留字:现有Java版本尚未使用，但以后的版本可能会作为关键字来使用。自己明明标识符时要避免使用这些个保留字。(现在还不是关键字--->将来可能是)
保留字：goto、const
2.标识符(Identifier)
- 定义：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符
定义合法标识符的规则：--->如果不遵守以下规则,则编译无法通过！必须严格遵守
(1)由26个英文字母的大小写，0-9,_或者$组成。
(2)数字不可以开头。
(3)不可以使用关键字和保留字，但可以包含关键字和保留字。
(4)Java中严格区分大小写，长度不限制。
(5)标识符不能包含空格。
标识符命名测试用例：
public class BSF_Test {
public static void main(String[] args) {
/*标识符：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
* 标识符可以包含26个英文字母的大小写，可以包含数字0-9，也可以包含_和$
* 注意：标识符不能以数字开头
*/
int miles = 3;
int Test = 11; //符合标识符的语法规范
int $san = 5; //标识符可以以$符号开头，java中是允许的
int _zhangsan = 6; //标识符可以以_符号开头，java中也是允许的
int publicabc = 8; //但是变量名称中可以包含我们的一个关键字，就不会出现错误了
//int 6mile = 4; //会报错，标识符不能以数字开头
//int public = 7; //会报错,单独的一个关键字或者保留字不能作为标识符，因为他们都在java中具有特殊含义的字符串
//int 4#R = 9; //会报错,java标识符允许范围定义中没有#符号
//int a++ = 10; //会报错,java标识符允许范围定于中没有++符号
//int b test = 11; //会报错,java标识符命名中不能包含空格
}
}Java中的名称命名规范:--->如果不遵守以下规范,则编译可以通过！建议大家这样命名
包名：多单词组成时所有的字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成是，第一个单词首字母小写，第二个单词开始首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意：
(1)在起名字的时候，为了提成代码的可读性，标识符名称要尽量有意义，做到"见名知意"。
(2)java采用unicode字符集,因此标识符可以使用汉字声明,但是不建议使用。
3.变量
- 概念：
(1)内存中的一个存储区域
(2)该区域的数据可以在同一类型范围内不断变化
(3)变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
- 作用：用于在内存中保存数据
- 使用变量的注意点：
(1)Java中每个变量都必须先声明，后使用
(2)使用变量名称来访问这块区域的数据
(3)变量的作用域:其定义所在的一对{}内
(4)变量只有在其作用域内才有效
(5)同一个作用域内，不能定义重名的变量
变量的测试用例：
public class VariableTest {
public static void main(String[] args) {
/*变量的定义格式: 变量类型 变量名 = 变量值;
* 说明：
* (1)变量必须先声明，后使用
* (2)变量都定义在作用域内，他是在作用域内是有效的，我们也可以理解为出了作用域之外，就会失效
* (3)同一个方法中，不可以定义我们的两个同名变量
*/
//1.变量的定义
int myAge = 10;
//int myAge = 22; //编译出错，报出变量已定义的错误，同一个方法(作用域)中不能定义两个同名变量，否则的话，java虚拟机在运行调用变量的时候不知道该调用哪一个了
//变量的使用
System.out.println(myAge);
//使用myNumber变量之前，必须先定义我们的变量
//System.out.println(myNumber); //编译出错，会报找不到符合的错误，变量必须先声明，后使用
//2.变量的声明
int myNumber;
//使用myNumber变量之前，必须先进行初始化，也就是我们所常说的赋值操作
//System.out.println(myNumber); //编译出错，可能尚未初始化myNumber变量
//变量的赋值
myNumber = 1001;
//变量的使用
System.out.println(myNumber);
//System.out.println(myClass); //编译出错，会报找不到符合的错误，变量只在指定的的作用域(方法(一对{ }))内有效，定义在我们的method()方法中，我们main()方法无法引用(找到)该变量
}
public void method() {
//myNuber变量是在主函数中定义的局部变量，当出了我们主函数的作用域，在我们的新方法method()中调用，那肯定是无效的
//System.out.println(myNumber);
int myClass = 1;
}
}
4.Java定义的数据类型
4.1基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
4.1.1整数类型：
整型的测试用例：
public class Varable1_Test {
public static void main(String[] args) {
//byte(1字节 = 8bit)(-2^8~2^8-1) short(2字节) int(4字节) long(8字节)
//计算机中是以bit为0或者1来存储数据的
//(1)byte的取值范围为-128~127
byte b1 = -6;
//byte b2 = 128; //编译不通过，超过byte的取值范围
System.out.println(b1);
//System.out.println(b2);+
//(2)声明为long类型的数据，我们要在赋值的末尾加上'l'或者'L',来表征这个数据是long长整型的数据
long l = 56168541441l;
System.out.println(l);
//(3)在我们实际开发中，由于int类型的数值范围的缘由，经常都将我们的整型变量定义为int类型的
int a = 123321563;
System.out.println(a);
//(4)整型常量默认为int型
long l1 = 16165165; //编译通过，这里得我们赋值得数据没有加long长整型得表征符号'l'或者'L'，为什么没有出现错误呢，因为在java中整型常量默认为int类型，int类型小容量得数值赋值给long长整型大容量得变量得时候，java内部会对其进行自动类型提升，一般我们定义long长整型得时候还是不要忘了在末尾加上表征符号'l'或者'L'
longl2 =156161616165412; //编译失败，过大的整数，未加表征符号整型常量默认为int型，超过int整型得表征数据得最大范围
//我们可以通过在末尾显式得加上long长整型表符号'l'或者'L'来避免出现这样得问题
System.out.println(l);
}
}
4.1.2浮点类型：
浮点类型得测试用例：
public class Varable1_Test {
public static void main(String[] args) {
//浮点型： float(4字节)单精度 精确到小数点后7位 \ double(8字节)双精度 精确到小数点后14位
//(1)浮点型：表示能代表小数的数值
double d = 3.1415926;
System.out.println(d);
//(2)小数类型常量数值默认是double类型
float f = 3.556416; //编译失败，当没在小数末尾加上单精度浮点型表征符号'f'或者'F'时,小数默认常量数值类型为double类型，赋值表达式是从右向左执行得，由大容量得数据类型double向小容量得数据类型转换时，必须进行强制类型转换
//也可以在小数数值后面加上单精度浮点型表征符号'f'或者'F'来避免出现这样得错误
//(3)定义单精度类型的小数时，我们需要在小数的末尾加上'f'或者'F'来标识我们的单精度float型小数，并且float类型的小数表示的数值范围比long长整型都大
//float f1 = 3.11747; //编译会报错
float f1 = 3.11747f;
System.out.println(f);
//(4)在日常开发中，由于double类型的小数精度更高，并且可以省略我们单精度的'f'或者'F'标识，所以我们常用double类型的小数
}
}
4.1.3字符类型：
字符类型的测试用例：
public class Varable1_Test {
public static void main(String[] args) {
//字符型：char(1字符 = 两个字节)
//(1)通常定义我们的char型变量，使用一对' ',内部 能且只能存放至多1个字符
char c = 'a';
//c = 'AB'; //编译报错，一对' '里面只能存放至多一个字符
System.out.println(c);
/*(2)表示方式
* 1.声明一个字符
* 2.转义字符
* 3.直接使用Unicode值来表示字符型常量
*/
char c2 = '\n'; //换行符，相当于一个System.out.println();
c2 = '\t'; //制表符，相当于我们键盘上一个tab键的效果
//System.out.println(c2);
char c3 = '\u0043'; //直接使用unicode编码来表示我们的一个字符
char c4 = 97;
System.out.println(c4);
System.out.println(c3);
System.out.print("Hello" + c2);
System.out.println("World!");
}
}
4.1.4 布尔类型：(占用4个字节) ：
布尔类型的测试用例：
public class Varable1_Test {
public static void main(String[] args) {
//boolean型
//(1)Java中的判断类型，只能取两个值：true 和 false
boolean b2 = true;
System.out.println(b2);
//(2)布尔类型当作成员变量使用时，未赋值的情况下默认为false
//(3)常常在条件判断和循环结构中使用
}
}
4.2引用数据类型：
类(class)（String）
接口（interface）
数组(array)
字符串类型：String解析
- 使用：
1.String属于引用数据类型，翻译为字符串
2.声明一对String类型得变量时，使用一对" "来声明，中间可以写入想加入得字符串
3.String类型变量可以为空值"",但是char类型得字符变量不能为空 ' '但是可以一个空格也是可以解析为一个字符得
4.String类型变量可以和8种基本数据类型都做运算得，且运算只能是连接(拼接)运算: +
5.运算结果仍然是String类型得
6.String字符串引用类型不能直接强制转换成基本数据类型，需要经过一定得步骤
String字符串的测试用例：
/*String类型变量的使用：
* 1.String属于引用数据类型，翻译为字符串
* 2.声明一对String类型得变量时，使用一对" "来声明，中间可以写入想加入得字符串
* 3.String类型变量可以为空值"",但是char类型得字符变量不能为空 ' '但是可以一个空格也是可以解析为一个字符得
* 4.String类型变量可以和8种基本数据类型都做运算得，且运算只能是连接运算: +
* 5.运算结果仍然是String类型得
*
* */
public class String_Test {
public static void main(String[] args) {
String s = "Hello World!";
System.out.println(s);
String s1 = "a"; //编译通过，字符串得定义比字符更大，里面存得是一个个得字符，可以存储多个字符，也可以存储单个字符，也可以为空
String s2 = ""; //编译通过，字符串型String变量可以为空
// char c = ''; 编译出错，报错内容解析时已到达文件末尾，char字符型变量定义时不能为空，必须添加一个字符，有且只能放一个
int number = 1688;
String s3 = "杨超越";
boolean b = true;
System.out.println(s3 + b); //输出为杨超越true
System.out.println(s3 + number); //输出为杨超越1688
//可以看出String字符串类型的引用变量在和其他基本数据类型进行+运算时，都是先将基本数据类型1688首先转换成字符串类型"1688"，然后再用+进行连接(拼接)原酸
//--------------------------------------->
//练习1
char c = 'a';
int num = 10;
String str = "Hello";
System.out.println(c + num + str); //107Hello
//加法运算从左到右执行，首先进行c + num得运算，此时这两个变量先运算，还没有遇到字符串类型得变量，"+"号表示两变量进行加法运算，结果为c得ASCII值97和整型num10相加，结果为107，之后将此结果107和字符串类型str进行运算，运算两边一旦出现字符串类型，那么"+"号代表拼接运算，将107和str变量Hello拼接得到字符串类型得"107Hello"
System.out.println(c + str + num); //aHello10
//c + str先进行运算，"+"号左右两边一旦有String字符串型变量，那么这个"+"号就代表着两变量要进行拼接运算，得到拼接结果为字符串类型"aHello"在和后面得num10进行拼接，得到结果为"aHello10"
System.out.println(c + (num + str)); //a10Hello
//在java中，()括号符号可以提高运算得优先级，那么就是得先num和str运算得出结果,因为"+"号两边有字符串类型，确定此时运算为拼接运算，得到结果为字符串类型"10Hello"，前面得字符类型'a'在和前面运算得结果进行拼接，得到最终结果为"a10Hello"
//练习2，输出"* *"
System.out.println("* *"); //* *
System.out.println('*' + '\t' + '*'); //93
System.out.println('*' + "\t" +'*'); //* *
System.out.println('*' + '\t' + "*"); //51*
System.out.println('*' + ('\t' + "*")); //* *
//以上输出均要把握"+"号两边有无字符串类型，把握"+"号得作用是进行加法运算，还是拼接运算
}
}
5.基本数据类型的转换：
前提：这里讨论的只是7种基本数据类型变量间的运算，不包含boolean类型的
说明：此时容量的大小指的是，表示数的范围的大和小，而不是在内存中所占字节数的大和小。比如，float容量要大于long的容量
1.自动类型转换： 容量小的类型自动转换为容量大的数据类型。数据类型按照容量从小到大排序为：
-
多种数据类型混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行运算。
-
byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型。(其中两种相同类型的数据类型在进行运算时，结果值也需要用int来接收)
-
boolean类型不能与其它数据类型运算。
-
当把任何基本数据类型和字符串(String)进行连接运算时(+),基本数据类型的值将自动转换成字符串(String)类型。
自动类型提升的测试用例：
public class Varable2_Test {
public static void main(String[] args) {
int i = 12121; //定义我们的一个精度为4个字节的int整型变量
byte b = 12; //定义我们的一个精度为1个字节的byte整型变量
char c = 'a';
//byte b1 = b + i; 编译会出错,大精度+小精度，显然我们不能把结果用一个小类型精度数据类型来接收
int b2 = b + i;//编译通过，用大精度的数据类型来接收数据，会进行自动数据类型的提升，结果提升为int类型，输出为12133
long l = b + i;//编译通过，用大精度的数据类型来接收数据，会进行自动数据类型的提升，结果提升为long类型，输出为12133
float f = b + i;//编译通过，用大精度的数据类型来接收数据，会进行自动数据类型的提升，结果自动提升为float单精度浮点型，输出为12133.0
int i1 = i + c;//编译通过，输出的值为整型i的值 + char字符型对应字符的对应的ASCII值进行相加运算，字符'a'的ASCII值为97，输出结果为12218
System.out.println(b2);
System.out.println(l);
System.out.println(f);
System.out.println(i1);
//------------------------特别的---------------------------->
short s = 3;
short s1 = 4;
char c1 = 'a';
// short s1 = s + c1; 编译报错，byte,short,char三者之间不会相互转换，他们三者在计算时首先转换为int类型的数值在进行计算
// char c2 = s+ c1; 编译报错
int i2 = s + c1; //既然他们三种数据类型在运算之前都转换成int型了，那么我们计算出的结果也只能最低用int整型来存储，最高double上限
// short s2 = s + s1; 编译报错，他们三种数据类型，其中的具有相同数据类型的两者相加，也满足上述规则，结果值也需要用int整型变量来接收
int i3 = s + s1; //其中他们中任意一种两个相同类型的数据类型在进行运算时，结果值也需要用int来接收
byte b1 = 12;
// byte b2 = b1 + 1; 编译出错，1为整型常量，默认为int类型得数值，int + byte <= int得数据类型来接收
int i4 = b1 + 1;
System.out.println(i2);
System.out.println(i4);
}
}
2.强制类型转换：自动类型转换的逆过程，将容量大的数据转换为容量小的数据类型。使用时要加上强制转换符:(),但有可能造成精度降低或者溢出，格外要注意。
- 通常，字符串不能直接转换为基本数据类型，但是通过基本数据类型的包装类则可以实现把字符串转换成基本数据类型。
- 注意：boolean类型不可以转换为其他的数据类型。
强制类型转换的测试用例：
public class Varable3_Test {
public static void main(String[] args) {
//强制类型转换造成滴后果:可能出现精度的丢失也有可能造成数据值得溢出
double d = 123.6561;
// int i = d; 直接由double类型的数值赋给int类型的变量会出现编译错误，因为在java中定义大容量的数据类型不能直接转型为小容量的数据类型
//精度损失举例1
int i = (int)d; //此时编译通过，我们这时候可以用强制类型转换符号()将我们的double类型的数值强制转换成我们int类型，然后再赋值给我们的int型变量，这是符合规范的
//强制类型转换符()里面写的是我们需要转换的更小容量的数据类型
//输出结果为123，对原数进行截断操作，不会进行四舍五入得操作,但是会损失精度
float f = (float)d; //虽然float单精度浮点型和double双精度浮点型都是浮点型，但是double容量更大，精度更高，仍然要遵循规则，从大容量数据类型转换成我们的小容量数据类型，进行我们的强制类型转换
System.out.println(i);
//精度损失举例2
int i1 = 128;
byte b = (byte) i1;
System.out.println(b); //输出结果为-128
}
}
6.原码、反码和补码解析
- 计算机中每个数字得最高位代表符号位：符号位为0代表该数为正数，符号位为1代表该数为负数
例：-14（十进制转换成二进制来表示）
二进制原码表示：1 0 0 0 1 1 1 0
二进制反码表示：1 1 1 1 0 0 0 1
二进制补码表示：1 1 1 1 0 0 1 0
注意：加粗二进制最高位为符号位
- 负数原码、反码、补码得转换关系(二进制情况下)：
原码：就是其他进制数直接转换成二进制数得表达方式
反码：就是通过原码符号位不变，剩下各位取反转换而来
补码：
通过原码符号位不变，剩下各位取反，末位加1转换而来
通过得到的反码符号位不变，末位加1转换而来
- 正数原码、反码、补码得转换关系(二进制情况下)：
原码 = 反码 = 补码；
- 计算机底层都以二进制补码得方式来存储数据的！
例：二进制转换成十进制
思路：因为计算机中的数据都是以二进制的补码来表示的，我们可以先求反码，再求原码，再将二进制数转换成十进制数，就是真正的十进制数据了
二进制补码表示：1 1 1 1 0 0 1 0
二进制反码表示：1 1 1 1 0 0 0 1(反码等于补码符号位不变，末位减1)
二进制原码表示：1 0 0 0 1 1 1 0(原码等于反码符号位不变，剩下各位取反得到)