Java系列文章目录
这篇文章详细的讲解了Java中的数据类型,无论是对于新手还是有一定基础的同学都十分友好。
0.标识符与关键字
0 .1标识符
标识符:在程序中由用户给类名、方法名或者变量所取的名字 。
【硬性规则】
标识符可以包含:字母、数字以及下划线和$符号等等。
注意:标识符不能以数字开头,也不能是关键字,且严格区分大小写。
【软性建议】
- 类名:每个单词的首写字母大写
- 方法名:首字母小写,后面每个单词的首字母大写
- 变量名:与方法名规则相同
0.2关键字
public、class、static等等**这些具有特殊含义的标识符称为关键字。**即:关键字是有Java语言提前定义好的,有特殊含义的标识符,或者保留字。
Java中的关键字有很多,后面的文章当中会详细讲解。
1.字面常量
常量即运行期间,固定不变的量称为常量。
public class TestDemo {
public static void main(String[] args) {
System.out.println("hello world");
System.out.println(100);
System.out.println(3.14);
System.out.println('a');
System.out.println(true);
System.out.println(false);
}
这里的:100、3.14、‘A’、true/false都是常量,将其称为字面常量。
字面常量的分类:
1. 字符串常量:由""括起来的,比如:“12345”、“hello”、“你好”。
2. 整型常量:程序中直接写的数字(注意没有小数点),比如:100、1000
3. 浮点数常量:程序中直接写的小数,比如:3.14、0.49
4. 字符常量:由’'括起来的单个字符,比如:‘A’、‘1’
5. 布尔常量:只有两种true和false
6. 空常量:null(后面的文章再讲)
2.JAVA中的数据类型
字符串、整型、浮点型、字符型以及布尔型,在Java中都称为数据类型。
Java中的数据类型可以分为两类:基本数据类型和引用数据类型。
基本数据类型 | 引用数据类型 |
---|---|
整型、浮点型、字符型、布尔型 (四类基本数据类型) | 数组、String、类、接口、枚举等等 |
八种基本数据类型:
数据类型 | 关键字 | 内存占用 | 范围 |
---|---|---|---|
字节型 | byte | 1字节 | -128 ~ 127 |
短整型 | short | 2字节 | -32768 ~ 32768 |
整型 | int | 4字节 | -2^31 ~ 2^31-1 |
长整型 | long | 8字节 | -2^63 ~ 2^63 -1 |
单精度浮点数 | float | 4字节 | 有范围,一般不关注 |
双精度浮点型 | double | 8字节 | 有范围,一般不关注 |
字符型 | char | 2字节 | 0~65535 |
布尔型 | boolean | 没有明确规定 | true和false |
字节型 | byte | 1字节 | -128~127 |
这里有几点需要注意: |
- 不论是16位系统还是32位系统,int都占用4个字节,long都占用8个字节
- 整型和浮点型都是带有符号的
- 整型默认为int型,浮点型默认为double
- float精确到小数点后六位,double精确到小数点后15位
3.字节
什么是字节?
字节是计算机中表示空间大小的基本单位.
计算机使用二进制表示数据,我们认为8个二进制位(bit)位一个字节(Byte).
我们平时计算机为8G内存,意思是8G个字节.
其中1Byte = 8bit, 1KB = 1024 Byte, 1MB = 1024KB, 1GB = 1024MB, 1TB = 1024GB, 1PB = 1024PB.
使用8GB相当于80多亿个字节.
4.变量
4.1冯诺依曼体系
在了解变量前,先了解一下冯诺依曼体系结构,现在计算都是这个结构。
冯诺依曼(计算机之父)体系:
所有的程序都在存储器上运行,包括接下来介绍的变量也在存储器当中。
4.2.变量概念
程序运行中可以修改的量称为变量,而数据类型就是用来定义不同种类的变量的。
定义变量的语法格式:
数据类型 变量名 = 初始值;
比如:
int a = 10;//定义整形变量a,a是变量名也称为标识符,该变量中放置的值为10
int a1 = 10, a2 = 20, a3 = 30;//在一行可以定义多个相同类型的变量
System.out.println(a1);
System.out.println(a2);
System.out.println(a3);
5.变量类型详解
Java里的数据类型都是有符号的,Java里没有无符号的类型!!!
5.1 整型变量
//方式1:在定义时给出初始值
int a = 10;
System.out.println(a);
//方式2:在定义时没有给初始值,但使用前必须设置初值
int b;
b = 10;
System.out.println(b);
//int型变量所能表示的范围:
System.out.println("最大值"+Integer.MIN_VALUE);//-2147483648
System.out.println("最小值"+Integer.MAX_VALUE);//2147483647
注意事项:
- int不论在何种系统下都是4个字节。【可移植性强】
- 在JAVA里面,int没有所谓的无符号整数。所以,int既能表示整数,也能表示负数
- 推荐使用方式一定义,如果没有合适的初始,可以设置为0。
- 在给变量设置初始值时,值不能超过int的表示范围,否则会导致溢出。
- 变量在使用之前必须要赋初始值,否则会编译报错。
- int包装类型为Integer.
5.2 长整型变量
/**\
* 1.int类型放不下,因此需要long类型 2^63 ~ 2^63-1
* 2.不管你是什么样的操作系统,大小都为8个字节
* 3.整型的默认类型是int类型,为了能与int类型相区别,在字面整型常量后赋上一个L/l来表示长整型来与整型相区分
* @param args
*/
public static void main(String[] args) {
int a = 10;//整型默认为int类型
long b = 10L;//赋上L与int类型相区分
System.out.println("最大值:"+Long.MAX_VALUE);//最大值:9223372036854775807
System.out.println("最小值:"+Long.MIN_VALUE);//最小值:-9223372036854775808
注意事项:
- 长整型变量的初始值后加L或者l,推荐加L
- 长整型不论在哪个系统下都占8个字节
- 长整型的范围为:-2^63 ~ 2^63-1
- long的包装类型为Long
5.3 短整型
public static void main(String[] args) {
short a = 10;//字面常量来赋值给短整型a
System.out.println(a);
System.out.println("最大值:"+Short.MAX_VALUE);//最大值:32767
System.out.println("最小值:"+Short.MIN_VALUE);//最小值:-32768
注意事项:
- short在任何系统下都占两个字节
- short的表示范围:-32768 ~ 32767
- 使用时注意不要超过范围(一般使用比较少)
- short的包装类型为Short
5.4 字节类型
public static void main(String[] args) {
byte b = 10;
System.out.println(b);
System.out.println("最大值:"+Byte.MAX_VALUE);//最大值:127
System.out.println("最小值:"+Byte.MIN_VALUE);//最小值:-128
注意事项:
- byte在任何系统下都占1个字节
- byte的范围是:-128~127
- 字节的包装类型为Byte
注意!!!
看下面代码:
byte的范围是-128~127,而字面常量130超出了byte的范围,因此会报错。
再看下面代码:
整数1默认为int类型,a是字节类型,因此再进加法运算时,a会提升为int类型,运算结束后的结果为int类型,存入字节型变量b中会发生阶段,如果不进型类型转换则会报错。
再看下面代码:
这个代码有几点需要注意:
*1.为什么没有报错?
因为a是变量,只有在程序运行时才知道a的大小,在编译的过程中只会认为a是字节类型,而在运行时byte的a被提升为了int类型,之后会将int类型强制转化为byte数据类型放到变量b里。
2.为什么结果是-128?
这是因为将运算结束的得到的整型强行转化为byte类型之后,代码能够正常通过,但是得到的值却不是128,而是-128,这是因为128的整型补码放到字节型里并且以字节型的方式来解读128对应的二进制补码,也就是 补码11111111—>反码01111111—>原码1000000 可以参考下面这张图:
思考:byte、short、int、long都可以定义整型变量,为什么要给出4种不同类型呢?
其实很容易理解,就是因为这四种不同的整型可以满足不同条件下对整型的要求,就好比衣服的尺码有大有小。
5.5 浮点类型
5.5.1 float单精度浮点型
float类型在Java中占四个字节,同样遵守IEEE 754 标准.由于表示的数据精度范围较小,一般在工程上用到浮点数都优先考虑double,不太推荐使用float.float的包装类型为Float.
float精确到到小数点后6位
float a = 5.0f;
float b = 5.0F;
浮点型默认double,在数字后使用F/f来与double做区分.
public static void main(String[] args) {
int a = 5;
int b = 2;
int c = a/b;// 整型/整型 = 整型 2
System.out.println(c);
float e = 5;// 虽然是5 但是会默认存的是5.0
float f = 2;
float g = e/f;// float/float = float 2.5
System.out.println(g);
float h = 5.0f;
float i = 2.0f;
float j = h/i;
System.out.println(j);// float/float = float 2.5
5.5.2 double双精度浮点型
- double在任何系统下都占8个字节
- 浮点数与整数在内存中的存储方式不同,不能单纯使用2^n的形式来计算
- double的包装类型为Double
- double类型的内存布局遵守IEEE 754 标准(和C语言一样)尝试使用有限的内存空间表示可能无限的小数,势必会存在一定的精度误差,因此浮点数是个近似值,并不是精确度。
float A = 1.1F;
float B = 1.1F;
float C = A*B;
System.out.println(C);//1.21
double a = 1.1;
double b = 1.1;
double c = a*b;
System.out.println(c);//1.2100000000000002 这是个近似值 因为double只能精确到小数点后15位
5.6 字符型变量
char ch1 = 'A';
char ch2 = '高';
char ch3 = 97;
System.out.println(ch1);//A
System.out.println(ch2);//高
System.out.println(ch3);//a
- 字符型不是整数类型
- 两个字节,不能表示你负数,范围(0,65535)
- Java当中 使用的是Unicode字符集【可以认为他包含这个Ascii】,Unicode字符集:包含了很多的语言-》中文,拉丁文,…,Ascii字符集:只能表示英文相关的
- 出现中文使用utf-8编码方式进行编码:javac -encoding utf-8 文件名.java
- char的包装类型为Character
5.7 布尔类型
boolean flg1 = 1;//报错
boolean flg2 = true;
boolean flg3 = false;
System.out.println(flg1);
System.out.println(flg2);
System.out.println(flg3);
System.out.println(flg2+1);//报错
注意事项:
- boolean类型的变量只有两种取值,true表示真,false表示假
- Java的boolean类型和int不能相互转换,不存在1表示true,0表示false这样的用法
- Java的虚拟机JVM规范中,并没有明确规定boolean占几个字节,也没有专门用来处理boolean的字节码指令,在Oracle公司的虚拟机实现中,boolean占1个字节
- boolean的包装类型为Boolean
6.类型转换
在Java中,当参与运算数据类型不一致时,就会进行类型转换。Java中类型转换主要分为两类:自动类型转换(隐式)和强制类型转换(显示)。
6.1自动类型转换(隐式)
自动类型转换即:代码不需要经过任何处理,在代码编译时,编译器会自动进行处理。特点:数据范围小的转化为数据范围大的时会自动进行。
int a = 100;
long b = 10L;
b = a;//a和b都是整型,a的范围小,b的范围大,当将a赋值给b时,编译器会自动将a提升为long类型,然后赋值
a = b;//编译报错,long的范围闭int范围大,会有数据丢失,不安全
float f = 3.14F;
double d = 5.12;
d = f;//编译器会将f转换为double,然后进行赋值
f = d;//double表示数据范围大,直接float交给double会有数据丢失,不安全
byte b1 = 100;//编译通过,100没有超过byte的范围,编译器隐式将100转化为byte
byte b2 = 257;//编译失败,257超过了byte的数据范围,有数据丢失
float f1 = 3.14f;
int n = 4;
n = f1;//float的数据宽度比int大,float存到int里,小数部分会丢失,不安全
f1 = n;//int被隐式转换为float
System.out.println(f1);//4.0
6.2 强制类型转换(显示)
强制类型转换:当进行操作时,代码需要经过一定的格式处理,不能自动完成。特点:数据范围大的转换为数据范围小的。
int a = 100;
long b = 10L;
b = a;//a和b都是整型,a的范围小,b的范围大,当将a赋值给b时,编译器会自动将a提升为long类型,然后赋值
a = (int)b;//编译报错,long的范围闭int范围大,会有数据丢失,不安全--->所以强制类型
System.out.println(a);//100
float f = 3.14F;
double d = 5.12;
f = (float)d;//double表示数据范围大,直接float交给double会有数据丢失,不安全--->所以强制类型转换
System.out.println(d);//5.12
System.out.println(f);//5.12
float f1 = 3.14f;
int n = 0;
n = (int)f1;//强制类型转换,只保留小数部分
System.out.println(n);//3
7. 类型提升
不同类型的数据之间相互运算时,数据类型小的会被提升到数据类型大的。
7.1 1.int与long之间:int会被提升为long
强制转换后:
int a = 10;
long b = 20;
int c =(int) (a + b);//编译出错:a+b==> int+long-->long+long 赋值给int时会丢失数据
long d = a+b;//编译成功
System.out.println(c);//30
System.out.println(d);//30
7 .2 2.byte与byte的运算
注意:byte与byte都是相同的类型,但是出现编译报错。原因是,虽然a和b都是byte,都是计算a+b会先将a和b都提升为int,再进行计算,得到的结果也是int,这是赋给c,就会出现上述错误。
由于计算机的CPU通常是按照4个字节为单位从内存中读写数据.为了硬件上实现方便,诸如byte和short这种低于4个字节的类型,会先提升成int,在参与计算.
正确的写法:
byte a = 10;
byte b = 20;
byte c =(byte)(a+b);
System.out.println(c);//30
7.3 3.你可能会疑惑的点
你可能会疑惑?整型数字不是默认为int类型吗?为什么代码1、2没有报错呢?
因为代码1、2都是用的字面常量,在编译的过程中会检查字面值是不是超过了数据类型的范围,如果发现字面常量没有超过数据类型的范围,那么会隐式转化为byte或者char类型。而第三个代码在编译的过程中会见+两边的数据都提升为int类型。
8.字符串类型
在Java中使用String类定义字符串类型,比如:
String s1 = "hello";
String s2 = "world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2);//s1+s2表示:将s1和s2进行拼接
有些情况下,需要将字符串和整型数字之间进行转换:
8.1 int转成String
int num = 10;
//方法1:用+与“”进行拼接
String str1 = num +"";
System.out.println(str1);//10
//方法2:
String str2 = String.valueOf(num);
System.out.println(str2);//10
8.2 String转成int
String str = "100";
int num = Integer.parseInt(str);
System.out.println(num);//100