疯狂Java讲义中的知识点02

疯狂java讲义02

（出处：根据李刚老师《疯狂java讲义》视频中的知识点于此记录下来）

★变量

-变量的定义、赋值（简单值、表达式）
-8个基本类型：（byte、short、int、long、float、double、char、boolean）

★运算符：

▲算数运算符：7个。(+、-、*、/、%、++、–)

复杂的数学运算，用Math类。

================

▲赋值运算符：=

=左边只能是变量
=右边可以是任何复杂的表达式
大部分时候，=右边往往都是复杂的表达式。
=将右边的值赋给左边的变量

================

▲位运算符：

它只能对整型（byte、short、int、long、char（0~65535））运算。
针对二进制码进行运算的

负数的进制码：保存的是补码。
原码：数，直接算出来叫原码，最高位，又叫符号位，0代表正数；1代表负数。
反码：除符号位之外，其它位都按位取反。
补码：反码+1.
（正数的补码和原码是一样的）
（补码-1=反码）

&：按位与。上下两位都是1时，得到的结果才是1

---

|：按位或。上下两位有一个是1时，得到的结果就是1.
当表示状态时，会用特定的数代表开关。
文本状态：粗体、 斜体、 下划线、 中划线
1 2 4 8
0000001 0000010 00000100 000001000
粗体、斜体 000011= 1 | 2
粗体、斜体、中划线 000001011 = 1 | 2 | 8

---

~：按位取反。原来是0变成1；原来是1变成0；
正数变成负的（绝对值+1），负数变成正的（绝对值-1）。

---

^：按位异或。上下两位相同时，得到的结果才是0。不同的时候，得到的结果是1。

---

（ << ）：左移。左移N位，相当于乘以2的N次方。
【面试题】2乘以8，最快的算法：
2<<3 （2乘以8==2乘以2的3次方）

（ >> ）：右移，右移N位，相当于除以2的N次方。
除不尽的情况下，实际结果总是比除得结果略小的整数

（ >>> ）：无符号右移。
如果被移位的数是整数，那么该运算符与>>运算符一样
如果被移位的数是负数，那么被空出来的最高位总是补0----这个数就会变成整数。
正数>>>，和>>是完全一样的。
负数>>>，得到一个很大的整数。

====================
比较运算符：
>
>=
<
<=
==
!=

比较运算符，正是用于比较两个变量或两个值，如果符合预期，得到true；否则得到false。

=========================
逻辑运算符：
只能对boolean值进行运算。

&&： 与：要求两个条件同时为true，结果才为true
&： 不短路与：
||： 或：要求任意一个条件为true，结果就为true
|： 不短路或
!： 非：条件为true，就变成false；原来条件为false，就变成true
^： 异或：两个条件相同（true true、false false）得到false；
不同（true false、false true）得到true

&& （短路与）与 &（不短路与）的区别：

&&：如果第一个操作数已经是false，&&运算符不会计算第二个操作数，----称之为短路。
&： 如果第一个操作数已经是false，&运算符依然会计算第二个操作数，----称之为不短路

||（短路或） 与 |（不短路或） 的 区别：

**||：**如果第一个操作数已经是true，||运算符不会计算第二个操作数，——称之为短路。
|： 如果第一个操作数已经是true，|运算符依然会计算第二个操作数，——称之为不短路。

一般来说，编程是都用短路与和短路或。

========================================

扩展的赋值运算符：

a+=b; a=(a的类型)（a+b）；
扩展的赋值运算符的左边，只能是变量。
【例】

public class PrintTriangle {

public static void main(String[] args) {

byte b = 2;
//	b =b+1;//b+1是表达式，类型是int。应该为 b=(byte)(b+1);
b +=1;//相当于b=（b的类型）（b+1）;
System.out.println(b);		
		}	
}

a-=b a=(类型)(a-b)；
a*=b a=（类型）（a*b）

基本上，前面介绍的双目运算符都可以与=结合，形成扩展的赋值运算符。

三目运算符

逻辑表达式 ？ 值1：值2

如果 逻辑表达式 为true，整个表达式返回值1；否则返回值2.

【例】

public class PrintTriangle {

public static void main(String[] args) {

int a=15000;
//三目运算符
String s = a>12000 ? "收入还行" : "收入普通" ;
System.out.println(s);	
		}	
  }

三目运算符的嵌套：嵌套后的三目运算符表达式可能返回3个、甚至更多值得其中一个。

【例】

public class PrintTriangle {

public static void main(String[] args) {

int a=15000;
//三目运算符
String s = a>12000 ? "收入还行" : "收入普通" ;
System.out.println(s);

int age =20;
String s2 = age>20 ? "age大于20" : (age <20 ?"age小于20 " : "age等于20");
System.out.println(s2);
//如果没有嵌套，那么如果变量是20的话，就会得出小于20，而不是等于20.	
		}	
}

运算符的结合性和优先级

结合性：控制运算符的运算方向：从左到右？还是从右到左？
大部分运算符都是从左到右。（=赋值运算符）=运算符是从右到左的。

