Java中基础 基本数据类型-引用数据类型

鳄鱼君

发表文章数:642

热门标签

, ,

Vieu四代商业主题

高扩展、安全、稳定、响应式布局多功能模板。

¥69 现在购买
首页 » Java » Java中基础 基本数据类型-引用数据类型

Java程序中有很多数据,每一个数据都是有有相关的数据类型的,不同数据类型的数据占用的空间大小不同。数据类型的作用就是指导JVM运行程序的时候该给数据分配多大的内存空间!

基本数据类型

基本数据类型包括整数型(byte,short,int,long)、浮点型(float,double)、布尔型(boolean)、字符型(char)。字符串”abc”不属于基本数据类型,属于“引用数据类型”,字符串使用双引号,字符使用单引号!

八种基本数据类型各自占用空间大小:

数据类型 占用空间大小[单位:字节]
byte 字节 1
short 短整型 2
int 整型 4
long 长整型 8
float 单精度浮点型 4
double 双精度浮点型 8
boolean 布尔型 1
char 字符型 2

计算机在任何情况下都只能识别二进制,例如101010101010..现代的计算机底层采用交流电的方式,接通和断开两种状态,计算机只识别1或者0,其它不认识。二进制表示慢二进一原则,十进制就是满十进一原则。

例如:十进制 0 1 2 3 4 5 6 7 8 9 10 11 ...
例如:二进制 0 1 10 11 100 101 110 111 1000 1001 ...
            0  1 2 3  4   5    6   7   8    9
1 byte = 8 bit 【1个字节 = 8个比特位】一个比特位就是二进制位 1或0
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB

1 TB = 1024*1024*1024*1024*8 bit

整数型当中的byte类型,占用1个字节,也就是8个比特位!Java中的数字都是由正负之分的,在数字的二进制当中有一个二进制位被称为“符号位”,并且这个“符号位”在所有二进制位最左边,0表示正数,1表示负数。

byte类型最大值:2的7次方-1,即127;byte类型最小值:-128

计算机只认识二进制,呢么计算机是怎么表示现实世界当中的文字的呢?

  1. 八种基本数据类型中,byte、short、int、long、float、double、boolean这7中数据类型,计算机在表示的时候比较容易,因为底层是数字,十进制的数字和二进制之间存在一种固定的转换规则。
  2. 八种基本数据类型的char类型表示现实生活中的文字,文字和计算机二进制之间,默认情况下是不存在任何转换关系的。
  3. 为了让计算机可以表示现实世界当中的文字,我们需要人为的干涉,需要人负责提前制定好“文字”和“二进制”之间的对照关系,这种对照转换关系被称为:字符编码
  4. 'a' --> 97 【01100001】
    'A' --> 65
    'b' --> 98
    '0' --> 48
    '1' -->49
    'a' --解码--> 01100001
    01100001 --编码--> 'a'
    
    编码和解码的时候采用同一套字典/对照表,不会出现乱码
    解码和编码的时候采用不同的对照表,则会出现乱码
  5. 八种数据类型的取值范围:
  6. byte  -128 ~ 127
    short  -32768 ~ 32767
    int    -2147483648 ~ 2147483647
    long
    float
    double
    boolean  true,false
    char   0 ~ 65535
    
    short和char表示的种类数是一样的,只不过char可以表示更大的正整数,因为char没有负数。

Java语言源代码采用Unicode编码方式,所以标识符可以写中文。在实际开发中,一般使用utf-8编码较多!

/*
	八种基本数据类的默认值    默认值
	---------------------------------
	byte、short、int、long     0
	float、double              0.0
	boolean                    false 【true是1,false是0】
	char                       \u0000
*/

public class DataTypeTest
{
	//成员变量,没有赋值,系统会默认赋值【局部变量不会】
	static int k; 
	public static void main(String[] args){
		System.out.println(k); // 0
	}
}

整数型byte、short、int、long

java语言当中的整数类型字面值有三种表示方式:

  1. 十进制,缺省默认的方式
  2. 八进制,以0开始
  3. 十六进制,以0x开始
/*
	整数型

	数据类型		占用空间		默认值		取值范围
	----------------------------------------------------
	byte		1	         0		-128 ~ 127
	short		2	         0		-32768 ~ 32767
	int		4	         0		-2147483648 ~ 2147483647
	long		8	         0L

	java语言中的“整数型字面值”被默认当作int类型处理,如果要当作long类型,需要在“整数型字面值”
	后面添加i/L
	
*/

public class DataTypeTest
{
	public static void main(String[] args){
		int a = 10;
		int b = 010;
		int c = 0x10;

		System.out.println(a); // 10
		System.out.println(b); // 8
		System.out.println(c); // 16
	}
}

