1、Java中的关键字 标识符 符号 注释

时间:2020-7-29 作者:admin


今日任务

1、Java关键字、保留字、标识符
2、Java的常量和变量★★★
3、Java数据类型★★★★
4、数据类型转换
5、算术运算符★★★
6、赋值运算符★★★
7、比较运算符★★★
8、逻辑运算符★★★
9、移位运算符★★★★
10、位运算
11、三元运算符★★★★

课堂笔记
1、Java中的关键字 标识符 符号 注释
1.1 关键字
HelloWorld里面写的东西,比如说蓝字部分,class ,public,static。这些都属于关键字。不同的关键字,在Java代码中有不同的使用场景。
关键字:在Java语言中被赋予了特定含义的一些单词或者字母的组合。
class:它在Java中是用来定义(创建)Java中的一个程序的开始。
1.2 标识符
标识符:表示起一定标识作用的符号。标识作用的符号指的是在程序中定义的名称。比如Demo,haha等。
main也是标识符,他是方法的名称。
方法或者类的名字可以让我们找到我们想使用的方法或者类使用。
标识符定义名字不能随便起,标识符定义是有规范的,只要不破坏这个规范,就没事,破坏就非法。
1.2.1标识符的组成
1、标识符由a-z ,26个英文字母大小写。同时还有0-9这十个数字,同时还有 _(下划线) $(美元符) 。标识符只能由这些符号组成。
1.2.2 标识符的书写规定
注意:(规定)
1、数字不可以开头
2、不可以使用关键字,因为关键字已经被特殊定义了。

规范:类名起的时候,所有单词首字母都要大写。
注意:
单词首字母不大写编译也可以通过,程序也可以运行。
解释:规范不一定要去遵守,只是最好去遵守。而规定一定要去遵守。
1.3 符号
书写的Java代码中常用的符号:
{} :它一般是在划定程序某些代码区域(范围)。
() :它表示的左侧一般是一个方法名,一般用在方法上。
英文分号:在java中一句话写完,一般需要一个分号结束。
[] :它表示的内容是数组。

1.4注释
注释:对Java中的程序代码进行解释说明的文字。
那么这里有了说明以后我们就要把不是代码的说明注释起来,不要让编译器对他操作了,引发编译错误。
Java语言中的注释有三种格式:
1)单行注释:单行注释的表现很简单,只要在开头写两个斜杠就可以了。
用法://后面书写注释的内容
2)多行注释:有开始就得有结束。/**/
用法:
/*
注释的内容
*/

注意:单行和多行注释,很多的语言都是支持的。而接下来讲的第三种注释只有Java语言支持,这个是Java特有的注释。

3)文档注释:文档注释稍微特殊,在文档注释里面可以写程序的作者,程序的日期等。同时在文档注释里面也可以写点注释的文字信息。
用法:
/**
@author 作者
@Date 日期
注释的内容
*/

在idea中简单的设置:
/**
@author: ${USER}
@Date: ${DATE} ${TIME}
*/

说明:前面加个@符号,说明这个单词是可以被解析的

Idea中的快捷键:生成main函数的快捷键:输入psvm,然后按回车键; 生成
Systemo.out.println()的快捷键是:输入sout,然后按回车键。

注意:
1、单行和多行注释,很多的语言都是支持的。而第三种注释文档注释只有Java语言支持,这个是Java特有的注释。
2、注释的内容仅仅是对源代码进行解释说明,而使用javac 编译之后生成的class文件中是不会存在的。
3、要求后期大家在写Java代码的时候,源代码中都需要添加注释。

注释的作用:
1)对程序进行说明
2)调试程序
2、Java的常量和进制
在我们的生活中会有一些固定不变的数据,而Java语言又是解决生活中问题的,那么Java就必须把生活中这些固定不变的数据也要进行相应的描述。

在Java中要描述一些固定不变的数据,这时就需要使用Java中的常量这个概念来描述。

