java前期补遗--基本数据类型与自动类型提升

关注

原创最新推荐文章于 2026-11-07 13:36:09 发布 243 阅读 AI 写同款· GEO 优化 ›

java基础项目练习二-客户信息管理程序，实现基本的增删改查练习基本的MVC设计模式，创建customer类，提供基本属性和对应的存取方法 package bean; public class Customer { private String name; private int age; private char gender; private String phone; private ... 阅读详情

/*
变量
基本数据类型
基本数据类型之间的转换
基本数据类型与String之间的转换
进制与进制之间的转换
变量概念
1，内存中的储存区域
2，该区域的数据可以在同一类型范围内不断变化
3，变量是程序中最基本的储存单元，包含变量类型，变量名和储存的值
变量的作用
1，用于在内存中储存数据
使用变量的注意事项
1，java中的每个变量必须先声明再使用
2，使用变量名来访问这块区域的数据
3，变量的作用域：其定义所在的一对{}中
4，变量只有在其作用域内有效
5，同一个作用域内，不能定义重名的变量

变量的使用
1，java定义变量的格式：数据类型变量名=变量值
2，变量必须先声明再使用；
变量都定义在其作用域内，在作用域内有效。在作用域外失效；
不可以在同一个作用域内声明两个名字相同的变量；

class  VariableTest{
	public static void main(String[] args) {
		
		int myAge = 22；//变量定义 int 为整数型
		//或者拆分为两步 第一步声明 int myAge，第二步赋值 myAge = 12
		System.out.println(myAge);//变量使用,变量在经过声明和赋值后才能被使用 
		System.out.println(myClass);//myClass变量在下方public中声明，无法作用到本作用域
	}
}
	public void method(){
		int myClass = 1；//在这里定义一个变量名myClass，只能用在本作用域
		System.out.println(myClass);
}

/*
java定义的数据类型
java属于强类型语言，对于每一种数据都定义了明确的具体类型，并在内存中分配不同大小的内存空间。
按照数据类型分
一，基本数据类型（primitive type）
1数值型（整数型 byte short int long，浮点型float double）内存空间有小到大
2字符型 char
3布尔型 boolean
二，引用数据类型（reference type）
1类 class 字符串属于类
2接口 interface
3数组 [] array

按照声明位置不同分类

在方法体内部声明的变量为局部变量

成员变量：1，实例变量（不以static修饰）
2，类变量（以static修饰）
局部变量：1，形参（方法，构造器中定义的变量）
2，方法局部变量（在方法内部定义）
3，代码块局部变量（在代码块内定义）

整形类型：byte short int long
java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性
java 的整形常量默认为int型，声明long型常量须后加“l”或者“L”
java程序中变量通常声明为ini型，除非不足以表示较大的数，才使用long
类型储存空间表数范围
byte 1字节=8bit -128到127 2的8次幂为256，分配正负两侧，中间一个0
short 2字节 -2的15次幂到2的15次幂-1
int 4字节 -2的31次幂到2的31次幂-1 约21亿
long 8字节 -2的63次幂到2的63次幂-1
1MB=1024KB 1KB=1024bit

浮点型：
与整数类型类似，java浮点类型也有固定的表数范围和字段长度
不受具体操作系统的影响

浮点类型有两种表达方式：
十进制数形式：例如 5.12 512.0f .512(必须有小数点)
科学计数法形式：例如 5.12e2 512E2 100E-2

float：单精度，位数可以精确到7位有效数字，很多情况下，精度很难满足要求
double：双精度，精度是float 的两倍，通常采用此类型
java 的浮点类型常量默认为double型，声明float型常量，须后加f或者F
单精度float 占用4字节表数范围 -3.403E38到 3.403E38 E38为10的38次幂范围比long大
双精度double 占用8字节表述范围 -1.798E308到1.798E308
因为浮点类型可以使用科学计数法，所以范围比整数型大

字符型：char
char类变量占用一个字符=2字节空间
java中的所有字符都使用Unicode码，所以一个字符可以储存一个字母或者汉字或者其他语言的一个字符

字符类型的三种表现形式
1，字符常量是用单引号’’ 括起来的单个字符，如char c1 = ‘a’
char c2 = ‘中’ char c3 = ‘9’
2,java中还允许使用转义字符\来将其后的字符转变为特殊字符常量
如 char c4 = ‘\n’ \n表示换行符 \表示后面的不再解释为转义，如果输出\n，书写格式为\n
3，直接使用Unicode值来表示字符型常量：如 ‘\xxxx’,其中XXXX代表
一个十六进制整数，如\u000a 表示\n

char类型是可以参与计算的，因为它都对应一个Unicode码

ASCII码
计算机内部所有数据使用二进制表示，每一个二进制位（bit）有0和1两种装填
因此8个二进制可以组合出256种状态，被称为一个字节，一个字节可以
用来表示256种不同的状态，一个状态对应一个符号，就是256个符号
20世纪60年代，美国制定一套字符编码，被称为ASCII码，一共规定了128个字符码
比如空格是32，二进制为00100000，A为65 二进制01000001。这128个符号包括不能被打出的32个控制符号
只占用一个字节的后面7位，最前面的1位统一为0
缺点，不能表示所有字符，相同编码表示的字符不一致
世界上存在多种编码方式，同一个二进制数字可以被解释称不同符号，因此打开一个文档需要知道编码方式，否则会出现乱码

Unicode码
将世界上所有的符号纳入其中，每一个符号都给予一个独一无二的编码，使用Unicode没有乱码问题。
缺点，只规定了符号的二进制代码，没有规定这个二进制代码如何储存
，无法区别Unicode与ASCII，计算机无法区分三个字节表示一个符号还是3个符号
另外英文字母只用一个字节表示，如果每个符号用三个或者四个字节规定，就会极大浪费存储空间

UTF-8编码

使用最广泛的Unicode实现方式
是变长编码方式，可以使用1-6个字节表示一个符号，根据不同符号变化字节长度
编码规则
1，对单字节UTF-8编码，最高位0，其余7位用来对字符编码，等同ASCII
2，对多字节UTF-8编码，如果包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0
，该字节剩余的各位用来对字符进行编码，在第一个字节之后的所有字节，都是最高两位为10，其余6位用来对字符编码

布尔类型（boolean）
只能取两个数值之一，true或者false
用于条件判断，循环结构。

class VariableTest1{
	public static void main(String[] args) {
		byte b1 = -128;
		byte b2 = 127;
		System.out.println(b1);
		System.out.println(b2);
		int i1 = 223242535;
		long l1 = 22323232214141L;//long类型变量赋值结尾加L或者l
		System.out.println(l1+1);
		double d1 = 123.34234;
		System.out.println(d1);
	    float f1 = 133.3456782F;//float类型的变量赋值结尾加f或F
		System.out.println(f1);
		char c1 = 'a';//定义char类型变量只能写一个字符 可以是字母数字中文特殊符号等
        char c3 = 97;//char 可以直接赋值ASCII码，很少这么写
		char c4 = '5';//在此处5为字符，对应一个ASCII码
		int i2 = (int)c4;//强转字符5为int型
		char c5;
		c5 = 'g';//赋值变量的书写方式也可以分步写。
		System.out.println(i2);//输出53，代表字符5的ASCII码
		System.out.println(c3);
		System.out.println("hello"+c1);
		char c2='\n';
		System.out.print("hello" + c2);
		System.out.println("world");
		System.out.println("\\n");
		System.out.println("你是\"最\"大的");//加\后表示后面的字符不做特殊用途
		boolean bb1 = false;
        System.out.println(bb1);
        boolean isOld = true;
			if(isOld){
				System.out.println("不行");
			}else{
			    System.out.println("可以");	
			}


	}
}

/*
String类型（字符串）变量的应用
1，String属于引用类变量类型，不属于基本数据变量类型
2，声明String类型变量时使用"",相对char变量声明使用’’。
3，String类型的值可以为单字符，也可以为空。char型中不可以为空，但可以为空格
例如char c = ‘’;编译不通过 char c = ’ ';可以编译
4,String 可以和八种基本数据类型做运算，且运算只能是连接运算，使用+号
5,String 和其他类型运算结果也是String类型。

class StringTest {
	public static void main(String[] args) {
        System.out.println("Hello World!");
		String s1 = "Hello大家好";
		String s2 = "H";
		String s3 = "";
		System.out.println(s1);
		//*************************
		int number = 100;
		String numberStr = "学号";
		String info =numberStr + number;//加号+表示连接运算
		boolean b1 =true;
		String info1 = info + b1;//加号+表示连接运算
		System.out.println(info1);
		System.out.println(info);
		// 练习1
		char c = 'a';//ASCII中 a 的值是97，A的值是65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//输出 107hello ，第一个加号是相加，char和int相加输出int型，第二个加号是连接，int与String连接输出String
		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
		System.out.println(str + 111);//输出 hello111
		System.out.println(str + "world");//输出 helloworld 
		//System.out.println(str + world);//无法编译，world必须加""才能被认为是String类

        //练习2
		//输出*  *的方法
		System.out.println("* *");//正确
		System.out.println('*' + '\t' + '*');//错误，输出char类型数值93
		System.out.println('*' + "\t" +'*');//正确
		System.out.println('*' + '\t' + "*");//错误 输出51*
		System.out.println('*' + ('\t' + "*"));//正确
		/*练习3
		String str1 = 4; 无法编译，没有""
		String str2 = 3.56f + "" ; 可以编译
		System.out.println(str2);输出3.56
		System.out.println(3 + 4 + "hello");输出7hello
		System.out.println("hello" + 3 + 4);输出hello34
		System.out.println('a' + 1 + "hello");输出98hello
		System.out.println("hello" + 'a' + 1);输出helloa1
		 练习4
		判断对错
      1   short s = 5;
		  s = s - 2;     无法编译，2是int型常量
      2   byte b = 3;
		  b = b + 4; 无法编译
		  b = (byte)(b + 4);可以编译，强制转换int为byte
	  3   char c = 'a';
		  int i = 5;
		  float d = .314f;
		  doule result = c + i + d;可以编译
      4   byte b = 5;
	      short s = 3;
		  short t = s + b;无法编译，byte与short运算应为int型
        */
		//String str1 = 123; 编译不通过
		String str1 = 123 + "";//编译可以通过，整数常量int型与String运算输出String类。
		System.out.println(str1);//输出123字符串,将数值转换为字符串可以用这种方式。
		
		//int num2 = str1; 编译不通过
		//int num2 = (int)str1;编译也不通过
		int num2 = Integer.parseInt(str1);
		System.out.println(num2);//通过Integer方法可以将String解析为int。
	}


}

