目录
1、Java的数据类型
Java的数据类型可分为基本数据类型和引用数据类型两种,而基本数据类型又分为四类八种。
哪四类八种呢?
四类有:整型、浮点型、字符型和布尔型
八种有:整型、短整型、长整型、单精度浮点型、双精度浮点型、字符型、布尔型、字节型(c语言种没有的)。
数据类型 | 关键字 | 内存占用 | 包装类 | 范围 |
整型 | int | 4个字节 | Integer | -2^31~2^31-1 |
短整型 | short | 2个字节 | Short | -2^15~2^15-1 |
长整型 | long | 8个字节 | Long | -2^63~2^63-1 |
单精度浮点型 | float | 4个字节 | Float | 有范围,一般不关注 |
双精度浮点型 | double | 8个字节 | Double | 有范围,一般不关注 |
字节型 | byte | 1个字节 | Byte | -128~127 |
字符型 | char | 2个字节 | Character | 0~65535 |
布尔型 | bollean | 没有明确规定 | Bollean | 只有true和false两种 |
引用数据类型有以下几种类型:
String、字符串、类、接口、枚举、数组等等
【注意】:(1)对于布尔型来说,一般是1个bit的大小,但在oracle种的Java虚拟机的实现中,Java编程语言中的布尔类型数组被编码为Java虚拟机字节数组,其中每个布尔元素的大小为1个字节(8位)。[bollean,在JVM中并没有明确具体的大小,但如果是boolean数组的话,会被JVM识别为字节数组]
(2)在Java中,不论操作系统是16位还是32位,int类型都是占4个字节,long都是占8个字节而c语言就不是如此(16位的情况下c语言中的int类型是占2个字节的,32位下是占4个字节的),这恰好体现了Java的可移植性。
(3)在Java中没有所谓的无符号和有符号.
(4)整型默认是int型,浮点型默认是double。
2、变量
2.1 变量的概念
在程序中,除了有始终不变的常量外,有些内容可能会经常改变,比如:人的年龄、身高、成绩分数、数学函数的计 算结果等,对于这些经常改变的内容,在Java程序中,称为变量。而数据类型就是用来定义不同种类变量的。
2.2 Java中变量的分类
Java中的变量有:局部变量(方法内部的变量)、成员变量(在类中定义, 访问修饰符 修饰符,有关类和对象中的)
【注意】:局部变量在使用的时候要初始化。
2.3基本数据类型取值范围的探讨
以int类型为例,在Java中int类型占4个字节(32位),其中最高位是符号位,剩余的31位为数值位。每一位都是二进制,31位数值位一共就有2^31个数字,而符号也是有1和0两种,那么一共就有2*(2^31)个数字。
当符号位位1时,因为数据是以补码的形式存储的,1000 0000 0000 ... 0001(-1)的补码为1111 1111 1111 .... 1111。从-1到-2^31共2^31个数字;
当符号位为0时开始计数,其数值是从0~2^31,又因为一共是由2^31个数字,因此其准确范围是0~2^31-1。
其他数据类型的取值范围也是如此。
2.4 整型变量
2.4.1整型变量
//定义时可以先对变量进行初始化
int a=2;
System.out.println(a);
//也可以再定义后再对其赋值
int a;
a=2;
System.Out.println(a);
//如果不对变量进行初始化,编译时会报错
// int型变量所能表示的范围:
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
(1) 在给变量设置初始值时,值不能超过int的表示范围(范围为-2^31~2^31-1),否则会导致溢出;
(2) 在给变量设置初始值时,值不能超过int的表示范围,否则会导致溢出;
(3) int不论在何种系统下都是4个字节。
2.4.2长整型变量
int a = 10;
long b = 10; // long定义的长整型变量
long c = 10L; // 为了区分int和long类型,一般建议:long类型变量的初始值之后加L或者l
long d = 10l; // 一般更加以加大写L,因为小写l与1不好区分
// long型变量所能表示的范围:这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
System.out.println(Long.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
2.4.3短整型变量
short a = 10;
System.Out.println(a);
// short型变量所能表示的范围:
System.out.println(Short.MIN_VALUE);
System.out.println(Short.MAX_VALUE);
短整型一般使用的比较少(范围过小,使用时容易超过取值范围),还是以int为主。
2.4.4字节类型
byte b = 10;
System.Out.println(b);
// byte型变量所能表示的范围:
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);
byte类型在使用的时候要多注意转换的问题.
例如:
byte b1=128;
byte b2=b1; //其输出结果b4会是-128
byte b3=180; 180-127=53 127+1=-128 127+2=-127...127+53=-76
byte b4=b3; //其输出结果会是-76
说到底还是取值范围的问题
2.4.5运算中该注意的问题
基本四则运算符:(* / % + -)
对于整型变量的运算,需要注意的是,在Java 中进行除法时,除数不能为0,否则编译会报错
public static void main(String[] args){
int a=5;
int b=0;
System.out.println(a/b);//编译会报错
}
Java里面把程序在运行(或编译)过程中出现的不正常行为称为异常。
以下代码也得注意以下
System.out.println(10%3); //结果为1
System.out.println(10%-3); //结果为1
System.out.println(-10%3); //结果为-1
System.out.println(-10%-3); //结果为-1
2.5浮点型变量
2.5.1单精度浮点型
//为了区分double和float类型可以在float类型的右值后面加上f或F
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);
float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都 优先考虑 double, 不太推荐使用 float. float的包装类型为Float。
2.5.2双精度浮点型
在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 0.5, 需要使用 double 类型计算.
int a=1,b=2;
System.out.println(a/b);//结果不是0.5而是0.
double a = 1.0;
double b = 2.0;
System.out.println(a / b); // 输出0.5
为什么以下输出情况不是1.21?
double num = 1.1;
System.out.println(num * num);
// 执行结果
1.2100000000000002
解析:此处涉及到浮点型数据的存储。
double类型之间的运算不能直接使用double来直接进行运算:因为计算机是二进制的。浮点数没有办法是用二进制进行精确表示。我们的CPU表示浮点数由两个部分组成:指数E和尾数M,这样的表示方法一般都会失去一定的精确度,有些浮点数运算也会产生一定的误差。
在大多数的商业计算中,一般采用java.math.BigDecimal类来进行精确计算。
【注意】: 1. double在任何系统下都占8个字节
2. 浮点数与整数在内存中的存储方式不同,不能单纯使用$2^n$的形式来计算
3. double的包装类型为Double
4. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必 会存在一定的精度误差,因此浮点数是个近似值,并不是精确值。
2.6字符型变量
char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
System.out.println(c1);
System.out.println(c2);
// 注意:java中的字符可以存放整形,还可以放中文
char c3 = '好';
System.out.println(c3);
1、在Java中的字符类型占2个字节,因为Java是采用Unicode表示字符的(不像c语言是以Ascii码表示字符的),这让Java 的字符有更多的种类
2、计算机中的字符本质是一个整数
3、Java 中使用 单引号 + 单个字母 的形式表示字符字面值
2.7布尔类型
boolean a = true;
System.out.println(a);
b = false;
System.out.println(b);
1、布尔类型只有true和false两种取值。
2、Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
3、Java虚拟机规范中,并没有明确规定boolean占几个字节,也没有专门用来处理boolean的字节码指令,在 Oracle公司的虚拟机实现中,boolean占1个字节(布尔数组被JVM识别成字节数组的情况,每个布尔元素占一个字节)。
boolean value = true;
System.out.println(value + 1);
// 代码编译会出现如下错误
Test.java:4: 错误: 二元运算符 '+' 的操作数类型错误
System.out.println(value + 1);
^
第一个类型: boolean
第二个类型: int
1 个错误
3、 类型的转换
在Java中,当参与运算数据类型不一致时,就会进行类型转换。Java中类型转换主要分为两类:自动类型转换(隐式) 和 强制类型转换(显式)。
平时如果对某个变量进行赋值,会考虑到两者的取值范围,进行转换或者编译时报错。
float a=1.0f;
double b=2.0;
b=a; //可以通过编译
a=b; //编译报错,取值范围大的赋给小的,造成精度丢失
3.1自动类型转换
自动类型转换即:代码不需要经过任何处理,在代码编译时,编译器会自动进行处理。特点:数据范围小的转为数据 范围大的时会自动进行。
例如:
System.out.println(1024); // 整型默认情况下是int
System.out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形,a的范围小,b的范围大,当将a赋值给b时,编译器会自动将a提升为long类型,然后赋值
a = b; // 编译报错,long的范围比int范围大,会有数据丢失,不安全
3.2 强制类型转换
强制类型转换:当进行操作时,代码需要经过一定的格式处理,不能自动完成。特点:数据范围大的到数据范围小 的。
例如:
int a = 10;
long b = 100L;
b = a; // int-->long,数据范围由小到大,隐式转换
a = (int)b; // long-->int, 数据范围由大到小,需要强转,否则编译失败
float f = 3.14F;
double d = 5.12;
d = f; // float-->double,数据范围由小到大,隐式转换
f = (float)d; // double-->float, 数据范围由大到小,需要强转,否则编译失败
a = d; // 报错,类型不兼容
a = (int)d; // int没有double表示的数据范围大,需要强转,小数点之后全部丢弃
byte b1 = 100; // 100默认为int,没有超过byte范围,隐式转换
byte b2 = (byte)257; // 257默认为int,超过byte范围,需要显示转换,否则报错
boolean flag = true;
a = flag; // 编译失败:类型不兼容
flag = a; // 编译失败:类型不兼容
【注意】:
1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功,不相干的类型不能互相转换
3.3类型提升
不同类型的数据之间相互运算时,数据类型小的会被提升到数据类型大的
例如(一):
1. int与long之间:int会被提升为long
int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功:a + b==>int + long--->long + long 赋值给long
2.byte与byte的运算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;
报错的原因是,a+b的运算会使byte类型的a和b提升成int类型再进行运算,之后就会出现取值范围大的赋给取值范围小的情况,从而导致编译报错。
结论:
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);
【类型提升小结】:
1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算
4. 字符串类型
在Java中使用String类定义字符串类型,可以让两个及两个以上的字符串用“+”进行拼接。
例如:
(一)
public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示:将s1和s2进行拼接
}
public static void main(String[] args){
int a=10,b=20;
System.out.println("a="+a+" "+"b="+b);//运行结果为a=10 b=20
System.out.println("a+b="+(a+b));//注意:不能写成("a+b="+a+b),这种写法会导致a和b两个也进行字符串拼接,其结果并不是a+b=30而是a+b=1020
}
在有些情况下,需要将字符串和整形数字之间进行转换:
1. int 转成 String
int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);
2. String 转成 int
//方法1
String str = "100";
int num = Integer.parseInt(str);
//方法2
String str2="200";
int num2=Integer.ValueOf(str2);
对于Integer的用法还很多,后序会详细列出。