0基础学习Java ——第五天
本帖最后由 回忆一遥远 于 2017-8-16 07:36 编辑三元运算符 if-else
三元操作符也称条件操作符。
其表达式采用形式为： Boolean-exp(布尔表达式) ? value1 : value2
如果 Boolean-exp 的结果为 true，就计算 value1，这个结果就是操作符最终产生的值；如果 Boolean-exp 的结果为 false，就计算 value2，这个结果也是操作符最终产生的值。
尽管三元操作符更加简洁，但是如果打算频繁使用它，请三思，因为它很容易产生可读性极差的代码！
条件操作符和 if-else 完全不同，因为它会产生一个值。
下面是两者间的比较
public class TernaryIfElse {
static int ternary(int i){
return i < 10 ? i * 100: i * 10;
}
static int standardIfElse(int i){
if(i < 10)
return i * 100;
else
return i * 10;
}
public static void main(String[] args){
System.out.println(ternary(9));
System.out.println(ternary(10));
System.out.println(standardIfElse(9));
System.out.println(standardIfElse(10));
}
}
输出:
900
100
900
100
可以看出，上面 ternary() 中的代码比 standardIfElse() 中不用三元操作符的代码相比，显得更紧凑；但 standardIfElse() 更易理解，而且不需要太多的录入。
控制执行流程
Java 使用了 C 的所有流程控制语句，涉及的关键词包括： if-else 、while 、do-while、for、return、break、switch。
Java 并不支持 goto 语句，但是仍有类似 goto 的跳转
true 和 false
所有条件语句都利用条件表达式的真或假来决定执行路径。所有关系操作符都可以拿来构造条件语句。
注意：Java 不允许将一个数字作为布尔值使用，如果要使用一个非布尔值，必须用一个条件表达式将其转换成布尔值。 如 if(a) -> if(a != 0)
if-else
if-else 语句是控制程序流程的最基本的形式。else 是可选的
使用方式
if (Boolean-expression)
statement
或
if (Boolean-expression)
statement
else
statement
Boolean-expression(布尔表达式)必须产生一个布尔结果，statement 是用分号结尾的简单语句，或复合语句——封闭在花括号内的一组简单语句。
下面是 if-else 的一个例子，test () 方法是，您猜的数是大于、小于还是等于目标数：
public class IfElse {
static int result = 0;
static void test(int testval, int target){
if(testval > target)
result = +1;
else if(testval < target)
result = -1;
else
result = 0;
}
public static void main(String[] args){
test(10, 5);
System.out.println(result);
test(5, 10);
System.out.println(result);
test(5, 5);
System.out.println(result);
}
}
输入：
1
-1
0
在 test() 中间部分有一个 “else if”，那并非新的关键词，仅仅是一个 else 后面紧跟另一个新的 if 语句。
迭代
while、do-while、for用来控制循环，有时把他们划分为迭代语句（iteration statement）。
语句会重复执行，直到起控制作用的布尔表达式（Booleanexpression）得到“假”的结果为止。
while 循环的格式如下：
while(Boolean-expression)
statement
在循环刚开始时，计算一次布尔表达式的值；在语句下一次迭代开始前会再计算一次。
下面这个例子可产生随机数，直到符合特定的条件为止：
public class WhileTest {
static boolean condition(){
booleanresult = Math.random() < 0.99;
System.out.print(result + ", ");
return result;
}
public static void main(String[] args){
while(condition())
System.out.println("Inside 'while'");
System.out.println("Exited 'while'");
}
}
输出：
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
true, Inside 'while'
false, Exited 'while'
condition() 方法用到了 Math 库里的 static 方法 random() ，该方法的作用是产生 0 和 1 之间（包括0，但不包括1）的一个 double 值。
① do-while
do-while 格式如下：
do
statement
while(Boolean-expression);
while 和 do-while 唯一的区别就是 do-while 中的语句至少会执行一次，即使布尔表达式第一次就计算为 false。在 while 循环结构中，如果条件第一次就为 false，那么里面的语句不会执行。
实际应用中，while 比 do-while 更常用一些。
② for
for 循环是最常用的迭代形式，这种语句在第一次迭代之前要进行初始化。随后会进行条件测试，在每一次迭代结束时，进行某种形式的步进
for 循环的格式如下：
for(initialization; Boolean-expression; step)
statement
初始化(initialization)表达式、布尔表达式(Boolean-expression)、步进(step)运算都可以为空。
每次迭代前会测试布尔表达式，若获得的结构是 false，就会执行 for 语句后面的代码行。每次循环结束，会执行一次步进。
for 循环常用来执行“计数”任务：
public class ListCharaccters {
public static void main(String[] args){
for(char c = 0; c < 128; c++)
if(Character.isLowerCase(c))
System.out.println("value: " + (int)c + "character: " + c);
}
}
输出：
value: 97character: a
value: 98character: b
value: 99character: c
value: 100character: d
value: 101character: e
value: 102character: f
value: 103character: g
value: 104character: h
value: 105character: i
value: 106character: j
value: 107character: k
value: 108character: l
value: 109character: m
value: 110character: n
value: 111character: o
value: 112character: p
value: 113character: q
value: 114character: r
value: 115character: s
value: 116character: t
value: 117character: u
value: 118character: v
value: 119character: w
value: 120character: x
value: 121character: y
value: 122character: z
变量 c 是在程序用到它的地方被定义的，也就是在 for 循环的控制表达式里，为不是 main() 开始的地方定义的。所以 c 的作用域就是 for 控制的表达式的范围内。
这个程序使用了 java.lang.Character 包装器类，这个类不仅能把 char 基本类型的值包装进对象，还提供了一些别的有用的方法。这个程序中用到了 static isLowerCase() 方法来检查程序中的字符是否为小写字母。
逗号操作符
Java 里唯一用到逗号操作符的地方就是 for 循环的控制表达式。在控制表达式的初始化和步进控制的部分，可以使用一系列由逗号分隔的语句；而且那些语句会独立执行。
通过使用逗号操作符，可以在 for 语句内定义多个变量，但是他们必须具有相同的类型。
public class CommaOperator {
public static void main(String[] args){
for (int i = 1, j = i + 10; i < 5; i++, j = i * 2)
System.out.println("i = " + i + " j = " + j);
}
}
输出：
i = 1 j = 11
i = 2 j = 4
i = 3 j = 6
i = 4 j = 8
for语句在初始化部分实际上可以拥有任意数量的具有相同类型的变量定义。
Foreach 语法
Java SE5 开始，引入了一种新的、更加简洁的 for 语法用于数组和容器，即 foreach 语法，表示不必创建 int 变量去对由访问项构成的序列进行计数，foreach 将自动产生每一项
举个例子，下面是 foreach 迭代在字符串中的所有字符：
public class ForEachString {
public static void main(String[] args){
for(char c : "An African Swallow".toCharArray())
System.out.print(c + " ");
}
}
输出：
A n A f r i c a n S w a l l o w
String 类有一个方法 toCharArray(), 它返回一个 char 数组。
foreach 还可用于任何 Iterable 对象。
return
在 Java 中有很多关键词表示无条件分支， 它们只是表示这个分支无需任何测试即可发生。
这些关键次包括 return、break、continue 和一种与其他语言中的 goto 类似的跳转到标号语句的方式。
return 关键词有两方面的用途：一方面指定一个方法的返回值（假设它没有 void 返回值），另一方面会导致当前的方法退出并返回那个值。
下面是根据已经写个的例子修改后使具备以上特点的源码：
public class IfElse2 {
static int test(int testval, int target){
if(testval > target)
return +1;
else if(testval < target)
return -1;
else
return 0;
}
public static void main(String[] args){
System.out.println(test(10,5));
System.out.println(test(5,10));
System.out.println(test(5,5));
}
}
输出：
1
-1
0
可以加上 else，因为方法在执行 return 后就不再继续执行。
如果在返回 void 的方法中没有 return 语句，那么在该方法结尾处会有一个隐式的 return ，因此在方法中总是必须要有一个 return 语句。
如果一个方法声明它将返回 void 之外的其他东西，必须要确保每一条代码路径都将返回一个值。
break 和 continue
在任何迭代语句的主体部分，都可以使用 break 和 continue 控制循环的流程。其中，break 用于强行退出循环，不执行循环中剩余的语句。continue 则停止执行当前迭代，然后退出循环起始处，开始下一次迭代。
下面这个程序展示了 break 和 continue 在 for 和 while 循环中的例子：
public class BreakAndContinue {
public static void main(String[] args){
for(int i = 0; i < 100; i++){
if(i == 74) break; // 退出循环
if(i % 9 != 0) continue; // 跳到下一循环
System.out.print(i + " ");
}
System.out.println();
// 使用 Foreach 语句
int[] a = new int;
for(int i = 0; i < 100; i++)
a = i;
for(int i : a){
if(i == 74) break; // 退出循环
if(i % 9 != 0) continue; // 跳到下一循环
System.out.print(i + " ");
}
System.out.println();
int i = 0;
// An "infinite loop":
while(true){
i++;
int j = i * 27;
if(j == 1269) break; // 退出循环
if(i % 10 != 0) continue; // 跳到下一循环
System.out.print(i + " ");
}
}
}
输出：
0 9 18 27 36 45 54 63 72
0 9 18 27 36 45 54 63 72
10 20 30 40
在这个 for 循环中， i 的值永远不会到100，i 一到74， break 语句就会中断循环。只要 i 不能被9整除， continue 语句就会使执行过程返回到循环开头。如果能整除，则将值显示出来。
第二种 for 循环展示了 foreach 用法，它将产生相同的结果。
最后是一个“无穷 while 循环”的情况。在循环内部有一个 break 语句可以终止循环。continue 语句执行序列移到循环的开头，而没有去完成continue 语句之后的所有内容。
无穷循环的第二种形式是 for(;;) 。编译器将 while(true) 与 for(;;) 看作是一回事。具体选用取决于自己的编程习惯。
goto!?
goto 起源于汇编语言的程序控制：“若 A成立，则跳到这里；否则跳到那里”。
goto 语句是源码级上的跳转，这使其招致了不好的声誉。这会造成程序的控制流程难于识别！
自从 Edsger Dijkstra 发表了著名论文 《Goto considered harmful》，众人开始痛斥 goto 的不同，甚至建议将它从关键词集合中扫地出门。
对于这个问题，真正的问题并不是在于使用 goto ，而在于 goto 的滥用；少数情况下， goto 还是组织控制流程的最佳手段。
尽管 goto 仍是 Java 中的一个保留字，但在语言中并未使用它； Java 没有 goto ，但是 Java 也能完成一些类似的跳转操作，这与 break 和 continue 这两个关键词有关。他们并不是真正的跳转，而是中断迭代语句的一种方法。之所以与 goto 一起讨论，是由于它们使用了相同的机制：标签。
标签是后面跟有冒号的标识符，类似下面：
label1：
break 和 continue 关键词通常只中断当前循环，但随同标签一起使用，它们就会中断循环，直到标签所在的地方：
label1:
outer-iteration{
inner-iteration{
//...
break; // ---1
//...
continue; // ---2
//...
continue label1; // ---3
//...
break label1; // ---4
}
}
1--- break 中断内部迭代，回到外部迭代。
2--- continue 使执行行点移回内部迭代的起始出。
3--- continue label1 同时中断内部迭代以及外部迭代，直接转到 label1 处； 它实际上是继续迭代过程， 但却从外部迭代开始。
4--- break labell 也会中断所有迭代，并回到 label1 处，但并不重新进入迭代。——它实际是完全终止了两个迭代。
下面是标签用于 for 循环的例子：
public class LabeledFor {
public static void main(String[] args){
int i = 0;
outer:
for(;true;){
inner:
for(; i < 10; i++){
System.out.println("i = " + i);
if(i == 2) {
System.out.println("continue");
continue;
}
if(i == 3){
System.out.println("break");
i++;
break;
}
if(i == 7){
System.out.println("continue outer");
i++;
continue outer;
}
if(i == 8){
System.out.println("break outer");
break outer;
}
for(int k = 0; k < 5; k++){
if(k == 3){
System.out.println("continue inner");
continue inner;
}
}
}
}
}
}
输出：
i = 0
continue inner
i = 1
continue inner
i = 2
continue
i = 3
break
i = 4
continue inner
i = 5
continue inner
i = 6
continue inner
i = 7
continue outer
i = 8
break outer
switch
switch 有时也被划归为一种选择语句。根据整数表达式的值， switch 语句可以从从一系列代码中选一段去执行。
格式如下：
switch(integral-selector){
case integral-value1: statement; break;
case integral-value2: statement; break;
case integral-value3: statement; break;
// ...
default: statement;
}
其中，Integral-selector (整数选择因子) 是一个能够产生整数值的表达式， switch 能将这个表达式的结果与每个 integral-value (整数值) 相比较。若发现相符的，就执行对应语句。若没有发现相符的，就执行 default （默认）语句。
在上面定义中，每个 case 均以一个 break 结尾，这样可使执行流程跳转至 switch 主体的末尾。这是构建 switch 语句的一种传统方式，但 break 是可选的。若省略 break， 会继续执行后面的 case 语句，直到遇到一个 break 为止。
下面这个例子可随机生成字母，并判断它们是元音还是铺音：
import java.util.*;
public class VowelsAndConsonants {
public static void main(String[] args){
Random rand = new Random();
for (int i = 0; i < 100; i++){
int c = rand.nextInt(26) + 'a';
System.out.print((char)c + ", " + c + ": ");
switch(c){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': System.out.println("vowel");
break;
case 'y':
case 'w': System.out.println("Sometimes a vowel");
break;
default: System.out.println("consonant");
}
}
}
}
输出：
f, 102: consonant
o, 111: vowel
j, 106: consonant
d, 100: consonant
k, 107: consonant
v, 118: consonant
n, 110: consonant
m, 109: consonant
o, 111: vowel
e, 101: vowel
m, 109: consonant
w, 119: Sometimes a vowel
m, 109: consonant
c, 99: consonant
p, 112: consonant
t, 116: consonant
e, 101: vowel
f, 102: consonant
n, 110: consonant
o, 111: vowel
b, 98: consonant
d, 100: consonant
b, 98: consonant
t, 116: consonant
s, 115: consonant
l, 108: consonant
w, 119: Sometimes a vowel
y, 121: Sometimes a vowel
s, 115: consonant
n, 110: consonant
g, 103: consonant
f, 102: consonant
m, 109: consonant
z, 122: consonant
b, 98: consonant
x, 120: consonant
l, 108: consonant
z, 122: consonant
s, 115: consonant
z, 122: consonant
o, 111: vowel
r, 114: consonant
k, 107: consonant
k, 107: consonant
r, 114: consonant
a, 97: vowel
e, 101: vowel
w, 119: Sometimes a vowel
i, 105: vowel
t, 116: consonant
m, 109: consonant
g, 103: consonant
z, 122: consonant
f, 102: consonant
h, 104: consonant
d, 100: consonant
x, 120: consonant
n, 110: consonant
z, 122: consonant
t, 116: consonant
e, 101: vowel
u, 117: vowel
w, 119: Sometimes a vowel
t, 116: consonant
b, 98: consonant
g, 103: consonant
s, 115: consonant
n, 110: consonant
g, 103: consonant
c, 99: consonant
g, 103: consonant
x, 120: consonant
f, 102: consonant
y, 121: Sometimes a vowel
h, 104: consonant
w, 119: Sometimes a vowel
c, 99: consonant
c, 99: consonant
i, 105: vowel
k, 107: consonant
k, 107: consonant
e, 101: vowel
l, 108: consonant
i, 105: vowel
l, 108: consonant
u, 117: vowel
c, 99: consonant
x, 120: consonant
r, 114: consonant
j, 106: consonant
u, 117: vowel
n, 110: consonant
x, 120: consonant
g, 103: consonant
v, 118: consonant
t, 116: consonant
c, 99: consonant
d, 100: consonant
a, 97: vowel
f, 102: consonant
woc 按错键 发帖了{:10_266:} 本帖最后由 回忆一遥远 于 2017-7-9 14:37 编辑
woc 做笔记好废时间啊， 就当这个是最后一次吧.... {:10_282:}
页:
[1]