Java语言基础03-标识符、关键字、字面值、变量、数据类型

关于java语言当中的标识符

  • 1.什么是标识符
    • 在java源程序当中凡是程序员有权力自己命名的单词都是标识符。
    • 标识符在EditPlus编辑器当中以黑色字体高亮显示
    • 标识符可以标识什么元素呢?
      • 类名
      • 方法名
      • 变量名
      • 接口名
      • 常量名
  • 2.标识符的命名规则【不按照这个规则来,编辑器会报错,这是语法】
    • 只能由"数字、字母、下划线_、美元符号$"组成,不能含有其他符号
    • 不能由数字开头
    • 严格区分大小写
    • 关键字不能做标识符
    • 理论上无长度限制,但是最好不要太长
  • 3.标识符的命名规范【只是一种规范,不属于语法,不遵守规范编辑器不会报错】
    • 最好见名知意
    • 遵守驼峰命名规范
      SystemService
      UserService
      CustomerService
    • 类名、接口名:首字母大写,后面每个单词的首字母大写。
    • 变量名、方法名:首字母小写,后面每个单词的首字母大写。
    • 常量名:全部大写,单词和单词之间用下划线连接

关于java语言当中的关键字

  • 什么是关键字?
    • SUN在开发java语言的时候,提前制定好的一些具有特定含义的字符序列。
    • 在语言当中具有特殊含义的单词,这些单词构成java程序的骨架,这些单词是需要记住的,不能随意编写,区分大小写。
  • 关键字在java语言中全部小写
  • 关键字在EditPlus工具中颜色是蓝色高亮
  • 常见的关键字有哪些?
    • public
    • class
    • static
    • void
    • if
    • for
    • while
    • do
    • default
    • byte
    • short
    • int
    • switch
    • true
    • false
    • throw
    • throws
    • try
    • catch
  • 提醒:关键字不需要单独拿出来记忆,编写程序的过程中记忆。

关于java语言当中的字面值

  • 字面值:
    • 10、100
    • 3.14
    • “abc”
    • ‘a’
    • true、false
  • 字面值就是数据
  • 字面值是java源程序的组成部分之一。包括标识符和关键字它们都是java源程序的组成部分。
  • 数据在现实世界当中是分门别类的,所以数据在计算机编程语言中也是有类别的:【数据类型】
    • 10、100       属于整数型字面值
    • 3.14              属于浮点型字面值
    • true、false    属于布尔型字面值
    • “abc”、"中国人"属于字符串型字面值
    • ‘A’、‘人’         属于字符型字面值
  • 注意:
    java语言当中所有的字符串型字面值必须使用双引号括起来,双引号是半角
    java语言当中所有的字符型字面值必须使用单引号括起来,单引号是半角,且单引号中只能存放单个字符。

关于java语言当中的变量

  • 1、什么是变量?
    • 变量本质来说是内存中的一块空间,这块空间有"数据类型"、“名字”、“字面值”
    • 变量包含三部分:数据类型、名称、字面值【数据】
    • 变量是内存中存储数据的最基本的单元
  • 2、数据类型的作用?
    • 不同的数据有不同的类型,不同的数据类型底层会分配不同大小的空间。
    • 数据类型是指导程序在运行阶段应该分配多大的内存空间。
  • 3、变量要求:
    变量中存储的具体的"数据"必须和变量的"数据类型"一致,当不一致的时候编译报错。
  • 4、声明/定义变量的语法格式:数据类型 变量名
    • 数据类型:
      例如整数型数据,int
    • 变量名:
      只要是合法的标识符就行。规范中要求:首字母小写,后面每个单词首字母大写
      例如:int i; int age; int length; int size
      其中int是数据类型,i,age,length,size都是变量名
  • 5、变量声明之后怎么赋值?
    • 语法格式:变量名 = 字面值
      要求:字面值的数据类型必须和变量的数据类型一致。
      = 等号是一个运算符,叫做赋值运算符,赋值运算符先运算等号右边的表达式,表达式执行结束之后的结果赋值给左边的变量。
  • 6、声明和赋值可以放到一起完成
int i = 10;
  • 7、变量赋值之后,可以重新赋值,变量的值可以变化:
int i = 10;
System.out.println(i);//10
int i = 20;
System.out.println(i);//20
int i = 100;
System.out.println(i);//100
  • 8、有了变量的概念之后,内存空间得到了重复的使用:
int i = 10;
System.out.println(i);
...
System.out.println(i);
  • 9、通常访问一个变量包括两种访问形式:
    • 第一种:读取变量中保存的具体数据  get/获取
    • 第二种:修改变量中保存的具体数据  set/设置
