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

分类:热门推荐日期:2024-06-21浏览:1评论:0

java 数据类型的定义与运算案例

  • Ⅰ、java 数据类型：
    • 1、 变量按照数据类型来分：
    • 2、 变量在类中声明的位置来分：
    • Ⅱ、基本数据类型：
      • 1、整型：
        • 其一、代码为：
        • 其二、截图为：
        • 2、浮点型：
          • 其一、代码为：
          • 其二、截图为：
          • 3、字符型：
            • 其一、代码为：
            • 其二、截图为：
            • 4、布尔型：
              • 其一、代码为：
              • 其二、截图为：
              • 5、基本数据类型之间的运算规则之一：自动类型提升
                • 其一、代码为：
                • 其二、截图为：
                • 6、基本数据类型之间的运算规则之二：强制类型转换
                  • 其一、代码为：
                  • 其二、截图为：
                  • 7、char 类型不常见的赋值情况：
                    • 其一、代码为：
                    • 其二、截图为：
                    • 8、变量运算规则的两个特殊情况：
                      • 其一、代码为：
                      • 其二、截图为：
                      • Ⅲ、String 类型变量：
                        • 其一、代码为：
                        • 其二、截图为：
                        • Ⅳ、String 与基本数据类型间运算的案例：
                          • 1、案例1：
                            • 其一、代码为：
                            • 其二、截图为：
                            • 2、案例2：
                              • 其一、代码为：
                              • 其二、截图为：
                              • 3、案例3：
                                • 其一、代码为：
                                • 其二、截图为：
                                • 4、案例4：
                                  • 其一、代码为：
                                  • 其二、截图为：
                                  • 5、案例5：
                                    • 其一、代码为：
                                    • 其二、截图为：
                                    • 6、案例6：
                                      • 其一、代码为：
                                      • 其二、截图为：
                                      • Ⅴ、小结：

                                        Ⅰ、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,创作不易，且行且珍惜！

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号