J2SE第二章——Java基本语法(二)
5.运算符
5.1.算术运算符:(数字参与的运算)
+- * / % 两侧的操作数可以是常量也可以是变量
除法（/）默认取整 如果想要小数：通常用1.0*该数！这样就是小数了
++-- 两侧的操作数必须是变量
i++ 先引用，后自增
i++作为单独语句存在，就相当于i= i + 1;
i++作为表达式的一部分，参与运算：先把i的值取出来参与运算，然后i的值再自增1
++i 先自增，后引用
++i作为独立的语句存在，就等价于 i++
++i如果作为表达式的一部分参与运算：i的值先自增1，然后参与表达式的运 i-- 先引用，后自减
i--作为单独语句存在，就相当于i= i - 1;
i--如果作为表达式一部分，参与运算：先把i的值取出来参与运算，然后i的值再自减1
--i 先自减，后引用
--i作为单独语句存在，就等价于i--
--i如果作为表达式的一部分参与运算：i的值先自减1，然后参与表达式的运算
5.2.逻辑运算符：（有布尔型参与运算的。多个条件-逻辑表达式的连接符号） 与(&& &) 两侧操作数都为true ,运算结果为true
或(| ||) 两侧操作数只要有一个为true,结果就为true
异或(^) 两侧操作数，不同为true，相同时为false
非(!) 两侧操作数为true，结果为false
booleana , b;
a b a&b a&&b a|b a||b a^b !a
true true true true true true false false
true flase false false true true true false
false true flase false true true true true
false false false false false false flase true
注意：
1.&& 和 &:&逻辑与，&&短路与。 ！用&& ！
如果左侧为true那么还需要判断右侧，此时&与&&没有区别
int i = 100;
boolean j = (5>3) &(i++>100);
true &
booleank = (5>3) && ()
true &&
!如果左侧为false，(&)右侧继续运算，(&&)右侧不再运算!
booleanj = (5<3) & (i++>100); // j为false,但i = 101
false&
booleank = (5<3) && (i++>100); //k为false，i= 100
false&&
2.||和 |: |逻辑非，||短路或。 ！用|| ！
如果左侧为false ,(|)(||)没有区别
如果左侧为true,使用(||)不再判断右侧 (|)依旧判别右侧
5.3.赋值运算符(一个常量赋值给变量。向内存中存储东西)
= 把右侧的“值”赋值给左侧的变量
扩展赋值运算符
+= --> i = i + 200; --> i += 200;
-= --> i = i - 200; --> i -= 200;
*= --> i = i * 200; --> i *= 200;
/= --> i = i / 200; --> i /= 200;
5.4.字符串的连接符号(有字符串时使用)
"abc" + "123" ="abc123"
+ : 1.两侧操作数都是数值，“+”就是数学中的加法运算。
2.两侧操作数只要有一个是字符串，则“+”表示字符串连接符号
System.out.println("abc"+ 100); //abc100
System.out.println(200+ 100); //300
System.out.println("200"+ 100); //200100
5.5.关系运算符：(运算结果是布尔型常量)
大于>
小于<
等于 ==
大于等于>=
小于等于<=
不等于！=
6.表达式
本质：一个常量“值”。
表达式就是用运算符连接的操作数的序列
表达式的值：表达式的最终运算结果
表达式的类型：运算结果的类型。
| public class Test { public static void main(String[] args) { int i = 100; int j = 200; i = j; //--> 300 出错！！！ （表达式的本质就是一个值！） } } |
运算符优先级：
1. “.” 点导航，读作“的” p.username= "zs" 变量p的指向的对象的username属性是“zs”
2.如果表达式比较复杂，善于使用小括号()
3.优先级最低的是赋值号"="
7.语句：
常量 --> 变量 --> 需要对变量运算--> 运算符 --> 表达式 --> 语句结构 -->方法
类体：
方法定义；
变量定义（声明）：
| { 变量的定义 变量赋值 语句: 赋值语句：用赋值号连接的表达式 方法的调用； } |
java语法规定：所有代码都要写在类的内部：变量 方法 （静态代码块）
对事物的描述无非有两个方面：
静态方面：成员变量（描述一类事物的静态属性）
动态方面：方法定义（描述一类事物的动态属性）
语句组织方式：
整体顺序结构：
细节包含条件结构：
细节包含循环结构
7.1条件语句：
条件成立，做什么
条件不成立，做什么
7.1.1.单条件：如果....否则....
逻辑表达式（逻辑常量）：逻辑运算发连接起来的式子。
if(逻辑表达式) {
语句体1
} else {
语句体2
}
如果逻辑表达式为true，执行语句体1，否则执行语句体2
7.2.2.多个条件
7.2.2.1 else 具有排他性。
if(逻辑表达式1) {
语句体1
}else if (逻辑表达式2) { //if 语句超过3层，太！繁杂 --> 高耦合
语句体2
}else if (逻辑表达式3) { //解耦和！！！if语句不要过于繁杂-->数据结构链表
语句体3
}else
7.2.2.2 平行的if
if(逻辑表达式1) {
}
if(逻辑表达式2) {
}
if(逻辑表达式3) {
}
7.2.2.3. 三目运算
if(逻辑表达式) {
赋值语句1
}else {
赋值语句2
}
且赋值语句1和赋值语句2是为同一个变量赋值
intscore = 70 ;
Stringresult;
if(score >= 60) {
result= "及格";
}else {
resulrt= "挂科";
}
(=====================)等价于三目运算符！
三目（3个操作数） Java中唯一一个三目运算符 ? :
变量 = 逻辑表达式 ？ 表达式1 : 表达式2；
intscore = 70;
Stringresult = (score >= 60) ? "及格" ："挂科";
7.2.2.4.多条件特例(switch)
要求：
逻辑表达式左侧的变量是int (char byte short int 枚举enum 字符串)
逻辑表达式使用的逻辑符号是=
| int i ; if (整型变量==整型常量1) { 语句体1 } else if (整型变量==整型常量2) { 语句体2 } else if (整型变量==整型常量3) { 语句体3 } else { 语句体4 }
int i; if (i == 0) { System.out.println("男"); } else if (i == 1) { System.out.println("女"); } else { System.out.println("不确定"); } |
(============================)switch
switch (整型变量) {
case整型常量1:
语句体1;
break;
case整型常量2:
语句体2;
break;
语句体3;
break;
}
| int i ; switch (i) { case 0: System.out.println("男"); break; case 1: System.out.println("女"); break; dafault: System.out.println("不确定"); break; } |
7.2.循环语句(连续执行逻辑)
for while (do while)
while 能干的活，for 都能干，但某些情形下，while比 for 简洁。
连续执行关键的是“执行次数”！执行次数也是while 和 for 的选择依据。次数-->变量
for()里面的三部分都不是必须的，但通常我们会这样做。i++ 和 ++i没有区别
int i 的初值设为0(通常设为0-->数组)，设执行一次，循环变量自增1，和终止条件比较
for (循环变量赋初值;循环变量终止条件;循环变量的步长) {
连续执行的业务逻辑
}
| for (int i = 0; i < 3; i++) { System.out.println(""); } |
int i = 0; 循环变量赋初值，当且仅当执行一次
i < 3 判断执行条件 0 < ３
第一次执行循环体：
i++(++i) 循环变量自增1 i = 1
i <3 判断执行条件 1 < 3
第二次进入循环体:
i++ (++i): 循环变量自增1 i = 2；
i <3 判断执行条件 2 < 3
第三次进入循环体
i++(++i): 循环变量自增1 i = 3;
i < 3判断执行条件 3 < 3
(===================================)while
循环变量赋初值
while (循环变量终止条件) {
循环体；
循环变量的步长；
}
| int i = 0; while (i < 3) { System.out.println("....."); i++; } |
语法上：for 循环更简洁紧凑 (一般用 for)
理解上：while 循环更容易理解 1.死循环----> 多线程(开启一个线程检测一件事)
2.循环次数不确定(Iterator遍历)
break:
1.switch 语句的 case 后面，相当于 if 语句中的 else
2.循环结构中，终止循环。
能起到终止作用的:
1.循环结构中的 break 终止循环体
2.方法体（语句块）内的：return
3.throw newRuntimeException();
continue:
只能用于循环体，终止当前循环
8.方法
方法只有被调用时才会被加载到内存！！调用完之后内存移除。
1)方法是用来完成特定功能的代码段
2)把重复的代码段定义成方法
先定义，再实现，后调用
public class类名 {
描述类的静态层面： 成员变量
描述类的动态层面： 方法
}
行为： 方法：
行为名称：（必须！） 方法名：
行为参数（条件）：（可以没有） 形式参数：
行为过程：（可以没有） 方法体：
行为结果：（可以没有） 方法的返回值：
返回值类型 方法名称(形式参数列表) {
方法体;
return返回值;
}
1.如果方法体没有返回值，两种语法：
1.return; 2.可以直接省略 同时在方法名称前使用 void 标记
2.如果方法体有返回值，那么语法：
return返回值;
同时在方法名称前使用该返回值的数据类型加以标记。
方法只是被定义，没有被调用 这个方法就是静态的~！
方法只有被调用时才会被加载到内存！！
注意：
先定义方法，才能调用方法
方法定义不能嵌套（方法的定义是平行的，不能在一个方法内部定义一个方法）
返回值类型是给调用方看的
需求转换为代码：
1.抽取名词
2.名词分类
3.动作---> 行为 --->描述某类事物
10.递归调用
数据结构：线性结构（一对一） 树形结构（一对多） 图形结构（多对多）
操作：填删改查（CRUD）
C:create
R:read
U:update
D:delete
自己 调用 自己 ，就是递归~~~！！（树形遍历必不可少）
递归算法实现步骤：
1.定义递归方法
需要形参：(递归的基本条件);
需要终止条件;
2.调用递归方法;
例子1:阶乘
| 阶乘（5！）： 发现：m! 和 (m-1)! 本质是一样的 假如定义一个方法fn(m)，用来计算m！那么 计算(m-1)!还需要再额外定义一个别的方法吗？ -----不需要！！只需要把参数由m改为m-1就可以了~~~ 即该模型变成了：fn(m)=m*fn(m-1); |
| public class Test { public static void main(String[] agrs) { int result = f(5);
}
public static void m1(int m) { int mul = 1;
for (int i = 1; i<=5;i++) { mul *= i; }
System.out.println("mul=" + mul); } public static int f(int m) { //定义递归算法需要一个初值 if (m == 1) { return 1; } else { return m * f(m-1); } } } |
例子：2 树形文件图
定义读取
控制树形结构每一行前面的缩进空格
1.首先 输出给定结点的名称（文件夹以及文件）
2.然后判断当前结点是否是“目录”
3.查询出该目录结点的孩子们
4.遍历孩子 对每个孩子 然后转到步骤1,2,3
| public class Test { public static void main(String[] args) { File firl = new File("D:\\jdk1.7");
tree(file,0); }
public static void tree(File file,int level) { for (int i = 0;i<level;i++) { System.out.println(" "); } System.out.println(file.getName());
if (file.isDirectory()) { File[] children = file.listFiles();
for (int i = 0;i<children.length:i++) { File child = children[i]; tree(child,level+1); } } } } |