VB2008从入门到精通(PDF格式英文版)-第18章

按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！





Imports　Calculator　



Module　Module1　

　　　　Public　Sub　TestSimpleAddition（）　

　　　　　　　　Dim　result　As　Integer　=　Operations。Add（1；　2）　



　　　　　　　　If　（total　　3）　Then　

　　　　　　　　　　　　Console。WriteLine（〃Oops　1　and　2　does　not　equal　3〃）　

　　　　　　　　End　If　

　　　　End　Sub　



　　　　Sub　Main（）　

　　　　　　　　TestSimpleAddition（）　

　　　　　　　　Console。ReadKey（）　

　　　　End　Sub　



End　Module　


…………………………………………………………Page　60……………………………………………………………

38　　　　　　　　　CH　AP　T　E　R　　　2　　　■　　　　L　E　A　R　N　IN　G　　　AB　OU　T　　　。　N　E　T　　N　U　M　B　E　R　　　A　N　D　　　V　A　L　U　E　　　T　Y　P　E　S　　



　　　　　　　　　　　　　　　　　Press　Ctrl＋F5　to　test　the　calculation。　When　executed；　the　testing　console　application　calls　　

　　　　　　　　　　　the　test　method　TestSimpleAddition（）；　which　calls　and　verifies　the　functionality　of　the　Calculator　　

　　　　　　　　　　　　class　library。　If　everything　works；　the　message　will　not　appear。　



　　　　　　　　　　　■Note　　Recall　that　the　Main（）　method　is　where　a　project　begins　its　operation。　To　make　an　application　do　　

　　　　　　　　　　　something；　you　must　add　code　to　its　Main（）　method。　



　　　　　　　　　　　　　　　　　To　see　that　the　test　also　fails；　change　the　Add（）　method　as　follows：　



　　　　　　　　　　　　　　　Public　Shared　Function　Add（ByVal　number1　As　Integer；　ByVal　number2　As　_　

　　　　　　　　　　　　Integer）　As　Integer　

　　　　　　　　　　　　　　　　　　　Return　number1　*　number2　

　　　　　　　　　　　　　　　End　Function　



　　　　　　　　　　　　　　　　　Now　rerun　the　program；　and　you’ll　see　the　failure　message。　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　THE　DEVELOPMENT　CYCLE　



　　　　　　　　　　　　　　So　far　in　this　chapter；　we’ve　dealt　with　three　pieces　of　code：　　



　　　　　　　　　　　　　　　　　o　　　The　code　segment　that　implements　the　Add（）　method　performs　the　calculation　operation。　



　　　　　　　　　　　　　　　　　o　　　The　code　that　represents　a　caller；　which　could　be　either　the　Windows　application　or　the　console　appli

　　　　　　　　　　　　　　　　　　　　　cation；　is　considered　production　code。　



　　　　　　　　　　　　　　　　　o　　　The　code　that　contains　the　production　code　with　some　verification　routines　represents　testing　code。　The　　

　　　　　　　　　　　　　　　　　　　　　testing　code　is　important　because；　if　the　ponent　implementation　is　altered；　you　need　to　rerun　only　　

　　　　　　　　　　　　　　　　　　　　　the　testing　code　to　make　sure　everything　works　as　it　should。　



　　　　　　　　　　　　　　　　　　　　These　three　pieces　of　code　have　demonstrated　a　plete　development　cycle。　



　　　　　　　　　　　Testing　the　Addition　of　Two　Very　Large　Numbers　



　　　　　　　　　　　The　code　and　projects　have　been　organized；　but　we’re　missing　some　tests。　The　current　test　　

　　　　　　　　　　　　adds　two　simple　numbers。　Another　test　could　be　to　add　two　really　big　numbers；　such　as　2　billion　　

　　　　　　　　　　　　and　2　billion。　　

　　　　　　　　　　　　　　　　　The　code　to　test　the　addition　of　two　really　big　numbers　is　shown　in　Figure　2…11。　Add　this　to　　

　　　　　　　　　　　Module1。vb　in　the　TestCalculator　project。　


…………………………………………………………Page　61……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　A　PT　E　R　　　2　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　。　N　E　T　　N　U　M　B　E　R　　　AN　D　　　V　A　L　U　E　　　T　Y　P　E　S　　39　



　　　　　　　　　　　　　　　　　　　　　　　　　　Addition　result　is　

　　　　　　　　　　　　　　　　　　　　　　　　　stored　in　a　variable　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2　billion　added　to　2　billion　



　　Public　Sub　TestReallyBigNumbers（）　

　　　　　　Dim　total　As　Integer　=　Operations。Add（2000000000；　2000000000）　



　　　　　　If　（total　　4000000000）　Then　

　　　　　　　　　　Console。WriteLine（〃Error　found（〃　&　total　&　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　〃）　should　have　been　（4000000000）〃）　

　　　　　　End　If　

　　End　Sub　



　　　　　　　　　　　　　　　　　　　　　　　　　　　Verification　of　addition　is　4　billion　　　　If　there　is　an　error；　a　string　is　built　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　using　concatenation　techniques　



Figure　2…11。　　Testing　the　addition　of　two　large　numbers　



　　　　　　The　test　to　add　two　very　large　numbers　is　identical　to　the　test　to　add　two　simple　numbers；　　

except　for　the　numbers　themselves。　The　error　message　is　handled　a　bit　differently　than　in　the　　

previous　code；　in　that　it　is　built　using　concatenation　techniques。　In　the　example；　a　string　is　　