i = 20; //set
System.out.println(i);  //get
  • 10、变量在一行中可以声明多个
int a,b,c
  • 11、java中的变量必须先声明,再赋值,才能访问
    int i;程序执行到这里,内存空间并没有开辟出来,变量i并没有初始化。所以没有赋值之前是无法访问的

举例:

public class VarTest01
{
	public static void main(String[] args){
	//声明一个int型的变量,起名为i
	int i;
	//编译报错,变量i并没有初始化
	//System.out.println(i);
	//给i变量赋值,i变量在这里完成初始化,内存开辟
	i = 100;
	System.out.println(i);
	//i再次重新赋值
	i = 200;
	System.out.println(i);
	
	//一行可以同时声明多个变量
	//a和b尚未初始化,c赋值给300
	int a,b,c = 300;
	//编译错误
	//System.out.println(a);
	//编译错误
	//System.out.println(b);
	System.out.println(c);
	a = 0;
	b = 1;
	System.out.println(a);
	System.out.println(b);
	}
}
  • 12、在同一个“作用域” 中,变量名不能重名,但是变量可以重新赋值
public class VarTest03{
	public static void main(String[] args){
		int i = 100;
		System.out.println(i);
		i = 200;
		System.out.println(i);
		//会报错,同一个作用域中变量名重复
		int i = 500;
		System.out.println(i);
	}
}
  • 13、 变量的作用域
    • 什么是作用域?
      变量的作用域,其实描述的是变量的有效范围。
      在什么范围之内是可以被访问的,只要出了这个范围该变量就无法访问了。
    • 变量的作用域只要记住一句话。
      出了大括号就不认识了
public class VarTest03
{
	//注意,这里的static不要去掉
	static int k = 90;
	public static void main(String[] args){
		//变量i的作用域是main方法
		//在整个main方法当中是有效的,可见的,可以访问的
		int i = 100;
		System.out.println(i);   //可以
		System.out.println(k);   //可以
		//a变量的作用域是整个for循环,for循环结束之后,a变量的内存就释放了
		for(int a=0;a<10;a++){
		}
		//这里无法访问变量a
		//System.out.println(a);
		int j;//作用域是main方法
		for(j=0;j<10;j++){
		}
		System.out.println(j);//访问的是main方法中的j变量
	}
	public static void dosome(){
	//这里无法访问main方法当中的变量;
	//已经出了i变量的作用域
	//System.out.println(i); //不可以
	System.out.println(k);   //可以
	}
}
  • 14、变量的分类
    • 根据变量声明的位置来分类:
      • 局部变量:在方法体当中声明的变量叫做局部变量
      • 成员变量: 在方法体外【类体内】声明的变量叫做成员变量
    • 在不同的作用域中,变量名是可以相同的
    • 在同一个作用域中,变量名不能重名
public classs VarTest04
{
	//主方法:入口
	public static void main(String[] args){
		//i变量就是局部变量
		int i = 3;
		System.out.println(i);//java遵循“就近原则”
	}
	//成员变量
	int i = 200;  //类体中不分先后顺序
	//类体中不能直接编写java语句【除声明变量之外】
	//System.out.println(i);
	public static void dosome(){
		//局部变量
		int i = 100;
	}
}

关于java语言当中的数据类型

  • 1.数据类型的作用时什么?
    • 程序当中有很多数据,每一个数据都是有相关类型的,不同数据类型的数据占用空间大小不同。
    • 数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。
  • 2、java中的数据类型包括两种:
    • 基本数据类型
    • 引用数据类型【后边讲】
      • 接口
      • 数组
  • 3、关于基本数据类型:
    • 基本数据类型包括四大类八小种:
      • 第一类:整数型
        byte 、short、int、long
      • 第二类:浮点型
        float、double
      • 第三类:布尔型
        boolean
      • 第四类:字符型
        char
  • 4、字符串"abc"不属于基本数据类型,但属于引用数据类型,字符属于基本数据类型
    • 字符串使用双引号""
    • 字符使用单引号’’
  • 5、八种基本数据类型各自占用空间大小是多少?