优先级：谁先算、谁后算的问题。
先乘除、再加减------推荐，记不清的时候，用括号来保证优先级

=============================================

流程控制

-顺序控制：从上到下，逐行执行。
-分支结构：根据具体情况，做出判断
-循环结构：根据条件，让一个或多个步骤重复执行很多次

顺序结构：
不加什么控制，程序代码总是从上到下，依次执行

分支结构：
if分支
语法：

if（条件）
{
	//条件执行体
}
else if（条件）		//可以出现0~N次
{
	//条件执行体	
}
...
else			//出现0~1次
{
}

【例】

	int age = 12;
	if(age >65)
	{
		System.out.println("老年人");
	}
	else if(age>40)
	{
		System.out.println("中年人");
	}
	else if(age>20)
	{
		System.out.println("青年人");
	}
	else
	{
		System.out.println("小孩");
	}

两个注意点：

A： 如果条件执行体只有一条语句，条件执行体的花括号可以省略。
如果省略了花括号，if条件只控制到紧跟if条件的第一分号。

B： else - 否则，就是对前面条件取反

建议：if语句中有多个else if 语块，一定要先处理范围小的条件。

（如果是一个年龄，大于20岁为青年人，大于40岁为中年人，大于65岁为老年人，那么，当一个人为50岁时，if（条件）可以选取范围比较小的（>65）开始，因为如果是（>20）开始的话，那么一个50岁的人，得出的不是（中年人），而是（青年人））

---

switch分支

switch（表达式）
{
	case 值1：		case块可出现1~N次
		执行体
		break；
	case 值2：
		执行体
		break；
	...
	
	default：			default块可出现0~N次
		执行体
		break；
}

程序会计算switch表达式的值，表达式的值等于哪个case值，就执行哪个case块；
如果都不等于，就执行default块。

java的switch不能处理范围！

两个注意点：

A：switch分支的表达式只能是byte、char、short、int、枚举、String（从Java7才行）这6个类型

B：如果不写break，会发生贯穿。
贯穿：Java会从第一个匹配的case块开始执行，在遇到break之前，直接忽略case值而执行每个case块的代码。

【例】

	char score ='A';
	switch (score)
	{
	case 'A':
	System.out.println("优秀");
	break;
	
	case 'B':
		System.out.println("普通");
	break;
	
	default :
		System.out.println("其他");
	
	}

=========================================
while循环
语法：

while（条件）
{
	//循环体
}

程序判断 循环条件，如果循环条件为true，执行循环体；
循环体执行完后，再次判断 循环条件，如果循环条件为true，执行循环体；

直到最后一次判断，循环条件为false，结束循环。

循环条件执行次数 == 循环体执行次数+1

死循环：无限循环。永远不会停止的循环。

注意点：
如果循环体只有一条语句，循环体的花括号可以省略。
如果省略了花括号，while条件只控制到紧跟while条件的第一个分号。

【例】

	int i=0;
	while (i++<10){
		System.out.println("ljh");
		}

---

	int i = 0;
	while(i<10);	//此处会用死循环执行“分号（空语句）”
	{
		System.out.println("i的值为：" + i);
		i +=2;
	}

===========================

do while 循环

语法：

do
{
	//循环体
}while（条件）;

程序先执行一次循环体。
循环体执行完后，再次判断 循环条件，如果循环条件为true，执行循环体；
直到最后一次判断，循环条件为false，结束循环。
循环条件执行次数 == 循环体执行次数

特征：即使循环条件开始时false，循环体也会执行一次。

【例】

	int i=20;
	
	do{
		System.out.println("ljh");
	}while(i<0);

	}

---

	int i=20;
	
	do{
		System.out.println("ljh" + i + "岁啦");
		i++;
		System.out.println("");
	}while(i<=25);

}

====================================
for循环：
语法：

for（[初始化语句]；[循环条件];[迭代语句]）
{
	//循环体
}

所有循环开始前，先执行 初始化语句，只执行一次。

程序判断 循环条件，如果循环条件为true，执行循环体；
循环体执行完后，执行迭代语句，然后再次判断，如果循环条件为true，执行循环体；

[初始化语句]
while(条件)
{
	//循环体
	[迭代语句]
}

【例】

	for(int i=0;i<5;i++){
	System.out.println("i的值为"+i);
	}

---

for循环的几个注意点：

A：for循环中，只有两个分号是必须的，其他都是可以省略。
如果省略循环条件，循环条件永远是true。
【例】

		for(  ;  ;  ){
		System.out.println("i的值为");//死循环
		}

B：尽量不要在循环体内改变循环计数器的值。

【例】

	for(int i=0; i<10 ;i++ ){
		System.out.println("i的值为"+i);
		i*=0.2;
		//	i = (int) (i*0.2);
	}

C：初始化语句可以初始化多个变量，只要它们的数据类型相同即可。
迭代语句也可有多条，多条迭代语句之间用逗号隔开即可。

=====================

流程控制：
if分支
switch分支
while循环
do while循环
for循环
循环嵌套

=================