2018-05-10 第四天

一、内存分析（栈）

二、注释：comment

注释的作用：帮助开发人员更好的理解记忆程序的。

 

java 中支持三种注释：

1：单行注释  //后续的内容都是注释的内容  可以单独占用一行，用来解释说明它下面一行的代码。  还可以放到一行代码的末尾，短注释。

 

2：多行注释： /* 注释的内容 */

3：多行文档注释: 帮助生成阅读文档的。  javadoc.exe  可以用来识别java 源代码中的文档注释的内容。将文档注释中的内容生成一个帮助文档。

/**  文档注释的内容 */

 

三、运算符

1：操作数  参与运算符运算的数据。

2：表达式  操作数使用运算符连接的整体。

3：一元运算符 ：需要一个操作数的运算符。  单目运算符。+1

4：二元运算符 ：需要两个操作数的运算符。  1+1 1-1  双目运算符

5：三元运算符 ：需要三个操作数的运算符。  三目运算符  only one。

                         条件运算符 (判断)?返回值1:返回值2;

6：返回值： 参与所有运算符运算的数据 都是 操作数  或者表达式的返回值 参与的。

参与运算的数据计算的结果  就是 参与运算数据的返回值。

 

四、算术运算符 + - * / %

//运算符练习

public class TestMath{

public static void main(String[] args){

//算术运算符

// 1 +  :  一元运算符(通常省略)  和  二元 运算符 （实现两个操作数相加）

//打印的是表达式 操作数 的 返回值。

System.out.println(+7);//7

System.out.println(1+7);//8

// 2: - : 一元 运算符  （负数）   二元运算符 （实现两个操作数相减）

System.out.println(-7);//-7

System.out.println(1-7);//-6

// 3 * : 二元运算符  (实现两个操作数相乘的结果)  正负号的结算的结果 和 数学中的规则一样

System.out.println(1*2);//2

System.out.println(-1*2);//-2

System.out.println(1*-2);//-2

System.out.println(-1*-2);//2

//4  /  : 二元运算符  （实现两个操作数相除的结果） 整数相除结果还是整数，余数忽略。有一个操作数是小数，结果就是小数。

// 正负号的规则和数学中一样。

System.out.println(5/3);//1

System.out.println(5.0/3);//1.666666666666666667

System.out.println();

// 5 %  取余: 二元运算符 ( a%b a 除以b 得到的余数)

System.out.println(5%3);//2

System.out.println(1%3);//1

//规则：结果的符号位 与 左边的操作数相同

System.out.println(5%3);//2

System.out.println(-5%3);//-2

System.out.println(5%-3);//2

System.out.println(-5%-3);//-2

//除 和  取余 的应用技巧

//比如我得到一个三位的随机数，求三位随机数的个位  十位  百位 上的具体的数值大小。 345

final int MIN = 100;

final int MAX = 1000;

int num = (int)(Math.random() * (MAX-MIN) + MIN);

System.out.println("num = " + num);

//个位的值

int unit = num % 10;

//十位的值

int decade = num /10 % 10;

//百位

int hundred = num/100;

System.out.println(num + " 的百位是：" + hundred + "\t十位是：" + decade + "\t个位是：" + unit);

 

}

}

 

五、自增、自减

    //运算符练习-2

public class TestMath1{

public static void main(String[] args){

// ++  自增运算符 ：一元运算符。对变量自身实现自增一的操作。

int age = 10;

//赋值操作最后执行。

age = age + 1;

//后缀模式 postfix

//自增后缀模式的表达式的返回值 是 变量自增之前的值。

//先返回，后自增。

age ++;

age = 0;

//后缀模式，首先 age ++ 产生返回值 返回 age 自增之前的值 num 。 然后age 做自增+1操作，然后将num 赋值给 value。

System.out.println(age ++);

int value = age ++;

System.out.println("age = " + age);

System.out.println("value = " + value);

age = 0;

value = age ++ + age ++  + age ++;

System.out.println("value = " + value);

//前缀模式 prefix

//先自增，后返回。

++ age;

age = 0;

System.out.println("age = " + ++age);

age = 0;

age = age ++;

System.out.println("age = " + age);

age = 0;

value = 0;

value = ++age + age ++ + age ++ + ++age;

System.out.println("age = " + age);//4

System.out.println("value = " + value);//8

// -- 自减运算符 ，实现 对变量自身自减一的操作。

// 前缀模式，先自减，后返回。

// 后缀模式，先返回，后自减。

}

}

 

 

六、赋值运算符

赋值运算符：=

二元运算符。

