java系統化基礎-day02-運算符、選擇結構、循環結構

1.java中的運算符

  1 package com.wfd360.day02;
  2 
  3 
  4 import org.junit.Test;
  5 
  6 import java.math.BigInteger;
  7 
  8 /**
  9  * 1.算術運算符[掌握]
 10  * <p>
 11  * 2.自增自減[掌握]
 12  * <p>
 13  * 3.賦值運算[掌握]
 14  * <p>
 15  * 4.比較運算符[掌握]
 16  * <p>
 17  * 5.邏輯運算符[掌握]
 18  * <p>
 19  * 6.位運算符[瞭解]
 20  * <p>
 21  * 7.三目運算符[掌握]
 22  */
 23 
 24 public class Demo01 {
 25     /**
 26      * 1.算術運算符[掌握]
 27      * 1)加法(+) 加法   正號  字符串拼接
 28      * 2)減法(-) 減法 負號
 29      * 3)乘法 (*) 乘法
 30      * 4)除法(/) 除法
 31      * 整數(小數)相除的例子
 32      * 10/3 =3;  10.0/3=3.33333…
 33      * 0/0
 34      * 0.0/0.0
 35      * 結果是NaN ,任何的NaN都不等於本身(面試題)
 36      * 1.0/0.0
 37      * Infinity,表示無窮大
 38      */
 39     @Test
 40     public void test() {
 41         int i1 = 3 + 2 - 5 * 6;
 42         int i2 = 10 / 3;  // 3
 43         // 3.0 表明整數相除,將運算結果,轉變爲double
 44         double d1 = 10 / 3;
 45         System.out.println("d1=" + d1);
 46         //double d2 = 10 / 3.0; // 3.3333333333333335
 47         double d2 = 10.0 / 3; // 3.3333333333333335
 48         System.out.println("d2=" + d2);
 49         // 0/0  報錯  java.lang.ArithmeticException: / by zero
 50         //int i3=0/0;
 51         // System.out.println("i3="+i3);
 52         //  結果是NaN ,任何的NaN都不等於本身(面試題)
 53         double d3 = 0.0 / 0;
 54         System.out.println(" d3=" + d3);
 55         double d4 = 1.0 / 0; // Infinity,表示無窮大
 56         System.out.println(" d4=" + d4);
 57     }
 58 
 59     /**
 60      * 取模(%) , 取餘數
 61      * 案例:假設大學的一個寢室能夠住6我的,那麼計算1024個大學生一共須要多少個寢室? (本質就是生產中常常用到的分頁算法)
 62      */
 63     @Test
 64     public void test2() {
 65         int n = 6;
 66         int m = 1024;
 67         //取餘數
 68         int y = m % n;
 69         System.out.println("y=" + y);
 70         //=====================
 71         //若是餘數爲零那麼,一共須要的寢室數=m/n;
 72         //若是餘數 不 爲零那麼,一共須要的寢室數=(m/n)+1;
 73     }
 74 
 75     /**
 76      * 2. 自增自減[掌握]
 77      * ++(自增)     --(自減)
 78      * 自增自減只可以用於 變量,不能用於常量
 79      * 自增自減運算的優先級  比  算術運算符  高
 80      */
 81     @Test
 82     public void test3() {
 83         //===========基本使用==================
 84         int i = 3;  // 表示把3賦值給變量i
 85         i++;      //表示變量i的值加1,i的值變成4
 86         ++i;      //表示變量i的值加 1,i的值變成5
 87         System.out.println("i=" + i);
 88     }
 89 
 90     /**
 91      * 面試題1
 92      */
 93     @Test
 94     public void test4() {
 95         int i = 3;
 96         int j = i++;  // 先複製,在運輸算
 97         // i等於多少,j等於多少?
 98         System.out.println("i=" + i);// 4
 99         System.out.println("j=" + j);// 3
100     }
101 
102     /**
103      * 面試題2
104      */
105     @Test
106     public void test5() {
107         int i = 3;
108         int j = ++i;  // 先運算,在賦值
109         // i等於多少,j等於多少?
110         System.out.println("i=" + i);// 4
111         System.out.println("j=" + j);// 4
112     }
113 
114     /**
115      * 面試題3
116      */
117     @Test
118     public void test6() {
119         int i = 3;
120         i = ++i;  // 先運算,在賦值
121         // i等於多少,j等於多少?
122         System.out.println("i=" + i); // 4
123         int j = 3;
124         j = j++;
125         System.out.println("j=" + j); // 3
126     }
127 
128     /**
129      * 面試題3
130      * 破題關鍵點:
131      * i++是先賦值在執行 自增
132      * ++i 是先執行自增 在賦值
133      */
134     @Test
135     public void test7() {
136         int i = 3;
137         //      3(4)  4(5)  5(6)
138         int a = i++ + i++ + i++;
139         //      7      8     9
140         int b = ++i + ++i + ++i;
141         //請問 a=?  b=? i=?
142         System.out.println("a=" + a);
143         System.out.println("b=" + b);
144         System.out.println("i=" + i);
145     }
146 
147     /**
148      * 3. 賦值運算[簡單,與平時的數學邏輯同樣]
149      * =    +=     -=     *=     /=    %=
150      * 1)賦值符號的運算順序?
151      * 從右到左,把符號右邊的值賦值到左邊的變量中
152      * 2)上面 後五個分別當作是一個總體: 例如 += 當作是一個符號,不要當作兩個;
153      */
154     @Test
155     public void test8() {
156         //請先在每行的後面給出i的值,而後用斷點觀察i值得變換
157         int i = 3;
158         i += 2;// 表示把2 累加到變量 i 中
159         i -= 1; // 表示把-1 累加到變量 i 中
160         i *= 3; // 等價  i=i*3;   劃重點:等價不是等於
161         i /= 3; // 等價  i=i/3;
162         i %= 3;  // 等價 i=i%3;
163         System.out.println("i=" + i);
164     }
165 
166     /**
167      * 超級面試題
168      */
169     @Test
170     public void test9() {
171         short s = 3;
172         s += 2; //正常
173         System.out.println("s=" + s);
174         //===========================
175         short s2 = 3;
176         // 語法錯誤,結果值是int,int不能自動轉換爲short
177         // s2 = s2+2;
178     }
179 
180     /**
181      * 4.比較運算符[掌握]
182      * ==    !=     >    <    >=    <=    instanceof
183      * 規律:比較運算的結果是一個布爾類型的值(true 或false);
184      * 舉例:
185      * 定義一個布爾表達式,打印輸出
186      * 特別說明:instanceof 是判斷一個對象是否屬於某種類型
187      * 是否能夠用於咱們以前學習的基本數據類型
188      */
189     @Test
190     public void test10() {
191         System.out.println(1 == 2); //false
192         System.out.println(1 <= 2); //true
193         // instanceof
194         //是否能夠用於咱們以前學習的基本數據類型  ==> 不能夠
195         // System.out.println( 1 instanceof int);
196         System.out.println("愛老虎油" instanceof String); // true
197     }
198 
199     /**
200      * 5.邏輯運算符[掌握]
201      * &    |     &&     ||   ^    !
202      * 是應用於多個條件的組合判斷。
203      * 示例說明:
204      * 例如小明參加2個學科的考試 java php
205      * 1)java 和 php 同時考100分,獎勵 歐洲十日遊
206      * 僞代碼描述:java==100 而且 php==100
207      * 2)java 和php,只要有一門考100分,獎勵 獎勵棒棒糖一個
208      * 僞代碼描述:java==100 或者 php==100
209      * <p>
210      * 邏輯運算的兩邊結果值都必須是什麼類型?  布爾
211      * <p>
212      * &   :兩邊都爲true ,結果爲true
213      * |    : 只要有一邊爲true,結果爲true
214      * && :   兩邊都爲true ,結果爲true
215      * ||    : 只要有一邊爲true,結果爲true
216      * ^    : 兩邊不同,結果爲true ,不然爲false,舉個例子打印一下
217      * !  : 邏輯非,舉個例子打印一下
218      */
219     @Test
220     public void test11() {
221         int java = 100;
222         int php = 100;
223         int c = 90;
224         int mysql = 80;
225         // ||    : 只要有一邊爲true,結果爲true
226         System.out.println(java == 100 || php == 100); //true
227         System.out.println(java == 100 || c == 100); //true
228         System.out.println(mysql == 100 || c == 100); //false
229         // && 兩邊都爲true ,結果爲true
230         System.out.println(java == 100 && php == 100); //true
231         System.out.println(java == 100 && c == 100); //false
232         // 邏輯非
233         System.out.println(java != 100); //false
234         System.out.println(c != 100); // true
235 
236         // ^    : 兩邊不同,結果爲true ,不然爲false,舉個例子打印一下 (用的不多)
237         System.out.println(java == 100 ^ php == 100); //false
238         System.out.println(mysql == 100 ^ c == 100); //false
239         System.out.println(java == 100 ^ c == 100); //true
240     }
241 
242     /**
243      * &&  ||   和   & |    區別?
244      * 1) & | 既能夠充當邏輯運算,也能夠是位運算符,怎麼區分是邏輯運算仍是位運算?
245      * 根據表達式的結果是否爲 布爾類型 來判斷
246      * 2)雙與  雙或  具備短路行爲  什麼意思?
247      * 舉個例子 上面小明的考試的成績 要求是兩科都爲100分,看到第一科低於100分以後沒有必要再看第二科成績
248      * 代碼表示:Java = 100  && php = 100   (java只考了5分)
249      * 若是邏輯運算左邊的值可以肯定整個邏輯運算表達式的值,那麼右邊就不執行了,短路了。
250      * && 什麼時候短路 ?    左邊表達式結果爲false
251      * ||  什麼時候短路 ?    左邊表達式結果爲true
252      * 思考:如何驗證短路行爲?
253      * 提示:
254      * 右邊表達式用  自增自減,例如 ++i = 5
255      * 或者使用一個編譯正常,運行報錯的表達式,例如 1/0
256      */
257     @Test
258     public void test12() {
259         int java = 5;
260         int php = 100;
261 
262         // 區分 && 與 &
263         System.out.println(java == 100 && (++php) == 100); // php=100  &&具備短路行爲,左邊爲false時,不在執行右邊
264         System.out.println(java == 100 & (++php) == 100); // php=101
265 
266         php = 100;
267         // 區分 || 與 |
268         System.out.println(php == 100 || (++java) == 100); // java=5  ||具備短路行爲,左邊爲true時,不在執行右邊
269         System.out.println(php == 100 | (++java) == 100); // java=6
270         System.out.println("java=" + java + " php=" + php);
271     }
272 
273     /**
274      * 面試錯誤題
275      * 例如:判斷一個整數的變量 a裏面的數據  在0-100之間
276      * 正確寫法: a>0   &&  a<100
277      * 錯誤寫法:   0<  a < 100  (java沒有這種語法,不支持)
278      */
279     @Test
280     public void test13() {
281         int a = 10;
282         System.out.println(a > 0 && a < 100);
283 
284         //System.out.println(0 < a < 100); 錯誤
285     }
286 
287     /**
288      * 十進制轉成二進制
289      * String s = Integer.toBinaryString(n)  //將十進制數轉成字符串,例如n=5 ,s = "101"
290      * <p>
291      * 將字符串轉成整形
292      * int a = Integer.valueof("1002");  //固然s只能是數字類的字符串
293      */
294     @Test
295     public void test14() {
296         //十進制轉成二進制
297         String s = Integer.toBinaryString(5);
298         System.out.println("s=" + s);
299         //二進制轉變爲十進制
300         BigInteger bi = new BigInteger("011", 2);    //轉換爲BigInteger類型
301         int a = Integer.parseInt(bi.toString());
302         System.out.println("a=" + a);
303     }
304 
305     /**
306      * 6.位運算符[瞭解]
307      * &    |    ^     ~    <<      >>     >>>
308      * 位運算就是 二進制的位進行運算。
309      * 示例:好比計算 125+176 ,從數學的角度是怎麼計算的?
310      * 同理,位運算也相似,好比 3&4
311      * <p>
312      * 能夠把1當作是true,把0當作是false
313      * &  :與 位運算,兩邊爲1,結果爲1
314      * |   :或 位運算,有一個爲1,結果爲1
315      * ^  :  異或,兩邊不同,就爲1,不然爲0
316      * ~  :  取反,1變成0  ,0 變成1
317      * << :  向左位移動,例如1<<3
318      * >> :   向右位移動,例如8>>2
319      * >>>:  無符號向右移動
320      * <p>
321      * 注意:
322      * 正數的補碼,反碼,原碼 都同樣;
323      * 負數的反碼:符號爲不變,其餘位取反;
324      * 負數的補碼:它的反碼+1;
325      */
326     @Test
327     public void test15() {
328         // &  :與 位運算,兩邊爲1,結果爲1
329         System.out.println(20 & 30); //獲得的是十進制數
330         System.out.println("20的二進制:" + Integer.toBinaryString(20));
331         System.out.println("           &");
332         System.out.println("30的二進制:" + Integer.toBinaryString(30));
333         System.out.println("----------------------------------------");
334         System.out.println("            " + Integer.toBinaryString(20 & 30));
335     }
336 
337     @Test
338     public void test16() {
339         // |   :或 位運算,有一個爲1,結果爲1
340         System.out.println(20 | 30); //獲得的是十進制數
341         System.out.println("20的二進制:" + Integer.toBinaryString(20));
342         System.out.println("           |");
343         System.out.println("30的二進制:" + Integer.toBinaryString(30));
344         System.out.println("----------------------------------------");
345         System.out.println("            " + Integer.toBinaryString(20 | 30));
346     }
347 
348     @Test
349     public void test17() {
350         //<< :  向左位移動,例如1<<3  , 左位易的本質運算是,假設 a<<b ,至關於數學中的運算 a乘以2的b次方
351         System.out.println(2 << 3); //獲得的是十進制數
352         System.out.println("2的二進制:000" + Integer.toBinaryString(2));
353         System.out.println("           <<3");
354         System.out.println("----------------------------------------");
355         System.out.println("           " + Integer.toBinaryString(2 << 3));
356     }
357 
358     /**
359      * 注意:
360      * 正數的補碼,反碼,原碼 都同樣;
361      * 負數的反碼:符號爲不變,其餘位取反;
362      * 負數的補碼:它的反碼+1;
363      */
364     @Test
365     public void test18() {
366         //~  :  取反,1變成0  ,0 變成1
367         System.out.println(~(-5)); //獲得的是十進制數
368         System.out.println("原碼:00000000000000000000000000000" + Integer.toBinaryString(5));
369         System.out.println("反碼:" + Integer.toBinaryString(-5));
370         System.out.println("補碼:00000000000000000000000000000" + Integer.toBinaryString(~(-5)));
371     }
372 
373     /**
374      * 7.三目運算符[掌握]
375      * 語法格式: X ? Y : Z
376      * 1)上面的三目運算總體當作是一個表達式,應該有一個結果值
377      * 2)X ?  布爾類型的值或者結果爲布爾類型的表達式
378      * 3)Y  Z  ? 通常來講數據類型相同的值或者表達式
379      * 4)運算的規則?
380      * X 爲true,就是 Y 的結果值 ( 冒號前面的表達式的值)
381      * X爲false,就是Z的結果值 ( 冒號後面的表達式的值)
382      * x ? y : z
383      * <p>
384      * 注意:  不要受  ? 和    :  的干擾,它們只是一個固定語法格式而已
385      */
386     @Test
387     public void test19() {
388         //舉例:找出兩個整型變量中的最大值
389         int a = 6;
390         int b = 7;
391         int c = a > b ? a : b;
392         System.out.println("c=" + c);
393         //舉例 判斷一個數是 奇數 仍是 偶數
394         int i = 9;
395         System.out.println(i % 2 == 0 ? "偶數" : "奇數");
396     }
397 
398 }
View Code

