java数据类型

最新推荐文章于 2024-09-06 14:04:18 发布

qq_45016525

最新推荐文章于 2024-09-06 14:04:18 发布

阅读量90

点赞数

分类专栏：初学java 文章标签： java

原文链接：https://www.bilibili.com/video/BV1Rx411876f

版权

初学java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

一、java数据类型的作用是什么？
二、java中的数据类型大的分类包括两种

一、java数据类型的作用是什么？

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

二、java中的数据类型大的分类包括两种

* 基本数据类型
* 引用数据类型

1.基本数据类型

基本数据类型包括四大类八小种：
第一类：整数型
byte,short,int,long
第二类：浮点型
float,double
第三类：布尔型
boolean
第四类：字符型
char

2.引用数据类型

字符串"abc"不属于基本数据类型，属于“引用数据类型”，字符属于基本数据类型：
* 字符串使用双引号 “abc”
* 字符使用单引号 ‘a’

3.八种基本数据类型：

    1.	基本数据类型		占用空间大小【单位：字节】
	--------------------------------------------------
	byte			1
	short		    2
	int		    	4
	long			8
	float			4
	double			8
	boolean			1
	char			2
    2.计算机在任何情况下都只能识别二进制
    3.字节（byte）：
    	1 byte = 8 bit	【一个字节 = 8个比特位】一个比特位就是一个二进制位，即1或0
	1 KB = 1024 Byte
	1 MB = 1024 KB
	1 GB = 1024 MB
	1 TB = 1024 GB
    4.整数型当中的byte类型，占用一个字节，所以byte类型的数据占用8个比特位。那么byte类型
    的取值范围是什么？
    	* 关于java中的数字类型，数字都是由正负之分的，所以在数字的二进制当中有一个二进制位
	被称为“符号位”。并且这个“符号位”在所有二进制位的最左边，0表示正数，1表示负数。
	* byte类型最大值：01111111
	* byte类型最小值：-128
	* byte类型的取值范围：[-128~127]
	* byte类型可以表示256个不同的数字
    5.计算机只认识二进制，那么计算机怎么表示现实世界中的文字的呢？
    	*八种基本数据类型当中，byte,short,int,long,float,double,boolean这七种
	数据类型计算机表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定，的转换规则

	*但是八种基本数据类型当中char类型表示的是现实当中的文字，文字和计算机二进制之间“默认”情况下是不存在任何转换关系的

	*为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好“文字”和“二级制”之间的对照关系
	这种对照关系被称为：字符编码。

	*计算机最初只支持英文，最先出现的字符编码是：ASCII码
	'a' --> 97 [01100001]
	'A' --> 65
	'o' --> 48

	'a'--（按照ASCII解码）-->01100001
	01100001 ---按照ASCII编码-->'a'

	编码和解码要采用同一套对照表/字典，不然会出现乱码的情况
	
	*随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，
	这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文，这种编码方式是：ISO-8859-1,又被称为：latin-1
	
	*随着计算机向着亚洲发展，计算机开始支持中文，日文，韩文等国家文字，其中支持简体中文的编码方式是：
	GB2313 < GBK <GB18030
	
	*支持繁体中文：大五码<big5>

	*后来出现了一种编码方式统一了全球所有的文字，容量较大，这种方式叫做：unicode编码
	unicode编码方式有多种具体的实现：
		- utf-8
		- utf-16
		- utf-32
		......

	*java语言采用的是哪一种编码方式呢？
		-java语言源代码采用的是unicode编码方式，所有“标识符”可以用中文。

	*在实际开发中，一般使用utf-8较多【统一编码方式】

    6.八种数据类型的取值范围：
    	类型			取值范围
	--------------------------------
	byte			[-128 ~ 127]
	short			[-32768 ~ 32767]
	int			[-2147483648 ~ 2147483647]
	boolean			[true,false]
	char			[0 ~ 65535]
	
	注意：short和char表示的种类总数是一样的，只不过char可以表示更大的正整数
	因为char没有负数

    7.  关于八种基本数据类型的默认值
             数据类型		默认值
          ------------------------------
        	byte,short,int,long	    0
            float,double		    0.0
         	boolean		        	false【再C语言中，true是1，false是0】
            char			        \u0000

     八种数据类型的默认值是一切向0看齐

public class DataTypeTest02
{
	//这里的static必须加
	static int k = 1000;
	
	//变量还是遵循这个语法，必须先声明，再赋值，才能访问
	//成员变量没有手动赋值系统会默认赋值【局部变量不会】
	static int f;//成员变量

	public static void main(String[] args){
		/*
		int i;//局部变量
		System.out.println(i);
		*/

		System.out.println(k);

		System.out.println(f);//0
	}

}

