——每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间（字节）
思维导图
一.整数类型
1.什么是整数类型
—— 用int、short、byte、long存储的整数值就是整数类型
2.整数的类型
类型 所占的字节数 数值范围
byte 1字节 -128 ~ 127
short 2字节 -2^15 ~ 2^15-1(-32768 ~ 32767)
int 4字节 -2^31 ~ 2^31-1
long 8字节 -2^63 ~ 2^63-1
3.一个小case快速了解整数类型
public class Test {
public static void main(String[] args) {
//整数的类型
byte a = 10;//占用1个字节(byte)的内存空间用于存储10
short b = 20;//占用2个字节(byte)的内存空间用于存储20
int c = 30;//占用4个字节(byte)的内存空间用于存储30
long d = 40;//占用8个字节(byte)的内存空间用于存储40
//输出值
System.out.println(a);//10
System.out.println(b);//20
System.out.println(c);//30
System.out.println(d);//40
}
}4.整型的细节讨论
1）Java各整数类型有固定的数值范围和字节数，不会受操作系统(OS)的影响，这样就保证了Java的可移植性
2）Java整型的常量值默认为int类型，若是声明了long型的变量的数值，则数值后面可加上l / L，表明这是一个long型的数值
public class Test {
public static void main(String[] args) {
//Java整型的常量值默认为int类型，若是声明了long型的变量的数值，则数值后面可加上l / L
//long num = 10;//10默认为int类型，若是想要10为long型则在后面加l/L
long num = 10L;
System.out.println(num);
}
}3）若是整型的高类型想要转化到低类型，则需要强制类型转换
强制类型转换格式：低数据类型变量 = (低数据类型) 高数据类型的变量
public class Test {
public static void main(String[] args) {
//若是整型的高类型想要转化到低类型，则需要强制类型转换
long num = 10;
byte n = 10;
//n = num;//错误，不能直接把long型的值转换为byte的值
n = (byte) num;//进行强制类型转换
}
}4）各数据类型给该数据类型的变量进行赋值的时候，赋的值不能超过该数据类型的数值范围
public class Test {
public static void main(String[] args) {
//各数据类型给该数据类型的变量进行赋值的时候，赋的值不能超过该数据类型的数值范围
//byte = 100;//错误，超过了byte的数值范围
//short b = 300010;//错误，超过了short的数值范围
//int c = 2111100000000000;//错误，超过了int的数值范围
}
}二. 浮点类型
1.什么是浮点型
—— 用float、double存储的数值就是浮点类型
2.浮点数的类型
类型 所占的字节数 数值范围
float 4字节 -3.403e38 ~ 3.403e38
double 8字节 -1.798e308 ~ 1.798e308
注：浮点数在机器中存放的形式：浮点数 = 符号位 + 指数位 + 尾数位
3.一个小case快速了解浮点型
public class Test {
public static void main(String[] args) {
float data = 1.314f;//data申请了4个字节的空间存储1.314
double num = 13.14;//data申请了8个字节的空间存储13.14
//输出
System.out.println(data);//1.314
System.out.println(num);//13.14
}
}4.浮点数的细节讨论
1）Java浮点数的类型有固定的数值范围和字节数，不受具体操作系统的影响
2）Java中浮点型常量默认是double类型，若声明了float型，使用数值给float型变量赋值的时候，数据值需加上f / F
3）通常情况下，应使用double类型，因为它的精度更高
public class Test {
public static void main(String[] args) {
//Java中浮点型常量默认是double类型，若声明了float型，使用数值给float型变量赋值的时候，数据值需加上f / F
float num = 10.13f;//10.13默认是double类型，想要10.13变成float型，需要在10.13后面加f / F
double data = 13.14;
//输出值
System.out.println(num);//10.13
System.out.println(data);//13.14
}
}4）浮点型常量有两种表示形式
i.十进制数形式：5.12、6.123、7.1345
ii.科学计数法形式：4.12e3 (4.12*10^3)、3.145e-5 (3.145*10^-5)
public class Test {
public static void main(String[] args) {
//十进制数形式：5.12、6.123、7.1345
float num1 = 5.12f;
double num2 = 6.123;
//科学计数法形式：4.12e3 (4.12*10^3)、3.145e-5 (3.145*10^-5)
float data1 = 4.12e3f;
double data2 = 3.145e-5;
}
}5）浮点数不要轻易做比较，若要比较，则需要使用Math.abs()进行比较【浮点数的比较方式】
public class Test {
public static void main(String[] args) {
double num1 = 2.7;
double num2 = 8.1 / 3;
System.out.println(num1 == num2);//false
//使用Math.abs()比较
if (Math.abs(num1 - num2) < 0.000001) {
System.out.println(true);//true
}
}
}三.字符类型
1.什么是字符型
—— 用char类型储存单个字符的值就是字符型，字符要用' '包含起来
2.一个小case快速了解字符型
public class Test {
public static void main(String[] args) {
char ch1 = '我';//ch1使用了两个字节的内存空间储存‘我’
char ch2 = 'l';//ch2使用了两个字节的内存空间储存‘l’
char ch3 = 'o';
char ch4 = 'v';
char ch5 = 'e';
char ch6 = '中';
char ch7 = '国';
//输出
System.out.println("" + ch1 + ch2 + ch3 + ch4 + ch5 + ch6 + ch7);//我love中国
}
}3.字符型的细节讨论
1）字符型常量是使用单引号' '包括起来的单个字符
2）Java中允许使用转义字符 '\' 来将后面跟着的字符转变了特殊的字符
public class Test {
public static void main(String[] args) {
//字符型常量是使用单引号(' ')包括起来的单个字符
char ch = 'a';
char c = 'b';
//Java中允许使用转义字符 '\' 来将后面跟着的字符转变了特殊的字符
char n1 = '\n';//换行
char n2 = '\b';//退格
char n3 = '\r';//回车
char n4 = '\t';//制表符
}
}3）在Java中，char的本质是一个整数，在输出char对应变量的值时，得到的结果是unicode码对应的字符
public class Test {
public static void main(String[] args) {
//在Java中，char的本质是一个整数，在输出char对应变量的值时，得到的结果是unicode码对应的字符
char ch1 = 'a';
char ch2 = '中';
char ch3 = '国';
char ch4 = 'h';
//输出对应的unicode码对应的值
System.out.println((int) ch1);//97
System.out.println((int) ch2);//20013
System.out.println((int) ch3);//22269
System.out.println((int) ch4);//104
}
}4）可以直接给char类型赋在其数值范围内的整数值，在输出的时候，会按照对应的unicode字符输出
5）char类型是可以进行运算的，相当于整数，因为它们有对应的unicode码
public class Test {
public static void main(String[] args) {
//可以直接给char类型赋在其数值范围内的整数值，在输出的时候，会按照对应的unicode字符输出
//char ch1 = 12223344;//错误，赋的值超过了char类型的数值范围
char ch1 = 1234;
char ch2 = 105;
System.out.println(ch1);//Ӓ
System.out.println(ch2);//i
//char类型是可以进行运算的，相当于整数，因为它们有对应的unicode码
char n1 = 'a' + 'n';
char n2 = 'b' + 'c';
System.out.println(n1);//Ï
System.out.println(n2);//Å
}
}四.布尔类型
1.什么是布尔类型
——只有true(真)和false(假)两个值的类型叫做布尔类型，布尔类型只能取true和false两个值
2.一个小case快速了解布尔类型
public class Test {
public static void main(String[] args) {
boolean b1 = false;//boolean至占用一个字节
boolean b2 = true;
//boolean b3 = null;//错误，不能取除了true和false外的其他值
//输出
System.out.println(b1);//false
System.out.println(b2);//true
}
}3.
3.一个小case快速了解自动类型转换
public class Test {
public static void main(String[] args) {
char ch = 'a';
int num = 10;
num = ch;//发生了自动类型转换，把char类型转换到了int类型
float data1 = 3.14159f;
double data2 = 3.123;
data2 = data1;//发生了自动类型转换，把float类型转换到了double类型
data2 = num;//把int型提升到double型
//输出
System.out.println(num);//97
System.out.println(data2);//97.0
}
}4.自动类型转换的细节讨论
1）有多种数据类型的数据进行混合运算时，系统首先自动将所有数据转换成精度最高的数据类型，然后再进行运算
public class Test {
public static void main(String[] args) {
//有多种数据类型的数据进行混合运算时，系统首先自动将所有数据转换成精度最高的数据类型，然后再进行运算
char ch = 'a';
byte num1 = 10;
short num2 = 100;
int num3 = 1000;
long num4 = ch + num1 + num2 + num3;//char,byte,short,int类型进行运算，将所有数据转换为int类型进行运算
//输出
System.out.println(num4);//1207
int data1 = 10;
float data2 = 1.314f;
double data = data1 + data2 + 1.3;//先将所有的数据转换为double类型，再进行运算
//输出
System.out.println(data);//12.614000129699708
}
}2）把精度大的数据类型赋给精度小的数据类型时，会报错
public class Test {
public static void main(String[] args) {
//把精度大的数据类型赋给精度小的数据类型时，会报错
double num1 = 1.13;
//float num2 = 12.13;//错误，12.13默认是double类型，但num2是float类型，不能从double转到float
int data = 0;
//char ch = data;//data是int类型，不能直接从int类型转换到char型
}
}3）byte、short和char类型之间不会相互自动转换
public class Test {
public static void main(String[] args) {
byte b1 = 10;
short b2 = 12;
char ch = 'a';
//byte、short和char类型之间不会相互自动转换
//ch = b1;//错误
//ch = b2;//错误
//b1 = ch;//错误
//b2 = ch;错误
}
}4）byte，short，char三者之间可以互相运算，但是再运算时需要转换为int类型进行计算
public class Test {
public static void main(String[] args) {
byte b = 12;
short num = 120;
char ch = 'a';
byte，short，char三者之间可以互相运算，但是再运算时需要转换为int类型进行计算
int data = b + num + ch;
System.out.println(data);//229
}
}5）boolean类型不与任何类型进行运算
public class Test {
public static void main(String[] args) {
boolean res = true;
//boolean类型不与任何类型进行运算
//int ret = res + 10;//错误
//double sum = 1.314 + res;//错误
//char sum1 = 'a' + res;//错误
}
}6）自动提升规则：表达式的结果自动提升为操作数中最大的类型
5.2 强制类型转换
1.什么是强制类型转换
——强制类型转换是自动类型转换的逆过程，将精度大的数据类型转换为精度小的数据类型，在使用时要加上强制类型转换符()，但是可能会导致精度丢失或精度溢出
2.一个小case了解强制类型转换
public class Test {
public static void main(String[] args) {
//强制类型转换
int num = (int) 1.3;//把double类型的值1.3强制转换为int类型
int data1 = 67;
byte data2 = (byte) data1;//把int类型data1转换为byte类型
char ch = (char) data1;//把int类型的data1转换为char类型
//输出
System.out.println(num);//1
System.out.println(data2);//67
System.out.println(ch);//'C'
}
}3.强制数据类型的细节讨论
1）当高精度的数据类型变成低精度的数据类型时，就需要使用强制类型转换
2）强制类型转换只会对离()最近的操作数有效，若是想要提高所有的操作数，则需要使用小括号()提高优先级
public class Test {
public static void main(String[] args) {
//当高精度的数据类型变成低精度的数据类型时，就需要使用强制类型转换
//使double类型变成int类型
double num1 = 13.14;
int num2 = 10;
num2 = (int) num1;//使double转向了int
System.out.println(num2);//13
//强制类型转换只会对离()最近的操作数有效，若是想要提高所有的操作数，则需要使用小括号()提高优先级
//int data = (int)1.3 + 2.3 + 3.3;//错误，(int)只对1.3起作用，而2.3，3.3还是double类型
//使用()提升优先级
int data = (int) (1.3 + 2.3 + 3.3);
System.out.println(data);//6
}
}3）char类型可以保存int的常量值，但不能保存int的变量值（需要使用强制类型转换）
public class Test {
public static void main(String[] args) {
//char类型可以保存int的常量值，但不能保存int的变量值（需要使用强制类型转换）
char ch = 120;//可以直接使用int的常量值
int num = 100;
//ch = num;//不能直接保存int的变量值
ch = (char) num;//强制类型转换
System.out.println(ch);//d
}
}4）byte、short和char类型在进行运算时，当做int类型处理
public class Test {
public static void main(String[] args) {
//byte、short和char类型在进行运算时，当做int类型处理
byte b = 10;
short s = 12;
char ch = 23;
int num = b + s + ch;
System.out.println(b + s + ch);//45
System.out.println(num);//45
}
}六.基本数据类型和字符串类型(String)的转换
1.什么是字符串类型
——使用" "号包括起来的一串字符叫做字符串，Java中字符串有特定的数据类型：String
2.一个小case快速了解String类型
public class Test {
public static void main(String[] args) {
//字符串常量需要使用""包括起来，使用String命名的变量叫做字符串变量
String str1 = "我";
String str2 = "爱";
String str3 = "中";
String str4 = "国";
//输出
System.out.println(str1 + str2 + str3 + str4);//我爱中国
}
}3.为什么需要使用字符串类型和基本数据类型的相互转换
1）基本数据类型转String类型：基本数据类型 + ""
2）String类型转基本数据类型：通过基本数据类型的包装类调用parseXXX方法
i.String类型转byte类型：Byte.parseByte();
ii.String类型转short类型：Short.parseShort();
iii.String类型转int类型：Integer.parseInt();
iv.String类型转long类型：Long.parseLong();
v.String类型转float类型：Float.parseFloat();
vi.String类型转double类型：Double.parseDouble();
vii.String类型转boolean类型：Boolean.parseBoolean();
public class Test {
public static void main(String[] args) {
int num = 100;
double data = 100.1314;
boolean b = true;
//基本数据类型转String类型：基本数据类型 + ""
String s1 = num + "";//100，字符串的"100"
String s2 = data + "";//100.1314，字符串的"100.1314"
String s3 = b + "";//true，字符串的"100.1314"
//输出
System.out.println(s1 + s2 + s3);//100100.1314true
//String类型转基本数据类型：通过基本数据类型的包装类调用parseXXX方法
String str1 = "12";
String str2 = "123";
String str3 = "165";
String str4 = "17766";
String str5 = "13.1456";
String str6 = "17.2345";
String str7 = "false";
//String类型转byte类型：Byte.parseByte();
System.out.println(Byte.parseByte(str1));//12,整数的12，不是字符串的12
//String类型转short类型：Short.parseShort();
System.out.println(Short.parseShort(str2));//123,整数的123，不是字符串的123
//String类型转int类型：Integer.parseInt();
System.out.println(Integer.parseInt(str3));//165
//String类型转long类型：Long.parseLong();
System.out.println(Long.parseLong(str4));//17766
//String类型转float类型：Float.parseFloat();
System.out.println(Float.parseFloat(str5));//13.1456
//vi.String类型转double类型：Double.parseDouble();
System.out.println(Double.parseDouble(str6));//17.2345
//String类型转boolean类型：Boolean.parseBoolean();
System.out.println(Boolean.parseBoolean(str7));//false
}
}4.String类型和基本数据类型转化的细节讨论
1）在String转化为基本数据类型的时候，要确保String类型能共转化为有效的数据
2）若是转化的格式不正确，则会抛出异常
注：异常是程序运行中可能发生的特殊情况，它会导致程序的终止，并可能产生不可预料的结果。异常的出现可能是由于程序的错误、硬件的故障或者其他不可预知的原因。当异常发生时，程序会停止执行，并且会产生一个异常信息，以提供更多的信息，以便程序员可以尽快修复错误。
public class Test {
public static void main(String[] args) {
//在String转化为基本数据类型的时候，要确保String类型能共转化为有效的数据
//若是转化的格式不正确，则会抛出异常
String str = "happy";
int data = Integer.parseInt(str);//错误，happy不是整数类型的值，不能转化
//System.out.println(data);//会抛出异常
}
}七.标识符的命名规则和规范
1.什么是标识符
——Java中对各种变量、方法和类等命名时使用的字符序列称为标识符
2.标识符的命名规则
1）由26个英文字母大小写，数字0-9，_和$组成
2）数字不能开头
3）不可以使用关键字和保留字，但能包含关键字和保留字
4）Java中严格区分大小写，标识符长度无限制，但是建议在64个字符以内
5）标识符不能包含空格
3.标识符的命名规范
1）包名：组成报名的所有字母都小写
2）类名、接口名：多个单词组成时，使用每个单词首字母大写，其余字母小写
3）变量名、方法名：多个单词组成时，第一个单词首字母小写，其它单词首字母大写
4）常量名：所有字母都要大写，多个单词时使用下划线_连接
4.关键字
class interface enum byte short int long float double char boolean void
true false null if else while do for switch case default break continue return
private protected public abstract final static synchronized extends implements
new this super instanceof try catch finally throw throws package import
native strictfp transient volatile assert
5.保留字
——现在的Java版本尚未使用，但以后的版本可能会作为关键字使用
byValue cast future generic inner operator outer rest var goto const
