文章目录
Java数据类型总览图：
整型变量（int）
4 个字节表示的数据范围是 [-2^31,2 ^31-1]
java的变量的不初始化就不能使用，就会报错( 安全性！)
int重点：
5、标示符的命名规则
标示符：字母 数字 下划线 $
Ineger->包装类-》还是整型
长整型变量（long）
long是8个字节
public class HelloWorld {
public static void main(String[] args) {
long a=10L;//建议使用大写L
System.out.println(a);
}
}
运行过程及结果
C:\Users\chuanfei>d:
D:\>cd D:\javacode\20220327
D:\javacode\20220327>javac HelloWorld.java -encoding utf-8
D:\javacode\20220327>java HelloWorld
10
public class HelloWorld {
public static void main(String[] args) {
long a=10L;
System.out.println("最大值是：" + Long. MAX_VALUE);//+的作用是拼接
System.out.println("最小值是：" + Long. MIN_VALUE);
System.out.println("a的值是" + a);
}
}
//运行结果是：
//D:\javacode\20220327>java HelloWorld
//最大值是：9223372036854775807
//最小值是：-9223372036854775808
//a的值是10
long的包装类是Long
双精度浮点数类型变量（double）
double是8个字节
int a = 1;
int b = 2;
System.out.println(a / b);
// 执行结果是0（与C语言一样）
//如果想得到 0.5, 需要定义 double 类型计算.
double num = 1.1;
System.out.println(num * num)
// 执行结果
1.2100000000000002
//double存在一定的精确值
小数建议使用double
单精度浮点数类型变量（float）
public class TestDemo{
public static void main(String[] args){
float d=12.5;
System.out.println(d);
}
}
//java规定小数默认是double类型，而double是8个字节，float是4个字节，所以会报错
//应在小数后面加上f
float的包装类是Float
字符类型变量（char）
public class TestDemo{
public static void main(String[] args){
char ch='a';
System.out.println(ch);
char ch2='邓';
System.out.println(ch2);
char ch3=97;
System.out.println(ch3);
}
}
char类型的编码表是Unicode，拥有更加多的字符，包括中文，所以char是2个字节
char的取值范围是0-65535，不存在负数
char的包装类是Character
字节类型变量（byte）
byte的取值范围是-128~127
public class TestDemo{
public static void main(String[] args){
byte a=12;
byte b=98;
System.out.println(a+b);
System.out.println(a +" "+ b);
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
}
}
//打印结果为
//110
//12 98
//127 最大值
//-128 最小值
但是，byte与int的最大值+1却不一样
System.out.println(Byte.MAX_VALUE+1);打印出来的是128，因为println是以整型进行打印的，此时就把右边当做是整型了，所以会打印128
1是整型，所以Byte.MAX_VALUE+1就会发生整型提升，所以右边就会变成整型，而左边是byte类型的，整型是8个字节，byte是4个字节，放不下，所以会报错。
无论是什么类型的数据，都不能放超过其最大取值的数字，否则就会报错。
整型提升
小于4个字节的数据类型（byte char short ）运算的时候，会发生整型提升
public class TestDemo{
public static void main(String[] args){
byte a=10;
byte b=30;
byte c=a+b;//10和30是整型，而c是byte类型的，所以发生类型冲突，进而报错
byte c=（byte）a+b；//改进：类型强转
int c=a+b;//transform c to int
System.out.println(c);
}
}
int 与char 的最大值加一比较：
短整型变量（short）
short是两个字节，取值范围是-32767~32768
public class TestDemo{
public static void main(String[] args){
System.out.println(Short.MAX_VALUE+1);//最大值是32768
System.out.println(Short.MIN_VALUE+1);//最小值是-32767
}
}
布尔类型（boolean）
在Java中，布尔类型没有明确的大小
在Java中，布尔类型只有两个取值：true 和 false
在Java中真就是true 假就是false，不存在 0为假，非0为真
布尔类型的包装类是Boolean
小结：
Java中的8中基本数据类型
Java当中的数据类型：
1.基本数据类型
2.引用数据类型: 类 String 数组 抽象类 接口 枚举 …
数据类型的取值范围就是-2^(比特位数-1)—2 ^(比特位数-1)-1
字符串类型变量（String）
public class TestDemo{
public static void main(String[] args){
String str1="\\wo lai le\\";
String str2="\"wo lai le\"";//转义字符的使用
System.out.println(str1);//打印的出来的就是\wo lai le\
System.out.println(str2);//打印出来的就是“wo lai le”
}
}
字符串类型中的+表示拼接
public static void main(String[] args) {
System.out.println("hello" + 10 + 20);//1
System.out.println(10 + 20 + "hello");//2
System.out.println("hello"+(10+20));//3
System.out.println(10+""+20+"hello");//4
}
结果：
hello1020
30hello
hello30
1020hello
第一段代码：代码运行的时候是从左往右的，10和20就是字符串类型了
第2段代码：先算出30再打印字符串
第3段代码：先算括号里面的数字
第4段代码：在10和20之间加上一个“ ”使其变为字符串
变量的作用域
局部变量的作用域就截止到花括号
public static void main(String[] args) {
int a=10;
{
a=89;
}
System.out.println(a);
}
数值提升
int与long的混合运算
int a = 10;
long b = 20;
int c = a + b; // 编译出错, 右边提升为long类型，提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过
char short 与int 提升
当一个类型（char byte）小于4个字节的时候，就会自动提升为int，
byte a = 10;
byte b = 20;
byte c = a + b;//右边为int，不能赋值给byte
byte c = (byte)(a + b);//运行成功
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte r=1+2;
System.out.println(r);
//这段代码是可以运行的，因为在编译的时候就已经将1+2变为3了
那么为什么要进行数值提升？
就是为了提高效率
变量的作用域
也就是该变量能生效的范围, 一般是变量定义所在的代码块 (大括号)
变量的命名规则
1.只能使用数字 字母 下划线
2.数字不能开头
3.使用小驼峰命名 (类名是大驼峰)
int maxValue = 100;
String studentName = "张三
尽量不要使用$ 和 下划线（合法但是不合理）
常量
常亮就是在程序运行的时候无法修改的量
public class TestDemo{
public static void main(String[] args){
final int MAXNUM=10;
//MAXNUM=20;报错
System.out.println(MAXNUM);
}
}
常量的关键字是final，常量不能被改变，常量命名的时候尽量写成大写
常量只能被初始化一次，且必须要初始化
类型转换
隐式类型转换：
把一个小类型自动转换为大类型
显示类型转换：
把一个大类型转换为一个小类型,需要强制类型转换
public class TestDemo{
public static void main(String[] args){
//long a=10;
//int b=(int)a;
//System.out.println(b);
int a=20;
long b=a;//自动就提升成了long类型的（隐性类型转换）
System.out.println(b);
}
}
其实就是因为long是8个字节，int是4个字节，将long放到int中，就会报错（Java是强类型语言），所以要进行类型强转，而将int放到 long里面就可以
注意：boolean类型是不能强转为int 的
int与String的相互转化
int —>String
int num = 10;
// 方法1
String str1 = num + "";//改成字符串类型(取巧)
// 方法2(更好)
String str2 = String.valueOf(num);//将int转换为String
String —>int
String str = "100";
int num = Integer.parseInt(str);//Integer是包装类
public class TestDemo{
public static void main(String[] args){
//int 转化为String
int a=20;
String str1=String.valueOf(a);
System.out.println(str1);
//String转化为int
String str2="20";
System.out.println(Integer.valueOf(str2));//其实这样子会有警告，按照提示替换一下就行了
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