public class DataTypeTest01
{
	public static void main(String[] args){
		
		//定义一个char类型的变量，起名c，同时赋值字符'a'
		char c = 'a';
		System.out.println(c);

		//一个中文占用2个字节，char正好是2个字节
		//所以java中的char类型变量可以存储一个中文字符
		char x = '国';
		System.out.println(x);

		//编译错误
		//ab是字符串，不能使用单引号括起来
		//char y = 'ab'；

		//"a"是字符串类型
		//k变量是char类型
		//类型不兼容，编译错误
		char k = "a";

		//声明
		char e;

		//赋值
		e = 'e';

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

关于java语言中的char类型：
	转义字符 \

转义字符出现在特殊字符之前，会将特殊字符转换成普通字符。
\n	换行符
\t	制表符
\'	普通的单引号
\\	普通的反斜杠
\"	普通的双引号

public class DataTypeTest03
{
	public static void main(String[] args){

	//普通的n字符
	char c1 = 'n';
	System.out.println(c1);

	char c2 = '\n'; //"\n"表示一个字符，这是一个换行符，属于char类型的数据
	//反斜杠在java语言当中具有转义功能。
	
	//System.out.println()和System.out.print()区别：
	//println输出之后换行，print表示输出，但是不换行
	
	System.out.print("A");
	System.out.print(c2);
	System.out.println("B");
	

	//普通的t字符
	System.out.println(x);

	//强调：制表符和空格不一样，他们的ASCII码不一样，体现在键盘上两个不同的按键
	//制表符tab
	char y = '\t';
	System.out.print("A");
	System.out.print(y);
	System.out.println("B");
	

	//要求在控制台上输出“反斜杠字符”
	//反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符，左边的单引号缺少了结束单引号字符
	/*
	char k = '\';
	System.out.println(k);
	*/
	char k = '\\';
	System.out.println(k);


	//在控制台上输出一个普通的单引号字符
	//char a = '';//java中不允许这样编写程序，编译报错
	
	//以下编译报错：第一个单引号和第二个单引号配对，最后一个单引号找不到另一半
	//char a = ''';

	char a = '\'';
	System.out.println(a);

	char m = '中'
	System.out.println(m);

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

	char n = '\u4e2d';//'中'对应的unicode编码是 4e2d
	System.out.println(n);
	
	//编译错误
	//char g = '4e2d';
	//编译错误
	//char g = 'u4e2d';
	//通过：反斜杠联合起来后面的一串数字是某个文字的unicode编码
	char g= ='\u4e2d';
	System.out.println(g);


	}
}

关于java语言当中的整数型：
	数据类型		占用空间大小		默认值		取值范围
	-------------------------------------------------------

	byte			1			0	    	[-128~127]
	short			2			0    		[-32768~32767]
	int			    4			0	    	[-2147483648~2147483647]
	long			8			0L		
1.java语言当中的“整数型字面值”被默认当作int类型来处理。要让这个整数型字面值当       作long类型来处理的话，
需要在“整数型字面值”后面添加1/L，建议使用大写的L

2.java语言当中的整数型字面值有三种表示方式：
第一种方式：十进制【是一种缺省默认的方式】
第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

public class DataTypeTest04
{
	public static void main(String[] args){
	
	int a = 10;
	int b = 010;//整数型字面值以0开头，后面那一串数字就是八进制数字
	int c = 0x10;//整数型字面值以0x开头的，后面那一串数字就是十六进制

	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;


	//解决错误
	//2147483648字面值一上来就当作long类型处理，在字面值后面添加L
	//2147483648L是8个字节的long类型
	//z是long类型变量，以下程序不存在类型转换
	long z = 2147483648L;
	System.out.println(z);
	}
}

public class DataTypeTest05
{
	public static void main(String[] args){
		//100L是long类型字面值
		//x是long类型变量
		//不存在类型转换，直接赋值
		long x = 100L;

		//x变量是long类型，8个字节
		//y变量是int类型，4个字节
		//编译报错，大容量不能直接赋值给小容量
		int y = x;

		//大容量转换成小容量，需要加上强制类型转换
		//强制类型转换需要“强制类型转换符”
		//加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度
		//所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重
		//强转原理：
			//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
			//强转之后的数据：00000000 00000000 00000000 01100100
			//将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】
		int y = (int)x;
		System.out.println(y);
		

		//原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
		//强转之后的数据：10000000 00000000 00000000 00000000
		//10000000 00000000 00000000 00000000目前存储在计算机内部，计算机存储数据都是采用补码的形式存储
		//所以10000000 00000000 00000000 00000000现在是一个补码
		//将以上的补码转换成原码就是最终的结果
		long k = 2147483648L;
		int e = (int)k;
		System.out.println(e);//损失精度严重，结果是负数【-2147483648】

		//分析以下程序是否可以编译通过？
		//依据目前所学内容，以下程序无法编译通过
		//理由：50是int类型的字面值，b是byte类型的变量
		//显然是大容量int转换成小容量byte
		//大容量转换成小容量是需要添加强制转换符的，以下程序没有添加强转符号，所以编译报错
		//但是在实际编译过程中时，以下代码编译通过，这说明：在java语言当中，当一个整数型字面值
		//没有超过byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量。
		
		byte b = 50;//可以
		byte c = 127;//可以
		//编译报错，128这个int类型的字面值已经超过了byte类型的取值范围，不能直接赋值给byte类型的变量
		//byte x = 128;

		//纠正错误，需要使用强制类型转换符
		//但是一定会损失精度
		//原始数据：00000000 00000000 00000000 10000000
		//强转之后：10000000,[这是存储在计算机内部的，这是一个补码。]
		byte b1 = (byte)128;
		System.out.println(b1)
	
		/*计算机二进制有三种表示方式：
			原码
			反码
			补码
		 计算机在任何情况下底层表示和存储数据的时侯采用了补码形式
		正数的补码：和原码相同
		负数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加1
  
		例如：
		补码：10000000
		原码的计算过程：
  			*10000000 -1 --> 01111111
			*10000000 --> 128
			*-128
		*/
		//原视数据：00000000 00000000 00000000 11000110
		//强制类型转换之后：11000110
		//11000110现在在计算机当中存储，它是一个补码，将补码转换成原码就是该数字
		//11000110 -1 --> 11000101
		//00111010 --> 58
		//-58
		byte m = (byte)198;
		System.out.println(m);//-58

		//short s = 32767;//通过
		//short s1 = 32768;//编译报错

		//65535是一个int类型，4个字节
		//cc是char类型，2个字节
		//按照以前所学知识，应该不能通过
		//char cc = 65535;//通过
		//cc = 65535;

		/*
			当一个整数型字面值没有超过byte，short,char的取值范围，这个字面值
			可以直接赋值给byte,short,char类型的变量，这种机制sun允许，
			目的是为了方便程序员编程
		*/
		}
	}

关于浮点型数据类型：
	float 单精度【4个字节】
	double 双精度【8个字节，精度较高】

double的精度太低【相对来说】不适合做财务软件
财务涉及到钱的问题，要求精度较高，所以sun在基础SE类库当中
为程序员准备了精度更高的类型，只不过这种类型是一种引用
数据类型，不属于基本数据类型，它是：java.math.BigDecimal

其实java程序中sun提供了一套庞大的类库，java程序员是基于这套
基础的类库来进行开发的。所以要知道java的SE类库的字节码在哪儿，
要知道Java的SE的类库的源码在哪儿？
	*SE类库字节码：jre\lib\rt.jar
	*SE类库源码：src.zip

例如：String.java和String.class
我们的(String[] args)中的String使用的就是String.class字节码文件

在java语言当中，所有的浮点型字面值【3.0】，默认当作double类型来处理
要想该字面值当作float类型来处理，需要在字面值后面添加F/f

注意：double和float在计算机内部二进制存储的都是近似值。
在现实世界当中有一些数字是无限循环的，例如：3.33333333333333.。。。。。
计算机的资源是有限的，用有限的资源来存储无限的数据只能存储近似值

public class DataTypeTest06
{
	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 f = 5.1f;

	}
}

关于布尔型数据类型：
boolean

在java语言当中boolean类型只有两个值：true和false，没有其他值
不像c语言，0和1可以表示假和真。

在底层存储的时候boolean类型占用一个字节，因为实际存储的时候false底层是0，
true底层是1

布尔类型在实际开发中非常重要，经常使用在逻辑运算和条件控制语句当中

public class DataTypeTest07
{
	public static void main(String[] args){
		//编译错误：不兼容类型
		//boolean flag = 1;

		boolean loginSuccess = true;
		
		//条件控制语句
		if(loginSuccess){
			System.out.println("恭喜你，登录成功！");
		}else{
			System.out.println("对不起，用户名不存在或者密码错误！");
		}
		
	}
}

关于基本数据类型之间的相互转换：转换规则
	1.八种基本数据类型当中除布尔型之外剩下的7种数据类型之间都可以互相转换
	2.小容量向大容量转换，称为自动类型转换，容量由小到大排序：
		byte<short<int<long<float<double
		     char <
	注意：
		任何浮点型不管占用多少个字节，都比整数型容量大。
		char和short可表示的种类数量相同，但是char可以取更大的正整数
	3.大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，
	但是在运行阶段可能会出现精度损失，所以谨慎使用

	4.当整数型字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char
	类型的变量
	5.byte,short,char混合运算的时候，各自先转换成int类型再做运算
	6.多种数据类型混合运算，先转换成容量最大那种类型再做运算
	注意：
		byte b = 3;	可以编译通过，3没有超出byte的取值范围
		int i = 10；
		byte b = i/3;	编译报错，编译器只检查语法，不会“运算”i/3