2.1常量的概念
常量:不能被改变的数据,固定不变的数据。
2.2常量的分类
1)数值型:
生活中的数字:1,2,8,18等
整数:1,2,3等
小数:1.1,1.2,2.3等
2)字符型:生活中的单个数字 汉字 字母 符号 等,
Java中单个数据,字符,Java中的字符书写需要使用英文单引号(‘’)引用。并且单引号中有且只有一个字符数据。
‘你’ ‘A’ ‘+’ ‘-’等。
这不是字符:’abc’
注意:字符表示单引号里面只有一个字母、数字或者符号。所以’123’不表示字符。
3) 字符串型:生活中的一句话 “62班是精英班”
Java中的字符串需要使用英文双引号(“”)引用。在Java中使用双引号把多个字符串在一起, 我们就称为字符串。
“abc” “hello world” “a” “” 表示空字符串 “’a’”
4)布尔型(boolean):生活中的判断后的真假 对错 对–真 错–假
Java中需要使用 true :真 或 false:假 表示。
5)空常量型:
只有一个数值就是null.(了解)

2.3 进制
进制:它表示的是一种数据的运算规律。

十进制:每个数位上的数字:0 1 2 3 4 5 6 7 8 9 ,运算规律:数位上满10高位进1。
1+9 = 10
八进制:每个数位上的数字:0 1 2 3 4 5 6 7,运算规律:数位上满8高位进1。
1 + 7 = 10(8)
十六进制:每个数位上的数字:0 1 2 3 4 5 6 7 8 9 A B C D E F,运算规律:数位上满16高位进1。
1 + F = 10(16)
二进制:每个数位上的数字:0 1,运算规律:数位上满2高位进1。
1 + 1 = 10(2)

由于不同的进制的存在,在书写常量数据的时候,可能会出现表示不是特别清晰:
如果我们要准确的表示不同进制的常量数据时,需要在数据的前面加上自己所属进制的表示形式:
二进制:0B10101010
八进制:01110
十进制:1010101
十六进制:0x1010101

2.4进制转换演示
所有数据在电子设备中都是以电信号在传播。电信号有强弱之分。通过开关控制电流的流通,由于开关它只有2种状态,正好二进制数据的每个数位上能够容纳的数字的形式正好吻合。
这时所有的数据可以通过电流的流通表示在电子设备中。于是我们就需要把不同进制的数据转成二进制,这样就可以把所有数据全部保存在电子设备中。

十进制到二进制:
对一个十进制除以2,倒着取余数。

二进制到十进制:
把二进制数从右边开始,往左边计算,用当前二进制数位上的数字,乘以2的n-1次方(次幂),n是从右侧往左侧数当前这个二进制的位数。需要把这些次幂全部展开,然后在相加。

使用规律计算:
在电子设备中,数据的存储最小单位是字节。
1个字节 = 8 个二进制数位。
1byte = 8bit 比特位
1024 字节 = 1kb
1024 kb = 1 mb
1024 mb = 1gb
1024 gb = 1tb
1个字节中能够表示的最大的十进制数:

注意:二进制的表示形式:0B10101010(jdk1.7之后可以这样表示)

8进制:
把二进制数据以3位为一组,称为八进制。如果前面位数不够可以拿0补。
每组的3位二进制数据相加之后将每组数据合并就是八进制数据。
表示形式:0-7,逢八进1
注意:
1)八进制的表示形式是以0作为开头。例如:053.
2)从二进制的最右侧开始,往左边,按照每三个二进制数位为一段,把这一段数据转成一个八进制数位。

3)八进制到二进制:把一个八进制数位 还原成三个二进制数位,然后将三个二进制数组合到一起。
举例:

十六进制:
把二进制数据以4位为一组,称为十六进制。如果前面位数不够可以拿0补。
每组的4位二进制数据相加之后将每组数据合并就是十六进制数据。
表示范围:0-15
表示形式:0-9 A-F(10-15)
注意:
1)十六进制在程序中以0x作为开头。

也就是:0x1E95
2)十六进制到二进制:把一个十六进制数位 还原成 四个 二进制数位
举例:

十进制和八进制、十六进制之间的转换:
十进制转换为八进制和十六进制:
原则:1)先把十进制转换为二进制,然后再由二进制转换为八进制或者十六进制;
八进制和十六进制转换为十进制:
原则:先把八进制或者十六进制转换为二进制,然后再由二进制转换为十进制。