2.條件選擇結構-if

  1 package com.wfd360.day02;
  2 
  3 
  4 import org.junit.Test;
  5 
  6 public class Demo02If {
  7     /**
  8      * if(判斷條件){
  9      * 知足 判斷條件(true),就執行此大括號裏面的內容
 10      * }
 11      */
 12     @Test
 13     public void test1() {
 14         //案例:若是a>90,輸出:優秀
 15         int a = 96;
 16         if (a > 90) {
 17             System.out.println("優秀");
 18         }
 19     }
 20 
 21     /**
 22      * if(判斷條件A){
 23      * 知足 判斷條件A(true),就執行此大括號裏面的內容,後面的else不會執行
 24      * }else{
 25      * 前面的 判斷條件A(false),執行else大括號裏面的內容
 26      * }
 27      */
 28     @Test
 29     public void test2() {
 30         //案例:若是a>90,輸出:優秀,不然輸出:通常
 31         int a = 96;
 32         if (a > 90) {
 33             System.out.println("優秀");
 34         } else {
 35             System.out.println("通常");
 36         }
 37     }
 38 
 39     /**
 40      * if(判斷條件A){
 41      * 知足 判斷條件A(true),就執行此大括號裏面的內容,後面的else-if不執行
 42      * }else if(判斷條件B){
 43      * 知足 判斷條件B(true),就執行此大括號裏面的內容
 44      * }
 45      */
 46     @Test
 47     public void test3() {
 48         //案例:若是a>90,輸出:優秀
 49         // 若是80<a<=90 ,輸出: 良好
 50         int a = 96;
 51         if (a > 90) {
 52             System.out.println("優秀");
 53         } else if (a > 80) {
 54             System.out.println("良好");
 55         }
 56     }
 57 
 58     /**
 59      * if(判斷條件A){
 60      * 知足 判斷條件A(true),就執行此大括號裏面的內容,後面的else-if不執行
 61      * }else if(判斷條件B){
 62      * 知足 判斷條件B(true),就執行此大括號裏面的內容
 63      * }else{
 64      * 前面的if  esle-if 都不知足條件(false),執行此大括號裏面的內容
 65      * }
 66      */
 67     @Test
 68     public void test4() {
 69         //案例:若是a>90,輸出:優秀
 70         // 若是80<a<=90 ,輸出: 良好
 71         // 不然,輸出通常
 72         int a = 96;
 73         if (a > 90) {
 74             System.out.println("優秀");
 75         } else if (a > 80) {
 76             System.out.println("良好");
 77         } else {
 78             System.out.println("通常");
 79         }
 80     }
 81 
 82     /**
 83      * else if 能夠有多個
 84      */
 85     @Test
 86     public void test5() {
 87         //案例:若是a>90,輸出:優秀
 88         // 若是80<a<=90 ,輸出: 良好
 89         // 若是70<a<=80, 輸出: 合格
 90         // 不然,輸出通常
 91         int a = 96;
 92         if (a > 90) {
 93             System.out.println("優秀");
 94         } else if (a > 80) {
 95             System.out.println("良好");
 96         } else if (a > 70) {
 97             System.out.println("合格");
 98         } else {
 99             System.out.println("通常");
100         }
101     }
102 
103     /**
104      * 簡寫
105      * if 後面的大括號若是不寫,表示執行是後面的第一行代碼(不建議這樣寫)
106      */
107     @Test
108     public void test6() {
109         //案例:若是a>90,輸出:優秀
110         int a = 96;
111         if (a > 90)
112             System.out.println("優秀");
113     }
114 
115     /**
116      * 練習(學編程有捷徑,那就是多敲,瘋狂的敲代碼,不管是簡單的仍是複雜的代碼)
117      * 1.求出2個變量中的最大值
118      * 2.判斷一個數是不是3的倍數
119      * 3.小明java 考試成績  按等級分   A B C  D ,判斷變量值在不一樣的範圍的,打印輸出不一樣的等級
120      * 90~100 A等。
121      * 80-89 B等。
122      * 70-79 C等。
123      * 60-69 D等。
124      * 60如下E等。
125      */
126     @Test
127     public void test7() {
128         //本身動手寫,寫完以後給老師檢查
129     }
130 }
View Code

 

