1 Java的環(huán)境配置 day01
2
3 1. 環(huán)境配置有如下的三種方法：
4 a) 我的電腦屬性： 從path 環(huán)境中配置
5 b) 利用臨時的變量設(shè)置： set path = java的所在路徑\bin%d%
6 c) 定義批處理文件 ： 設(shè)置步驟如下：
7 a) set path = %cd%\H:\java\jdk1.7\bin
8 b)
9 c) start
10
11 一． java的環(huán)境搭配
12 1. 安裝jdk >1.jdk是java的開發(fā)和運行環(huán)境 >2.jre是java的運行環(huán)境
13 2. 配置環(huán)境變量?為什么呢?方便在任意的目錄下使用java工具
14 a. 我的電腦—屬性—高級—環(huán)境變量
15 在已有的環(huán)境變量path的基礎(chǔ)下，添加一個jdk\bin目錄即可.
16 這種方法較為一勞永逸
17 技巧：為了日后修改方便，不需要總是修改path，可以首先定義一個環(huán)境變量 JAVA_HOME 把前面的路徑保存下來.并且通過%JAVA_HOME%來動態(tài)的獲取該變量
18 b. 也可以通過臨時環(huán)境變量，通過dos控制臺，使用set命令即可。
19 set path = (java的按照目錄)jdk\bin;&path&;
20
21 c. 如果是在別人的電腦去完成java開發(fā)，還不想配置java環(huán)境變量.咱們可以使用批處理來完成：
22 a) 假設(shè)： a.bat
23 b) set path = %cd%jdk\bin;%path% %cd%代表獲取當前目錄.
24 c) 為了避免了不讓它一閃而過：start.
25
26 二：轉(zhuǎn)義字符
27 1.\n：換行
28 2.\t：tab鍵
29 3.\b:退格鍵
30
31
32 三： 數(shù)據(jù)運算符
33
34 & : 只有兩邊都為true結(jié)果為true，否則為false。
35 |：只有兩邊為flase才為false,否則都為true
36 ^ : 只有兩邊相同 結(jié)果為false，否則為true。
37
38
39
40 Java基礎(chǔ)知識 day02
41
42 二．變量：
43 在內(nèi)存中所開辟的空間將常量值進行存儲、方便運算。
44 好處：該空間可以重復(fù)使用..
45 定義格式：
46 數(shù)據(jù)類型 變量名 = 初始值
47 使用變量的注意事項：
48 1. 變量有自己的作用域
49 2. 變量不能賦空值.
50
51 基本數(shù)據(jù)類型：
52 byte int long char short double boolean float
53 引用數(shù)據(jù)類型：
54 接口 類 數(shù)組
55
56 什么時候需要定義變量：
57 當數(shù)據(jù)不確定時,或者運算后的結(jié)果需要進行下一步的操作
58 這時候就要定義一個變量將該不確定的數(shù)據(jù)進行存儲。
59
60 三.運算符：
61 1. 算術(shù)運算符：
62 1. +：連接符
63 2. %取余： 任何數(shù)%2 結(jié)構(gòu)非零急一
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 特點：運算后結(jié)構(gòu)非false 或true
72 == 相等于
73
74 4.邏輯運算符
75 & | ^ 這些運算符不僅僅可以代表boolean表達式，也可以進行位運算。
76 &和&&：當左邊為false時，&：兩邊的表達式都參與運算。&&右邊的表達式不參與運算。
77 |和||：當左邊為true時，|：兩邊的表達式都參與運算。||右邊的表達式不參與運算。
78 ^:兩邊一樣結(jié)果為false。
79
80 5．位運算符
81 左移：<< 3<<2=12 3<<4 = 48
82 右移：>> 和 >>> 區(qū)別：
83 >>:右移后，空位按照移位前的最高位來填充。最高位為0，用0補。最高位為1用1來補
84 >>>:無符號右移,無論最高位是什么，都用0補。
85
86 6.負數(shù)的由來：取反+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 解答： 簡化形式因為是一個運算，所以咱們必須要有一個結(jié)果。
103
104 if(x >１)
105 Y = 100;
106 else
107 Y = 200;
108 Y =(x>1)? 100: 200;
109 注意：無論條件表達式有多復(fù)雜，只要有true ||flase 出現(xiàn)，則沒問題.否則條件表達式會出錯：if(x =1);
110
111 選擇:switch(表達式)
112
113 switch(表達式)
114 {
115 case 1:
116 執(zhí)行語句;
117 break;
118 case 2:
119 執(zhí)行語句;
120 break;
121 case 3:
122 執(zhí)行語句;
123 break;
124 default;
125 執(zhí)行語句;
126 }
127
128 特點：
129 1.表達式運算四種類型的值:byet int short char(它有一個自動型轉(zhuǎn)換過程)
130 2.case和default之間是可以沒有任何的順序，但是在運算期間，肯定會先讀取第一個case ,當case不匹配，會繼續(xù)執(zhí)行其他的case。當所有的case不匹配的時候.會運行default。
131 3.switch語句結(jié)束的兩個方式：a.讀取switch語句大括號結(jié)束b.碰到break語句結(jié)束.注意:如果沒有碰到break，也沒有讀取結(jié)束的時候，那么程序是一直往下面運行，直到程序運算完畢
132
133
134
135 循環(huán)：while du{}while; for
136
137 1. while(表達式){執(zhí)行語句}(先判斷后執(zhí)行)
138 2. do{執(zhí)行語句}while(條件表達式);(先執(zhí)行一次,再判斷)
139 3. for(初始化表達式;循環(huán)判斷條件;循環(huán)后的操作表達式){}
140
141 什么時候用這些語句呢?
142 當對固定的幾個值進行判斷的時候，建議使用switch
143 當對范圍的判斷，或者對運算后的真假進行判斷的時候,我們需要用到if
144
145 當需要執(zhí)行語句多次的時候.我們使用到循環(huán)
146 while與for循環(huán)是可以相互交換
147 因為作用域的關(guān)系：
148 在使用兩個語句的時候有些區(qū)分，如果定義變量只為循環(huán)存在，循環(huán)結(jié)束后就沒有意義。我們使用到for循環(huán)語句。
149 如果變量在循環(huán)后再執(zhí)行別的運算，那么我們使用while比較好~
150
151 break：選擇結(jié)構(gòu)和循環(huán)結(jié)構(gòu)
152 continue：循環(huán)結(jié)果：結(jié)束本次循環(huán).繼續(xù)下一次循環(huán)
153
154 函數(shù)：
155 特點：
156 --類中的一個獨立小程序
157 --只有被調(diào)用的時候才會運算
158 --可以重復(fù)的去運行
159 好處：
160 對代碼進行封裝,可以提高代碼的復(fù)用性
161 格式：
162 返回值類型 函數(shù)名(參數(shù)類型 形式參數(shù)1)
163 {
164 執(zhí)行語句;
165 return 返回值;
166 }
167
168 如果定義一個函數(shù)？
169 1. 明確該功能函數(shù)運算后的結(jié)果。（明確返回值類型）
170 2. 明確該功能實現(xiàn)的過程，是否需要有未知值參與運算（明確函數(shù)的參數(shù)類型）
171 要定義一個加法運算功能
172
173 int getSum(int x ,int y)
174 {
175 return x + y;
176 }
177
178 方法的重載：@overload(標記重載)
179 特點：當多個函數(shù)的功能一致，只是參與運算不同的時候，為了提高代碼的可閱讀性,我們可以使用方法的重載.用參數(shù)來進行區(qū)分.
180 int getSum(int x,int y,int z)
181 {
182 return x + y + z;
183 }
184
185 函數(shù)的特點：
186 有一種情況，函數(shù)執(zhí)行一個功能，但沒有具體的返回值。返回值類型不可以具體的來確定的時候,那么我們用void關(guān)鍵字來表示.那么函數(shù)的return 語句是可以忽略不寫的. 也可以:return ;
187
188
189 day03 數(shù)組
190
191 五.數(shù)組： 其實就是同類型的一組數(shù)字
192
193 同一種類型數(shù)據(jù)的集合，類型一定要一致。
194
195 內(nèi)存圖：
196 java劃分了兩片內(nèi)存，方便了運算
197
198 棧內(nèi)存：存放局部變量，函數(shù)上和函數(shù)定義的變量都是局部變量
199 變量一點使用完畢,自動清空。
200 棧內(nèi)存： new關(guān)鍵字所建立的,都稱為實例.在堆內(nèi)存里面存放的.
201
202
203 數(shù)組常見的如下問題：
204 角標越界異常:使用到數(shù)組中不存在的角標。
205 (ArrayIndexOutOfBoundsException) 數(shù)組特有異常
206
207 空指針異常：引用型變量等于null，也就是沒有指向。
208 （NullPointsException）
209 ########
210 本身就是一個容器，用來存儲數(shù)據(jù).
211 特點：固定的長度.
212 好處：給元素進行編號，從零開始。同時也可以length屬性獲取數(shù)組的長度.
213
214 什么時候使用數(shù)組？
215 當數(shù)據(jù)較多的時候，通常是為了方便操作這些數(shù)據(jù)都需要進行臨時存儲.
216
217 習慣：
218 通常操作數(shù)組都需要遍歷，獲取數(shù)組中的元素需要一個指針。
219 通常對指針的值的改變也就是更改了數(shù)組里邊的值啦~~
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 面向?qū)ο?
255 面向?qū)ο螅?
256 1. 符合現(xiàn)實中人民思考習慣的一種思想.
257 2. 它將程序員的角色（執(zhí)行者）轉(zhuǎn)換成（指揮者）
258 3. 將復(fù)雜的問題簡單化.
259
260 對象無處不在,一切皆對象
261
262 對象是實實在在存在的個體,那么我們需要使用計算機語言來進行描述
263 在java當中，描述事物是通過類來完成,在計算機中是通過new 類來創(chuàng)建對象.并且指揮對象完成事情.
264
265 例如： 制造汽車，通過汽車來描述：圖紙。對應(yīng)的java中的類class
266 通過圖紙來產(chǎn)生汽車： 對象，對應(yīng)的就是java在堆內(nèi)存中所產(chǎn)生的實例
267
268 通過java語言編寫程序，其實就是不斷的定義類,創(chuàng)建對象的一個過程。
269 成員變量（事物的屬性） 成員方法(事物的行為)。
270
271 對象的存在有什么好處？或者說怎么才叫做對象?
272 對象可以用于封裝數(shù)據(jù).可以在對象中定義屬性和行為,并指揮.
273
274 在編寫程序中，當要完成某個功能的時候,先看一下java是否提供了自有的對象.如果有,那么可以直接的去使用這個對象里面的功能.否則如果該對象不存在.那么我們需要定義一個對象，并將需要的功能封裝到該對象中,以便對象的重復(fù)使用.。
275
276 對象是如何使用呢?
277 通過new 關(guān)鍵字來建立，并且通過 對象.成員變量 的形式操作對象所做的事情..
278
279
280 匿名對象：
281 其實就是一個沒有名字的對象,可以理解為創(chuàng)建對象的簡化形式.
282
283 1. 當只對對象方法進行一次操作的時候可以使用
284 a) new person();
285 2. 可以做為實際參數(shù)的傳遞:
286 a) public void show(new Person());
287
288
289 封裝：
290 什么是封裝呢?
291 其實就是隱藏實現(xiàn)細節(jié)，提供了安全性
292
293 在通過類來創(chuàng)建對象的時候，可以通過對象調(diào)用成員，也可以使用對象的屬性
294 為了提高安全性，所以避免了直接對屬性進行訪問：我們可以把它設(shè)計為私有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 在代碼的體現(xiàn)：
309 1.函數(shù)就是一個最小的封裝體
310 2.類本身就是一種封裝
311 3.包也是一種封裝
312 4.ssh框架也是一種封裝.
313 5.timcat服務(wù)器軟件
314
315
316 /*
317
318 體現(xiàn)良好的封裝！
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 執(zhí)行的過程：
367 1. 加載Person .class文件到堆內(nèi)存中
368 2. 因為new，在堆內(nèi)存中開辟空間，創(chuàng)建對象。在對象中出現(xiàn)了name 與age
369 3. 對象中的屬性默認初始化
370 4. 對象中的屬性顯式初始化
371 5. 構(gòu)造函數(shù)初始化
372 6. 創(chuàng)建引用變量，并將該對象的首地址給變量，該變量這時候就指向了對象。
373
374
375 this語句代碼什么?
376 1.this所在的函數(shù)所屬對象的引用
377 2.this被那個對象調(diào)用.那this就代表那個對象
378
379 A）this還可以用與區(qū)分成員變量與局部變量同名的情況
380
381 B)什么時候使用this?
382 當定義功能時，該變量內(nèi)部使用了本類的對象,同時，this表示該對象
383
384 C）this語句：
385 在構(gòu)造函數(shù)中，方便于構(gòu)造函數(shù)調(diào)用,但注意：this語句只能在構(gòu)造函數(shù)的第一位.因為要對執(zhí)行的數(shù)據(jù)進行初始化.
386
387
388
389 day05 面向?qū)ο?
390 1， 構(gòu)造函數(shù)
391 a. 函數(shù)名與類名相同
392 b. 沒有返回值
393 c. 函數(shù)中沒有return語句
394
395 作用： 可以對對象進行初始化
396
397 比喻：Person p = new Person();
398 a,加載Person.class文件到堆內(nèi)存中
399 b,在堆內(nèi)存中開辟空間，創(chuàng)建實例對象
400 c,對對象的內(nèi)容進行默認的初始化
401 d,對對象的內(nèi)容進行顯式的初始化
402 e,對對象自定義的內(nèi)容進行初始化，通過構(gòu)造函數(shù)來完成的.
403 f,在棧內(nèi)存中定義變量存入對象的地址值，指向該對象
404
405 注意：
406 在用class文件時，jvm會自動的在該類添加一個默認的構(gòu)造函數(shù)（沒有構(gòu)造函數(shù),你就創(chuàng)建不了對象的哦）該函數(shù)的形參是空的.
407 構(gòu)造函數(shù)可以通過this來進行互相的調(diào)用，是通過this語句來完成
408 this的語句一定要放在構(gòu)造函數(shù)的第一行
409
410
411 2,static關(guān)鍵字
412 特點：
413 ---隨著類的加載而加載，隨著類的消失而消失，靜態(tài)成員的聲明周期最長
414 ---優(yōu)先于對象
415 ---被所有的對象所共享
416 ---可以直接通過類名來調(diào)用
417
418 注意：
419 ---靜態(tài)方法只能訪問靜態(tài)的成員（因為我是不需要創(chuàng)建對象就可以使用的）
420 ---靜態(tài)方法中不能出現(xiàn)this，super關(guān)鍵字.因為靜態(tài)方法沒有所謂的對象
421 ---主函數(shù)是靜態(tài)的
422
423
424 2， 設(shè)計模式：解決某類問題之間有效的方法.
425 java中有23種設(shè)計模式
426
427 單例設(shè)計模式：
428 a) 私有化構(gòu)造函數(shù)
429 b) 定義一個靜態(tài)私有化的本類對象
430 c) 定義一個靜態(tài)方法返回內(nèi)部對象的地址
431
432
433
434
435 class Singleton
436 {
437 private Singleton()
438 {
439 //私有化構(gòu)造函數(shù),避免創(chuàng)建對象！
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,靜態(tài)的代碼塊:
460 特點：隨著類的加載而加載，執(zhí)行一次，優(yōu)先于函數(shù)
461 作用：對于類的初始化
462
463
464 4,內(nèi)部類：
465 其實就是一個類的內(nèi)部中定義另外一個類，內(nèi)部類可以定義在外部類里面
466 內(nèi)部類可以直接訪問外部類的成員，那是因為內(nèi)部類只有一個外部類的引用（類名.this）而外部類訪問內(nèi)部類的成員需要創(chuàng)建對象
467
468 什么時候使用內(nèi)部類？
469 描述事物時，該事物內(nèi)部與還有事物，那么可以通過內(nèi)部類來完成
470
471 當內(nèi)部類在成員位置上，可以被成員修飾符所修飾。
472 當內(nèi)部類中定義了靜態(tài)成員時，內(nèi)部類是必須要靜態(tài)的.但是靜態(tài)內(nèi)部類局限性
473 但方法中里面定義了內(nèi)部類，方法里面的屬性內(nèi)部類是不能所訪問的.因為局部變量是存儲在棧內(nèi)存中,系統(tǒng)會不知道什么時候會被釋放.那么我們?nèi)绻x成final 就是沒問題.定義成final就是常量.是不能改變的量.是存儲在堆內(nèi)存中.
474
475
476 day06面向?qū)ο螅嫦驅(qū)ο蟮目偨Y(jié)）
477
478 異常：
479
480 異常的處理機制：
481
482 1.可以在方法后面使用throws關(guān)鍵字，聲明向外拋出一個異常
483 2.可以使用try catch語句塊捕獲異常
484 3.finally語句塊的作用： finally需要結(jié)合try使用.不論如何finally當中的代碼都是會被執(zhí)行
485 4.如果是運行時異常,那么jvm是自動的拋出一個異常對象.讓虛擬機去處理.也可以自己手動的去處理.
486
487 自定義異常：
488
489 1.自定義編譯時異常，定義一個類繼承與Exception
490 2.可以在程序中使用throw關(guān)鍵字向外拋出一個編譯時異常對象,這時方法必須向外拋出一個異常
491 throw關(guān)鍵字相當于return
492
493 異常的使用細節(jié)：
494 因為都是為了多態(tài)而服務(wù)的,所以當父類型的引用指向子類型的對象的時候/jvm就分辨不清楚啦~~）
495
496 1. 子類重寫父類的方法.不能拋出被父類更多的方法.沒拋,子類不能拋.父類拋了.子類可以不拋.要拋也只能拋父類一樣的異常，或者父類異常的子類.
497 2. 一個try語句可以跟多個catch語句一起來捕獲異常
498 3.try finally 可以嵌套使用.
499
500 異常的使用總結(jié)：
501
502 1.異常是在程序運算期間發(fā)生的錯誤，所有的異常類都是Throwable的子類
503 2.error,java的虛擬機錯誤，比較嚴重。處理不了.不用處理。編譯是不會出錯
504 3.Exception：異常{
505 一個特殊的子類,RuntimeException這個類的所有的子類都是運行的時候異常,不必要處理,編譯時不會報錯.交給默認的處理程序.其它的子類都是編譯時異常,比較嚴重的錯誤！在方法后面應(yīng)該跑出去,我們在調(diào)用方法一定要處理.否則編譯器會報錯。
506 }
507 4.異常處理方式：try {} catch捕獲異常,throws 向外拋出一個異常
508 5.thorw 與throws 的區(qū)別?
509 throws聲明方法向外拋出一個異常
510 throw和return一樣,只不過是要創(chuàng)建一個對象
511 注意：
512 拋出一個對象,一定需要在方法外面聲明拋出一個異常.
513
514 6.自定義異常:
515 1.可以自己寫一個類繼承與Exception,這個類就是編譯時異常
516 2.可以自己寫一個類繼承于RuntimeException，這個類就是運算期間異常
517
518
519 面試題目：
520
521 1.請說說final 與 finalize 和 finally的區(qū)別？三者有什么共同點?
522 解答： 除了單詞有點像,他們都是沒什么緣分的..
523 1.final是java的修飾關(guān)鍵字.修飾類,類不能被繼承.修飾屬性.屬性會編程常量.不能修改的值.修飾方法.這個方法不能被重寫.
524 2.finalize：是在Object類當中定義的一個方法,所有的類都是默認繼承與Object類.也就是說：繼承了這個方法.當對象被垃圾回收之前.jvm會自動的調(diào)用該對象的finalize方法,所以我們一般通過finalize來做一些內(nèi)存釋放的工作..
525 3.finally ：java中的關(guān)鍵字，必須結(jié)合try語句一起來使用.寫在finally代碼中的語句.一定會被執(zhí)行.除非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 //匿名內(nèi)部類.重寫了父類的方法！
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(); //結(jié)束,有了一個對象！
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 優(yōu)點：隱藏內(nèi)部實現(xiàn)過程，方便權(quán)限的管理
593
594 2)方法的封裝：在實現(xiàn)功能的時候，應(yīng)該盡可能的多抽取方法，盡量將別人用不到的方法私有化，實現(xiàn)一個封裝性。將提供方法進行功能調(diào)用方法設(shè)置為公有的public就可以
595 優(yōu)點：讓類看起來更加的整潔，對外隱藏了實現(xiàn)的細節(jié)。
596
597 2. 抽象：
598 a) 為了描述顯示的事物，在程序中通過對象來映射顯示中類的事物（萬物皆對象）
599 b) 將一組特征相似的對象共同的特征和行為抽象出一個類來定義
600 c) 類的成員變量（屬性）來描述特征，用成員方法來描述對象的行為
601 3. 繼承：
602 a) 使用extends 關(guān)鍵字讓子類繼承父類，子類就可以自動復(fù)用了父類的所有屬性和方法（非私有）
603 b) 子類實例化過程：
604 1. 子類的構(gòu)造方法一定會調(diào)用父類的構(gòu)造方法,可以在第一行使用this（實參）來調(diào)用自己其他的構(gòu)造方法，使用super(實參)來調(diào)用父類的構(gòu)造方法
605 2. 如果第一行沒有聲明，jvm會自動調(diào)用父類的無參的構(gòu)造方法
606 3. 子類和父類之間的轉(zhuǎn)換
607 1,可以將子類實例當做父類來用，反則不能.
608 2,把子類當做父類來用時：調(diào)用方法是子類的（重寫的關(guān)系）,這個是做了動態(tài)的綁定,如果是訪問屬性的（靜態(tài)的綁定）也就說：調(diào)用的數(shù)父類的屬性.
609 3，把子類當做父類來使用時，不能調(diào)用子類特有方法，因為編譯器會檢查語法,發(fā)現(xiàn)該父類沒有這個方法，會報錯！
610 4,如果是把子類當做父類來使用的時候，這時候可以強制類型轉(zhuǎn)換，則再有把握：咱們都需要用instanceof來判斷一些對象的類型。
611 4. 多態(tài)：
612 1. 把子類當做父類來用
613 2. 我們在編程無時無刻不使用多態(tài)，在定義一個方法形參的時候，為了便于方法的通用性，通常會將形參定義為父類類型，最好是接口類型，當調(diào)用方法的時候.那么就可以子類實例當做父類來使用，正因為有了多態(tài)，我們經(jīng)常把子類當做父類來使用。所以有了以下的規(guī)定。
614 ii. 返回值類型必須和父類的一致，或者是父類返回值類型的子類實例
615 iii. 子類不能有比父類更加嚴格的訪問權(quán)限,假設(shè)父類是 public 而你子類是：private 那么在傳遞參數(shù)的時候，有可能會因為訪問權(quán)限而出錯！所以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 //構(gòu)造函數(shù)在構(gòu)造搖獎的對象
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.根據(jù)poorCount創(chuàng)建數(shù)組,
644 2.將1~poorCount填充數(shù)組,
645 */
646 int[] arr = new int[poorCount];
647 for(int i=0; i<poorCount; i++)
648 arr[i] = i+1; //37個數(shù)字
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.定義循環(huán),循環(huán)次數(shù)是luckyPoorCount
665 for(int i=0; i<luckyPoorCount; i++)
666 {
667 //1.產(chǎn)生一個隨機的中獎號碼
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]; //幸運的數(shù)字
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) 編輯 收藏