3、Java中的变量
3.1 变量的概念
变量的官方定义:它表示的是一个空间,在程序运行的过程中,可以随时去更改这个空间中的数据。体现在计算机中,就表示的是计算机内存中的一个存储区域。

常量:表示不能被改变的数据。就是一个固定的量(值),不能改变。
变量:就是一个可以改变的量(值),可以改变其值。

在Java程序中,需要保存数据,这时首先需要在内存中开辟一个空间,然后把数据保存在这个空间中。
例:在学习数学时,有一个未知数x,x是可以改变的,x就是变量。
3.2、变量的书写格式
变量有两种书写格式:
1)空间中保存的数据类型 空间名称 ; ——>数据类型 变量名; 整数 x; int x;
2) 空间中保存的数据类型 空间名称 = 空间中要保存的数据;——>
数据类型 变量名=初始值(常量值); 整数 x= 6;

当JVM运行到这个语句的时候,JVM就知道这里需要在内存中开辟一个空间,然后把6保存在这个空间。int 表示的空间的类型, x 表示的是空间的名称。6表示空间中要保存的数据。
3.3、变量的起名
空间名称就是变量名称。它就是一个普通的标识符。
书写规范:
如果变量名是由多个单词组成,第一个单词全部小写,从第二个单词开始,首字母大写。

类名:所有单词的首字母都需要大写
变量名:第一个单词的首字母小写,后面每个单词的首字母都需要大写(驼峰命名)
3.4、变量的注意事项
1、变量空间在使用之前需要先保存初始化的数据。

2、Java中定义的变量,都有自己存在的范围。

4、Java数据类型
不同的数据,当需要在Java程序中保存的时候,我们需要给其分配不同的内存空间(变量空间)。

我们需要把不同的数据,划分成不同的类型。

Java中把数据共计划分成2大类型:
1)引用数据类型:它表示是数组 、 类 、接口等
2)基本数据类型:
对基本的数据进行的类型划分:

整数:由于整数有非常大的数据,也有非常小的数据。于是把整数类型又区分成4种:
byte 、 short 、 int 、 long
小数:
float、double
字符:
char
布尔:
boolean
这八种基本类型数据,就是前面介绍过的关键字。

比如:有个字符数据,需要保存起来。
这时就需要开辟一个字符空间保存
char ch = ‘A’;
当JVM去执行上述这句话时,首先JVM遇到的char ,它就知道这里需要在内存中开辟一个字符类型的变量空间。在给空间中保存数据的时候,这时JVM就会确定要保存的数据,和空间的类型是否一致,不一致,不让保存。

注意:JAVA语言是强类型语言,对于每一种数据都定义了明确的具体数据类型。
4.1、布尔类型boolean
当我们在写Java程序的时候,有不同的数据,就需要在内存中创建不同的数据类型空间来保存。

在程序中有 true 或者false 数据, 可以保存在boolean 类型空间中。

4.2、字符类型char
可以在内存中开辟一个 字符类型的空间,然后保存字符数据。

char类型在内存中开辟的空间,占据内存的2个字节。
在Java的char类型空间中 可以 保存中文。

4.3、字符串类型
字符串类型不属于Java中的基本数据类型。属于引用类型。

后期专门学习String类。

4.4、转义字符
在Java中有些符号,具备了特定的含义,如果我们想表示这个字符本身格式,这时需要使用Java中的转义字符完成,格式:
‘\转义字符的内容’

需求:需要在一个char类型的空间中保存 左单引号。

4.5、整数类型
整数分成4个关键字来表示类型: byte(字节类型) 、 short (短整型) 、 int (整型) 、long(长整型) , 它们开辟的内存空间都可以保存整数。

4个类型的区别:
byte 开辟的空间 占内存 1个字节。 范围 -128~127
short开辟的空间 占内存 2个字节。 char也是占用两个字节
int 开辟的空间 占内存 4个字节。
long 开辟的空间 占内存 8个字节。long l=12345678903L;

