【JAVA基础】02 Java基础语法
一、内容
- 注释
- 关键字
- 标识符
- 常量、进制和进制转换
- 变量
- 数据类型和类型转换
- 运算符
- 语句
二、注释
- 注释概述
- 用于解释说明程序的文字
- 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. 标识符中常见的命名规则
见名知意
包
- 要求全部小写
- 一般是公司的域名倒着写
- 如：公司域名www.baidu.com
- com.baidu. 包的作用
类或者接口
如果是一个单词首字母大写。如：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(数组部分讲解)
六、进制和进制转换
1. 进制概述，二、八、十六进制
什么是进制
进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
例如：一周有七天，七进制，一年有十二个月，十二进制
十进制的由来
十进制的由来是因为人类有十个手指
二进制的由来
其实二进制来源与中国,请看史料记载
18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中，读到了八卦的组成结构，惊奇地发现其基本素数（0）（1），即《易经》的阴爻yao- -和__阳爻，其进位制就是二进制，并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的，同时也证明了《易经》数理学是很了不起的。
八进制的由来
任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。
所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7.超过7就进位了，这就是八进制。
十六进制的由来
但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。
不同进制表现同一个数据的形式特点
进制越大，表现形式越短
2. 不同进制数据的表现形式
二进制的数据表现形式
由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
}
}
3. 任意进制到十进制的转换图解
A:任意进制到十进制的转换原理
系数：就是每一位上的数据。
基数：X进制，基数就是X。
权：在右边，从0开始编号，对应位上的编号即为该位的权。
结果：把系数*基数的权次幂相加即可。
B:画图练习
二进制--十进制
八进制--十进制
十六进制--十进制
4. 十进制到任意进制的转换图解
A:十进制到任意进制的转换原理
除积倒取余
B:画图练习
十进制--二进制
十进制--八进制
十进制--十六进制
5. 快速的进制转换法
A:8421码及特点
8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
B:通过8421码的方式进行二进制和十进制的相互转换
C:二进制到八进制的简易方式
D:二进制到十六进制的简易方式
5. 原码反码补码
为什么要学习原码反码补码?
后面要学习强制类型转换，如果不知道有原反补会看不懂结果
有符号数据表示法的几种方式
原码
就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
通过一个字节,也就是8个二进制位表示+7和-7
0(符号位) 0000111
1(符号位) 0000111
反码
正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码
正数的补码与其原码相同；负数的补码是在其反码的末位加1。
原码反码补码的练习)(了解)
A:已知原码求补码
0b10110100
B:已知补码求原码
0b11101110
七、变量
1. 变量的概述和格式
什么是变量
在程序执行的过程中，在某个范围内其值可以发生改变的量
变量的定义格式
数据类型 变量名 = 变量值;
为什么要定义变量
用来不断的存放同一类型的常量，并可以重复使用
八、数据类型和类型转换
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
boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小
2. 定义不同数据类型的变量
案例演示
定义不同基本数据类型的变量，并输出
赋值时候注意float类型,long类型
- long x = 8888888888L;
- float f = 12.3F;
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. 使用变量的注意事项
案例演示
作用域问题
同一个区域不能使用相同的变量名
初始化值问题
局部变量在使用之前必须赋值
一条语句可以定义几个变量
int a,b,c...;
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+int类型的问题
说明：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类型，其他类型进行混合运算的是小的数据类型提升为大的
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位代表尾数位
*/
}
}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 = 22^3^38 = 2*2^114 > 2^63-1
7. 字符和字符串参与运算
案例演示
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结果不是0就是1可以用来当作切换条件
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的值?
int a = 10; int b = 10; int c = 10;
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则true，非true则false。
特：偶数个不改变本身。
- 逻辑运算符 && 和 & 的区别
案例演示
&&和&的区别?
最终结果一样。
&&具有短路效果。左边是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); //
System.out.println(6 | 3); //
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);
}
}位异或运算
- 位异或运算符的特点
^的特点：一个数据对另一个数据位异或两次，该数本身不变。
面试题：
请自己实现两个整数变量的交换
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);
}
}x，y值变换
- 位运算符的基本用法
案例演示 >>,>>>,<<的用法:
<<：左移 左边最高位丢弃，右边补齐0
- >>：右移 最高位是0，左边补齐0；最高为是1，左边补齐1
- >>>：无符号右移 无论最高位是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); // /*
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. 三元运算符的基本用法
三元运算符的格式
(关系表达式) ? 表达式1 : 表达式2;
三元运算符的执行流程
案例演示
获取两个数中的最大值
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);
}
}
键盘练习1
/*
* 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);
}
}
键盘练习2
【JAVA基础】02 Java基础语法的更多相关文章
- 002 01 Android 零基础入门 01 Java基础语法 01 Java初识 02 Java简介
002 01 Android 零基础入门 01 Java基础语法 01 Java初识 02 Java简介 学习Java的基础语法 Java是一门编程语言,学习的逻辑其实和现实世界的语言是一样的,需要了 ...
- # 095 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 03 封装总结 01 封装知识点总结
095 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 094 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 02 static关键字 04 static关键字（续）
094 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 093 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 02 static关键字 03 static关键字（下）
093 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 092 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 02 static关键字 02 static关键字（中）
092 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 091 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 02 static关键字 01 static关键字（上）
091 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 090 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 04 使用包进行类管理（2）——导入包
090 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 089 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 使用包进行类管理（1）——创建包
089 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 03 # 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 ...
- 088 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 02 封装的代码实现
088 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 02 封装的代码实现 本文知识点:Java封装的代码实现 说明:因为时间紧张,本人写博客过程中只 ...
- 087 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 01 封装的概念和特点
087 01 Android 零基础入门 02 Java面向对象 02 Java封装 01 封装的实现 01 封装的概念和特点 本文知识点:封装的概念和特点 说明:因为时间紧张,本人写博客过程中只是对 ...
随机推荐
- 3-1. 基于epoll架构的视频采集端设计
精通epoll架构 epoll:Linux中最优秀的多路复用机制! 与select .poll区别 1.select和poll没有太大区别,除了select有文件描述符限制(1024个).select ...
- JS中的栈和堆
一.栈和堆 栈(stack):栈会自动分配内存空间,会自动释放,存放基本类型,简单的数据段,占据固定大小的空间. 基本类型:String,Number,Boolean,Null,Undefined 堆 ...
- find的基本查询命令《一》
一. find的基本查询命令 find命令最常用的是查找某个文件,如: find ./ -name "abc.txt" 则会在当前目录及子目录下查找abc.txt文件 更常用的是查 ...
- scratch算立方根
10((1/3)lgx)＝x(1/3)也就是立方根
- 微信小程序H5预览页面框架
<!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content ...
- go 基本包
像 fmt.os 等这样具有常用功能的内置包在 Go 语言中有 150 个以上,它们被称为标准库,大部分(一些底层的除外)内置于 Go 本身 unsafe: 包含了一些打破 Go 语言“类型安全”的命 ...
- Linux网络基础，路由的追踪
一.traceroute traceroute [-46ndFT] [-f<存活数值>] [-g<网关>] [-i(--interface)<device>] [- ...
- Dubbo 路由机制的实现
Dubbo 路由机制是在服务间的调用时,通过将服务提供者按照设定的路由规则来决定调用哪一个具体的服务. 路由服务结构 Dubbo 实现路由都是通过实现 RouterFactory 接口.当前版本 du ...
- windows上jmeter目录结构功能
1.bin :存储了jmeter的可执行程序,如启动 2.lib:存储了jmeter的整合的功能(如.jar文件程序) 3.启动jmeter:双击bin\apachejmeter.jar jmeter ...
- 实战if-else 过多详解
1.本文实例代码仅仅是俩个小例子. package com.example.demo.pattern.ifElse; import java.util.HashMap; import java.uti ...