/*
基本数据类型之间的运算规则
只讨论7种基本数据类型变量之间的运算，不包含boolean类型

1，自动类型提升
当容量小的数据类型变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
此时的容量大小指的是表示数的范围大小，不是占用字节的大小，比如float（4个字节）的容量大于long（8个字节）的容量
byte–>short–>int–>long–>float–>double
byte，char，short–>int–>long–>float–>double
byte，char，short三个互相做运算时输出都是int或更大的类型
2，强制类型转换
是自动类型提升运算的逆运算
1, 需要使用强转符号（）例如long l1 = 112.9L;short s1 = （short）l1; 输出为112，只取整数部分。
2，使用强制类型转换，可能会出现精度损失。

注意
1，编码情况
long 1 = 122;也可以编译通过，会默认为int类型
long l2 = 12345673333;编译不通过，超出int范围，需要末尾加L，
float f1 = 12.3;编译失败，必须加F，因为默认为double类型。
2，编码情况2
byte b = 12;
byte b1 = b + 1;编译失败，数字1为整数型常量，默认为int型，小数型默认为double

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

		byte b1 = 2;
		int i1 = 1278;
		//byte b2 = b1 + i1
		//编译不通过,因为int范围大
		int i2 = b1 + i1;
		long l1 = b1 +i1;	
		System.out.println(i2);
		System.out.println(l1);
		float f1 = b1 + i1; //整数型数值运算结果可以定义为浮点型，系统输出自动加小数点
		System.out.println(f1);
		short s1 = 123;
		double d1 = s1;//可以将整数型直接转换为浮点型，后面自动加小数点
		System.out.println(d1);
		char c1 = 'a';// a 对应的数值为97
		int i3 = 10;
		int i4 = c1 + i3;//char只能容纳一个字符，所以i4不能为char类型
		System.out.println(i4);
	}
}
 class VariableTest3{
	public static void main(String[] args) {
        long l1=123L;//数值没有超出long范围可以不加L，也能编译，会自动转换为int类型
		short s1 = (short)l1;//数值没有超出short范围，强制转换后精度没有损失。
		System.out.println(s1);
		double d1 = 12.9;
		int i1 = (int)d1;//执行截断操作，结果只取整数部分，不是四舍五入
		System.out.println(i1);//输出12，损失小数点，精度损失
		int i2 = 128;
		byte b1 = (byte)i2;
		System.out.println(b1);//输出-128跟二进制规则有关，损失精度。
		long l2=128456744453453L;
		int i3 = (int)l2;
		System.out.println(i3);
		short s2 = (short)l2;
		System.out.println(s2);
		byte b2 = (byte)l2;
		System.out.println(b2);

	}
}