基本数据类型
1.Java程序体解读
//public 表示公开的
//class 表示一个类
//Helloworld表示一个类名
public class HelloWorld {
/** 类体
* public 表示公开的
* static 表示静态的
* void 表示空
* main 表示方法名是main
* (String[] args) 是一个main方法的形式参数列表
*/
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
//方法体 java语句
System.out.println("Hello world! Java,我来了！");
}
}
2.基本数据类型
关于基本数据类型之间的相互转换，转换规则：
1，八种基本数据类型除布尔类型之外剩下的七中类型之间都可以相互转换。
-
2，小容量向大容量转换，称为自动类型转换，容量大小排序：byte < short/char < int < long < float < double。
PS：任何浮点类型不管占用多少个字节，都比整数型容量大， char和short可表示的种类型数量相同，但char可以取更大的正整数。 3，大容量转换成小容量，叫强制类型转换，需要加强制类型转换符，程序才能编译通过；但运行阶段可能会损失精度，所以谨慎使用。
4，当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量。
5，byte，short，char混合运算的时候，各自先转换成int类型再做运算。
6，多种数据类型混合运算，先转换成容量最大的那种数据类型再做运算。
2.1 基本数据类型
- 整数型：byte，short，int，long
- 浮点型：float，double
- 布尔型：boolean
- 字符型：char
| 关键字 | 类型 | 字节 | 取值范围 | 默认值 |
|---|---|---|---|---|
| byte | 字节型 | 1 | -128 ~ 127 | 0 |
| short | 短整型 | 2 | -32768 ~ 32767 | 0 |
| int | 整型 | 4 | -2147483648 ~ 2147483647 | 0 |
| long | 长整型 | 8 | -9223372036854775808 ~ 9223372036854775808 | 0 |
| float | 单精度浮点型 | 4 | 大约 ± 3.40282347E + 38F（有效位数6~7位） | 0.0f |
| double | 双精度浮点型 | 8 | 大约 ± 1.79769313486231570E + 308（有效位数15位） | 0.0d |
| boolean | 布尔型 | 1 | true/false | false |
| char | 字符型 | 2 | 0 ~ 65535 | '\u0000' |
1 byte = 8 bit [一个字节 = 8个比特位] 1个比特位表示一个二进制位：1/0
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
byte类型最大值：2的7次方 - 1，即：127
byte类型最小值：-128【位运算】
2.2 成员变量和局部变量~~基本数据类型默认值
代码示例：
public class HelloWorld {
/* 类体 */
//声明定义成员变量
//八种基本数据类型的默认值是一切向0看齐。
//成员变量没有手动赋值系统会默认赋值【局部变量不会】
//变量还是遵守这个语法：必须先声明，再赋值。
//这里的static必须加，没有为什么
static int k = 1000;
static int f;
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//声明定义局部变量
int i=10;
//java语句
System.out.println("Hello world! Java,我来了！");
System.out.println(i);
System.out.println(f);
}
}
2.3 基本数据char类型
代码示例：
public class HelloWorld {
/* 类体 */
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//声明定义局部变量
/* //反斜杠具有转义功能
* \n 换行符
* \t 制表符
* \' 普通单引号
* \\ 普通的反斜杠
* \" 普通双引号
* 反斜杠u联合起来后面的一串数字是某个文字的unicode编码
*/
char b= '\n';//换行
System.out.println(b);
char c= '\n';//制表
System.out.println(c);
char k= '\\';
System.out.println(k);
char a = '\'';
System.out.println(a);
// jak中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
// 怎么使用这个命令
// 在命令行输入native2ascii,回车，然后输入文字之后回车既可获得unicode编码
char e = '中';
System.out.println(e);
char ff = '\u0000';
System.out.println(ff);
}
}
2.3 基本数据类型int与long（强制类型转换）
java语言当中的"整数型字面值"被默认当成int类型来处理。要让这个"整数型字面值"被当做long类型来处理的话，需要"整数型字面值"后面添加1/L，建议使用大写的L。
java语言当中的整数型字面值有三种表示方式：
- 第一种方式：十进制【是一种缺省默认的方式】
- 第二种方式：八进制【在编写八进制整数型字面值得时候需要以0开始】
- 第三种方式：十六进制【在编写十六进制整数型字面值得时候需要以0x开始】
代码示例：
public class HelloWorld {
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//声明定义局部变量
int a = 10;
int b = 010;//整数型字面值以0开始，后面的一串数字就是八进制形式
int c = 0x10;//整数型字面值以0x开始，后面的一串数字就是十六进制形式
//java语句
System.out.println("Hello world! Java,我来了！");
System.out.println(a); //10
System.out.println(b); //8
System.out.println(c); //16
System.out.println(a + b + c); //34
// 123这个整数型字面值是int类型
// i变量声明的时候也是int类型
// int类型的123赋值给int类型的变量i，不存在类型转换
int i = 123;
System.out.println(i);
// 456整数型字面值被当做int类型，占用4个字节
// x变量在声明的时候是long类型，占用8个字节
// int类型的字面值456赋值给long类型的变量x，存在类型转换
// int类型转换成long类型
// int类型是小容量 long类型是大容量
// 小容量可以自动转换成大容量，称为自动类型转换机制
long x =456;
System.out.println(x);
// 2147483647字面值int类型，占用4个字节
// y是long类型，占用8个字节，自动类型转换
long y = 2147483647;
System.out.println(y);
// 编译错误：过大的整数：2147483648
// 2147483648被当做int类型4个字节处理，但这个字面值超出int类型范围
// long z = 2147483648;
// System.out.println(z);
//解决错误
// 2147483648字面值一上来就当做long类型来处理，在字面值后面添加L
// 2147483648L是8个字节的long类型
// z是long类型变量，以下程序不存在类型转换
long z = 2147483648L;
System.out.println(z);
}
}
2.3 基本数据类型 byte,short,char（强制类型转换）
当一个整数型字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量。这种机制sun允许了，目的是为了方便程序员的编程。
代码示例：
public class HelloWorld {
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//java语句
System.out.println("Hello world! Java,我来了！");
// long m =100L 不存在类型转换是直接赋值
long m =100L;
// 赋值：n = m
// 会编译报错，大容量不能直接赋值给小容量
// int n = m;
// 大容量转换成小容量，需要强制类型转换
// 强制类型转换需要加"强制类型装换符"
// 加上强制类型转换符之后可以编译通过，但运行阶段可能损失精度
// 所以强制类型装换谨慎使用，因为损失精度之后可能损失严重
// 强转原理：（二进制）
// 原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
// 强转之后数据：00000000 00000000 00000000 01100100
// 将左边二进制砍掉【所以的数据强转都是这样完成的】
int n = (int)m;
System.out.println(n);
//举例：
//控制台e输出：-2147483648
long k = 2147483648L;
int e = (int)k;
System.out.println(e);// 精度损失严重，结果为负数【-2147483648】
// 分析一下程序是否可以通过编译？
// 理解：没有强制类型转换无法编译通过
// 50是int类型字面值，h是byte类型变量，是大容量int转换成小容量byte
// 大容量转换成小容量，需要强制类型转换
// 实际编辑通过了
// 在java语言当中，当一个整数型字面值没超出byte取值范围的话，该字面值可以直接赋值给byte类型的变量
// byte h = 128;//编译报错
byte h = 50; //编译通过
System.out.println(h);
//short s = 32767;//通过
//short s1 = 32768;//编译报错
//char cc = 65535;//通过
//cc = 65536;//编译报错
// 当一个整数型字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量
// 这种机制sun允许了，目的是为了方便程序员的编程
}
}
2.4 基本数据 double,float（强制类型转换）
在java语言中，所有的浮点型字面值【例：3.0】,默认被当成double类型来处理， 想要该字面值当做float类型来处理，需要在字面值后面加F/f。
注意：
- double和float在计算机内部二进制存储的时候存储的都是近似值
- 在现实世界中有些数字是无限循环的例：3.333333333333333333333...
- 计算机的资源有限，用有限的资源存储无限的数据只能存储近似值。
代码示例：
public class HelloWorld {
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//java语句
System.out.println("Hello world! Java,我来了！");
// 3.0是double类型的字面值
// d是double类型的变量 不用类型转换直接赋值
double d = 3.0;
// 5.1是double类型的字面值
// f是float类型变量
// 大容量转换成小容量需要加强制类型转换符，所有下面程序编译错误
// float f =5.1;
// 解决方案一 强制类型装换
float f = (float)5.1;
// 解决方案二 不用类型转换
f = 5.1f;
}
}
2.4 基本数据 boolean
- boolean类型在java语言中只有两个值：true、false，没有其他值。
- 在底层存储时boolean类型占用一个字节，实际存储的时候false底层是0，true底层是1。
- 布尔类型在实际开发中非常重要，经常使用在逻辑运算和条件控制语句中。
代码示例：
public class HelloWorld {
public static void main(String[] args) {//表示定义一个公开的静态的主方法 ps：程序执行入口
/* 方法体 */
//java语句
System.out.println("Hello world! Java,我来了！");
//编译错误，类型不兼容
// boolean loginSuccess = 1;
boolean loginSuccess = true;
//if语句
if (loginSuccess){//true
System.out.println("你好吗");
}else {//false
System.out.println("你好的");
}
}
}
上篇： Java基础学习 前言
下篇： Java基础学习二 运算符
