1 Java的環境配置 day01
2
3 1. 環境配置有如下的三種方法：
4 a) 我的電腦屬性： 從path 環境中配置
5 b) 利用臨時的變量設置： set path = java的所在路徑\bin%d%
6 c) 定義批處理文件 ： 設置步驟如下：
7 a) set path = %cd%\H:\java\jdk1.7\bin
8 b)
9 c) start
10
11 一． java的環境搭配
12 1. 安裝jdk >1.jdk是java的開發和運行環境 >2.jre是java的運行環境
13 2. 配置環境變量?為什么呢?方便在任意的目錄下使用java工具
14 a. 我的電腦—屬性—高級—環境變量
15 在已有的環境變量path的基礎下，添加一個jdk\bin目錄即可.
16 這種方法較為一勞永逸
17 技巧：為了日后修改方便，不需要總是修改path，可以首先定義一個環境變量 JAVA_HOME 把前面的路徑保存下來.并且通過%JAVA_HOME%來動態的獲取該變量
18 b. 也可以通過臨時環境變量，通過dos控制臺，使用set命令即可。
19 set path = (java的按照目錄)jdk\bin;&path&;
20
21 c. 如果是在別人的電腦去完成java開發，還不想配置java環境變量.咱們可以使用批處理來完成：
22 a) 假設： a.bat
23 b) set path = %cd%jdk\bin;%path% %cd%代表獲取當前目錄.
24 c) 為了避免了不讓它一閃而過：start.
25
26 二：轉義字符
27 1.\n：換行
28 2.\t：tab鍵
29 3.\b:退格鍵
30
31
32 三： 數據運算符
33
34 & : 只有兩邊都為true結果為true，否則為false。
35 |：只有兩邊為flase才為false,否則都為true
36 ^ : 只有兩邊相同 結果為false，否則為true。
37
38
39
40 Java基礎知識 day02
41
42 二．變量：
43 在內存中所開辟的空間將常量值進行存儲、方便運算。
44 好處：該空間可以重復使用..
45 定義格式：
46 數據類型 變量名 = 初始值
47 使用變量的注意事項：
48 1. 變量有自己的作用域
49 2. 變量不能賦空值.
50
51 基本數據類型：
52 byte int long char short double boolean float
53 引用數據類型：
54 接口 類 數組
55
56 什么時候需要定義變量：
57 當數據不確定時,或者運算后的結果需要進行下一步的操作
58 這時候就要定義一個變量將該不確定的數據進行存儲。
59
60 三.運算符：
61 1. 算術運算符：
62 1. +：連接符
63 2. %取余： 任何數%2 結構非零急一
64 3. ++自增 (++a先運算后賦值 a++先賦值后運算)
65 2. 賦值運算符：
66 1. int a,b;
67 2. a=b=c = 4;
68 3. i+=4; i=i+4;
69
70 3．比較運算符：
71 特點：運算后結構非false 或true
72 == 相等于
73
74 4.邏輯運算符
75 & | ^ 這些運算符不僅僅可以代表boolean表達式，也可以進行位運算。
76 &和&&：當左邊為false時，&：兩邊的表達式都參與運算。&&右邊的表達式不參與運算。
77 |和||：當左邊為true時，|：兩邊的表達式都參與運算。||右邊的表達式不參與運算。
78 ^:兩邊一樣結果為false。
79
80 5．位運算符
81 左移：<< 3<<2=12 3<<4 = 48
82 右移：>> 和 >>> 區別：
83 >>:右移后，空位按照移位前的最高位來填充。最高位為0，用0補。最高位為1用1來補
84 >>>:無符號右移,無論最高位是什么，都用0補。
85
86 6.負數的由來：取反+1
87 -6: 00000000 00000000 00000000 00000110
88 取反： 11111111 11111111 11111111 11111001
89 加一： 11111111 11111111 11111111 11111010
90
91
92 四.語句
93
94 判斷：if
95 1. if(條件表達式){}
96 2. if(條件表達式){}else{};
97 3. if(條件表達式){}else{}
98
99 對于第二種格式：簡化形式，三元運算符
100 變量 =(條件表達式)? 表達式1 ：表達式2
101 簡化形式與非簡化形式有如果不同：
102 解答： 簡化形式因為是一個運算，所以咱們必須要有一個結果。
103
104 if(x >１)
105 Y = 100;
106 else
107 Y = 200;
108 Y =(x>1)? 100: 200;
109 注意：無論條件表達式有多復雜，只要有true ||flase 出現，則沒問題.否則條件表達式會出錯：if(x =1);
110
111 選擇:switch(表達式)
112
113 switch(表達式)
114 {
115 case 1:
116 執行語句;
117 break;
118 case 2:
119 執行語句;
120 break;
121 case 3:
122 執行語句;
123 break;
124 default;
125 執行語句;
126 }
127
128 特點：
129 1.表達式運算四種類型的值:byet int short char(它有一個自動型轉換過程)
130 2.case和default之間是可以沒有任何的順序，但是在運算期間，肯定會先讀取第一個case ,當case不匹配，會繼續執行其他的case。當所有的case不匹配的時候.會運行default。
131 3.switch語句結束的兩個方式：a.讀取switch語句大括號結束b.碰到break語句結束.注意:如果沒有碰到break，也沒有讀取結束的時候，那么程序是一直往下面運行，直到程序運算完畢
132
133
134
135 循環：while du{}while; for
136
137 1. while(表達式){執行語句}(先判斷后執行)
138 2. do{執行語句}while(條件表達式);(先執行一次,再判斷)
139 3. for(初始化表達式;循環判斷條件;循環后的操作表達式){}
140
141 什么時候用這些語句呢?
142 當對固定的幾個值進行判斷的時候，建議使用switch
143 當對范圍的判斷，或者對運算后的真假進行判斷的時候,我們需要用到if
144
145 當需要執行語句多次的時候.我們使用到循環
146 while與for循環是可以相互交換
147 因為作用域的關系：
148 在使用兩個語句的時候有些區分，如果定義變量只為循環存在，循環結束后就沒有意義。我們使用到for循環語句。
149 如果變量在循環后再執行別的運算，那么我們使用while比較好~
150
151 break：選擇結構和循環結構
152 continue：循環結果：結束本次循環.繼續下一次循環
153
154 函數：
155 特點：
156 --類中的一個獨立小程序
157 --只有被調用的時候才會運算
158 --可以重復的去運行
159 好處：
160 對代碼進行封裝,可以提高代碼的復用性
161 格式：
162 返回值類型 函數名(參數類型 形式參數1)
163 {
164 執行語句;
165 return 返回值;
166 }
167
168 如果定義一個函數？
169 1. 明確該功能函數運算后的結果。（明確返回值類型）
170 2. 明確該功能實現的過程，是否需要有未知值參與運算（明確函數的參數類型）
171 要定義一個加法運算功能
172
173 int getSum(int x ,int y)
174 {
175 return x + y;
176 }
177
178 方法的重載：@overload(標記重載)
179 特點：當多個函數的功能一致，只是參與運算不同的時候，為了提高代碼的可閱讀性,我們可以使用方法的重載.用參數來進行區分.
180 int getSum(int x,int y,int z)
181 {
182 return x + y + z;
183 }
184
185 函數的特點：
186 有一種情況，函數執行一個功能，但沒有具體的返回值。返回值類型不可以具體的來確定的時候,那么我們用void關鍵字來表示.那么函數的return 語句是可以忽略不寫的. 也可以:return ;
187
188
189 day03 數組
190
191 五.數組： 其實就是同類型的一組數字
192
193 同一種類型數據的集合，類型一定要一致。
194
195 內存圖：
196 java劃分了兩片內存，方便了運算
197
198 棧內存：存放局部變量，函數上和函數定義的變量都是局部變量
199 變量一點使用完畢,自動清空。
200 棧內存： new關鍵字所建立的,都稱為實例.在堆內存里面存放的.
201
202
203 數組常見的如下問題：
204 角標越界異常:使用到數組中不存在的角標。
205 (ArrayIndexOutOfBoundsException) 數組特有異常
206
207 空指針異常：引用型變量等于null，也就是沒有指向。
208 （NullPointsException）
209 ########
210 本身就是一個容器，用來存儲數據.
211 特點：固定的長度.
212 好處：給元素進行編號，從零開始。同時也可以length屬性獲取數組的長度.
213
214 什么時候使用數組？
215 當數據較多的時候，通常是為了方便操作這些數據都需要進行臨時存儲.
216
217 習慣：
218 通常操作數組都需要遍歷，獲取數組中的元素需要一個指針。
219 通常對指針的值的改變也就是更改了數組里邊的值啦~~
220
221
222
223 選擇排序：
224 int[]arr = {1,2,45,657,33,214,64,16,32,13};
225
226 for(int i = 0;i<arr.length;i++)
227 {
228 for(int j = i+1;j<arr.length;j++)
229 {
230 if(arr[j]>arr[i])
231 {
232 swap(arr,j,i);
233 }
234 }
235 }
236
237 冒泡排序： bubbleSort
238
239 public static int[] bubbleSort(int[]arr)
240 {
241 for(int i = 0;i<arr.length;i++)
242 {
243 for(int j = 0;j<arr.length-i-1;j++)
244 {
245 if(arr[j]>arr[j+1])
246 {
247 swap(arr,j,j+1);
248 }
249 }
250 }
251 return arr;
252
253
254 day 04 面向對象
255 面向對象：
256 1. 符合現實中人民思考習慣的一種思想.
257 2. 它將程序員的角色（執行者）轉換成（指揮者）
258 3. 將復雜的問題簡單化.
259
260 對象無處不在,一切皆對象
261
262 對象是實實在在存在的個體,那么我們需要使用計算機語言來進行描述
263 在java當中，描述事物是通過類來完成,在計算機中是通過new 類來創建對象.并且指揮對象完成事情.
264
265 例如： 制造汽車，通過汽車來描述：圖紙。對應的java中的類class
266 通過圖紙來產生汽車： 對象，對應的就是java在堆內存中所產生的實例
267
268 通過java語言編寫程序，其實就是不斷的定義類,創建對象的一個過程。
269 成員變量（事物的屬性） 成員方法(事物的行為)。
270
271 對象的存在有什么好處？或者說怎么才叫做對象?
272 對象可以用于封裝數據.可以在對象中定義屬性和行為,并指揮.
273
274 在編寫程序中，當要完成某個功能的時候,先看一下java是否提供了自有的對象.如果有,那么可以直接的去使用這個對象里面的功能.否則如果該對象不存在.那么我們需要定義一個對象，并將需要的功能封裝到該對象中,以便對象的重復使用.。
275
276 對象是如何使用呢?
277 通過new 關鍵字來建立，并且通過 對象.成員變量 的形式操作對象所做的事情..
278
279
280 匿名對象：
281 其實就是一個沒有名字的對象,可以理解為創建對象的簡化形式.
282
283 1. 當只對對象方法進行一次操作的時候可以使用
284 a) new person();
285 2. 可以做為實際參數的傳遞:
286 a) public void show(new Person());
287
288
289 封裝：
290 什么是封裝呢?
291 其實就是隱藏實現細節，提供了安全性
292
293 在通過類來創建對象的時候，可以通過對象調用成員，也可以使用對象的屬性
294 為了提高安全性，所以避免了直接對屬性進行訪問：我們可以把它設計為私有private
295
296 對外提供方法來間接訪問age進行賦值！
297
298 private int age ;
299 public void setAge(int age)
300 {
301 this.age = age;
302 }
303
304 public int getAge()
305 {
306 retrun age;
307 }
308 在代碼的體現：
309 1.函數就是一個最小的封裝體
310 2.類本身就是一種封裝
311 3.包也是一種封裝
312 4.ssh框架也是一種封裝.
313 5.timcat服務器軟件
314
315
316 /*
317
318 體現良好的封裝！
319 */
320
321 class Person
322 {
323 private String name ;
324 private int age;
325
326
327 /*
328 這是隱藏下來的代碼~~
329 */
330 Person()
331 {
332 super();
333 }
334 public void setName(String name)
335 {
336 this.name = name;
337 }
338 public String getName()
339 {
340 return name ; //this.name
341 }
342
343 public void setAge(int age)
344 {
345 this.age = age;
346 }
347 public int getAge()
348 {
349 return age;
350 }
351 }
352 class Demo5
353 {
354 public static void main(String[] args)
355 {
356 Person p = new Person();
357 p.setName("kudy");
358 String name = p.getName();
359
360 p.setAge(18);
361 int age = p.getAge();
362 }
363 }
364
365
366 執行的過程：
367 1. 加載Person .class文件到堆內存中
368 2. 因為new，在堆內存中開辟空間，創建對象。在對象中出現了name 與age
369 3. 對象中的屬性默認初始化
370 4. 對象中的屬性顯式初始化
371 5. 構造函數初始化
372 6. 創建引用變量，并將該對象的首地址給變量，該變量這時候就指向了對象。
373
374
375 this語句代碼什么?
376 1.this所在的函數所屬對象的引用
377 2.this被那個對象調用.那this就代表那個對象
378
379 A）this還可以用與區分成員變量與局部變量同名的情況
380
381 B)什么時候使用this?
382 當定義功能時，該變量內部使用了本類的對象,同時，this表示該對象
383
384 C）this語句：
385 在構造函數中，方便于構造函數調用,但注意：this語句只能在構造函數的第一位.因為要對執行的數據進行初始化.
386
387
388
389 day05 面向對象
390 1， 構造函數
391 a. 函數名與類名相同
392 b. 沒有返回值
393 c. 函數中沒有return語句
394
395 作用： 可以對對象進行初始化
396
397 比喻：Person p = new Person();
398 a,加載Person.class文件到堆內存中
399 b,在堆內存中開辟空間，創建實例對象
400 c,對對象的內容進行默認的初始化
401 d,對對象的內容進行顯式的初始化
402 e,對對象自定義的內容進行初始化，通過構造函數來完成的.
403 f,在棧內存中定義變量存入對象的地址值，指向該對象
404
405 注意：
406 在用class文件時，jvm會自動的在該類添加一個默認的構造函數（沒有構造函數,你就創建不了對象的哦）該函數的形參是空的.
407 構造函數可以通過this來進行互相的調用，是通過this語句來完成
408 this的語句一定要放在構造函數的第一行
409
410
411 2,static關鍵字
412 特點：
413 ---隨著類的加載而加載，隨著類的消失而消失，靜態成員的聲明周期最長
414 ---優先于對象
415 ---被所有的對象所共享
416 ---可以直接通過類名來調用
417
418 注意：
419 ---靜態方法只能訪問靜態的成員（因為我是不需要創建對象就可以使用的）
420 ---靜態方法中不能出現this，super關鍵字.因為靜態方法沒有所謂的對象
421 ---主函數是靜態的
422
423
424 2， 設計模式：解決某類問題之間有效的方法.
425 java中有23種設計模式
426
427 單例設計模式：
428 a) 私有化構造函數
429 b) 定義一個靜態私有化的本類對象
430 c) 定義一個靜態方法返回內部對象的地址
431
432
433
434
435 class Singleton
436 {
437 private Singleton()
438 {
439 //私有化構造函數,避免創建對象！
440 }
441
442
443 private static Singleton singleton = new Singleton();
444 public static Singleton getSingLeton()
445 {
446 return singleton;
447 }
448 }
449 class Demo7
450 {
451 public static void main(String[] args)
452 {
453 Singleton s1 = Singleton.getSingLeton();
454 Singleton s2 = Singleton.getSingLeton();
455 System.out.println(s1== s2);
456 }
457 }
458
459 3,靜態的代碼塊:
460 特點：隨著類的加載而加載，執行一次，優先于函數
461 作用：對于類的初始化
462
463
464 4,內部類：
465 其實就是一個類的內部中定義另外一個類，內部類可以定義在外部類里面
466 內部類可以直接訪問外部類的成員，那是因為內部類只有一個外部類的引用（類名.this）而外部類訪問內部類的成員需要創建對象
467
468 什么時候使用內部類？
469 描述事物時，該事物內部與還有事物，那么可以通過內部類來完成
470
471 當內部類在成員位置上，可以被成員修飾符所修飾。
472 當內部類中定義了靜態成員時，內部類是必須要靜態的.但是靜態內部類局限性
473 但方法中里面定義了內部類，方法里面的屬性內部類是不能所訪問的.因為局部變量是存儲在棧內存中,系統會不知道什么時候會被釋放.那么我們如果定義成final 就是沒問題.定義成final就是常量.是不能改變的量.是存儲在堆內存中.
474
475
476 day06面向對象（面向對象的總結）
477
478 異常：
479
480 異常的處理機制：
481
482 1.可以在方法后面使用throws關鍵字，聲明向外拋出一個異常
483 2.可以使用try catch語句塊捕獲異常
484 3.finally語句塊的作用： finally需要結合try使用.不論如何finally當中的代碼都是會被執行
485 4.如果是運行時異常,那么jvm是自動的拋出一個異常對象.讓虛擬機去處理.也可以自己手動的去處理.
486
487 自定義異常：
488
489 1.自定義編譯時異常，定義一個類繼承與Exception
490 2.可以在程序中使用throw關鍵字向外拋出一個編譯時異常對象,這時方法必須向外拋出一個異常
491 throw關鍵字相當于return
492
493 異常的使用細節：
494 因為都是為了多態而服務的,所以當父類型的引用指向子類型的對象的時候/jvm就分辨不清楚啦~~）
495
496 1. 子類重寫父類的方法.不能拋出被父類更多的方法.沒拋,子類不能拋.父類拋了.子類可以不拋.要拋也只能拋父類一樣的異常，或者父類異常的子類.
497 2. 一個try語句可以跟多個catch語句一起來捕獲異常
498 3.try finally 可以嵌套使用.
499
500 異常的使用總結：
501
502 1.異常是在程序運算期間發生的錯誤，所有的異常類都是Throwable的子類
503 2.error,java的虛擬機錯誤，比較嚴重。處理不了.不用處理。編譯是不會出錯
504 3.Exception：異常{
505 一個特殊的子類,RuntimeException這個類的所有的子類都是運行的時候異常,不必要處理,編譯時不會報錯.交給默認的處理程序.其它的子類都是編譯時異常,比較嚴重的錯誤！在方法后面應該跑出去,我們在調用方法一定要處理.否則編譯器會報錯。
506 }
507 4.異常處理方式：try {} catch捕獲異常,throws 向外拋出一個異常
508 5.thorw 與throws 的區別?
509 throws聲明方法向外拋出一個異常
510 throw和return一樣,只不過是要創建一個對象
511 注意：
512 拋出一個對象,一定需要在方法外面聲明拋出一個異常.
513
514 6.自定義異常:
515 1.可以自己寫一個類繼承與Exception,這個類就是編譯時異常
516 2.可以自己寫一個類繼承于RuntimeException，這個類就是運算期間異常
517
518
519 面試題目：
520
521 1.請說說final 與 finalize 和 finally的區別？三者有什么共同點?
522 解答： 除了單詞有點像,他們都是沒什么緣分的..
523 1.final是java的修飾關鍵字.修飾類,類不能被繼承.修飾屬性.屬性會編程常量.不能修改的值.修飾方法.這個方法不能被重寫.
524 2.finalize：是在Object類當中定義的一個方法,所有的類都是默認繼承與Object類.也就是說：繼承了這個方法.當對象被垃圾回收之前.jvm會自動的調用該對象的finalize方法,所以我們一般通過finalize來做一些內存釋放的工作..
525 3.finally ：java中的關鍵字，必須結合try語句一起來使用.寫在finally代碼中的語句.一定會被執行.除非jvm退出。
526
527 class MyException extends Exception
528 {
529 public String getMessage()
530 {
531 return "上帝~~";
532 }
533 }
534
535 class Student
536 {
537 public void readBook(int num) throws Exception
538 {
539 if(num >300 || num <1){
540 throw new Exception(){ //返回一個對象
541 //匿名內部類.重寫了父類的方法！
542 public String getMessage()
543 {
544 return "你在吹牛嗎?";
545 }
546 };
547 }
548 else
549 {
550 System.out.println("好孩子！");
551 }
552
553 }
554
555 public void eat(int week) throws MyException //向外拋出去一個異常
556 {
557 if(week<1||week>7)
558 throw new MyException(); //結束,有了一個對象！
559 else
560 System.out.println("星期是正確的！！");
561 }
562 }
563 class Demo10
564 {
565 public static void main(String[] args)
566 {
567 try
568 {
569 new Student().readBook(400);
570 }
571 catch (Exception e)
572 {
573 e.printStackTrace();
574 }
575
576
577 try
578 {
579 new Student().eat(88);
580 }
581 catch (Exception e) //父類型的引用所指向子類型的對象 Exception e = new MyException();
582 {
583 e.printStackTrace();
584 }
585
586 }
587 }
588
589
590 1. 封裝性：
591 1)類的封裝：將屬性都私有化(private)，防止外界的直接訪問，對外提供s et 與get方法。
592 優點：隱藏內部實現過程，方便權限的管理
593
594 2)方法的封裝：在實現功能的時候，應該盡可能的多抽取方法，盡量將別人用不到的方法私有化，實現一個封裝性。將提供方法進行功能調用方法設置為公有的public就可以
595 優點：讓類看起來更加的整潔，對外隱藏了實現的細節。
596
597 2. 抽象：
598 a) 為了描述顯示的事物，在程序中通過對象來映射顯示中類的事物（萬物皆對象）
599 b) 將一組特征相似的對象共同的特征和行為抽象出一個類來定義
600 c) 類的成員變量（屬性）來描述特征，用成員方法來描述對象的行為
601 3. 繼承：
602 a) 使用extends 關鍵字讓子類繼承父類，子類就可以自動復用了父類的所有屬性和方法（非私有）
603 b) 子類實例化過程：
604 1. 子類的構造方法一定會調用父類的構造方法,可以在第一行使用this（實參）來調用自己其他的構造方法，使用super(實參)來調用父類的構造方法
605 2. 如果第一行沒有聲明，jvm會自動調用父類的無參的構造方法
606 3. 子類和父類之間的轉換
607 1,可以將子類實例當做父類來用，反則不能.
608 2,把子類當做父類來用時：調用方法是子類的（重寫的關系）,這個是做了動態的綁定,如果是訪問屬性的（靜態的綁定）也就說：調用的數父類的屬性.
609 3，把子類當做父類來使用時，不能調用子類特有方法，因為編譯器會檢查語法,發現該父類沒有這個方法，會報錯！
610 4,如果是把子類當做父類來使用的時候，這時候可以強制類型轉換，則再有把握：咱們都需要用instanceof來判斷一些對象的類型。
611 4. 多態：
612 1. 把子類當做父類來用
613 2. 我們在編程無時無刻不使用多態，在定義一個方法形參的時候，為了便于方法的通用性，通常會將形參定義為父類類型，最好是接口類型，當調用方法的時候.那么就可以子類實例當做父類來使用，正因為有了多態，我們經常把子類當做父類來使用。所以有了以下的規定。
614 ii. 返回值類型必須和父類的一致，或者是父類返回值類型的子類實例
615 iii. 子類不能有比父類更加嚴格的訪問權限,假設父類是 public 而你子類是：private 那么在傳遞參數的時候，有可能會因為訪問權限而出錯！所以java是不允許的.
616 iv. 子類不能被父類拋出更多的異常.
617 v. 異常： throw 拋出一個異常對象.方法外部也是需要向外聲明拋出一個異常
618
619
620 彩票的搖獎過程：
621
622 import java.util.Random;
623 class Lottery
624 {
625 private int poorCount;
626 private int luckyPoorCount;
627 private int[] poor;
628 private int []luckPoor;
629
630 //構造函數在構造搖獎的對象
631 Lottery(int poorCount,int luckyPoorCount)
632 {
633 this.poorCount = poorCount;
634 this.luckyPoorCount = luckyPoorCount;
635 setPoor();
636 }
637
638 //填充獎池
639 private void setPoor()
640 {
641 /*
642 怎么做?
643 1.根據poorCount創建數組,
644 2.將1~poorCount填充數組,
645 */
646 int[] arr = new int[poorCount];
647 for(int i=0; i<poorCount; i++)
648 arr[i] = i+1; //37個數字
649 poor = arr;
650 luckPoor = new int[luckyPoorCount];
651 }
652
653 public void run()
654 {
655 //搖出所有的中獎號碼放在中獎池中
656 setLuckyPoor();
657 //輸出所有的中獎號碼
658 listLuckyPoor();
659 }
660
661 //獲得所有的中獎號碼~~
662 public void setLuckyPoor()
663 {
664 //1.定義循環,循環次數是luckyPoorCount
665 for(int i=0; i<luckyPoorCount; i++)
666 {
667 //1.產生一個隨機的中獎號碼
668 int luckyNumber = getLuckyNumber();
669 //2.將中獎號碼從里面刪除
670 deleteNumber(luckyNumber);
671 //3.將中獎號碼放在獎池中
672 luckPoor[i] = luckyNumber;
673 }
674 }
675
676 private int getLuckyNumber()
677 {
678 int randomNum = new Random().nextInt(poor.length);
679 return poor[randomNum];
680 }
681
682 private void deleteNumber(int luckyNumber)
683 {
684 int[] newArr = new int[poor.length-1];
685 int pos = 0;
686 for(int i=0; i<poor.length; i++)
687 {
688 if(poor[i] == luckyNumber)
689 continue;
690 newArr[pos++] = poor[i]; //幸運的數字
691 }
692 poor = newArr;
693 }
694
695 private void listLuckyPoor()
696 {
697 StringBuffer sb = new StringBuffer();
698 for(int num : luckPoor)
699 sb.append(num +" ");
700 System.out.println("中獎的號碼為：");
701 System.out.println(sb);
702 }
703 }
704
705 public class Demo11
706 {
707 public static void main(String[] args)
708 {
709 Lottery lottery = new Lottery(36,7);
710 lottery.run();
711 }
712 }
posted on 2012-08-07 01:04
、小細 閱讀(143)
評論(0) 編輯 收藏