Java编程基础：变量、数据类型与类型转换-CSDN博客

本文介绍了Java中的基本语法，包括最小存储单位bit和基本存储单元byte的关系，变量的声明和使用规则，以及不同数据类型的细节，如整型（byte,short,int,long）、浮点型（float,double）、字符型(char)和布尔型(boolean)。文章还讨论了程序中+号的用法，以及浮点数的精度问题。此外，重点讲解了自动类型提升的原则和强制类型转换的注意事项，并给出了实例。最后，提到了String类型的转换方法，包括基本数据类型与String之间的转换。

第二章基本语法

2.1 bit

bit：计算机中的最小存储单位
byte：计算机中的基本存储单元
1byte = 8bit

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0p83TKk-1685024156445)(E:\Java_learning\typora_note\images\image-20230224192429019.png)]$

2.2 变量

变量的使用
1.java变量的格式：变量类型变量名 = 变量值；
2.说明
1.变量必须先声明，后使用
2.变量都定义在其作用域内，在作用域内他是有效的，出了作用域就失效了
3.同一个作用域内，不可以声明两个同名的变量名

![在这里插入图片描述](https://img-blog.csdnimg.cn/ce343c6d58b540429b722871367b1be1.png

程序中+号的使用
    1.如果+号两边同为数值型，那么则进行加法运算
    2.如果+号两边有一方为字符串，那么则进行拼接运算
    3.运算的顺序为从左到右
Java定义的数据类型
一、变量按照数据类型来分：
	基本数据类型：
		1.整形：byte（1字节=8bit） \ short（2字节） \ int（4字节） \ long（8字节）
            >byte范围：-128 ~ 127
            >声明long型变量，必须以“l”或者“L”结尾
            >通常定义变量时，使用int型
		2.浮点型：float(4字节) \ double (8字节)
            >浮点型，表示带小数点的数值
            >float表示的数值的范围比long还大
            >float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
            >double:双精度，精度是float的两倍。通常采用此类型。
            >定义float类型变量时，变量要以“F”或者“f”结尾
            >通常定义浮点型变量时，使用double类型
            	~关于浮点数在机器中的存放形式的简单说明：浮点数= 符号位+指数位+尾数位
                ~尾数部分可能丢失，造成精度损失（小数都是近似值）
 public class FloatDetail{
	public static void main(String[] args){
		//java中的浮点数常量默认类型为double，声明float类型须在后边加上“F”或“f”
		// double n1 = 1.2F; 错误的 
		// double n2 = 1.2F; 正确的
		// float n3 = 1.3 	错误的
		// float n4 = 1.3F  正确的 
		
		double num5 = .123; //等价 0.123

		
		System.out.println(5.12e2);//512.0
		System.out.println(5.12E-2);//0.0512


		//通常情况下，应该使用 double 型，因为它比 float 型更精确。
		//[举例说明]double num9 = 2.1234567851;float num10 = 2.1234567851F;
		double num9 = 2.1234567851;
		float num10 = 2.1234567851F;
		System.out.println(num9);
		System.out.println(num10);

		//浮点数陷阱： 2.7 和 8.1 / 3 比较
		//看看一段代码
		double num11 = 2.7;
		double num12 = 2.7; //8.1 / 3; //2.7
		System.out.println(num11);//2.7
		System.out.println(num12);//接近 2.7 的一个小数，而不是 2.7
		//得到一个重要的使用点: 当我们对运算结果是小数的进行相等判断是，要小心
		//应该是以两个数的差值的绝对值，在某个精度范围类判断
		if( num11 == num12) {
		System.out.println("num11 == num12 相等");
		}
		//正确的写法 , ctrl + / 注释快捷键, 再次输入就取消注释
		if(Math.abs(num11 - num12) < 0.000001 ) {
		System.out.println("差值非常小，到我的规定精度，认为相等...");
		
		}
		// 可以通过 java API 来看 下一个视频介绍如何使用 API
		System.out.println(Math.abs(num11 - num12));
		//细节:如果是直接查询得到的小数或者直接赋值，是可以判断相等
	}
}
		字符型：char（1个字符 = 2个字节 = 16bit）                                                                                                                                                                                                                                                                                                                                                                                                                
			>定义char变量，通常使用一对‘’，单引号内部只能写一个字符，本质是一个整数
			>表示方式：1.表示一个字符 2.转义字符 3.直接使用Unicode值来表示字符常量
		布尔型：boolean :true / false
		


	引用数据类型：
		类(class)：
		接口(interface)：
		数组(array)：


二、变量在类中声明的位置
		成员变量 vs 局部变量

2.3 自动类型提升

![在这里插入图片描述](https://img-blog.csdnimg.cn/71b87ed5ece14aa0aeb0e09998e5ad1b.png

自动类型转换细节
1.有很多类型数据混合运算时，系统首先自动将所有数据转换为容量最大的那种数据类型
2.当我们把精度容量大的数据类型赋值给容量小的将报错,反之就会进行自动类型转换
3.(byte short ) 和 char 之间不会自动类型转换
4.byte short char 三者进行计算时候首先会自动转换为int类型
5.boolean 不参与自动类型转换
*6.自动提升原则：表示结果的类型，自动提升为操作数中最大的数据类型

public  class AutoConvert{
	public static void main(String[] args){
		//1有很多类型数据混合运算时，系统首先自动将所有数据转换为容量最大的那种数据类型
		int n1 = 10;
		//float d1 = n1 + 1.1; // 错误  n1 + 1.1 => 结果类型为double
		float d1 = n1 + 1.1F; // 对  n1 + 1.1F => 结果为float

		//2.当我们把精度容量大的数据类型赋值给容量小的 将报错,反之就会进行自动类型转换
		//int n2 = 1.1;  错误的  1.1 为double  无法赋值给double


		//3.(byte  short ) 和 char 之间不会自动类型转换		
		// 当把具体数赋给byte时，先判断该数是否在byte范围内，如果是则可以
		
		byte b1 = 10; // 对的  byte 范围 -128 - 127
		int n2 = 1 ;	//n2 为int 
		byte b2 = n2; //错误，原因；如果是变量赋值，会判断类型		

		char c1 = b1 ; //错误 原因 btye 不能自动转换为char

		//4.byte short char 三者进行计算时候首先会自动转换为int类型
		byte a1 = 1;
		byte b4 = 1;
		short a2 = 2;
		char a3 = 'a';
		// short a4 =  a1 + a2 + a3; 错误 a4 =  a1 + a2 + a3; 结果为int 
		// byte  a5 = a1 + b4 ;	错误 ：a5 = a1 + b4 ; 结果为int

		// 5.boolean 不参与自动类型转换
		boolean num1 = true;
		//int num2 = num1; // boolean 不参与自动类型提升

		// 6.自动提升原则：表示结果的类型，自动提升为操作数中最大的数据类型	
		
		byte b4 = 3;
		short a2 = 4;
		char a3 = 'b';
		double a6 = 1.1;

		//int b9 = b4 + a2 + a3 + a6 ; 结果类型为double 
		

	}
}

2.4 强制类型转换

强制类型转换细节（自动类型转换的逆运算）

0.强转符：（）
1.当进行数据的从大往小，就需要强制转换
2.强制符号只针对于最近的操作数有效，往往会使用括号提升优先级
3.char类型可以保存int的常量值，但是不能保存变量值，需要强转
4.byte short char 类型进行运算时，会被当成int类型

public  class ForceConvertDetail{
	public static void main(String[] args){
		//演示
		//强制符号只针对于最近的操作数有效，往往会使用括号增加优先级
		//int x = (int)10 * 3 + 6 * 1.5; // 错误  此结果为double  不是int

		int x = (int)(10 * 3.5 + 6 * 1.5);
		System.out.println("x = "+x); //44

		char c1 = 100;	//ok
		int  m = 100;	//ok
		//char c2 = m ;	//no  char类型可以保存int的常量值，但是不能保存变量值，需要强转
		char c3 = (char)m;
		System.out.println(c3);
	}
}

2.5 String类型的转换

/*
基本数据类型转String类型
	语法：将基本数据类型的值+"" 即可



 */
public class StringBasic{
	public  static void main(String[] args) {
		//基本数据类型-->String
		
		int n1 = 100;
		float f1 = 1.1f;
		double d1 = 4.6;
		boolean b1 = true;

		String s1 = n1 + "";
		String s2 = f1 + "";
		String s3 = d1 + "";
		String s4 = b1 + "";

		System.out.println(s1 + " " + s2 + " " + s3 + " " + s4 + " ");

		//String -> 对应的基本数据类型
		//解读：使用基本数据类型对应的包装类，相应方法得到基本数据类型
		String s5 = "12";
		int num1 = Integer.parseInt(s5);
		double num2 = Double.parseDouble(s5);
		float num3 = Float.parseFloat(s5);
		short num4 = Short.parseShort(s5);
		byte num5 = Byte.parseByte(s5);
		long num6 = Long.parseLong(s5);
		boolean num7 = Boolean.parseBoolean("true");
		System.out.println(num1); //123
		System.out.println(num2);//123.0
		System.out.println(num3);//123.0
		System.out.println(num4);//123
		System.out.println(num5);//123
		System.out.println(num6);//123
		System.out.println(num7);//true


		//怎么把字符串转成char --> 含义是指把字符串的第一个字符得到
		//解读：s5.charAt(0) 得到s5的第一个字符
		System.out.println(s5.charAt(0));
	}
}