基本数据类型占用空间大小【单位:字节】
byte1
short2
int4
long8
float4
double8
boolean1
char2
  • 6、计算机在任何情况下都只能识别二进制,例如:只认识1010101010…
    【现代的计算机底层采用交流电的方式,接通和断开就两种状态,计算机只识别1或0,其他不认识】
  • 7、什么是二进制?
    • 数据的一种表示形式。十进制是满十进一原则,二进制表示满二进一原则。
      例如 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
      18 19 20
      例如 0 1 10 11 100 101 110 111 1000…
  • 8、字节:
    1 Byte = 8 bit【1个字节 = 8个比特位】1个比特位表示1个二进制位:1/0
    1 KB = 1024 Byte
    1 MB = 1024 KB
    1 GB = 1024 MB
    1 TB = 1024 GB
  • 9、整数型当中的Byte类型,占用1个字节,所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么?
    • 关于java中的数字类型,数字都是有正负之分的,所以在数字的二进制当中有一个二进制位被称为“符号位”。并且这个“符号位”在所有二进制位的最左边,0代表正数,1代表负数。
    • byte类型最大值:01111111
    • byte类型最大值:2的7次方 - 1,结果是127
    • byte类型最小值:-128【和原码、反码、补码有关系,非11111111】
  • 10、二进制和十进制转换规则:略
  • 11、计算机只认识二进制,那么计算机是如何认识现实生活中的文字呢?
    • 八种基本数据类型当中,byte,short,int,long,float,double,boolean这7种数据类型计算机在表示的时候比较容易,因为底层都是数字,十进制的数字和二进制之间存在一种固定的转换规则。
    • 但是八种基本数据类型当中char类型表示的是现实世界中的文字,文字和计算机二进制之间“默认”情况下是不存在任何转换关系的。
    • 为了让计算机可以表示现实世界当中的文字,我们需要进行人为的干涉,需要人负责提前制定好“文字”和”二进制“之间的对照关系。这种对照转换关系被称为:字符编码
    • 计算机最初只支持英文,最先出现的字符编码是:ASCII码【一个字节编码】
      ‘a’–>97【01100001】 ‘b’–>98 …
      ‘A’–>65  ‘B’–>66 …
      ‘0’–>48  ‘1’–>49 …
      • 后来出现了一种编码方式统一了全球所有的文字,容量较大,这种编码方式叫做:unicode编码,unicode编码方式有多种具体的实现:
        • UTF-8
        • UTF-16
        • UTF-32
      • java语言源代码采用的是unicode编码方式,所以“标识符”可以用中文,比如类名可以为中文。
      • 现在实际开发中,一般使用UTF-8编码方式
  • 12、 八种基本数据类型的取值范围:
数据类型取值范围
byte[-128 ~ 127]
short[-32768 ~ 32767]
int
long
float
double
boolean[true,false]
char[0 ~ 65535]

注意:short和char所表示的种类总数是一样的,不过char没有负数。

  • 13、关于八种基本数据类型的默认值
public class DataTypeTest02
{
	//变量还是遵守这个语法:先声明,再赋值,才能访问
	//成员变量没有手动赋值系统会默认赋值【局部变量不会】
	static int f;//成员变量
	public static void main(String[] args){
		/*
		int i;//局部变量
		System.out.println(i);
		*/
		System.out.println(f);//0
	}
}
数据类型默认值
byte,short,int,long0
float,double0.0
booleanfalse【在c语言中,true是1,false是0】
char\u0000

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

详细阐述各类数据类型

  • 1、char
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';
	}
}
  • 转义字符   
    转义字符会出现特殊字符之前,会将特殊字符转换成普通字符
    • \n 换行符
    • \t 制表符
    • \’ 普通的单引号
    • \\ 普通的反斜杠
    • \" 普通的双引号
public class DataTypeTest03
{
	public static void main(Sting[] args){
	//普通的n字符
	char c1 = 'n';
	System.out.println(c1);
	
	//这是一个换行符,属于char类型的数据
	//反斜杠在java语言当中具有转义功能
	char c2 = '\n';
	
	//System。out.println()和System.out.print()区别:
	//println输出后换行,print表示输出,但是不换行

	//普通的t字符
	char x = 't';
	System.out.println(x);
	
	//制表符tab
	//强调制表符和空格不同,他们的ASCII不一样,体现在键盘是上两个不同的“按键”
	char y = '\t';
	System.out.print("A");
	System.out.println(y);
	System.out.println("B");//A	B
	
	//要求在控制台上输出“反斜杠字符”
	//反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符
	//左边的单引号缺少了结束的单引号字符,编译报错
	/*char k = '\';
	System.out.println(k);*/
	
	/*
	\\
	解释:第一个反斜杠具有转义功能,将后面的反斜杠转义为普通的反斜杠字符
	结论:在java当中两个反斜杠代表一个普通的反斜杠字符
	*/
	char k = '\\';
	System.out.println(k);
	
	//在控制台上输出一个普通的单引号字符
	//第一个单引号和最后单引号配对儿
	char a = '\,';
	System.out.println(a);
	
	char f = '"';
	System.out.println(f);//输出"
	
	System.out.println("HelloWorld!");
	System.out.println("“HelloWorld!”");//内部是全角双引号
	//编译错误
	//System.out.println(""HelloWorld!"");//内部是半全角字符
	System.out.println("\"HelloWorld!\"");
	
	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';
	//通过:反斜杠u联合起来后面的一串数字是某个文字的unicode编码
	char g = '\u4e2d';
	//char类型的默认值
	char c10 = '\u0000';
	System.out.println(c10);//空字符
	System.out.println(c10+1);//1
	}
}
  • 2、整数型