int和long类型

public class DataTypeTest
{
	public static void main(String[] args){
		
		// 456整数型字面值被当作int类型,占用4个字节
		// 变量x在声明的时候是long类型,占用8个字节
		// int类型的字面值456赋值给long类型的变量x,存在类型转换
		// int类型是小容量,long类型是大容量
		// 小容量可以自动转换为大容量,称为自动类型转换
		long x = 456;
		System.out.println(x);
		

		// 2147483648字面值是int类型,但是已经超出int的最大取值,所以报错
		// long a = 2147483648;

		// 2147483648L是8个字节的long类型
		// z是long类型变量,以下程序不存在类型转换
		long z = 2147483648L;
		System.out.println(z);
	}
}

强制类型转换

public class DataTypeTest
{
	public static void main(String[] args){
		
		// 100L是long类型,x是long类型变量,不存在类型转换
		long x = 100L;
		// x变量是long类型,8个字节
		// y变量是int类型,4个字节
		// 以下程序编译报错,大容量不能直接转换为小容量
		// int y = x;


		// 大容量转换成小容量,需要进行强制类型转换
		// 强制类型转换,需要使用“强制类型转换符”
		// 使用强制类型转换符之后编译通过,但是运行阶段可能会损失精度

		// 强转原理:
		//       原始数据:0000000 0000000 0000000 0000000 0000000 0000000 0000000 0110100
		//		 转换之后数据: 0000000 0000000 0000000 0110100
		// 将左边的二进制去掉
		int y = (int)x;
		System.out.println(y);


		// 原始数据:0000000 0000000 0000000 0000000 1000000 0000000 0000000 0000000
		// 转换之后数据: 1000000 0000000 0000000 0000000
		long k = 2147483648L;
		int e = (int)k;
		System.out.println(e); // 损失京都严重,负数 -2147483648

	}
}

byte类型

public class DataTypeTest
{
	public static void main(String[] args){
		
		// 50属于int类型的字面值,b是byte类型的变量,大容量int转换为小容量byte
		// 大容量转换为小容量,需要加强制类型转换符的,但是byte类型是个例外
		// 以下程序编译不会报错
		byte b = 50;
		byte d = 127;

		// 整数类型字面值没有超出字节类型范围的,可以直接赋值给byte类型的变量

		byte k = 128; // 编译报错

		// 原始数据: 0000000 0000000 0000000 000000
		// 强转之后: 1000000 
		byte s = (byte)128; // -128
		System.out.println(s);
	}
}

整数型float、double

Java程序有一套庞大的类库,java程序员是基于这套基础的类库进行开发的,所以我们需要知道Java的SE类库的字节码:一般都在lib\src.zip压缩包中,JDK版本不同,位置也不一样,

/*
	float 单精度 【4个字节】
	double 双精度 【8个字节 精度较高】

	如果涉及到财务,double的精度太低,在基础SE类库中的应用数据类型:java.matn.BigDecimal

	java语言中,所有的浮点型字面值【3.0】,默认被当作double类型来处理
	如果想修改为float类型,需要在字面值后面添加 F/f
        double和float在计算机内部二进制存储的时候都是近似值
*/

public class DataTypeTest
{
	public static void main(String[] args){
		// 3.0是double类型字面值
		// d变量属于double类型,不存在类型转换
		double d = 3.0;
		System.out.println(d);

		// 5.1是double类型的字面值
		// f是float类型的变量
		// 大容量转换成小容量需要加强制转换符,以下程序编译报错
		// float f = 5.1;

		// 第一种解决方式
		float f = (float)5.1;
		// 第二种解决方式
		float g = 6.1f;
		System.out.println(f);
		System.out.println(g);
	}
}

布尔型boolean

在Java语言中,boolean类型只有两个值:true、false,没有其它值。在底层存储的boolean类型占用1个字节,在实际存储的时候false底层是0,true底层是1。

public class DataTypeTest
{
	public static void main(String[] args){
		// 编译错误,不兼容的类型
		// boolean a = 1;
		
		boolean loginSuccess = true;

		// if语句
		if(loginSuccess){
			System.out.println("恭喜你,登录成功!");
		}else{
			System.out.println("对不起,登陆失败!");
		}

	}
}

字符型char

public class DataTypeTest
{
	public static void main(String[] args){
		// 定义一个char类型的变量,名字c,变量值'a'
		char c = 'a';
		System.out.println(c);

		// 一个中文占用2个字节,char类型正好是2个字节
		// 所以Java中的char类型正好可以存储一个中文字符
		char a = '鳄';
		System.out.println(a);

		// 编译错误, ab是字符串,不能使用单引号括起来
		// char b = 'ab';
		
		
		// 编译错误,"a"是字符串类型,d变量是字符类型,类型不兼容
		// char d = "a";

		// 声明
		char e;
		// 赋值
		e = 'e';

		// 再次赋值
		e = 'f';
		System.out.println(e);
	}
}

