一、内容
- 注释
- 关键字
- 标识符
- 常量、进制和进制转换
- 变量
- 数据类型和类型转换
- 运算符
- 语句
二、注释
- 注释概述
- 用于解释说明程序的文字
- Java中注释分类格式
- 单行注释
- 格式：//注释文字
- 多行注释
- 格式：/* 注释文字 */
- 文档注释
- 格式：/** 注释文字 **/
- 单行注释
-
注释的作用
-
解释说明程序
-
帮助我们调试错误
三、关键字
1. 关键字的概述和使用
-
什么是关键字
-
被Java语言赋予特定含义的单词
-
-
关键字的特点
-
组成关键字的字母全部小写
-
-
常见关键字
-
public static void class等
-
-
关键字的注意事项
-
goto和const作为保留字存在,目前并不使用
-
类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观
- Editplus中蓝色的都是关键字
-
| 用于定义访问权限修饰符的关键字 | ||||
| private | protected | public | ||
| 用于定义类、函数，变量修饰符的关键字 | ||||
| abstract | final | static | synchronized | |
| 用于定义类与类之间关系的关键字 | ||||
| extends | implements | |||
| 用于定义建立实例及引用实例，判断实例的关键字 | ||||
| new | this | super | instanced | |
| 用于异常处理的关键字 | ||||
| try | catch | finally | throw | throws |
| 用于包的关键字 | ||||
| package | import | |||
| 其他修饰符的关键字 | ||||
| native | strictfp | transient | volatile | assert |
四、标识符
1. 标识符的概述和组成规则
-
什么是标识符
-
就是给类,接口,方法,变量等起名字时使用的字符序列
-
-
标识符的组成规则
-
英文大小写字母
-
数字字符
-
$和_
-
-
标识符注意事项
-
不能使用关键字
-
不能数字开头
- 区分大小写
- 标识符示例
- 合法
- HelloWorld
- _123_
- Demo
- Bj_zj$88
- 非法
- Hello World
- 2B
- Demo#
- a12.3
- 合法
2. 标识符中常见的命名规则
-
见名知意
-
包
-
类或者接口
-
如果是一个单词首字母大写。如：Com
-
如果是多个单词每个单词首字母大写(驼峰命名)。如：StudentName
-
-
方法或者变量
-
如果是一个单词全部小写。如：name
-
如果是多个单词，从第二个单词首字母大写。如：studentName
-
-
常量
-
如果是一个单词，所有字母大写。如：PATH
-
如果是多个单词，所有的单词大写,用下划线区分每个单词。如：SYSTEM_PATH
五、常量
-
-
在程序执行的过程中其值不可以发生改变
-
-
Java中常量的分类
-
字面值常量
-
自定义常量(面向对象部分讲)
-
-
字面值常量的分类
-
字符串常量 用双引号括起来的内容
-
整数常量 所有整数
-
小数常量 所有小数
-
字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
- System.out.println('1');
- System.out.println('a');
- System.out.println('#');
- System.out.println('1');
-
布尔常量 较为特殊，只有true和false
-
System.out.println(true);
-
System.out.println(false);
-
-
空常量 null(数组部分讲解)
-
六、进制和进制转换
-
-
进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
-
例如：一周有七天，七进制，一年有十二个月，十二进制
-
-
十进制的由来
-
十进制的由来是因为人类有十个手指
-
-
二进制的由来
-
其实二进制来源与中国,请看史料记载
-
18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中，读到了八卦的组成结构，惊奇地发现其基本素数（0）（1），即《易经》的阴爻yao- -和__阳爻，其进位制就是二进制，并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的，同时也证明了《易经》数理学是很了不起的。
-
-
八进制的由来
-
任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。
-
所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7.超过7就进位了，这就是八进制。
-
-
十六进制的由来
-
但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。
-
-
不同进制表现同一个数据的形式特点
-
-
-
由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了) 0b110
-
-
八进制的数据表现形式
-
由0,1,…7组成。以0开头
-
-
十进制的数据表现形式
-
由0,1,…9组成。整数默认是十进制的
-
-
十六进制的数据表现形式
-
由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头（x可以大写，可以小写）
-
-
案例演示
-
输出不同进制表现100的数据。
-
0b100
-
0100
-
100
-
0x100
-
class Demo1_Scale { public static void main(String[] args) { /* 0b100 0100 100 0x100 */ System.out.println(0b100); // 输出4 System.out.println(0100); // 输出64 System.out.println(100); // 输出100 System.out.println(0x100); // 输出256 } }
-
-
系数：就是每一位上的数据。
-
基数：X进制，基数就是X。
-
权：在右边，从0开始编号，对应位上的编号即为该位的权。
-
结果：把系数*基数的权次幂相加即可。
-
-
B:画图练习
-
二进制--十进制
-
八进制--十进制
-
-
-
-
除积倒取余
-
-
B:画图练习
-
十进制--二进制
-
十进制--八进制
-
-
-
8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
-
-
B:通过8421码的方式进行二进制和十进制的相互转换
-
C:二进制到八进制的简易方式
-
-
-
后面要学习强制类型转换，如果不知道有原反补会看不懂结果
-
-
有符号数据表示法的几种方式
-
原码
-
就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
-
通过一个字节,也就是8个二进制位表示+7和-7
-
0(符号位) 0000111
-
1(符号位) 0000111
-
-
反码
-
正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
-
-
补码
-
-
-
A:已知原码求补码
-
0b10110100
-
-
B:已知补码求原码
-
0b11101110
-
七、变量
1. 变量的概述和格式
-
-
在程序执行的过程中，在某个范围内其值可以发生改变的量
-
-
变量的定义格式
-
数据类型 变量名 = 变量值;
-
-
为什么要定义变量
-
八、数据类型和类型转换
-
-
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
-
-
Java中数据类型的分类
-
基本数据类型
-
引用数据类型
-
面向对象部分讲解
-
-
-
基本数据类型分类(4类8种)
-
整数型
-
byte 占一个字节 -128到127
-
short 占两个字 -2^15~2^15-1
-
int 占四个字节 -2^31~2^31-1
-
long 占八个字节 -2^63~2^63-1
-
-
浮点型
-
float 占四个字节 -3.403E38~3.403E38 单精度
-
double 占八个字节-1.798E308~1.798E308 双精度
-
-
字符型
-
char 占两个字节 0~65535
-
-
布尔型
-
boolean
-
-
-
2. 定义不同数据类型的变量
-
定义不同基本数据类型的变量，并输出
-
-
class Demo1_DataType { //DataType数据类型 public static void main(String[] args) { //整数类型 byte b = 10; //占一个字节,-128 到 127 short s = 20; //占两个字节 int i = 30; //占四个字节 整数默认的数据类型就是int类型 long x = 8888888888L; //占八个字节 如果long类型后面加L进行标识最好加大L,因为小l太像一了 System.out.println(b); System.out.println(s); System.out.println(i); System.out.println(x); // System.out.println(12345 + 54321L); //浮点类型 float f = 12.3F; //占四个字节 double d = 33.4; //占八个字节 小数默认的数据类型是double,double类型后面也可以用D或d标识,但是一般不加 System.out.println(f); System.out.println(d); //字符类型 char c = 'a'; //占两个字节 System.out.println(c); //布尔类型 boolean b1 = true; boolean b2 = false; System.out.println(b1); System.out.println(b2); } }
3. 使用变量的注意事项
-
作用域问题
-
同一个区域不能使用相同的变量名
-
-
初始化值问题
-
局部变量在使用之前必须赋值
-
-
一条语句可以定义几个变量
-
class Demo2_DataType { public static void main(String[] args) { /* * a:作用域问题 * 同一个区域不能使用相同的变量名 * b:初始化值问题 * 局部变量在使用之前必须赋值 * c:一条语句可以定义几个变量 * int a,b,c...; */ /* int x = 10; int x = 20; System.out.println(x); // 出错，不能重复声明两个相同的变量 */ int y; y = 10; System.out.println(y); // 输出10，可以先声明变量类型，再赋值 int a,b,c,d,e; // 同时声明多个变量的变量类型 a = 10; b = 20; c = 30; d = 40; e = 50; System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); System.out.println(e); // int x = 10; // int y = 20; // int z = 30; } }
4. 数据类型转换之隐式转换
-
-
int + int
-
byte + int
-
-
Java中的默认转换规则
-
取值范围小的数据类型与取值范围大的数据类型进行运算，会先将小的数据类型提升为大的，再运算
-
-
说明：byte b是一个字节的byte类型，int x是占4个字节的int类型；两个变量进行计算相加，则在byte b上进行补位，隐式将byte b转换为int类型，然后进行 运算，得到的结果也是 int类型。
5. 数据类型转换之强制转换
-
-
int a = 10;
-
byte b = 20;
-
b = a + b;
-
-
强制转换的格式
-
b = (byte)(a + b);
-
class Demo3_DataTypeConversion { //Conversion转换 public static void main(String[] args) { //数据类型转换之隐式转换 /*int x = 3; byte b = 4; x = x + b; System.out.println(x); // 输出7 */ //数据类型转换之强制转换 int x = 3; byte b = 4; // b = (x + b); // 编译报错，x+b的结果是int类型，存储到byte类型的b中，无法成功，报错 b = (byte)(x + b); // 将x+b的结果（int类型），强制转换为byte类型 System.out.println(b); } }
- 强制转换的注意事项
- 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
class Demo3_DataTypeConversion { //Conversion转换 public static void main(String[] args) {
byte b = (byte)(126 + 4);
System.out.println(b);// 输出-126
} }
解析为什么输出结果是-126 。
-
- 第一，126 + 4，得到的结果是130，默认数据类型为 int 类型，占4个字节；
- 130的字节表示值为，00000000 00000000 00000000 10000010
- 通过 (byte)(126+4)的方式，将130的结果强制转换为byte，即一个字节，得到 10000010
- 【通过补码计算反码，通过反码，得到原码】在java中计算都是通过补码计算的，进行bit运算-1，得到反码，10000001
- 根据反码，计算原码，得到11111110，换算成二进制则是 -126（JAVA中最高位是符号位）。
- 面试题之变量相加和常量相加的区别：
-
案例演示
-
class Test1_DataTypeConversion { public static void main(String[] args) { //面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。 byte b1 = 3; byte b2 = 4; //byte b3 = b1 + b2; //报错 /* 从两方面 1. byte与byte(或short,char)进行运算的时候会提升为int,两个int类型相加的结果也是int类型 2. b1和b2是两个变量,变量存储的值是变化,在编译的时候无法判断里面具体的值,相加有可能会超出byte的取值范围 */ //System.out.println(b3); //byte b4 = 3 + 4; //java编译器有常量优化机制 byte b4 = 7; System.out.println(b4); } }
-
面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
-
byte b1 = 3;
-
byte b2 = 4;
-
byte b3 = b1 + b2;
-
从两方面去回答这个题
-
b1和b2是两个变量,变量里面存储的值都是变化的，所以在程序运行中JVM是无法判断里面具体的值
-
byte类型的变量在进行运算的时候，会自动类型提升为int类型
-
-
byte b4 = 3 + 4;
-
3和4都是常量，java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了
-
-
-
6. long与float的取值范围谁大谁小
-
byte，short，char -- int -- long -- float -- double
-
long: 8个字节
-
float：4个字节
-
class Test2_DataTypeConversion { public static void main(String[] args) { float f = 12.3f; long x = 12345; //f = x; //隐式转换 //System.out.println(f); // 输出12345.0 x = (long)f; //强制转换 System.out.println(x); /* float占4个字节。 IEEE 754规定 32个二进制位（4*8=32） 1位代表是符号位 8位代表指数位 8位的值域为：00000000 - 11111111，即0-255之间。 0 - 255 0代表0 255代表无穷大 1 - 254，都减去127，得到-126 ~ 127。 23位代表尾数位 */ } }
通过代码可以看出，long类型的变量值可以赋值给float类型的变量，而float类型的变量值不可以直接赋值给long类型的变量，需要进行强制类型转换。
-
IEEE754规定
-
4个字节是32个二进制位
-
1位是符号位
-
8位是指数位
-
00000000 11111111
-
0到255
-
1到254
-
-126到127
-
-
23位是尾数位
-
每个指数位减去127
-
-
它们底层的存储结构不同。
-
float表示的数据范围比long的范围要大
-
long：2^63-1
-
float：3.410^38 > 210^38 > 28^38 = 2
-
-
案例演示
-
System.out.println('a'); 输出a
-
System.out.println('a'+1); 输出98
-
通过看结果知道'a'的值是多少，由此引出ASCII码表
-
class Demo4_DataTypeConversion { public static void main(String[] args) { System.out.println('a' + 1); // 输出98 //因为有ASCII码表,a字符对应的是int类型的97 System.out.println((char)('a' + 1)); // 输出b 将得到的98强制转换为b System.out.println("hello"+'a'+1); // 输出helloa1 //任何数据类型用+与字符串相连接都会产生新的字符串 System.out.println('a'+1+"hello"); // 输出98hello System.out.println(" 5 + 5 = " + (5 + 5)); } }
-
-
ASCII码表的概述
-
记住三个值：
-
'0' 48
-
'A' 65
-
'a' 97
-
-
-
案例演示
-
System.out.println("hello"+'a'+1);
-
System.out.println('a'+1+"hello");
-
-
+在有字符串参与中被称为字符串连接符
-
System.out.println("5+5="+5+5);
-
System.out.println(5+5+"=5+5");
-
8. char数据类型
class Demo5_Char { public static void main(String[] args) { char c = 'a'; System.out.println(c); // 输出a byte b = 100; char c1 = 97; //0 - 65535 System.out.println(c1); // 输出a char c2 = 3; char c3 = 4; char c4 = 5; char c5 = 6; System.out.println(c2); // 输出对应ascii码符号 System.out.println(c3); // 输出对应ascii码符号 System.out.println(c4); // 输出对应ascii码符号 System.out.println(c5); // 输出对应ascii码符号 //char类型是否可以存储中文 char c6 = '中'; System.out.println(c6); // java以unicode编码，每个字符占两个字节，中文也是占2个字节，所以可以存储 } }
-
char c = 97; 0到65535
-
Java语言中的字符char可以存储一个中文汉字吗？为什么呢？
-
可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
-
所以，Java中的字符可以存储一个中文汉字
-
九、运算符
1. 算数运算符的基本用法
-
-
就是对常量和变量进行操作的符号。
-
-
运算符的分类
-
算术运算符
-
赋值运算符
-
比较(关系或条件)运算符
-
逻辑运算符
-
位运算符
-
三目(元)运算符
-
-
算数运算符有哪些
-
+
-
-
-
*
-
/
-
%
-
++
-
--
-
-
注意事项：
-
+号在java中有三种作用
-
代表正号
-
做加法运算
-
字符串的连接符
-
-
整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
-
-
-
当左边的绝对值小于右边绝对值时，结果是左边
-
当左边的绝对值等于右边或是右边的倍数时，结果是0
-
当左边的绝对值大于右边绝对值时，结果是余数
-
%运算符结果的符号只和左边有关系，与右边无关
-
-
-
2. 算术运算符++和--的用法
-
-
自加（++）自减（--）运算
-
++：自加。对原有的数据进行+1
-
--：自减。对原有的数据进行-1
-
-
-
案例演示
-
a:单独使用：
-
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
-
-
b:参与运算使用：
-
放在操作数的前面，先自增或者自减，然后再参与运算。
-
-
-
class Demo2_Operator { /* * a:单独使用： * 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的) * b:参与运算使用： * 放在操作数的前面，先自增或者自减，然后再参与运算。 * 放在操作数的后面，先参与运算，再自增或者自减。 */ public static void main(String[] args) { //单独使用 /*int a = 3; //a++; //a = a + 1; 输出4 ++a; //a = a + 1; 输出4 System.out.println(a);*/ //参与运算使用 int a = 3; int b; //b = a++; //当++在变量后面的时候,会先将变量中的值取出做赋值操作,然后再自身加1 // 相当于 b=a；然后a=a+1 //System.out.println("a = " + a); // 输出4 //System.out.println("b = " + b); // 输出3 b = ++a; //当++在变量前面的时候,会先自身加1,然后在将结果赋值 // 相当于 a=a+1; 然后b=a System.out.println("a = " + a); // 输出4 System.out.println("b = " + b); // 输出4 } }
-
案例演示
-
请分别计算出a,b,c的值?
-
a = b++;
c = --a;
b = ++a;
a = c--;
-
-
案例演示
-
请分别计算出x,y的值?
int x = 4; int y = (x++)+(++x)+(x*10);
-
-
面试题
-
byte b = 10;
-
b++;
-
b = b + 1;
-
问哪句会报错,为什么
-
class Test1_Operator { public static void main(String[] args) { //第一题 /*int a = 10; int b = 10; int c = 10; a = b++; //a = 10 ,b = 11 c = --a; //a = 9, c = 9 b = ++a; //a = 10, b = 10 a = c--; //a = 9, c = 8 System.out.println("a = " + a + ",b = " + b + ",c = " + c);*/ //第二题 /*int x = 4; // 4 + 6+ 60 int y = (x++)+(++x)+(x*10); System.out.println("x = " + x + ",y = " + y);*/ //第三题问哪句会报错,为什么 byte b = 10; b++; //b = (byte)(b + 1) //b = b + 1; //当byte与int进行混合运算的时候,会提升为int类型,两个int相加的结果还是int,赋值给byte会损失精度 System.out.println("b = " + b); } }
3. 赋值运算符的基本用法
-
赋值运算符有哪些
-
基本的赋值运算符：=
-
把=右边的数据赋值给左边。
-
-
扩展的赋值运算符：+=,-=,*=,/=,%=
-
+= 把左边和右边做加法，然后赋值给左边。
-
-
-
案例演示
-
面试题：看下面的程序是否有问题，如果有问题，请指出并说明理由。
-
short s=1;s = s+1;
-
short s=1;s+=1;
-
class Test1_Operator { public static void main(String[] args) { // 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。 //short s=1;s = s+1; //当short与int进行运算的时候,会提升为int类型,两个int类型相加的结果也是int类型 short s=1;s+=1; //s = (short)(s + 1); System.out.println(s); } }
4. 关系运算符的基本用法
-
关系运算符有哪些(比较运算符,条件运算符)
-
==,!=,>,>=,<,<=
-
-
注意事项：
-
无论你的操作是简单还是复杂，结果是boolean类型。
-
"=="不能写成"="。
-
5. 逻辑运算符的基本用法
-
逻辑运算符有哪些
-
&，|，^，!
-
&&，||
-
-
案例演示
-
逻辑运算class Demo1_Operator { public static void main(String[] args) { //&,|,^,! //int x = 10; //5 < x < 15 //x > 5 & x < 15 //逻辑与 & 并且and 遇false则false int a = 10; int b = 20; int c = 30; /*System.out.println(a < b & b < c); //true & true = true System.out.println(a < b & b > c); //true & false = false System.out.println(a > b & b < c); //false & true = false System.out.println(a > b & b > c); //false & false = false*/ //逻辑或 或or 遇true则true /*System.out.println(a < b | b < c); //true | true = true System.out.println(a < b | b > c); //true | false = true System.out.println(a > b | b < c); //false | true = true System.out.println(a > b | b > c); //false | flase = false*/ //逻辑异或 ^ 两边相同为false,两边不同为true /*System.out.println(a < b ^ b < c); //true | true = false System.out.println(a < b ^ b > c); //true | false = true System.out.println(a > b ^ b < c); //false | true = true System.out.println(a > b ^ b > c); //false | flase = false*/ //逻辑非! System.out.println(!true); System.out.println(!!true); } }
-
-
逻辑运算符的基本用法
-
注意事项：
-
逻辑运算符一般用于连接boolean类型的表达式或者值。
-
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
-
算术表达式：a + b
-
比较表达式：a == b(条件表达式)
-
-
-
结论：
-
&逻辑与：有false则false。
-
|逻辑或：有true则true。
-
^逻辑异或：相同为false，不同为true。
-
-
特：偶数个不改变本身。
-
-
- 逻辑运算符 && 和 & 的区别
-
案例演示
-
&&和&的区别?
-
最终结果一样。
-
&&具有短路效果。左边是false，右边不执行。
-
&是无论左边是false还是true,右边都会执行
-
&& 和 & 的区别
class Demo2_Operator { /* &&与&的区别 * a:最终结果一样。 * b:&&具有短路效果。左边是false，右边不执行。 ||与|的区别 a:最终的结果是一样 b:||具有短路效果,左边为true,右边不执行 */ public static void main(String[] args) { /*int a = 10; int b = 20; int c = 30; System.out.println(a < b && b < c); //true && true = true System.out.println(a < b && b > c); //true && false = false System.out.println(a > b && b < c); //false && true = false System.out.println(a > b && b > c); //false && false = false*/ int x = 3; int y = 4; //System.out.println((++x == 3) & (++y == 4)); //false & false = false //System.out.println("x = " + x); //x = 4 //System.out.println("y = " + y); //y = 5 System.out.println("---------------------------"); System.out.println((++x == 3) && (++y == 4)); //false & false = false System.out.println("x = " + x); //x = 4 System.out.println("y = " + y); //y = 4 } }
-
-
同理||和|的区别?
-
开发中常用谁?
-
&&，||，!
-
-
6. 位运算符的基本用法
-
位运算符有哪些
-
&,|,^,~ ,>>,>>>,<<
-
-
案例演示
-
位运算符的基本用法
-
&,|,^,~ 的用法
-
&：有0则0
-
|：有1则1
-
^：相同则0，不同则1
-
~：按位取反
-
-
位运算
class Demo1_Operator { public static void main(String[] args) { /* * &,|,^,~ 的用法 * &:有0则0 * |:有1则1 * ^:相同则0，不同则1 * ~:按位取反 */ System.out.println(6 & 3); //2 System.out.println(6 | 3); //7 System.out.println(6 ^ 3); //5 System.out.println(~6); //-7? } } /* 110 & 011 ----------- 010 110 | 011 ----------- 111 110 ^ 011 ----------- 101 00000000 00000000 00000000 00000110 6的原码反码补码都是本身 11111111 11111111 11111111 11111001 对6取反 - 00000000 00000000 00000000 00000001 --------------------------------------- 11111111 11111111 11111111 11111000 反码 10000000 00000000 00000000 00000111 原码(-7) */
-
-
- 位异或运算符的特点
-
案例演示
-
位异或运算
class Demo2_Operator { public static void main(String[] args) { /* * 位异或运算符的特点 * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。 */ //System.out.println(5 ^ 10 ^ 10); //System.out.println(5 ^ 10 ^ 5); /* * 请自己实现两个整数变量的交换(不需要定义第三方变量) * 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。 */ int x = 10; int y = 5; //需要第三方变量,开发推荐用这种 /*int temp; temp = x; x = y; y = temp;*/ //不需要定义第三方变量,有弊端,有可能会超出int的取值范围 /*x = x + y; //10 + 5 = 15 y = x - y; //15 - 5 = 10 x = x - y; //15 - 10 = 5*/ //不需要第三方变量,通过^来做 x = x ^ y; // 10 ^ 5 y = x ^ y; // 10 ^ 5 ^ 5 y = 10 x = x ^ y; // 10 ^ 5 ^ 10 x = 5 System.out.println("x = " + x + ",y = " + y); } }
- 位异或运算符的特点
-
^的特点：一个数据对另一个数据位异或两次，该数本身不变。
-
-
-
面试题：
-
请自己实现两个整数变量的交换
-
x，y值变换
class Demo2_Operator { public static void main(String[] args) { /* 请自己实现两个整数变量的交换(不需要定义第三方变量) */ int x = 10; int y = 5; //需要第三方变量,开发推荐用这种 /*int temp; temp = x; x = y; y = temp; */ //不需要定义第三方变量,有弊端,有可能会超出int的取值范围 /*x = x + y; //10 + 5 = 15 y = x - y; //15 - 5 = 10 x = x - y; //15 - 10 = 5*/ //不需要第三方变量,通过^来做 x = x ^ y; // 10 ^ 5 y = x ^ y; // 10 ^ 5 ^ 5 y = 10 x = x ^ y; // 10 ^ 5 ^ 10 x = 5 System.out.println("x = " + x + ",y = " + y); } }
-
- 位运算符的基本用法
-
案例演示 >>,>>>,<<的用法:
-
- >>：
- >>>：无符号右移 无论最高位是0还是1，左边补齐0
- 最有效率的算出2 * 8的结果
- System.out.println(2 << 3);
-
向左位移，向右位移
class Demo3_Operator { public static void main(String[] args) { /* * <<:左移 左边最高位丢弃，右边补齐0 * >>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1 * >>>:无符号右移 无论最高位是0还是1，左边补齐0 * 最有效率的算出2 * 8的结果 */ //左移,向左移动几位就是乘以2的几次幂 //System.out.println(12 << 1); //24 //System.out.println(12 << 2); //48 /* 00000000 00000000 00000000 00001100 12的补码 (0)0000000 00000000 00000000 000011000 24的补码 (00)000000 00000000 00000000 0000110000 48的补码 */ //右移,向右移动几位就是除以2的几次幂 //System.out.println(12 >> 1); //System.out.println(12 >> 2); /* 00000000 00000000 00000000 00001100 12的补码 000000000 00000000 00000000 0000110(0) 6 0000000000 00000000 00000000 000011(00) 3 */ //最有效率的算出2 * 8的结果 System.out.println(2 << 3); } }
-
-
7. 三元运算符的基本用法
-
三元运算符的格式
-
-
三元运算符的执行流程
-
-
案例演示
-
获取两个数中的最大值
-
两数比较，取最大值
class Demo1_Operator { public static void main(String[] args) { //(关系表达式) ? 表达式1 : 表达式2; int x = 10; int y = 5; int z; z = (x > y) ? x : y; System.out.println("z = " + z); } }
-
- 三元运算符的练习
-
案例演示
-
比较两个整数是否相同
-
-
案例演示
-
获取三个整数中的最大值
-
-
三元运算
class Test1_Operator { public static void main(String[] args) { /* * A:案例演示 * 比较两个整数是否相同 * B:案例演示 * 获取三个整数中的最大值 */ //比较两个整数是否相同 /*int x = 10; int y = 10; //boolean b = (x == y) ? true : false; boolean b = (x == y); System.out.println("b = " + b);*/ //获取三个整数中的最大值 int a = 10; int b = 20; int c = 30; //先比较任意两个数的值,找出这两个数中的最大值 int temp = (a > b) ? a : b; //用前两个数的最大值与第三个数比较,获取最大值 int max = (temp > c) ? temp : c; System.out.println("max =" + max); } }
-
8. 键盘录入的基本格式讲解
-
为什么要使用键盘录入数据
-
为了让程序的数据更符合开发的数据
-
让程序更灵活一下
-
-
如何实现键盘录入呢?
-
先照格式来。
-
导包
-
格式：
-
import java.util.Scanner;
-
-
-
在class上面。
-
-
-
创建键盘录入对象
-
格式：
-
Scanner sc = new Scanner(System.in);
-
-
-
通过对象获取数据
-
格式：
-
int x = sc.nextInt();
-
-
-
import java.util.Scanner; //导入包中的类Scanner class Test2_Scanner { /* * A:案例演示 * 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果 * B:案例演示 * 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值 */ public static void main(String[] args) { Scanner sc = new Scanner(System.in); //创建键盘录入对象 //键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果 /*System.out.println("请输入第一个整数:"); int x = sc.nextInt(); //将键盘录入的数据存储在x中 System.out.println("请输入第二个整数:"); int y = sc.nextInt(); //将键盘录入的数据存储在y中 int sum = x + y; System.out.println(sum);*/ //键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值 System.out.println("请输入第一个整数:"); int x = sc.nextInt(); //将键盘录入的数据存储在x中 System.out.println("请输入第二个整数:"); int y = sc.nextInt(); //将键盘录入的数据存储在y中 int max = (x > y) ? x : y; //获取x和y中的最大值 System.out.println("max = " + max); } }
/* * A:案例演示 * 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等 * B:案例演示 * 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值 */ import java.util.Scanner; //导包 class Test3_Scanner { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //创建键盘录入对象 //键盘录入练习：键盘录入两个数据，比较这两个数据是否相等 /*System.out.println("请输入第一个整数:"); int x = sc.nextInt(); //将键盘录入的数据存储在x中 System.out.println("请输入第二个整数:"); int y = sc.nextInt(); //将键盘录入的数据存储在y中 //boolean b = (x == y)? true : false; boolean b = (x == y); System.out.println(b);*/ //键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值 System.out.println("请输入第一个整数:"); int x = sc.nextInt(); //将键盘录入的数据存储在x中 System.out.println("请输入第二个整数:"); int y = sc.nextInt(); //将键盘录入的数据存储在y中 System.out.println("请输入第三个整数:"); int z = sc.nextInt(); //将键盘录入的数据存储在y中 //定义临时变量记录住比较出前两个变量中的最大值 int temp = (x > y) ? x : y; //将比较后的结果与第三个变量中的值比较,比较出三个数中的最大值 int max = (temp > z) ? temp : z; System.out.println(max); } }