07、java 数据类型(包含: 基本数据类型和引用数据类型)的定义、基本数据类型间的运算规则及案例、String类型变量的使用及案例

文章07、java 数据类型(包含: 基本数据类型和引用数据类型)的定义、基本数据类型间的运算规则及案例、String类型变量的使用及案例分享给大家，欢迎收藏Java资料网，专注分享技术知识

Ⅰ、java 数据类型：

1、 变量按照数据类型来分：

基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean

引用数据类型：
类(class)(注意：字符串是一个类 类型的)
接口(interface)
数组(array)

2、 变量在类中声明的位置来分：

成员变量 vs 局部变量

Ⅱ、基本数据类型：

1、整型：

整型包括：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
① byte范围：-128 ~ 127;
② 声明long型变量，必须以 “l” 或 “L” 结尾;
③ 通常，定义整型变量时，使用 int 型;

其一、代码为：

class VariableTest1 {
	public static void main(String[] args) {
		//1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		//① byte范围：-128 ~ 127
		//
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;//编译不通过(因为超过了 byte 的范围)
		System.out.println(b1);//12
		System.out.println(b2);//-128

		// ② 声明long型变量，必须以"l"或"L"结尾
		// ③ 通常，定义整型变量时，使用int型。
		short s1 = 128;
		int i1 = 1234;
		long l1 = 3414234324L;
		System.out.println(l1);//3414234324

	}
}

其二、截图为：

2、浮点型：

浮点型：float(4字节) \ double(8字节)
① 浮点型，表示带小数点的数值;
② float 表示数值的范围比 long 还大;
③ 定义 float 类型变量时，变量要以 “f” 或 “F” 结尾;
④ 通常，定义浮点型变量时，使用 double 型;

其一、代码为：

class VariableTest1 {
	public static void main(String[] args) {
		//2. 浮点型：float(4字节) \ double(8字节)
		//① 浮点型，表示带小数点的数值
		//② float表示数值的范围比long还大

		double d1 = 123.3;
		System.out.println(d1 + 1);//124.3
		//③ 定义float类型变量时，变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1);//12.3
		//④ 通常，定义浮点型变量时，使用double型。

	}
}

其二、截图为：

3、字符型：

字符型：char (1字符=2字节)
① 定义char型变量，通常使用一对 ’ ’ ,内部只能写一个字符;
② 表示方式(即：声明 char 型变量的几种表示方式)：
a.声明一个字符;
b.转义字符;
c.直接使用 Unicode 值(即：十六进制)来表示字符型常量;

其一、代码为：

class VariableTest1 {
	public static void main(String[] args) {
		//3. 字符型：char (1字符=2字节)
		//① 定义char型变量，通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		//c1 = 'AB'; //编译不通过，因为 char 型变量内部只能写一个字符;
		System.out.println(c1);//a

		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		System.out.println(c2);//1
		System.out.println(c3);//中
		System.out.println(c4);//ス

		//② 表示方式(即：声明 char 型变量的几种表示方式)：
		//1.声明一个字符 2.转义字符 3.直接使用 Unicode 值(即：十六进制)来表示字符型常量
		char c5 = '\n';//换行符，\n并不是两个字符，而是一个转义字符;
		c5 = '\t';//制表符(即：类似 Tab 键的制表符);
		System.out.print("hello" + c5);
		System.out.println("world");//hello     world

		char c6 = '\u0043';
		System.out.println(c6);//C

	}
}

其二、截图为：

4、布尔型：

布尔型：boolean
① 只能取两个值之一：true 、 false;
② 常常在条件判断、循环结构中使用;

其一、代码为：

class VariableTest1 {
	public static void main(String[] args) {
		//4.布尔型：boolean
		//① 只能取两个值之一：true 、 false
		//② 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		System.out.println(bb1);//true

		boolean isMarried = true;
		if(isMarried){
			System.out.println("你就不能参加\"单身\"party了！\\n很遗憾");
			//你就不能参加"单身"party了！\n很遗憾
		}else{
			System.out.println("你可以多谈谈女朋友！");
		}

	}
}

其二、截图为：

5、基本数据类型之间的运算规则之一：自动类型提升