数据类型占用空间大小默认值取值范围
byte10【-128~127】
short20【-32768~32767】
int40【-2147483648~2147483647】
long80L
  • java语言当中的“整数型字面值”被默认当做int类型来做处理。要让这个“整数型字面值”被当做long类型来处理的话,需要在“整数型字面值”后面添加l/L;建议使用大写L。
  • java语言当中的整数型字面值有三种表示方式:
    • 第一种方式:十进制【是一种缺省默认的方式】
    • 第二种方式:八进制【在编写八进制整数型字面值的时候需要以0开始】
    • 第三种方式:十六进制【在编写十六进制整数型字面值的时候需要以0x开始】
public class DataTypeTest04
{
	public static void main(Sring[] args){
		int a = 10;
		int b = 010;
		int c = 0x10;
		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;
		
		//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
	  //将左边的4个字节的二进制砍掉【所有的数据强转的时候都是这样完成的】
	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 a = (int)k;
	System.out.println(a);//损失精度严重,结果是负数 【-2147483648】

	//分析以下程序是否可以编译通过?
	//依据目前所学内容,以下程序是无法编译通过的
	//理由:50是int类型的字面值,b是byte类型的字面值,显然是大容量int转换成小容量byte
	//大容量转换成小容量是需要添加强制类型转换符的,以下程序没有添加强转符号,所以编译报错
	//但是,在实际编译的时候,以下代码编译通过了,这说明:在java语言当中,当一个整数型字面值
	//没有超出byte类型取值范围的话,该字面值可以直接赋值给byte类型的变量。
	byte b = 50;//编译通过
	byte b = 127;//编译通过
	//编译报错,128这个int类型字面值已经超出了byte类型的取值范围,不能直接赋值给byte类型的变量
	//byte b = 128;
	
	//纠正错误,需要使用强制类型转换符
	//但是一定会损失精度
	//原始数据:00000000 00000000 00000000 10000000
	//强转之后:10000000【这是存储在计算机内部的,是一个补码形式,则它的原码是什么?】
	byte b = (byte)128;//-128
	System.out.println(b);
	
	/*
	计算机二进制有三种形式:
		原码
		补码
		反码
	计算机在任何情况下底层表示和存储数据的时候都采用了补码形式
	正数的补码:和原码相同
	负数的补码:负数的绝对值对应的二进制码所有二进制数取反,再加1
	补码:10000000
	原码计算过程:
		1.减1,01111111
		2.全部取反,10000000(128)
		3.根据补码确定为负数,则最终原码为-128
	*/
	//short s = 32767;//通过
	//short s = 32768;//编译报错
		
	//65535是int类型,4个字节
	//cc是char类型,2个字节
	//按照以前所学知识点来说,以下程序是编译报错的。
	//char cc = 65535;//通过
	//char cc = 65536;//编译报错

	/*总结:
		当一个整数字面值没有超出byte,short,char的取值范围时,这个字面值可以直接赋值给byte,short,char类型的变量,这种机制SUN允许了,目的是为了方便程序员的编程。
	*/
	}
}
  • 3、浮点型
    • float 单精度【4个字节】
      double 双精度【8个字节,精度较高】
    • double的精度太低【相对来说】,不适合做财务软件。财务涉及到钱的问题,要求精度更高,所以SUN在基础SE类库当中为程序员准备了精确度更高的类型,只不过这种类型是一种引用数据类型,不属于基本数据类型,它是java.math.BigDecimal
    • 其实java程序中SUN提供了一套庞大的类库,java程序员是基本这套基础的类库进行开发的。所以要知道java的SE类库的字节码在哪,要知道java的SE类库的源码在哪。
      • SE类库字节码:D:\JAVA\java8\pack\jre\lib\rt.jar
      • SE类库源码:
        D:\JAVA\java8\pack\src.zip
    • 例如:String.java和String.class
      我们的(String[ ] args)中的String使用的是String.class字节码文件
    • 在java语言当中,所有的浮点型字面值【3.0】,默认被当做double类型来处理
      要想该字面值当做float类型来处理,需要在字面值后面添加F/f。
    • 注意:
      double和float在计算机内部二进制存储的时候都是近似值。
      在现实世界中有一种数字是无限循环的,例如:3.3333333333333333…
      计算机的资源是有限的,用有限的资源存储无限的数据只能存储近似值。
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;
	}
}
  • 4、布尔型
    • boolean
    • 在java语言当中boolean只有两个值,true、false,没有其他值
    • 不像c语言当中,0和1可以表示假和真。
    • 在底层存储时boolean类型只占用1个字节,因为实际存储的时候false底层是0,true底层是1
    • 布尔类型在实际开发当中非常重要,经常使用在逻辑运算和条件控制语句当中。
