1. 動態綁定
          若子類SubClass覆蓋了父類SuperClass的某個非final非private方法f1()
          即使子類被聲明為
          SuperClass child = new SubClass();
          使用child.f1()時仍然訪問子類的f1()
          2. 如果把某個方法聲明為final,可以防止其他人覆蓋該方法。更為重要的一點是,這樣做可以有效的關閉動態綁定,從而生成更有效的代碼。然而,大多數情況下,這樣做對程序的整體性能不會有什么改觀。因此并不提倡為了僅僅提高性能而使用final。
          3. private方法無法被覆蓋,但還是要注意覆蓋private方法的現象,上面的例子中,如SuperClass中含有private方法f2(),而子類中也聲明了同名的方法f2(),子類被聲明為
          SuperClass child = new SubClass();
          child.f2()時訪問了父類的f2()
          4. 構造器和多態
          構造器基本順序:
          1)調用基類構造器(遞歸過程)
          2)按聲明順序調用成員的初始化方法。
          3)調用導出類構造器的主體。
          5. 繼承與清理
          通過組合與京城方法來創建新類時,不必擔心對象的清理問題。如果確實遇到清理的問題,那么必須為新類創建dispose()方法。當覆蓋被繼承類的dispose()方法時,務必記住調用基類的dispose()方法,也要注意清理順序。
          6. 構造器內部的多態方法的行為
          如果要調用構造器內部的一個動態綁定的方法,就要用到那個方法的被覆蓋后的定義。然而,產生的效果可能相當難于預料,并且可能造成一些難于發現的隱藏錯誤。
          在任何構造器的內部,整個對象可能只是部分形成,然而一個動態綁定的方法調用卻會向外深入到繼承層次結構內部,它可以調用導出類的方法。如果在構造器里這么做,那么就可能會調用某個方法,而這個方法所操縱的成員可能還未初始化--這肯定會出問題。
          import com.bruceeckel.simpletest.*;
          abstract class Glyph {
          abstract void draw();
          Glyph() {
          System.out.println("Glyph() before draw()");
          draw();
          System.out.println("Glyph() after draw()");
          }
          }
          class RoundGlyph extends Glyph {
          private int radius = 1;
          RoundGlyph(int r) {
          radius = r;
          System.out.println(
          "RoundGlyph.RoundGlyph(), radius = " + radius);
          }
          void draw() {
          System.out.println(
          "RoundGlyph.draw(), radius = " + radius);
          }
          }
          public class PolyConstructors {
          public static void main(String[] args) {
          new RoundGlyph(5);
          }
          }
          最后顯示
          Glyph() before draw()
          RoundGlyph.draw(), radius = 0
          Glyph() after draw()
          RoundGlyph.RoundGlyph(), radius = 5
          實際應用中,或許這會導致RoundGlyph對象生成后只畫了一個點,而不是預期的半徑為1的圓。
          解釋:初始化的實際過程是:
          1)將分配給對象的儲存空間初始化為二進制的0。
          2)調用基類構造器。即此時調用了draw()方法,但radius仍然為0。
          3)按照聲明的順序調用成員的初始化方法。
          4)調用導出類的構造器主體。
          邏輯方法已經十分完美,但行為卻會出錯(這種情況下,C++會產生更合理的行為)
          因此,編寫構造器有一條有效的準則:用盡可能簡單的方法使對象進入正常狀態;如果可以的話,避免調用其他方法。在構造器內唯一能夠安全調用的那些方法是基類中的final方法(包括private方法),這些方法不能被覆蓋,也就不會出現上述問題。
          7. 依然是繼承/組合的選擇
          一條通用的準則是,用繼承表達行為間的差異,用字段表達狀態上的變化。
          8. 純繼承:只有在基類或接口中已經建立的方法才可以在導出類中被覆蓋,基類與導出類的接口相同。
          9. 向下轉型

          posted @ 2007-04-22 20:24 ZelluX 閱讀(295) | 評論 (0)編輯 收藏

          2007-02-17 23:16:32
          花個20分鐘入個門吧,恩
          from http://www.regexlab.com/zh/regref.htm
          正則表達式(regular expression)描述了一種字符串匹配的模式,可以用來:(1)檢查一個串中是否含有符合某個規則的子串,并且可以得到這個子串;(2)根據匹配規則對字符串進行靈活的替換操作。
          正則表達式規則:
          1. 普通字符
          舉例:表達式 "bcd",在匹配字符串 "abcde" 時,匹配結果是:成功;匹配到的內容是:"bcd";匹配到的位置是:開始于1,結束于4。(注:下標從0開始還是從1開始,因當前編程語言的不同而可能不同)
          2. 簡單的轉義符
          表達式 可匹配
          \r, \n 代表回車和換行符
          \t 制表符
          \\ 代表 "\" 本身
          \^ 匹配 ^ 符號本身
          \$ 匹配 $ 符號本身
          \. 匹配小數點(.)本身

          舉例:表達式 "\$d",在匹配字符串 "abc$de" 時,匹配結果是:成功;匹配到的內容是:"$d";匹配到的位置是:開始于3,結束于5。

          3. 能夠與 '多種字符' 匹配的表達式
          \d 任意一個數字,0~9 中的任意一個
          \w 任意一個字母或數字或下劃線,也就是 A~Z,a~z,0~9,_ 中任意一個
          \s 包括空格、制表符、換頁符等空白字符的其中任意一個
          . 小數點可以匹配除了換行符(\n)以外的任意一個字符

          舉例:表達式 "\d\d",在匹配 "abc123" 時,匹配的結果是:成功;匹配到的內容是:"12";匹配到的位置是:開始于3,結束于5。
          4. 自定義能夠匹配 '多種字符' 的表達式
          [ab5@] 匹配 "a" 或 "b" 或 "5" 或 "@"
          [^abc] 匹配 "a","b","c" 之外的任意一個字符
          [f-k] 匹配 "f"~"k" 之間的任意一個字母
          [^A-F0-3] 匹配 "A"~"F","0"~"3" 之外的任意一個字符
          5. 修飾匹配次數的特殊符號
          {n}
          表達式重復n次,比如:"\w{2}" 相當于 "\w\w";"a{5}" 相當于 "aaaaa"
          {m,n}
          表達式至少重復m次,最多重復n次,比如:"ba{1,3}"可以匹配 "ba"或"baa"或"baaa"
          {m,}
          表達式至少重復m次,比如:"\w\d{2,}"可以匹配 "a12","_456","M12344"...
          ?
          匹配表達式0次或者1次,相當于 {0,1},比如:"a[cd]?"可以匹配 "a","ac","ad"
          +
          表達式至少出現1次,相當于 {1,},比如:"a+b"可以匹配 "ab","aab","aaab"...
          *
          表達式不出現或出現任意次,相當于 {0,},比如:"\^*b"可以匹配 "b","^^^b"...

          舉例:表達式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 時,匹配的結果是:成功;匹配到的內容是:"goooooogle";匹配到的位置是:開始于7,結束于17。
          6. 其他一些代表抽象意義的特殊符號
          ^ 與字符串開始的地方匹配,不匹配任何字符
          $ 與字符串結束的地方匹配,不匹配任何字符
          \b 匹配一個單詞邊界,也就是單詞和空格之間的位置,不匹配任何字符

          舉例:表達式 ".\b." 在匹配 "@@@abc" 時,匹配結果是:成功;匹配到的內容是:"@a";匹配到的位置是:開始于2,結束于4。
          進一步說明:"\b" 與 "^" 和 "$" 類似,本身不匹配任何字符,但是它要求它在匹配結果中所處位置的左右兩邊,其中一邊是 "\w" 范圍,另一邊是 非"\w" 的范圍。

          posted @ 2007-04-22 20:24 ZelluX 閱讀(252) | 評論 (0)編輯 收藏

          2007-02-16 22:15:50

          1.

          主  題: 請教關于method override
          作  者: amatuer () Blog
          等  級:
          信 譽 值: 100
          所屬社區: Java J2SE / 基礎類
          問題點數: 80
          回復次數: 2
          發表時間: 2007-2-16 23:50:00


          在調用SubClass中的addAll()時,結果輸出為"sub"。SuperClass中的addAll()調用的是super.addAll(),按我的理解盡管super.add()被重寫,super.addAll()應該調用super.add(),而結果卻不是這樣。誰給解釋一下?
          以下示意性的代碼:
          class SuperClass {
          public add() {
          System.out.println("super");
          }

          public addAll() {
          add();
          }
          }

          class SubClass extends SuperClass {
          public add() {//overriding
          System.out.println("sub");
          }

          public addAll() {//overriding
          super.addAll();
          }
          }

          interpb(曾曾胡,深怕情多累美人!!!) ( ) 信譽:87 Blog 2007-2-16 23:58:48 得分: 0


          public addAll() {//overriding
          super.addAll();
          }


          這樣只是說 調用父類的addAll 方法

          但是父類在調用這個addAll的時候會調用add 這個時候因為多態所以調用SubClass的add




          Top
          interpb(曾曾胡,深怕情多累美人!!!) ( ) 信譽:87 Blog 2007-2-17 0:05:02 得分: 0


          public void addAll() {//overriding
          super.addAll();
          System.out.println(super.getClass());
          System.out.println(super.hashCode());
          System.out.println(this.hashCode());
          }

          你可以打印出super的實際是屬于SubClass的對象的一個引用
          實際上super與this是同一個對象

          2.

          如果經常對字符串進行各種各樣的修改,或者說,不可預見的修改,那么使用String來代表字符串的話會引起很大的內存開銷。因為String對象建立之后不能再改變,所以對于每一個不同的字符串,都需要一個String對象來表示。這時,應該考慮使用StringBuffer類,它允許修改,而不是每個不同的字符串都要生成一個新的對象。并且,這兩種類的對象轉換十分容易。
          instanceof有一些用處。比如我們寫了一個處理賬單的系統,其中有這樣三個類:

          public class Bill {//省略細節}
          public class PhoneBill extends Bill {//省略細節}
          public class GasBill extends Bill {//省略細節}

          在處理程序里有一個方法,接受一個Bill類型的對象,計算金額。假設兩種賬單計算方法不同,而傳入的Bill對象可能是兩種中的任何一種,所以要用instanceof來判斷:

          public double calculate(Bill bill) {
          if (bill instanceof PhoneBill) {
          //計算電話賬單
          }
          if (bill instanceof GasBill) {
          //計算燃氣賬單
          }
          ...
          }
          這樣就可以用一個方法處理兩種子類。

          然而,這種做法通常被認為是沒有好好利用面向對象中的多態性。其實上面的功能要求用方法重載完全可以實現,這是面向對象變成應有的做法,避免回到結構化編程模式。只要提供兩個名字和返回值都相同,接受參數類型不同的方法就可以了:

          public double calculate(PhoneBill bill) {
          //計算電話賬單
          }

          public double calculate(GasBill bill) {
          //計算燃氣賬單
          }

          所以,使用instanceof在絕大多數情況下并不是推薦的做法,應當好好利用多態。

          posted @ 2007-04-22 20:24 ZelluX 閱讀(270) | 評論 (0)編輯 收藏

          2007-02-16 19:03:01
          1. 類的復用有兩種方法:組合(composition)和繼承
          組合技術通常用于想在新類中使用現有類的功能而非它的接口這種情形,一般在新類中嵌入一個現有類的private對象。但有時,允許類的用戶訪問新類中的組合部分是極具意義的。如果成員對象自身都隱藏了具體實現,那么將它聲明為public也是安全的。
          2. 為了繼承,一般的規則是將所有的數據成員都指定為private,將所有的方法指定為protected/public。
          3. 編譯器僅會在子類的無參構造器中自動調用父類的無參構造器,如果父類沒有無參構造器,或者要在子類的含參構造器中調用父類的構造器,就必須用關鍵字super顯式地調用父類構造器。
          4. dispose()方法可以將未存于內存之中的東西恢復到對象存在之前的狀態。注意清理的順序與生成的順序相反,先執行類的所有特定的清理動作,然后調用基類的清理方法。
          最好除了內存以外,不要以來垃圾回收器去做任何事。如果需要進行清理,最好是編寫自己的清理方法,但不要依賴finalize()
          5. 做了個實驗,得出父類的private方法會因為子類的同名方法而隱藏,但仍然存在。
          class Father {
          private void f1() {
          System.out.println("Father.f1() is invoked");
          }
          public void f2() {
          f1();
          System.out.println("Father.f2() is invoked");
          }
          }
          class Child extends Father {
          public void f1() {
          System.out.println("Child.f1() is invoked");
          }
          }
          public class TestHiding {
          public static void main(String[] args) {
          Child c = new Child();
          c.f1();
          c.f2();
          }
          }
          6. 對于基本類型,final使數值恒定不變;對于對象引用,final使引用恒定不變,但對象本身是可以被修改的。
          7. 空白final,字段可以被聲明為final而不給定初值,但是必須在每個構造器中對final進行賦值。
          8. final 參數
          void f(final int i) 這樣就不能在f程序塊中修改i的值了
          9. final 方法
          使用final方法的原因有兩個:一是把方法鎖定,以防被繼承類修改;二是效率,將一個方法指明為final,就是同意編輯器將針對該方法的所有調用轉為內嵌調用。
          類中所有的private方法都隱式地指定為是final的,因此對private方法添加final修飾詞沒有什么意義。
          10. final 類
          由于無法被繼承,final類中的所有方法都被隱式地定為final,因為無法覆蓋它們。

          posted @ 2007-04-22 20:24 ZelluX 閱讀(240) | 評論 (0)編輯 收藏

          2007-02-16 17:59:42
          1. 類的訪問權限僅有兩個選擇:包訪問權限或者public。如果不希望其他任何人對該類擁有訪問權限,可以把所有的構造器都指定為private,從而組織任何人創建該類的對象,但是有一個例外,就是在該類的static成員內可以創建。如
          class Soup {
          private Soup() {}
          // (1) Allow creation via static method:
          public static Soup makeSoup() {
          return new Soup();
          }
          // (2) Create a static object and return a reference
          // upon request.(The "Singleton" pattern):
          private static Soup ps1 = new Soup();
          public static Soup access() {
          return ps1;
          }
          public void f() {}
          }

          如果把類構造器都指定為private,別人要使用這個類的話,上面的例子給出了兩種方法:
          1)創建一個static方法,它創建一個新的Soup對象并返回該對象的引用。如果想要在返回引用之前在Soup上做一些額外的工作,或者如果想要記錄到底創建了多少Soup對象(可能要限制其數量),這種做法將會是大有裨益的。
          2)用到了設計模式。這種特定的模式被稱為singleton,這是因為始終只能創建它的一個對象ps1。

          posted @ 2007-04-22 20:24 ZelluX 閱讀(239) | 評論 (0)編輯 收藏

          2007-02-16 15:58:27
          開始加工連連看。一點心得
          1. 窗口設計時應先把所有的組件都加入,設置好大小,然后再setVisible(true);否則就得repaint();一下

          posted @ 2007-04-22 20:24 ZelluX 閱讀(210) | 評論 (0)編輯 收藏

          2007-02-15 17:27:19
          1. 每個編譯單元只能有一個public類,且該類的名稱必須與文件名相同。
          2. 如果兩個含有相同名稱的類的程序庫被導入,使用時應明確指出類的位置。
          3. 不要錯誤地認為Java總是講當前目錄視作是查找行為的起點之一。如果你的CLASSPATH中缺少一個"."作為路徑之一的話,Java就不會查找那里。
          4. private 關鍵字的一個用處:阻止別人直接訪問某個(或全部)構造器
          class Sundae {
          private Sundae() {}
          static Sundae makeASundae() {
          return new Sundae();
          }
          }

          posted @ 2007-04-22 20:23 ZelluX 閱讀(151) | 評論 (0)編輯 收藏


          去某網站注冊個帳號都要身份證,還檢查得那么仔細,汗

          18位身份證標準在國家質量技術監督局于1999年7月1日實施
          的GB11643-1999《公民身份號碼》中做了明確的規定。
          GB11643-1999《公民身份號碼》為GB11643-1989《社會保障
          號碼》的修訂版,其中指出將原標準名稱“社會保障號碼”更名
          為“公民身份號碼”,另外GB11643-1999《公民身份號碼》從實
          施之日起代替GB11643-1989。
          GB11643-1999《公民身份號碼》主要內容如下:
          一、范圍
          該標準規定了公民身份號碼的編碼對象、號碼的結構和表現
          形式,使每個編碼對象獲得一個唯一的、不變的法定號碼。
          二、編碼對象
          公民身份號碼的編碼對象是具有中華人民共和國國籍的公民。
          三、號碼的結構和表示形式
          1、號碼的結構
          公民身份號碼是特征組合碼,由十七位數字本體碼和一位校
          驗碼組成。排列順序從左至右依次為:六位數字地址碼,八位數
          字出生日期碼,三位數字順序碼和一位數字校驗碼。
          2、地址碼
          表示編碼對象常住戶口所在縣(市、旗、區)的行政區劃代碼,
          按GB/T2260的規定執行。
          3、出生日期碼
          表示編碼對象出生的年、月、日,按GB/T7408的規定執行,
          年、月、日代碼之間不用分隔符。
          4、順序碼
          表示在同一地址碼所標識的區域范圍內,對同年、同月、同
          日出生的人編定的順序號,順序碼的奇數分配給男性,偶數分配
          給女性。
          5、校驗碼
          (1)十七位數字本體碼加權求和公式
          S = Ai * Wi, i = 2, ... , 18
          Y = mod(S, 11)
          i: 表示號碼字符從右至左包括校驗碼字符在內的位置序號
          Ai:表示第i位置上的身份證號碼字符值
          Wi:表示第i位置上的加權因子
          i: 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
          Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1
          (2)校驗碼字符值的計算
          Y: 0 1 2 3 4 5 6 7 8 9 10
          校驗碼: 1 0 X 9 8 7 6 5 4 3 2
          四、舉例如下:
          廣東省汕頭市: 440524188001010014

          posted @ 2007-04-22 20:23 ZelluX 閱讀(200) | 評論 (0)編輯 收藏

          2007-02-15 11:23:55
          寫連連看界面時把JButton.x JButton.y JButton.getX() JButton.getY() 給覆蓋掉了,結果老是出現重影,汗啊汗 -,-
          1. 初始化的順序,以Dog類為例
          1)首次創建類型為Dog的對象(構造器可以看成靜態方法),或者Dog類的靜態方法/靜態字段被首次訪問時,Java解釋器必須查找類路徑,以定位Dog.class文件。
          2)載入Dog.class(這將創建一個Class對象),執行有關靜態初始化的所有動作。因此,靜態初始化只在Class對象首次加載的時候進行一次。
          3)當用new Dog()創建對象的時候,首先在堆上為Dog對象分配足夠的存儲空間。
          4)該存儲空間清零,也就自動把Dog對象中的所有基本類型數據設置成了缺省值。
          5)執行所有出現于字段定義處的初始化動作。
          6)執行構造器。這里將會牽涉到很多動作。
          2. 數組初始化
          基本類型的數組在初始化時自動把元素設為“空”值,而對象的數組則設為了null。

          posted @ 2007-04-22 20:23 ZelluX 閱讀(98) | 評論 (0)編輯 收藏

          僅列出標題
          共39頁: First 上一頁 31 32 33 34 35 36 37 38 39 下一頁 
          posts - 403, comments - 310, trackbacks - 0, articles - 7
            BlogJava :: 首頁 :: 新隨筆 :: 聯系 :: 聚合  :: 管理

          2007-02-19 19:47:20
          開始學servlet/jsp,偶的網站:
          不過當且僅當((筆記本在使用狀態) && (在WinXP下))才能訪問, Linux下安裝花生殼動態郁悶出錯,以后再試試

          posted @ 2007-04-22 20:24 ZelluX 閱讀(305) | 評論 (0)編輯 收藏

          2007-02-18 22:08:25
          2007-02-15 16:41:36
          主站蜘蛛池模板: 洞头县| 长宁县| 慈溪市| 巴塘县| 焦作市| 镇宁| 汝城县| 乌鲁木齐市| 都江堰市| 黔东| 深泽县| 农安县| 页游| 留坝县| 东乡族自治县| 潞西市| 石门县| 莱阳市| 万安县| 绥化市| 嘉峪关市| 五华县| 高安市| 两当县| 马山县| 宜宾市| 新安县| 正蓝旗| 青河县| 平舆县| 区。| 柳河县| 赣州市| 师宗县| 谢通门县| 原阳县| 平度市| 防城港市| 耿马| 手机| 遂平县|