concatenated　with　an　integer　with　a　string。　Visual　Basic　will　automatically　convert　the　integer　　

into　a　string。　

　　　　　　Often；　you　will　write　tests　where　the　only　real　difference　is　the　data　itself；　not　the　ramifica

tions　of　the　data。　Do　you　think　of　adding　two　very　large　numbers　（such　as　2　billion　plus　2　billion）　　

and　two　smaller　numbers　（such　as　2　plus　2）　as　different？　No；　because　to　humans；　the　major　　

difference　between　2　billion　and　2　is　a　bunch　of　zeros；　the　result　is　either　4　billion　or　4；　which　　

seems　very　trivial。　Yet　with　respect　to　a　puter；　4　billion　is　very　different　from　4；　as　you’ll　　

soon　see。　

　　　　　　Before　you　run　the　test；　you　need　to　add　a　call　to　it　in　the　Main（）　method：　



　　　　Sub　Main（）　

　　　　　　　　TestSimpleAddition（）　

　　　　　　　　TestReallyBigNumbers（）　

　　　　　　　　Console。ReadKey（）　

　　　　End　Sub　



　　　　　　Now　run　the　very　large　number　test。　You　will　see　the　output　shown　in　Figure　2…12。　

　　　　　What　happened？　The　problem　has　to　do　with　the　addition　of　very　large　numbers　that　cause　　

an　overflow；　which　is　a　puter　construct。　


…………………………………………………………Page　62……………………………………………………………

40　　　　　　　　CH　AP　T　E　R　　　2　　　■　　　　L　E　A　R　N　IN　G　　　AB　OU　T　　　。　N　E　T　　N　U　M　B　E　R　　　A　N　D　　　V　A　L　U　E　　　T　Y　P　E　S　　



　　　　　　　　　　　Figure　2…12。　　Visual　Basic　Express　highlighting　the　overflow　error　



　　　　　　　　　　　Understanding　Problems　with　Numeric　Numbers　



　　　　　　　　　　　What　you　understand　as　numbers　and　what　the　puter　understands　as　numbers　are　two　　

　　　　　　　　　　　pletely　different　things。　As　a　child；　you　learn　to　count　starting　at　1　and　ending　at　100；　which　　

　　　　　　　　　　　you　thought　was　a　gargantuan　number。　As　you　grew　up；　you　learned　about　zero　and　numbers　　

　　　　　　　　　　　less　than　zero。　Later；　you　advanced　to　studying　fractions　and　decimal　values。　

　　　　　　　　　　　　　　　　Throughout　all　of　this　learning　about　numbers；　you　considered　the　number　1　and　the　　

　　　　　　　　　　　number　1。5　to　be　the　same　kind　of　thing—that　is；　numbers。　Yet　to　the　puter；　they　are　not　　

　　　　　　　　　　　the　same　type　of　values。　

　　　　　　　　　　　　　　　　The　reason　numbers　are　different　to　puters　has　to　do　with　puter　efficiency　and　　

　　　　　　　　　　　how　the　puter　stores　numbers。　For　those　who　have　learned　the　decimal　system　with　place

　　　　　　　　　　　holders；　you　start　counting　at　0；　continue　to　9；　and　then　the　next　number　is　a　decimal　increment　　

　　　　　　　　　　　called　10。　The　decimal　system　is　originally　accredited　to　the　Babylonians；　but　they　used　a　decimal　　

　　　　　　　　　　　system　that　was　sexagesimal　（60　unique　identifiers　versus　our　decimal　10　unique　identifiers）。　　

　　　　　　　　　　　The　puter　has　a　similar　counting　scheme；　except　it　is　binary　with　only　two　unique　identi

　　　　　　　　　　　fiers：　1　and　0。　puters　have　two　unique　identifiers　because　they　signify　two　unique　states：　　

　　　　　　　　　　　on　and　off。　At　the　heart　of　a　puter　is　a　transistor　that　has　the　ability　to　distinguish　between　　

　　　　　　　　　　　on　and　off；　there　are　no　“sort　of”　on　and　“sort　of”　off　states。　　

　　　　　　　　　　　　　　　　Figure　2…13　shows　an　example　of　how　a　puter　would　count　to　7　using　the　binary　system。　

　　　　　　　　　　　　　　　　In　theory；　you　could　count　until　you　die。　You　have　that　ability　because　you　are　human　and　　

　　　　　　　　　　　have　no　limits　on　how　high　you　can　count。　A　puter　does　have　limits；　such　as　random…access　　

　　　　　　　　　　　memory　（RAM）；　hard　disk；　and　so　on。　Specific　numeric　data　types　on　a　puter　also　have　　

　　　　　　　　　　　limits　on　how　high　they　can　count。　For　example；　the　Integer　data　type　that　we　have　been　using　　

　　　　　　　　　　　can　count　to　only　a　specific　number　and　can　store　only　whole　numbers。　　

　　　　　　　　　　　　　　　　Think　of　the　different　numeric　data　types　as　odometers。　Most　car　odometers　have　upper　　

　　　　　　　　　　　limits　of　1　million　miles/kilometers。　Imagine　adding　900；000　and　200；000　using　an　odometer。　　

　　　　　　　　　　　The　result　would　be　100；000；　and　not　the　1。1　million　that　you　expected。　This　is　exactly　the　　

　　　　　　　　　　　problem　that　we　encountered　when　adding　2　billion　and　2　billio