转义字符

/*
	转义字符
	\n  换行符
	\t  制表符
	\'  单引号
	\"  双引号
	\\  反斜杠
*/

public class DataTypeTest
{
	public static void main(String[] args){
		// 普通的字符n
		char c = 'n';
		System.out.println(c);

		// 换行符
		char d = '\n';
		
		
		// print不换行输出;println输出之后换行
		System.out.print("Hello ");
		System.out.println(d); // 换行符
		System.out.println("World!");


		// 制表符tab
		// 制表符和空格的ASCII不一样
		char y = '\t';
		System.out.println("Hello ");
		System.out.println(y);
		System.out.println("eyujun!");

		// 输出反斜杠字符\
		char k = '\\';
		System.out.println(k);

		// 输出单引号字符
		char f = '\'';
		System.out.println(f);


		// JDK中自带的native2ascii.exe命令,可以将文字转换成unicode编码形式
		// 在命令行输入native2ascii 回车,然后输入文字之后即可得到unicode编码,JDK14没有这个命令

                // 输出空白
                char v = '\u0000';  
		System.out.println(v);

	}
}

/*
	十进制:0 1 2 3 4 5 6 7 8 9 10 11 ...
	二进制:0 1 10 11 100 101 ...
	十六进制:0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 ...
	八进制:0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 ...

*/

基本数据类型互相转换

基本数据类型之间的相互转换,转换规则:

  1. 八种基本数据类型当中除布尔类型之外剩下的7中类型之间都可以互相转换
  2. 小容量向大容量转换,称为自动类型转换,容量从小到大排序
  3. byte < short < int < long < float < double
  4. 任何浮点型不管占用多少个字节,都比整数型容量大
  5. char和short可表示的种类数量相同,但是char可以取更大的正整数
  6. 大容量转换成小容量,叫做强制类型转换,需要加强制类型转换符,程序才能编译通过,但是在运行阶段可能会损失精度!
  7. 当整数字面值没有超出byte、short、char的取值范围,可以直接赋值给byte、short、char
  8. byte、short、char混合运算的时候,需要先转换成int类型再做运算!
  9. 多种数据类型混合运算,先转换成容量最大的呢种类型再做运算!
public class DataTypeTest
{
	public static void main(String[] args){
		// byte取值范围-128 ~ 127
		// byte a = 1000; 报错
		byte a = 20; // 变量不能重名
		short b = 1000; // 正确
		int c = 1000; // 默认就是int类型,并且没有超出int范围
		long d = c; // 正确,小容量转换为大容量,自动类型转换
		// int e = d; 错误,大容量转换为小容量,且没有强制转换符
		int e = (int)d; // long强制转换为int,运行阶段精度可能会丢失
		int f = 10/3; // 3 正确,10和3属于int,运算后的最大类型也是int
		long g = 10; // 正确
		// int h = g/3;  错误,long和int运算,会转换成long类型,而h为int,大容量转换为小容量
		int h = (int)g/3; // 正确,强制类型转换,结果没有超过int范围
		long i = g/3; // 正确
		// byte k = (byte)(int)g/3; 错误,long强转为int,然后有转换为byte,运算之后结果属于int类型,int类型赋值给byte,会损失精度
		byte k = (byte)(int)(g/3); // 正确,转换之后为byte类型
		// byte l = (byte)g/3; 错误,转换之后为int类型,大容量转换为小容量需要强制转换符
		byte l = (byte)(g/3);
		short s = 10;
		byte j = 5;
		// short k = s + j; 错误,short和byte运算,会先转换为int,运算结果为int,int转换为short会出现精度损失
		short p = (short)(i + j); // 正确
		int m = s + j; // 正确
		char n = 'a'; // 正确
		System.out.println(n); // 97

		int w = n + 100; 
		System.out.println(w); // 197

		double r = 10 / 3;
		System.out.println(r);// 3.0
		r = 10.0 / 3;
		System.out.println(r);// 3.3333333333333335
	}
}

引用数据类型

未经允许不得转载:作者:鳄鱼君, 转载或复制请以 超链接形式 并注明出处 鳄鱼君
原文地址:《Java中基础 基本数据类型-引用数据类型》 发布于2020-07-30

分享到:
赞(0) 赏杯咖啡

评论 抢沙发

8 + 6 =


文章对你有帮助可赏作者一杯咖啡

支付宝扫一扫打赏

微信扫一扫打赏

Vieu4.6主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册