1、关键字(keyword)的定义和特点
定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
2、保留字(reserved word)
Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字goto、const。
1、Java 中的名称命名规范：
2、注意点
1、变量的概念：
2、变量的作用：
3、使用变量注意：
4、声明变量
语法：<数据类型> <变量名称>
例如：int var;
5、变量的赋值
语法：<变量名称> = <值>
例如：var = 10;
6、声明和赋值变量
语 法：<数据类型><变量名>= <初始化值>
例如：int var = 10
7、补充：变量的分类-按声明的位置的不同
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
8、注意：二者在初始化值方面的异同:
2、变量的分类-按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。
| 类型 | 占用存储空间 | 表数范围 |
| byte | 1字节=8bit位 | -128 ~ 127 |
| short | 2字节 | -2^15~ 2^15-1 |
| int | 4字节 | -2^31~ 2^31-1 (约21亿) |
| long | 8字节 | -2^63~ 2^63-1 |
在这里插入代码片/*
Java定义的数据类型
一、变量按照数据类型来分：
基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类：class
接口：interface
数组：array
二、变量在类中声明的位置：
成员变量 vs 局部变量
*/
class VariableTest1{
public static void main(String[] args) {
//1. 整型：byte(1字节=8bit) short(2字节） \ int (4字节）\ long(8字节)
//① byte范围：-128 ~ 127
byte b1 = 12;
byte b2 = -128;
// b2 = 128; //编译不通过
System.out.println(b1);
System.out.println(b2);
// ② 声明long型变量，必须以“1”或“L”结尾
short s1 = 128;
int i1 = 12345;
long l1 = 345678586;
System.out.println(l1);
}
}
与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
浮点型常量有两种表示形式：
float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
| 类型 | 占用存储空间 | 表数范围 |
| 单精度float | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度double | 8字节 | -1.798E308 ~ 1.798E308 |
/*
Java定义的数据类型
一、变量按照数据类型来分：
基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类：class
接口：interface
数组：array
二、变量在类中声明的位置：
成员变量 vs 局部变量
*/
class VariableTest1{
public static void main(String[] args) {
//2. 浮点型：float(4字节) \ double(8字节)
//① 浮点型，表示带小数点的数值
//② float表示数值的范围比long还大
double d1 = 12.3;
System.out.println(d1 +1);
//定义float类型变量时，变量要以"f" 或"F"结尾
float f1 = 12.3F;
System.out.println(f1);
//② 通常，定义浮点型变量时，使用double变量
//3. 字符型：char(1字符=2字节)
//① 定义char型变量，通常使用一对''
char c1 = 'a';
//编译不通过
//c1 = 'AB';
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = '&';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//② 表示方式：1.声明一个字符；2.转义字符；3.直接使用Unicode值来表示字符型常量
char c5 = '\n'; //换行符
c5 = '\t'; //制表符
System.out.print("hello" + c5);
System.out.println("world");
char c6 = '\u0123';
System.out.println(c6);
char c7 = '\u0043';
System.out.println(c7);
}
}
了解：ASCII 码
了解：Unicode 编码
了解：UTF-8
class VariableTest1{
public static void main(String[] args) {
//4. 布尔型：boolean
//① 只能取两个值之一：true 、false
//② 常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried){
System.out.println("禁止入内！");
}else{
System.out.println("可以参观！");
}
}
}
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
在这里插入代码片/*
基本数据类型之间的运算规则：
前提：这里讨论只是7中基本数据类型变量的运算。不包含boolean类型的。
1. 自动类型提升：
当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
char、byte、short-->int-->long-->float-->double
特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
2. 强制类型转换：
说明：此时容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2{
public static void main(String[] args) {
byte b1 = 2;
int i1 = 129;
//编译不通过
// byte b2 = b1 + i1;
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);
System.out.println(l1);
float f = b1 + i1;
System.out.println(f);
//***************特别的**************************
char c1 = 'a'; //97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
//编译错误
// char c3 = c1 + s2;
byte b2 = 10;
// char c3 = c1 + b2; //编译不通过
// short s3 = b2 + s2; //编译不通过
// short s4 = b1 + b2; //编译不通过
}
}
class VariableTest4{
public static void main(String[] args){
//1. 编码情况
long l = 123456;
System.out.println(l);
//编译失败：过大的整数
//long l1 = 452367894586235;
long l1 = 452367894586235L;
//**************************
//编译失败
// float f1 = 12.3;
//2. 编码情况2:
//整型变量，默认类型为int型
//浮点型变量，默认类型为double型
byte b = 12;
// byte b1 = b + 1; //编译失败
// float f1 = b + 12.3; //编译失败
}
}
/*
String类型变量的使用
1. String属于引用数据类型
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算；+
4. 运算的结果任然是String类型
*/
class StringTest{
public static void main(String[] args){
String s1 = "Good Moon!";
System.out.println(s1);
String s2 = "a";
String s3 = "";
// char c = ''; //编译不通过
//*******************************
int number = 1001;
String numberStr = "学号:";
String info = numberStr + number; //连接运算
boolean b1 = true;
String info1 = info + true;
System.out.println(info1);
}
}
练习1
String str1 = 4; //判断对错：no
String str2 = 3.5f + “”; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out.println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1
练习2
判断是否能通过编译
short s = 5;
s = s-2; //判断：no
byte b = 3;
b = b + 4;//判断：no
b = (byte)(b+4);//判断：yes
char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes
byte b = 5;
short s = 3;
short t = s + b;//判断：no
关于进制
所有数字在计算机底层都以二进制形式存在。
对于整数，有四种表示方式：
class BinaryTest{
public static void main(String[] args){
int num1 = 0b110;
int num2 = 110;
int num3 = 0127;
int num4 = 0x110A;
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
System.out.println("num3 = " + num3);
System.out.println("num4 = " + num4);
}
}
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
二进制——》十进制
原码与反码是帮助推导出补码而存在的！！！
十进制——》二进制
十进制二进制互转