注意:在计算机中,所有的整数默认都是int类型。

整形:byte ->short->int->long
由小到大。
4.6、小数类型
float 和 double 它们开辟的空间 都可以保存小数。

float 开辟的空间是 4 个字节
double 开辟的空间是 8 个字节

错误的解释:默认的是double类型,而float类型是4个字节,double类型是8个字节,所以将double类型的3.14赋值给float类型的变量f,会报损失精度的错误,如果小数能满足4个字节的,可以这样赋值。
解决办法:

小数后面加f可以表示float类型存储。

总结:在计算机中,所有的整数 默认是int 类型, 所有的小数默认double类型。

5、数据类型转换
在java中,不同的数据需要保存在不同的空间中,而开辟空间的时候,需要通过不同的类型关键字来定义当前这个空间是什么类型的空间。

开辟的空间如果和保存的数据类型不一致,那么就很容易导致程序出现错误。
这时我们就需要使用数据类型的转换技术,完成数据的保存工作。
数据类型的转换,可以分为两种:
1)隐式类型转换(自动类型转换)
2)强制类型转换

5.1、隐式类型转换
隐式类型转换:在程序中,空间保存的数据类型不一致的时候,java内部会自动的帮助我们转换。
要能够自动转换,必须遵守Java中的自动转换的规则:
可以把小空间中的数据给大空间中保存。
byte 空间中的数据, 可以自动的转成 short int long float double
但是不能把double 保存在 byte 、int 、 short 、long 等空间。

转换规律:
容量小的类型可自动转换为容量大的数据类型;

5.2、强制类型转换
强制类型转换:它一般都会有数据的丢失。
格式:
( 需要转成的数据类型 )( 被转的数据 );

int i = (int )dd + 3.14; 报错。——》int i=(int)(dd+3.14);编译成功

6、运算符
学习运算的原则:知道每类运算的运算符号,以及符号的运算规则。
在生活中,存在各种各样的数据运算,例:加、减、大于(>)、小于(<)
Java中的运算:
目的就是为了解决生活中的问题,就需要把生活中的所有常见的运算移植到Java中。

Java中的运算:
算术运算、赋值运算、比较运算(关系运算)、逻辑运算、位运算。
6.1、算术运算符符号
算术运算:和数学中的算术运算基本一致。

运算符号: + – *(×) /(÷) % (算余数 模运算) ++ –

6.2、算术运算符举例
算术运算:
1)在Java中进行算术运算的时候,运算符两侧的类型一致的时候,
运算的结果必须和运算的数据类型保持一致。
举例:int d = 4321 / 1000* 1000;
4321 是int类型数据
1000 也是int类型数据
他们的商 也必须是int类型
4321 /1000 结果是 4 不是4.321

2)当算术运算两侧的类型不一致的时候,结果向大的类型保持。

举例:double d = 4321 / 1000.0* 1000;

/*
算术运算:
在Java中进行算术运算的时候,运算符两侧的类型一致的时候,
运算的结果必须和运算的数据类型保持一致。
4321 是int类型数据
1000 也是int类型数据
他们的商 也必须是int类型
4321 /1000 结果是 4 不是4.321

	当算术运算两侧的类型不一致的时候,结果向大的类型保持。

*/

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

	int a = 12;
	int b = 23;

	//  23/12

	int c = a + b;
	// 重点代码   研究为什么
	double d = 4321 / 1000.0 * 1000;

	System.out.println(c);
	System.out.println(d);
}

}

6.3、算术运算符的注意问题
%运算:算余数。取余数。
在Java中 / 它是除号,它的功能是计算两个数的商值。
% 它是取模运算符号,它的功能是计算两个数的余数。

10 % 4 =2 4 %10=4 20%3=2

m % n :
当m 等于 n 时,结果是 零
当m 小于 n 时,结果是 m
当m 大于 n 时,结果是 大于零 小于n

思考:任何一个正整数,模(%)2,结果是什么,有什么启发?
结果要么是零, 要么是1。通过这个余数,可以确定被除数的奇偶性。

注意:算术运算符两侧类型的统一问题。