public class DataTypeTest07
{
	public static void main(String[] args){
		//编译错误:不兼容的类型
		//boolean flag = 1;
		boolean loginSucsess = true;
		if(loginSucsess )
		{
			System.out.println("恭喜你,登录成功");	}
		else{
			System.out.println("对不起,同户名不存在或者密码错误!");
			}
	}
}
  • 5、数据类型转换
    • 八种基本数据类型当中除了布尔类型之外剩下的7种数据类型之间都可以互相转换。
    • 小容量向大容量转换,称为自动类型转换,容量从小到大排序:
   byte < short < int < long < float < double
        < char  <
   注:
   		任何浮点类型不管占用多少个字节,都比整数型容量大
   		charshort可表示的种类数量相同,但是char可以取更大的正整数。
  • 大容量转换成小容量,叫做强制类型转换,需要加强制类型转换符,程序才能编译通过,但是在运行阶段可能会损失精度,所以谨慎使用。
  • 当整数字面值没有超出byte,short,char的取值范围,可以直接赋值给byte,short,char类型的变量
  • byte,short,char混合运算的时候,各自先转换成int类型再做运算.
  • 多种数据类型混合运算,先转换成容量最大的那种类型再做运算
  • 注意:分析编译阶段和运行阶段,不要在编译阶段掺杂运行运算
byte b = 3;//可以编译通过,3没有超出byte类型取值范围

int i = 10;
byte b = i / 3;//编译报错,编译器只检查语法,不会“运算”i/3,错误是int/int类型,结果为int类型,转成byte时,没有加强制类型转换符
//10和3默认是int类型,所以运算后的最大类型也是int,为3
//所以是正确的
int f = 10 / 3;// 3

//先计算10/3,为3,再根据自动类型转换,将3转换成3.0
double dd = 10 / 3;// 3.0

//先将3转换成3.0,然后计算10.0/3.0,然后转换成double类型
dd = 10.0 / 3;//3.33333333333333

long g = 10;
//错误:g是long类型,计算g/3时,3会由int类型转换成long类型,于是g/3得到long类型,而将long类型转换成int类型,没有加强制转换符
int h = g/3;
int h = (int)g/3;//正确
long h = g/3;//正确

//错误:g先由long类型强制转换成int类型,再由int强制转成byte类型,而byte/int,则根据最大容量原则,最后为int类型,byte h = int,没有加强制类型转换符
byte h = (byte)(int)g/3;
//注意:编译器javac只检查语法,不进行计算
byte h = 3;//正确
byte h = (byte)(int)(g/3);//正确,计算优先级原则,先计算右边括号中
byte h = (byte)g/3;//不能转换,因为优先级问题,byte/int类型为int类型
byte h = (byte)(g/3);//可以转换,因为运算结果没有超出byte取值范围

//编译错误,short和byte运算,首先会转换成int类型再运算
//所以运算结果为int,但由于编译器不会计算,只能判断语法,所以它判断将大容量int转换成小容量short,没有加强制类型转换,会报错
short i = 10;
byte j = 5;
short k = i + j;
short k = 15;//编译通过,15没有超出short取值范围
short k = (short)(i + j);//编译通过

char l = 'a';
System.out.println(l);//a
//将char类型强制类型转换成byte类型,但由于没有超出byte取值范围,不存在精度损失,仍为97
System.out.println((byte)l);//97

//先将char类型l转换成int类型,为97,再与100相加
int m = l + 100;
System.out.println(m);//197
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值