3.條件選擇結構-switch 

 1 package com.wfd360.day02;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 條件選擇結構-switch
 7  * 做用和if差很少,只是語法結構不一致而已。
 8  * <p>
 9  * <p>
10  * switch(變量或者一個表達式){
11  * case 變量的可能值1: 功能語句;break;
12  * case 變量的可能值2: 功能語句;break;
13  * case 變量的可能值3: 功能語句;break;
14  * ........
15  * default:功能語句;break;
16  * }
17  */
18 public class Demo03Switch {
19     /**
20      * 案例:將數字1,2,3....7 輸出對應的星期:週一,週二,週三,.....週末
21      */
22     @Test
23     public void test1() {
24         int week = 5;
25         switch (week) {
26             case 1:
27                 System.out.println("週一");
28                 break;
29             case 2:
30                 System.out.println("週二");
31                 break;
32             case 3:
33                 System.out.println("週三");
34                 break;
35             case 4:
36                 System.out.println("週四");
37                 break;
38             case 5:
39                 System.out.println("週五");
40                 break;
41             case 6:
42                 System.out.println("週六");
43                 break;
44             case 7:
45                 System.out.println("周天");
46                 break;
47             default:
48                 System.out.println("沒有對應數字的星期");
49         }
50     }
51 
52     /**
53      * 1) case的順序(包括default) 能夠是任意的,可是建議先按照case的值的大小順序排列,default放最後
54      * 2)執行順序,是先依次找完全部的case,若是都不匹配纔會執行default
55      * 3) break的做用,結束當前的這個switch結構
56      * 從第一個匹配的條件開始,到第一個break之間的全部case判斷失效 (這個特色很是重要,結合下面的例子理解)
57      * 在執行功能語句時,若是到末尾都沒有break,自動結束,不會再循環回去。
58      * 最後一個break 能夠省略掉,可是建議仍是寫上
59      * 4) case後面的值應該和變量的類型一致;
60      * 5) switch中的()中的變量地方類型能夠是哪些?
61      * java5以前   :  byte short char int
62      * java5支持   :   enum枚舉  (面向對象部分學習了以後回頭測試)
63      * java7支持   :  String 類型
64      */
65     @Test
66     public void test2() {
67         //根據月份,輸出春夏秋冬 ,從第一個匹配的條件開始,到第一個break之間的全部case判斷失效 (這個特色很是重要,結合例子理解)
68         int month = 2;
69         switch (month) {
70             case 1:
71             case 2:
72             case 3:
73                 System.out.println("春天");
74                 break;
75             case 4:
76             case 5:
77             case 6:
78                 System.out.println("夏天");
79                 break;
80             case 7:
81             case 8:
82 
83             case 9:
84                 System.out.println("秋天");
85                 break;
86             case 10:
87             case 11:
88             case 12:
89                 System.out.println("冬天");
90                 break;
91             default:
92                 System.out.println("月份數字錯誤");
93                 break;
94         }
95     }
96 }
View Code

 