功能：将右边表达式的返回值赋值给左边的 变量或者是终态变量。

 

注意：赋值语句也有返回值：左边变量被赋予的值。

 

赋值运算符左边的：左值，右边的叫：右值。

 

左值：变量或者是终态变量。

右值：常量（1）、变量(age)、常量表达式（1+1）.变量表达式(age + value).,常量变量表达式(1+age)。

 

注意：

赋值运算符 最后执行。

左值的类型和右值的类型需要兼容。

 

复合赋值运算符： +=、-=、*=、/=、%=、&=、|=、^=、&&=、||=

复合赋值运算符 和 普通的赋值方式的区别：

1：复合赋值运算符 生成的字节码要小一点点。省一点点内存。

2：byte value = value + 1;(错)

  byte value = (byte)value + 1;(对)

  byte value = 1;value ++;(对)

 

//复合赋值运算符

public class Test1{

public static void main(String[] args){

//对指定的变量实现自增一的操作。

int age = 10;

age = age + 1;

age ++;

++ age;

age += 1;

//自增10

//age = age + 10;

age += 10;

//自减10

//age = age - 10;

age -= 10;

//自乘10

//age = age * 10;

age *= 10;

//自除10

age /= 10;

//age = age/10;

//自余10

//age = age%10;

age %= 10;

}

}

 

 

七、关系运算符

关系运算符：关系运算符一共有6个。

 

都是二元运算符。用来表示运算符左右量变的关系是否成立的！

如果关系成立，关系表达式的返回值 是true。否则 是false。

 

>：大于，左边是否大于右边

<：小于，左边是否小于右边

>=：大于等于，左边是否大于等于右边

<=：小于等于，左边是否小于等于右边

==：等于，左边是否等于右边

!=：不等于，左边是否不等于右边。

 

 

6种数值类型的数据都可以进行 关系的比较。 byte short int long float double

 

char 可以被看作整数对待，所以也可以进行所有关系的比较。

 

布尔类型：只适用于比较是否相等（==、!=）。不能用于比较大小。

 

//关系运算符

public class TestReleation{

public static void main(String[] args){

System.out.println(5 > 6);//false

boolean bool = 5 != 6;//

System.out.println(bool);//true

System.out.println('a'-32 == 'A');

System.out.println('你'+0);

char c1 = 20320;

System.out.println(c1);

int age = 0;

System.out.println( age ++ > age);//false

System.out.println( age ++ < age);//true

System.out.println( age ++ == age);//false

System.out.println( age ++ != age);//true

age = 0;

System.out.println( ++ age != (age += 1));//true

}

}

 

八、逻辑运算符

逻辑运算符：6个。

 

& ： 逻辑与

| ： 逻辑或

^ :  逻辑异或

! ：  逻辑非，逻辑取反。

 

&&：条件与、短路与

||：条件或、短路或

 

注意：参与逻辑运算的操作数 必须是 boolean值。 逻辑表达式的返回值也是 boolean 值。

 

//逻辑运算符

public class TestLogic{

public static void main(String[] args){

// &  逻辑与  二元的运算符。 规则：全真则真，有假则假。 表达的是并且的意思。

System.out.println((2>1) & true);//true

System.out.println(true & false);//false

System.out.println(false & true);//false

System.out.println(false & false);//false

System.out.println();

// | 逻辑或  二元运算符  规则：有真则真，全假则假。  表达的是或者的意思。

System.out.println(true | true);//true

System.out.println(true | false);//true

System.out.println(false | true);//true

System.out.println(false | false);//false

System.out.println();

//^ 逻辑异或  二元运算符  规则：相异为 真true  相同 为假false

System.out.println(true ^ true);//false

System.out.println(true ^ false);//true

System.out.println(false ^ true);//true

System.out.println(false ^ false);//false

System.out.println();

// ! 逻辑 非 一元运算符  规则：true 取反 返回 false，false 取反 返回 true

System.out.println(!true);//false

System.out.println(!false);//true

System.out.println();

// && 条件与 短路与   二元运算符 规则  全真则真，有假则假。 表达的是并且的意思。

System.out.println((2>1) && true);//true

System.out.println(true && false);//false

System.out.println(false && true);//false

System.out.println(false && false);//false

System.out.println();

// & 和 && 的区别：参与逻辑与&运算的所有的操作数表达式，都会被计算，并得到结果。不管前面的操作数是否是false。

// && 条件与 如果第一个操作数的返回值是 false，那么后面的参与逻辑运算的表达式 将不再被计算，而直接将整个逻辑表达式的返回值返回 false。

// && 效率往往高于 & 。建议使用 && 。

int age = 0;

System.out.println((10 > 12) && (age ++ != 0));//false

System.out.println("age = " + age);

// | 和 ||  区别：

// | : 参与逻辑或 | 运算的所有的操作数  都会被计算，即使前面的操作数已经是 true了。

// || 短路或 : 如果进行短路或 运算的操作数，前面的操作数 的返回值 是 true，那么后面的表达式将不再被计算，而直接返回整个表达式的值为true。

// 建议使用 || 短路或。 效率相对较高一点。

}

}

 

 