前提：这里讨论只是 7 种基本数据类型变量间的运算。不包含 boolean 类型的。

自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。 byte 、char 、short --> int --> long --> float --> double;

特别的：当 byte、 char、 short 三种类型的变量做运算时，结果为 int 型;

说明：此时的容量大小指的是，表示数的范围的大和小(而不是其占用空间的大和小);
比如：float 容量要大于 long 的容量(即：表示数范围的大小);

其一、代码为：

class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过(因为：byte 类型与 int 类型的运算结果应该是 int 类型)
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		System.out.println(i2);//131
		System.out.println(l1);//131

		float f = b1 + i1;
		System.out.println(f);//131.0

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);//123.0


		//***************特别地*********************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);//107

		short s2 = 10;
		//short c2  = c1 + s2;//编译不通过(因为：char 类型与 short 类型的运算结果应该是 int 类型)
		//char c2  = c1 + s2;//编译不通过(因为：char 类型与 short 类型的运算结果应该是 int 类型)

		byte b2 = 10;
		//byte c3 = c1 + b2;//编译不通过(因为：char 类型与 byte 类型的运算结果应该是 int 类型)
		//char c3 = c1 + b2;//编译不通过(因为：char 类型与 byte 类型的运算结果应该是 int 类型)

		//short s3 = b2 + s2;//编译不通过(因为：byte 类型与 short 类型的运算结果应该是 int 类型)
		//byte s3 = b2 + s2;//编译不通过(因为：byte 类型与 short 类型的运算结果应该是 int 类型)

		//short s4 = b1 + b2;//编译不通过(因为：byte 类型与 byte 类型的运算结果应该是 int 类型)
		//byte s4 = b1 + b2;//编译不通过(因为：byte 类型与 byte 类型的运算结果应该是 int 类型)
		//****************************************

	}
}

其二、截图为：

6、基本数据类型之间的运算规则之二：强制类型转换

强制类型转换：自动类型提升运算的逆运算;
A、需要使用强转符：();
B、注意点：强制类型转换，可能导致精度损失;

其一、代码为：

class VariableTest3 {
	public static void main(String[] args) {
		
		double d1 = 12.9;
		//int i1 = d1;//编译不通过(因为：double 类型不能自动类型提升为 int 类型，因此编译报错)

		//精度损失举例1
		int i1 = (int)d1;//截断操作
		System.out.println(i1);//12(此时是将 double 类型强制转换为 int 类型，会有精度损失)
		
		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;//123(此时是将 long 类型强制转换为 short 类型)
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);//-128(此时是将 int 类型强制转换为 byte 类型，会有精度损失)

	}
}

其二、截图为：

7、char 类型不常见的赋值情况：

其一、代码为：

class ReviewTest{

	public static void main(String[] args){
		char c1 = 'a';
		char c2 = 97;//开发中非常少见(即：直接写 ACSII 对应的数值)

		System.out.println(c2);//a

		char c3 = 5;
		char c4 = '5';
		char c5 = 53;

		int i1 = (int)c4; // 其实直接 int i1 = c4; 赋值是 ok 的(即：自动类型转换);
		System.out.println(c4);//5
		System.out.println(c5);//5
		System.out.println(i1);//53(即：此时输出的是 5 所对应的 SCII 值)

	}
}

其二、截图为：

8、变量运算规则的两个特殊情况：

其一、代码为：

class VariableTest4 {
	// 变量运算规则的两个特殊情况：
	public static void main(String[] args) {
		
		//1.编码情况1：
		long l = 123213; // 此时的 123213 默认是 int 类型，然后再赋值给 long 型(即：自动类型提升); 
						 // 而 123213l 默认是 long 型;
		System.out.println(l);//123123
		//编译失败：过大的整数
		//long l1 = 21332423235234123;//此时超过 int 的范围而未超过 long 的范围就会报错(但本不应该报错);
		long l1 = 21332423235234123L;//此时超过 int 的范围而未超过 long 的范围就不会报错;


		//****************
		//编译失败
		//float f1 = 12.3;//此时的 12.3 默认是 double 类型，因此会报错(因为丢失精度);
		float f1 = (float)12.3;
		//2.编码情况2：
		//整型常量，默认类型为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败,此时应该用 int 型来接收，因为常量 1 默认是 int 类型;

		int b1 = b + 1; // 此时的编译没有问题;

		//float f1 = b + 12.3;//编译失败,此时应该用 double 型来接收，因为常量 12.3 默认是 double 类型;

		double f11 = b + 12.3;
		
	}
}

