-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、常量
1、概念：
在程序执行的过程中，其值不发生改变的量
2、分类：
(1)：字面值常量
A： 字符串常量 "hello"
B： 整数常量 12,23
C： 小数常量 12.345
D： 字符常量 'a','A','0'
E： 布尔常量 true,false
F： 空常量 null
(2)：自定义常量
public final int num = 20
3、在Java中针对整数常量提供了四种表现形式
A： 二进制 由0，1组成。以0b开头。
B： 八进制 由0，1，...7组成。以0开头。
C： 十进制 由0，1，...9组成。整数默认是十进制
D： 十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
4、进制转换
(1)：其他进制到十进制
系数：就是每一个位上的数值
基数：x进制的基数就是x
权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数
结果：系数*基数^权次幂之和。
图解：
(2)：十进制到其他进制
除基取余，直到商为0，余数反转。
图解：
(3)：进制转换的快速转换法
A: 十进制和二进制间的转换
8421码。
B: 二进制到八进制，十六进制的转换
二、变量：
1、概念：
在程序的执行过程中，其值在某个范围内可以发生改变的量
2、变量的定义格式：
A:数据类型 变量名 = 初始化值;
B:数据类型 变量名;
变量名 = 初始化值;
三、:数据类型
1、分类：
A:基本数据类型：4类8种
B:引用数据类型：类，接口，数组。
2、基本数据类型
A:整数 占用字节数
byte 1
short 2
int 4
long 8
B:浮点数float 4
double 8
C:字符
char 2
D:布尔
boolean 1
注意：
(1)：整数默认是int类型，浮点数默认是double。
(2)：长整数要加L或者l，单精度的浮点数要加F或者f。
3、:数据类型转换
(1)：boolean类型不参与转换
(2)：默认转换
A:从小到大
B:byte,short,char -- int -- long -- float -- double
C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)：强制转换
A：从大到小
B：可能会有精度的损失，一般不建议这样使用。
C：格式： 目标数据类型 变量名 = (目标数据类型) (被转换的数据);
Eg：
<span style="font-family:Arial Black;">public static void main(String[] args){
byte a = 3;
int b =4;
//没问题
//int c = a+b;
//byte c = 7;
//没问题
//byte c = a+b;
//用强制类型转换；
byte c = (byte) (a=b);
System.out.println(c);
} </span></span>
四、:运算符
(1)：算术运算符
A：+,-,*,/,%,++,--B：+的用法：a: 加法
b: 正号
c: 字符串连接符
C：/和%的区别： 数据做除法操作的时候，/取得是商，%取得是余数
D：++和--的用法
a：他们的作用是自增或者自减
b：使用
(a)：单独使用：放在操作数据的前面和后面效果一样。
( a++或者++a效果一样。)
(b)：参与操作使用:放在操作数的前面：
(1)先自增或者自减，再参与操作
eg: int a = 10;
int b = ++a;
(2)放在操作数的后面：先参与操作，再自增或者自减
eg: int a = 10;
int b = a++;
Eg:
<span style="font-family:Arial Black;"><span style="font-family:Arial Black;">/*
第一题：
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
请分别计算出a,b,c的值
第二题：
int x = 4;
int y = (x++)+(++x)+(x*10);
请分别计算出x,y的值
*/
class OperatorTest {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;
a = b++; //a=10,b=11,c=10
c = --a; //a=9,b=11,c=9
b = ++a; //a=10,b=10,c=9
a = c--; //a=9,b=10,c=8
System.out.println("a:"+a);
System.out.println("b:"+b);
System.out.println("c:"+c);
System.out.println("--------------");
int x = 4;
int y = (x++)+(++x)+(x*10);
//4+6+60
//x=5,6
System.out.println("x:"+x);
System.out.println("y:"+y);
}
}</span>
(2)：赋值运算符
A：=,+=,-=,*=,/=,%=等B：=叫做赋值运算符，也是最基本的赋值运算符
int x = 10; 把10赋值给int类型的变量x。
C：扩展的赋值运算符的特点
隐含了自动强制转换。
(3)：比较运算符
A：==,!=,>,>=,<,<=B：无论运算符两端简单还是复杂最终结果是boolean类型。
C：千万不要把==写成了=
(4)：逻辑运算符
A：&,|,^,!,&&,||B：逻辑运算符用于连接boolean类型的式子
C：结论
&：有false则false
|：有true则true
^：相同则false，不同则true。
!：非true则false，非false则true
&&：结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
||：结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
Eg：
<span style="font-family:Arial Black;">/*
&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false，右边不执行。
开发中常用的逻辑运算符：
&&,||,!
*/
class OperatorDemo2 {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
//&&双与
System.out.println((a > b) && (a > c)); //false && false = false
System.out.println((a > b) && (a < c)); //false && true = false
System.out.println((a < b) && (a > c)); //true && false = false
System.out.println((a < b) && (a < c)); //true && true = true
System.out.println("----------------");
int x = 3;
int y = 4;
//boolean b1 = ((x++ == 3) & (y++ == 4));
//boolean b1 = ((x++ == 3) && (y++ == 4));
//boolean b1 = ((++x == 3) & (y++ == 4));
boolean b1 = ((++x == 3) && (y++ == 4));
System.out.println("x:"+x);
System.out.println("y:"+y);
System.out.println(b1);
}
}</span>
(5)：位运算符
A：^ 的特殊用法： 一个数据针对另一个数据位异或两次，该数不变B：面试题
a：请实现两个变量的交换
**采用第三方变量
**用位异或运算符
左边a,b,a
右边a^b
b：请用最有效率的方式计算出2乘以8的结果
2<<3
Eg：
<span style="font-family:Arial Black;">/*
<<:左移左边最高位丢弃，右边补齐0
>>:右移最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移 无论最高位是0还是1，左边补齐0
请用最有效率的方式写出计算2乘以8的结果?
2 * 8
2 << 3
*/
class OperatorDemo3 {
public static void main(String[] args) {
//<< 把<<左边的数据乘以2的移动次幂
System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
//>> 把>>左边的数据除以2的移动次幂
System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
System.out.println(24 >>> 2);
System.out.println(-24 >> 2);
System.out.println(-24 >>> 2);
}
}
/*
计算出3的二进制：11
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) 补码
补码：1111111111 11111111 11111111 111010
反码：1111111111 11111111 11111111 111001
原码：1000000000 00000000 00000000 000110
结果：-6
>>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)
结果：
*/</span>
(6)：三元运算符
A：格式比较表达式?表达式1:表达式2;
B：执行流程：
首先计算比较表达式的值，看是true还是false。
如果是true，表达式1就是结果。
如果是false，表达式2就是结果。
Eg：
<span style="font-family:Arial Black;">/*
获取两个整数中的最大值
获取三个整数中的最大值
比较两个整数是否相同
*/
class OperatorTest {
public static void main(String[] args) {
//获取两个整数中的最大值
int x = 100;
int y = 200;
int max = (x > y? x: y);
System.out.println("max:"+max);
System.out.println("--------");
//获取三个整数中的最大值
int a = 10;
int b = 30;
int c = 20;
//分两步：
//A:先比较a,b的最大值
//B:拿a,b的最大值在和c进行比较
int temp = ((a > b)? a: b);
//System.out.println(temp);
int max1 = (temp > c? temp: c);
System.out.println("max1:"+max1);
//一步搞定
//int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
//这种做法不推荐。
//int max2 = a > b?a > c? a: c:b > c? b: c;
//System.out.println("max2:"+max2);
System.out.println("--------");
//比较两个整数是否相同
int m = 100;
int n = 200;
//boolean flag = (m == n)? true: false;
boolean flag = (m == n);
System.out.println(flag);
}
}</span>