/*算术运算练习:

需求:把一个指定的四位数,拆成4个数字,然后打印在屏幕上。

6785
6 7 8 5
分析:
1、有个四位数,就需要一个变量空间来保存这个数据。
2、需要对这个数据进行拆分。
拆分就是进行数学运算。肯定需要使用学习的各种关于算术运算的符号
+ – * / %
3、分析具体的拆分:
假设这个数字为 4321 4 3 2 1
4:对4321 除以 1000
1:对4321 取模 10 对于任何一个整数 % 10 结果就是它的个位上的那个数字
3:对4321 %1000/100
2:对4321 %100/10

步骤:
	1、定义变量,保存四位数
	2、定义4个变量,保存 千百十个位上的数字
	3、打印

*/
class Test
{
public static void main(String[] args)
{
int x = 4321;

	int q,b,s,g;

	q = x / 1000;			//计算千位
	b = x % 1000 / 100;		//计算百位
	s = x % 100 / 10;		//计算十位		
	g = x % 10;				//计算个位		

	System.out.println(q);
	System.out.println(b);
	System.out.println(s);
	System.out.println(g);
}

}

注意: +、-、*、/、% 都属于二元运算符

6.4、自加自减(一元运算符)

Java中 ++(自加,自增) 和 –(自减)
当自加、自减出现的时候,需要给它们所在的那个变量空间中加1 ,或者 减1.
自加、自减运算:
自加自减运算符,称为一元运算符。
表现形式:
1)++或者–在变量的右侧,举例:i++,j–;
2)++或者–在变量的左侧,举例:++i,–j;

自加自减运算规律:
1)当自加自减在变量的右侧时,需要先把变量空间中的值临时存储,也就是说在内存中需要开辟一个临时空间,把这个值保存到临时空间中。然后给原来变量空间中+1或-1,最后把临时存储的那个数据和其他的运算符号进行运算。
2)当自加自减在变量的左侧时,这时直接给变量空间+1 或 -1,然后把空间中的值与其他的运算符号进行运算。

/*
自加自减练习
*/
class Demo1
{
public static void main(String[] args)
{
//定义变量
int a=3;
int b=a++;
int c=3;
int d=++c;
int i=3;
i=i++;
//在控制台中输出变量的值
System.out.println(a);
System.out.println(b);
System.out.println©;
System.out.println(d);
System.out.println(i);
}
}

Int a =3; int b = a++; int c = a+++++b;
注意:针对一个变量,当把它的空间中的值改变了,后面再使用这个空间时,就使用的是改变后的值。

注意算术运算中的+号和字符串的问题:
在Java中如果让字符串和+进行运算,这时这个+号变成连接符,它会把当前这个字符串和+号后面的内容连接成一个更长的字符串。

/*
算术运算中的+号和字符串连接问题
*/
class Demo3
{
public static void main(String[] args)
{
System.out.println(“x=”+1235); //x=1235
}
}

7、赋值运算
赋值运算符号 = 它是Java中的赋值号,它的功能是把右侧的结果,赋值到左侧的变量空间中。

==
Aa = 45

赋值运算: = 
	//4 = 4 ; 右侧是一个具体的结果,即常量,但是左侧也是常量,不是变量,所以错误

在赋值运算中还有混合运算:
	+=  -=   *=  /=  %=  称为算术运算和赋值运算的混合运算。
	运算原则:既要遵守算术运算的规则,同时还要遵守赋值运算的规则。
	a += b   相当于: a=a+b 

(a++)+=(++b);

class Demo4
{
public static void main(String[] args)
{
int a = 3 ;
//4 = 4 ;
System.out.println(“a=”+a);

	//////////面试题////////////
	byte b = 127;
	//byte b2 = 128;   编译报错
	short s = 32767;
	//short s2 = 32768;  编译报错

	int x = 127;
	int x2 = 32768;

	byte b2 = 3;
	byte b3 = 4;
	/*
		当我们对源代码进行编译的时候,只会启动编译器,对代码进行语法的检查,
		这时是不会再内存中分配空间,那么这些变量就不会存在。
		byte b4 = b2 + b3; //报错
		byte b5 = 3 + 4;  // 不会
	*/
	byte b4 = (byte)(b2 + b3);

	//////////////////////////
	byte b5 = 3;
	
	//b5 += 10;  不报错,混合运算中有强制类型转换  b5 = (byte)(b5 +10);
	//b5 = b5 + 10;  报错,
}

}