其二、截图为：

// 说明：此上代码编译都能通过，语法没有问题;

Ⅲ、String 类型变量：

String 类型变量的使用:
①. String 属于引用数据类型,翻译为：字符串
②. 声明 String 类型变量时，使用一对""(即：英文双引号)
③. String 可以和 8 种基本数据类型变量做运算，且运算只能是连接运算：+
④. 运算的结果仍然是 String 类型

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		String s1 = "Hello World!";

		System.out.println(s1);//Hello World!

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过，此时需要声明为' '或'a',编译才没有问题;
					  //即：char 声明变量有且仅能放一个字符(即：少了多了字符,编译都会报错);

	}
}

其二、截图为：

Ⅳ、String 与基本数据类型间运算的案例：

1、案例1：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//***********************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);//学号：1001true


	}
}

其二、截图为：

2、案例2：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//***********************
		//练习2(即： + 是加号还是连接符的情况区分):
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

	}
}

其二、截图为：

3、案例3：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//练习3(即：希望在控制台输出如下* *结果):
		//*	*
		System.out.println("*	*");//* *
		System.out.println('*' + '\t' + '*');//93，因为 char 对应的是 SCII 码，做的是加法运算;
		System.out.println('*' + "\t" + '*');//* *
		System.out.println('*' + '\t' + "*");//51*
		System.out.println('*' + ('\t' + "*"));//* *

	}
}

其二、截图为：

4、案例4：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//***********************
		// 如下是两道 pdf 文档例题的讲解：
		//String str1 = 123;//编译不通过，因此不能说 String 是自动类型提升的最后一档;
		String str1 = 123 + "";
		System.out.println(str1);//123 (但实际是 "123" 这样的字符串类型)
		
		//int num1 = str1;//编译不通过，不能将 String 类型直接转成 int 类型;
		//int num1 = (int)str1;编译不通过，不能将 String 类型以此强制类型转换成 int 类型;

		int num1 = Integer.parseInt(str1);// 此时的 Integer.parseInt(str1) 是包装类;
		System.out.println(num1);//123, 此时的输出结果是 int 类型的 123 的值;

	}
}

其二、截图为：

5、案例5：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//******************************************************
		//String str111 = 4; //判断对错：no，编译报错;
		String str222 = 3.5f + ""; //判断str2对错：yes
		System.out.println(str222); //输出：3.5(表示的是字符串，实际是："3.5")
		System.out.println(3+4+"Hello!"); //输出：7Hello!
		System.out.println("Hello!"+3+4); //输出：Hello!34
		System.out.println('a'+1+"Hello!"); //输出：98Hello!
		System.out.println("Hello"+'a'+1); //输出：Helloa1
	}
}

其二、截图为：

6、案例6：

其一、代码为：

class StringTest {
	public static void main(String[] args) {
		
		//******************************************************
		//判断是否能通过编译
		//short s = 5;
		//s = s-2; //判断：no, 因为 2 是常量，是 int 类型，因此返回值是 int 类型;
		int s = 5;
		s = s-2; //此时的编译才没有问题;

		byte b = 3;
		//b = b + 4; //判断：no, 同上，因为 4 是常量，是 int 类型，因此返回值是 int 类型;
		b = (byte)(b+4); //判断：yes，因为强制类型转换没有问题;

		char c1 = 'a';
		int i = 5;
		float d = .314F;
		double result = c1+i+d; //判断：yes

		byte b2 = 5;
		short s4 = 3;
		//short t = s4 + b2; //判断：no, 同上, 因为 byte 与 short 的运算结果是 int 类型;
		int t = s4 + b2;//此时的编译才没有问题;

	}
}

其二、截图为：

Ⅴ、小结：

其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！

文章来源:https://blog.csdn.net/weixin_43405300/article/details/139360659
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！