九、位运算符

位运算符：直接对底层的二进制位 做操作，效率比其他的运算符要高。只对整数类型使用。

 

7个位运算符。

&: 按位与

|: 按位或

^: 按位异或

~：按位取反

>>：带符号右移

<<: 左移

>>>：无符号右移

 

 

//位运算符练习

import java.util.Random;

 

public class TestRandom{

public static void main(String[] args){

// &: 按位与  二元运算符  规则：对应的位上进行按位与 全1 则 1  有0则0.

System.out.println(3 & 5);//1

//应用技巧：可以使用按位与 得到 指定的二进制位上的表示的数值的大小。将指定的二进制位设置为0.  关灯

int age = 0b1010101;

System.out.println(age & 0xf);//5

System.out.println(age & 0b111);//5

// | : 按位或  二元运算符   规则： 对应的位上进行按位或，，有1则1，全0 则0

System.out.println(3 | 5);//7

//应用技巧：1：如果两个操作数 对应的位上没有全1 的情况，那么按位或和加结果一样。

System.out.println(1|2);//3

System.out.println(1|4);//5

System.out.println(4|2);//6

System.out.println(16|2);//18

System.out.println(7|16);//23

//找10个数，任意的组合十个数的加的结果。都是不同的。

//技巧2 ：将指定位 设置为 1.  开灯

 

// ^: 按位异或  二元运算符  规则：相同为 0 ，相异为1.  。一个数值，先后异或了一个值2次，那么结果是它自身。

System.out.println(3 ^ 5 ^5);//3

//应用技巧：1 不需要中间变量交换两个变量的值

int num1 = 15;

int num2 = 6;

num1 ^= num2;   //num1 = num1 ^ num2;

num2 ^= num1;//num2 = num2 ^ num1;

num1 ^= num2;//num1 = num1 ^ num2;

System.out.println(num1 + "\t" + num2);

//2 可以实现加密效果  

//明文  密文  密钥

char c1 = '我';

char c2 = '爱';

char c3 = '你';

//密钥

int key = 5210;

System.out.println("密文："+(char)(c1^key)+(char)(c2^key)+(char)(c3^key));

System.out.println("解密："+(char)(c1^key^key)+(char)(c2^key^key)+(char)(c3^key^key));

// ~：按位取反  规则：所有的二进制位 0变1  1 变0

System.out.println(~0);//-1

//移位 必须是整数类型 byte ，short char int long

//如果是小于等于int 类型的数据。移动n位，如果n 大于等于32 等价于 移动 n%32位    a >> n%32

// >>：带符号右移  二元运算符  规则：低位被挤走，高位补符号位，正数补0  负数 补 1.

//应用：在某些区间内，如果想对某个数实现除以 2的n 次幂 可以通过对该数进行带符号右移n 位来实现。

System.out.println(24 >> 3);// 24/2^3=3

System.out.println(16 >> 5);// 16/2^5=0

System.out.println(-16 >> 5);// -1

System.out.println(-16 >> 2);//-4

// <<: 左移  二元运算符  规则：高位被挤走，低位补0

// 应用：在int 区间内 左移n 位 和 乘以2的n次幂等价。

System.out.println(3 << 2);// 3*2^2=12

System.out.println(5 << 32);// 5 * 2^(32-32) = 5

// >>>：无符号右移  二元运算符，规则：低位被挤走，高位补0.

//应用：得到一个正整数。

//得到区间[10~30]之间的一个随机数。

//创建得到随机数的对象

System.out.println( -16 >>> 3);

Random random = new Random();

final int MIN = 10;

final int MAX = 31;

//得到一个随机的int 值。

int num = random.nextInt();

System.out.println(num);

//得到了一个正整数

//num = num >>> 1;

num >>>= 1;

System.out.println(num);

num = num % (MAX-MIN) +MIN;

System.out.println(num);

//一句代码实现

int value = (random.nextInt()>>>1)% (MAX-MIN) +MIN;

System.out.println(value);

}

}