补充:当我们对源代码进行编译的时候,只会启动编译器,对代码进行语法的检查,将java代码编译成二进制字节码文件,即 .class文件。
编译时是不会在内存中分配空间,那么变量空间就不会存在。只有在程序运行的时候才会给变量分配空间。
结论:混合运算符的好处:可以自动类型提升转换

8、比较运算
比较运算:就是我们数学中的比较大小。
运算符号:

= < <= == !=

==表示的是左右两边是否相等。如果相等结果为true,不等结果false
= 在Java中称为赋值号。

注意:比较运算的结果一定是boolean值。

/*
比较运算:

*/

class Demo5
{
public static void main(String[] args)
{
int a = 3;
int b = 5;

	System.out.println(a > b);  //比较a和b空间中值的大小
	System.out.println(a = b); //把b空间中的值赋值给a空间,那么a空间就变成了5

	System.out.println(a == b);// 由于在上面把b中的值赋值到了a空间中,那么这里再使用的a空间中的值已经是5
	System.out.println(a < b);
	System.out.println(a != b);
}

}

9、逻辑运算
在数学中有命题的真假。或 且 非运算。
逻辑运算:就是针对上面介绍的或 且 非运算。

9.1、逻辑运算符号
&&双与(短路与) &单与
||双或(短路或) |单或
^异或 !非
Java中的逻辑运算符:要求两侧的运算类型必须是boolean类型。

9.2、运算规律
逻辑运算符号:
逻辑与运算规则:
针对逻辑与运算:当两侧都为true的时候,结果才为true。否则结果为false。
true 与 true = true
false 与 true = false
true 与 false = false
false 与 false = false

	单与和双与的区别:
		&&:它在进行运算的时候,当左侧为false的时候,右侧不会参与运算。
		& :它在进行运算的时候,不管左边是什么,右边都要运算。

	或运算原则:
		针对逻辑或运算:当两侧都为false的时候,结果才为false。否则结果为true。
		true 或 true = true
		false 或 true = true
		true 或 false = true

		false 或 false = false

	单或和双或的区别:
		||:当左边为true的时候,右侧的不参与运算。
		|:不管左边是什么结果,右侧都要运算。

需求:对字符空间中的数据进行比较,保证它一定是个字母字符
	char ch = 'a';
	关系运算:需要对数据进行大小的确定时,就需要使用。
	逻辑运算:一般需要对数据的区间进行确定。

	ch >= 'A' && ch <= 'Z'   确定的是大写字母

	ch >= 'a' && ch <= 'z'   确定的是小写字母

	字母字符 : ( ch >= 'A' && ch <= 'Z' ) || ( ch >= 'a' && ch <= 'z' )

^逻辑异或:
	两侧相同为false,两侧不同为true。

!非运算:
	非true 为false  ,非false 为 true 
	
int a = 11;
a % 2 == 0  // 说明当前这个a 一定是偶数
a % 2 == 1   // 说明当前a一定是奇数

a % 2 != 0

!( a % 2 == 0 )

10、位运算符
位运算:二进制数位的运算。需要把数据转成二进制再进行运算。二进制运算是所有运算中速度最快的运算。

10.1、运算符符号
&:按位与运算
|:按位或运算
^:按位异或运算
<<:左移运算

:右移运算

:无符号右移运算

&(按位与运算):运算规则:
相同的二进制数位上,都是1的时候,结果为1,否则为零。

十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100
&

8 0000 0000 0000 0000 0000 0000 0000 1000

|(按位或运算):运算规则:
相同的二进制数位上,都是0的时候,结果为0,否则为1。
十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100

13 0000 0000 0000 0000 0000 0000 0000 1101

^(按位异或运算):运算规则:
相同的二进制数位上,数字相同,结果为0,不同为1。