4.java中的循環結構-while

  1 package com.wfd360.day02;
  2 
  3 import org.junit.Test;
  4 
  5 /**
  6  * Java中提供了3  種循環
  7  * while  do-while  for
  8  * 1.上面的3中循環功能都是同樣的,只是語法結構不同,不少時候是能夠相互交換的
  9  * , 既然都差很少,爲何有多個呢?
 10  * 不一樣的循環結構,有不一樣的使用場景和優點
 11  * <p>
 12  * 2.在寫循環代碼以前呢?
 13  * 1)要作什麼事情
 14  * 2)次數
 15  * 3)要寫循環,必須知道循環的語法
 16  */
 17 public class Demo04While_循環 {
 18     /**
 19      * while 基本用法[掌握]
 20      * 語法格式:
 21      * while(條件(布爾類型的)){
 22      * // 循環體具體作什麼事情
 23      * }
 24      * <p>
 25      * 執行流程
 26      * 1.一個循環可能會循環執行屢次
 27      * 第一次判斷條件true,繼續執行
 28      * 第二次判斷條件true,繼續執行
 29      * 第三次判斷條件true,繼續執行
 30      * 。。。。。
 31      * 直到第n次判斷條件false,終止循環
 32      * <p>
 33      * 爲何第一次 第二次是true 。。。 n次就是false?
 34      */
 35 
 36     /**
 37      * 條件能夠是一個常量
 38      * 舉個例子(條件爲布爾值true)
 39      * <p>
 40      * 這個例子是死循環,當心電腦崩潰,啓動後建議立刻手動中止
 41      */
 42     @Test
 43     public void test1() {
 44         while (true) {
 45             System.out.println("------死循環中-------");
 46         }
 47     }
 48 
 49     /**
 50      * 通常咱們使用一個變量來充當條件循環,
 51      * 舉個例子:播放一首歌,循環播放10次
 52      * 1)定義一個整數的變量記錄循環的次數
 53      * 2)循環一次,自增一次
 54      * 根據次數進行判斷是否繼續循環
 55      */
 56     @Test
 57     public void test2() {
 58         int i = 1;// 1. 初始值
 59         while (i <= 10) {// 2. i<==10 循環條件
 60             System.out.println("北京歡迎你----" + i);
 61             i++; //變化量,很重要,不然就是死循環
 62         }
 63     }
 64 
 65     /**
 66      * 寫一段代碼計算1-10的和。
 67      * 1)傳統的作法
 68      * 1+2+3+4+5+6+7+8+9+10
 69      * 若是要求計算1-100 , 1-1000 這樣寫是否合理?
 70      * 能夠動態的得到每個加數
 71      * 2)使用while循環,每循環一次,把取到的加數累加起來
 72      * 3)在循環的外面定義一個變量用來放計算的和的值
 73      */
 74     @Test
 75     public void test3() {
 76         //案例:計算 1 +2+3...10
 77         int n = 1;
 78         int sum = 0;
 79         while (n <= 10) {
 80             sum += n;
 81             n++;
 82         }
 83         System.out.println("sum=" + sum);
 84     }
 85 
 86     /**
 87      * 練習:
 88      * 1.求出10之內2的倍數的數字 和 個數。
 89      */
 90     @Test
 91     public void test4() {
 92 
 93     }
 94 
 95     /**
 96      * 練習:
 97      * 2.求出 1-10的全部偶數的和
 98      */
 99     @Test
100     public void test5() {
101 
102     }
103 
104     /**
105      * do-while 基本用法[掌握]
106      * do-while    先執行一次,再判斷  (*****)
107      * 語法格式:
108      * do{
109      * // 循環體
110      * }while(條件);
111      * <p>
112      * 舉例:循環10次
113      * 和while區別?
114      * 1)定義一個 布爾變量,默認值false
115      * 2)將這個布爾變量放在 while  和 do-while 條件中,看有什麼區別
116      */
117     @Test
118     public void test6() {
119         boolean b = false;
120         System.out.println("-----執行while以前--------");
121         while (b) {
122             System.out.println("------正在執行while------------");
123         }
124         System.out.println("-----執行while以後--------");
125 
126         System.out.println("-----執行do-while以前--------");
127         do {
128             System.out.println("------正在執行do-while------------");
129         } while (b);
130         System.out.println("-----執行do-while以後--------");
131     }
132 
133     /**
134      * 案例:使用do-while  求出1-100的和
135      */
136     @Test
137     public void test() {
138 
139     }
140 }
View Code

 

5.java中的循環結構-for

  

相關文章
相關標籤/搜索