十进制 二进制
9 0000 0000 0000 0000 0000 0000 0000 1001
12 0000 0000 0000 0000 0000 0000 0000 1100
^

5 0000 0000 0000 0000 0000 0000 0000 0101

<<(左移运算):运算规则:
就是把当前这个二进制数向左移动多少位。低位空出的补零。高位移出的舍弃

9 << 2 = 36 向左移动几位 ,相当于给原数乘以2的多少次方

9 0000 0000 0000 0000 0000 0000 0000 1001
0000 0000 0000 0000 0000 0000 0000 100100

(有符号右移符号):运算规则:
就是把当前这个二进制数向右移动多少位。在使用>>移动的时候,高位空出的来,需要根据原来最高位是什么,就补什么。低位移除的舍弃。
9>>2 =2
9 0000 0000 0000 0000 0000 0000 0000 1001
000000 0000 0000 0000 0000 0000 0000 1001

(无符号右移):运算规则:
就是把当前这个二进制数向右移动多少位。在使用 >>> 移动的时候,高位空出来的全部用零补。低位移除的舍弃。
位运算图解:

10.2、位运算应用
如果在程序中 出现了 & | ^ 这时他们到底是逻辑运算还是位运算。注意,运算符两侧的数据类型。如果是boolean类型,就是逻辑运算,如果是数值类型,他们都是位运算。

需求:有2个数,需要交换它们的位置。

class Test2
{
public static void main(String[] args)
{
int a = 3 ;
int b = 7;
System.out.println(“a=”+a);
System.out.println(“b=”+b);
/*
// 把b空间中的7 复制一份 保存到 a 中,
//但是 a中原来的3 就被覆盖了,此时a中已经变成7
a = b;
// 此时a中已经是 7
b = a;
/
/

上述代码不可以,因为在使用b空间中的给a空间中保存的时候,
没有预先把a空间中的值保留住,这个在赋值结束之后,a空间中的值就不存在了。
解决这个问题:就需要使用第三个空间,先保存其中某个变量空间中的值,
然后再进行交换
*/
int temp ;
temp = a;
a = b;
b = temp;
System.out.println(“a=”+a);
System.out.println(“b=”+b);
}
}

/*
不使用第三方变量交换两个空间中的值:

1、使用加减法完成,但是这种方式适合较小的数据。如果数据特别大,容易导致内存溢出。
2、使用位运算中的^完成。

/
class Test3
{
public static void main(String[] args)
{
int a = 3;
int b = 7;
System.out.println(“a=”+a);
System.out.println(“b=”+b);
/

a = a+b;
b = a-b;
a = a-b;
System.out.println(“a=”+a);
System.out.println(“b=”+b);
*/
System.out.println(377);
System.out.println(373);

	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	System.out.println("a="+a);
	System.out.println("b="+b);
}

}

11、三元运算符
11.1、三元运算符的格式
三元运算:三目运算。
格式:
表达式1 ? 表达式2 : 表达式3;
11.2、三元运算符的运算原则
要求表达式1 运行的结果必须是一个boolean的结果。通过表达式1的这个结果确定到底是执行表达式2还是表达式3.
当表达式1为true,就把表达式2的结果作为三元运算的结果。
当表达式1为false的时候,把表达式3的结果作为三元运算的结果。

11.3、三元运算符举例
/*
三元运算:
*/

class Demo8
{
public static void main(String[] args)
{
int a = -13;
int b = -7;
/*
在运行下面程序的时候,JVM遇到了三元运算,
这时JVM 会先执行 a > b 这个表达式,3 > 7不成立
这时JVM 就会把表达式3的结果作为三元运算的结果,赋值给max
*/
int max = a > b ? a : b;
System.out.println(“max=”+max);

	/*
		有三个值,找出最大的,先使用其中2个进行比较,找出较大的,在和第三个值进行比较
	*/
	int c = 1;

	//int max2 = max > c ? max : c;
	int max2 = (a > b ? a : b) > c ? (a > b ? a : b) : c;
	System.out.println("max2="+max2);
}

}

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。