VB2008从入门到精通(PDF格式英文版)-第79部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！



　　　　　　　　　　　　　　　Public　WearsHats　As　Boolean　

　　　　　　　　　　　　　　　Public　RunsSlowly　As　Boolean　

　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　　In　this　definition；　each　attribute　of　PersonWithAttributes　is　its　own　data　member。　Another　　

　　　　　　　　　　　way　to　achieve　the　same　effect　is　to　consider　each　attribute　as　its　own　binary　flag　that　is　encoded　　

　　　　　　　　　　　into　PersonWithAttributes。　The　class　would　be　rewritten　as　follows：　



　　　　　　　　　　　Class　PersonWithAttributes　　

　　　　　　　　　　　　　　　Public　Attributes　As　Integer　

　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　　In　the　rewritten　example；　the　Boolean　attributes　are　encoded　into　the　data　member　　

　　　　　　　　　　　Attributes　using　bitwise　operators。　　

　　　　　　　　　　　　　　　　To　encode　a　flag　in　a　number　means　to　tweak　the　individual　binary　bits　of　a　number。　To　　

　　　　　　　　　　　access　the　individual　bits；　you　need　to　create　constant　numbers　that　are　a　power　of　2。　We　use　a　　


…………………………………………………………Page　441……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　419　



power　of　2　convention　because　binary　is　a　counting　system　based　on　the　power　of　2。　Thus；　the　　

three　Boolean　data　members　are　converted　to　constants：　



Const　isTall　As　Integer　=　1　

Const　wearsHats　As　Integer　=　2　

Const　runsSlow　As　Integer　=　4　　



　　　　　Now　you　could　create　a　person　that　is　tall　and　runs　slowly；　like　this：　



Dim　person　As　PersonWithAttributes　=　New　PersonWithAttributes（）　

person。Attributes　=　isTall　Or　runsSlow　



　　　　　The　variable　person。Attributes　is　assigned　the　operations　of　isTall　and　runsSlow。　So　if　　

isTall　is　0001；　and　runsSlow　is　0100；　taking　the　bitwise　OR　（Or）　of　the　two　values　results　in　0101。　

　　　　　A　bitwise　OR　is　when　you　pare　two　values；　and　if　either　value　is　nonzero；　then　the　　

answer　is　nonzero。　If　you　were　to　convert　the　binary　number　into　a　decimal　number；　you　would　　

get　the　value　of　5。　You　could　verify　that　the　person　isTall　like　this：　



If　（person。Attributes　And　isTall）　　0　Then　

　　　　Console。WriteLine（〃Person　is　tall〃）　

Else　　

　　　　Console。WriteLine（〃Person　is　not　tall〃）　

End　If　



　　　　　A　bitwise　shift　is　the　shifting　of　the　bits　to　the　left　or　to　the　right　by　the　number　of　places　indi

cated　by　the　shift。　The　following　code　demonstrates　shifting　the　bits　two　places　to　the　left　（》　2　



　　　　　The　result　is　2；　which　has　the　binary　value　10。　

　　　　　For　the　most　part；　you　probably　will　not　use　the　binary　shift　operators。　Unless　you　are　dealing　　

with　hardware…related　programming　（such　as　GUI　interactions）；　whatever　you　can　do　with　　

flags　can　be　replicated　using　a　bination　of　Boolean　types　and　structures。　However；　when　　

you　do　encounter　bitwise　operators；　you　will　recognize　what　they　are　doing。　　



Modulus　



The　modulus　operator　（Mod）　is　very　useful　when　you　want　to　perform　division　operations　and　　

need　to　know　how　much　is　left　over。　For　example；　the　following　calculation　yields　a　value　of　3。　



Dim　a　As　Integer　=　17　/　5　


…………………………………………………………Page　442……………………………………………………………

420　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　　　　　　Yet　because　it　is　an　integer　division；　you　don’t　know　if　the　value　is　evenly　divided　by　5。　The　　

　　　　　　　　　　following　calculation　lets　you　figure　out　the　remainder　for　the　division。　



　　　　　　　　　　Dim　remainder　As　Integer　=　17　Mod　5　



　　　　　　　　　　Increment　and　Decrement　　



　　　　　　　　　　The　increment　（＋=）　and　decrement　（　…=）　operators　are　useful　in　place　of　the　addition　and　subtrac

　　　　　　　　　　tion　operators。　Visual　Basic　also　has　the　*=　and　/=　operators；　which　you　can　use　in　place　of　the　　

　　　　　　　　　　multiplication　and　division　operators。　The　idea　behind　these　operators　is　to　perform　an　operation　　

　　　　　　　　　　on　the　variable　itself。　

　　　　　　　　　　　　　　　Let’s　say　you　execute　this　code：　



　　　　　　　　　　Dim　a　As　Integer　=　2　

　　　　　　　　　　a　＋=　1　



　　　　　　　　　　　　　　　Then　after　the　increment　operation；　the　variable　a　will　have　a　value　of　3。　



　　　　　　　　　　Overloading　Operators　



　　　　　　　　　　Suppose　you　want　to　implement　a　special　type；　such　as　a　plex　number　type；　and　want　to　　

　　　　　　　　　　support　the　＋　sign。　To　do　so；　you　would　need　to　implement　the　＋　operator；　which；　in　turn；　over

　　　　　　　　　　loads　the　＋　operator。　

　　　　　　　　　　　　　　　As　an　example；　let’s　walk　through　implementing　the　＋　operator　for　the　plex　number　　

　　　　　　　　　　type。　plex　numbers　are　numbers　that　have　two　parts：　real　and　imaginary。　For　example；　a　＋　b　　

　　　　　　　　　　is　a　plex　number；　where　a　is　the　real　part　and　b　is　the　imaginary　part。　To　add　a　plex　　

　　　　　　　　　　number；　you　add　the　real　parts；　and　then　add　the　imaginary　parts；　and　that　gives　you　the　new　　

　　　　　　　　　　number。　The　following　is　the　plex　number　type；　plexType；　declaration。　



　　　　　　　　　　Public　NotInheritable　Class　plexType　

　　　　　　　　　　　　　　Private　ReadOnly　_imaginary　As　Double　

　　　　　　　　　　　　　　Private　ReadOnly　_real　As　Double　



　　　　　　　　　　　　　　Public　Sub　New（ByVal　real　As　Double；　ByVal　imaginary　As　Double）　

　　　　　　　　　　　　　　　　　　_real　=　real　

　　　　　　　　　　　　　　　　　　_imaginary　=　imaginary　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　　　　　Public　Overrides　Function　ToString（）　As　String　

　　　　　　　　　　　　　　　　　　Return　String。Concat（New　Object（）　｛〃（〃；　_real；　〃）　（〃；　_imaginary；　〃）i〃｝）　

　　　　　　　　　　　　　　End　Function　



　　　　　　　　　　　　　　Public　ReadOnly　Property　Imaginary（）　As　Double　

　　　　　　　　　　　　　　　　　　Get　

　　　　　　　　　　　　　　　　　　　　　　Return　_imaginary　

　　　　　　　　　　　　　　　　　　End　Get　

　　　　　　　　　　　　　　End　Property　


…………………………………………………………Page　443……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　421　



　　　　Public　ReadOnly　Property　Real（）　As　Double　

　　　　　　　　Get　

　　　　　　　　　　　　Return　_real　

　　　　　　　　End　Get　

　　　　　　　　Set（ByVal　value　As　Double）　

　　　　　　　　　　　　_real　=　value　

　　　　　　　　End　Set　

　　　　End　Property　

End　Class　



　　　　　plexType　is　an　immutable　type　that　has　two　data　members　representing　the　real　and　　

imaginary　number　parts。　

　　　　　The　goal　is　to　define　the　＋　operator　so　that　the　following　code　can　be　piled。　



Dim　a　As　plexType　=　New　plexType（1。0；　10。0）　

Dim　b　As　plexType　=　New　plexType（2。0；　20。0）　



Dim　c　As　plexType　=　a　＋　b　



　　　　　Overloading　the　＋　operator　means　to　add　a　method　that　has　a　special　notation。　The　following　　

is　the　modified　plexType　type　with　the　overloaded　operator　implemented　（bolded）。　



Public　NotInheritable　Class　plexType　

　　　　Private　ReadOnly　_imaginary　As　Double　

　　　　Private　ReadOnly　_real　As　Double　



　　　　Public　Sub　New（ByVal　real　As　Double；　ByVal　imaginary　As　Double）　

　　　　　　　　_real　=　real　

　　　　　　　　_imaginary　=　imaginary　

　　　　End　Sub　



　　　　Public　Shared　Operator　＋（ByVal　a　As　plexType；　ByVal　b　As　plexType）　_　

　　　　　　As　plexType　

　　　　　　　　Return　New　plexType（（a。Real　＋　b。Real）；　（a。Imaginary　＋　b。Imaginary））　

　　　　End　Operator　



　　　　Public　Overrides　Function　ToString（）　As　String　

　　　　　　　　Return　String。Concat（New　Object（）　｛〃（〃；　_real；　〃）　（〃；　_imaginary；　〃）i〃｝）　

　　　　End　Function　



　　　　Public　ReadOnly　Property　Imaginary（）　As　Double　

　　　　　　　　Get　

　　　　　　　　　　　　Return　_imaginary　

　　　　　　　　End　Get　

　　　　End　Property　


…………………………………………………………Page　444……………………………………………………………

422　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　　　　　Public　ReadOnly　Property　Real（）　As　Double　

　　　　　　　　　　　　　　　　　　Get　

　　　　　　　　　　　　　　　　　　　　　　Return　_real　

　　　　　　　　　　　　　　　　　　End　Get　

　　　　　　　　　　　　　　End　Property　



　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　　The　declaration　of　the　overloaded　operator　is　a　specially　defined　function；　which　follows　　

　　　　　　　　　　these　rules：　



　　　　　　　　　　　　　　　o　　The　method　is　always　declared　as　Shared　in　the　context　of　the　type。　



　　　　　　　　　　　　　　　o　　The　method　has　a　return　type；　which　should　be　the　type　that　you　want　to　construct。　In　　

　　　　　　　　　　　　　　　　　　most　cases；　it　is　the　type　of　the　declaration　（except　where　a　Boolean　is　required）。　



　　　　　　　　　　　　　　　o　　The　method　identifier　starts　with　the　keyword　Operator；　followed　by　a　space；　and　then　　

　　　　　　　　　　　　　　　　　　the　operator　being　overloaded　（＋；　…；　and　so　on）。　



　　　　　　　　　　The　GoTo　Statement　



　　　　　　　　　　The　GoTo　statement　allows　you　to　jump　from　one　spot　in　the　code　to　another。　In　the　past；　when　　

　　　　　　　　　　we　did　not　have　objects；　methods；　and　other　advanced　programming　constructs；　developers　　

　　　　　　　　　　used　the　GoTo　statement　because　they　had　no　other　choice。　Currently；　many　in　the　software　　

　　　　　　　　　　industry　dislike　the　GoTo　statement。　They　think　that　the　GoTo　statement　is　a　sign　of　poor　program

　　　　　　　　　　ming；　and　that　you　never　need　to　use　it。　The　Channel　9　forum　（http：//channel9。msdn。/　

　　　　　　　　　　　ShowPost。aspx？PageIndex=1&PostID=14652）　has　a　good　discussion　on　the　use　of　GoTo　statements。　　

　　　　　　　　　　In　this　discussion；　a　person　who　was　against　the　GoTo　statement　said　this：　



　　　　　　　　　　　　　　　　The　only　possible　exception　would　be　if　you　are　doing　some　sort　of　puter　graphics　

　　　　　　　　　　　　　　　　app；　where　I　would　tolerate　a　（for　y）　（for　x）　nesting；　because　the　inner　loop　is　likely　to　be　

　　　　　　　　　　　　　　　　quite　simple　and　the　structure　makes　more　sense　as　an　entirety。　



　　　　　　　　　　　　　　　　So；　he　would　tolerate　the　GoTo　statement　in　a　specific　situation；　and　that　means　that　one　　

　　　　　　　　　　can’t　argue　that　GoTo　is　all　bad。　　

　　　　　　　　　　　　　　　　What　I　like　about　how　Visual　Basic　implemented　GoTo　is　that　it　is　designed　to　solve　a　partic

　　　　　　　　　　ular　problem；　but　not　raise　the　old　problems　of　spaghetti　code　making　a　mess　of　things。　So　if　　

　　　　　　　　　　you　need　to　use　a　GoTo　statement；　go　ahead；　just　don’t　use　it　excessively。　　

　　　　　　　　　　　　　　　　One　example　where　it　is　not　easily　possible　to　avoid　using　a　GoTo　statement　is　in　the　　

　　　　　　　　　　following　pseudo…code。　



　　　　　　　　　　Do　While　FirstActionLoop（）　

　　　　　　　　　　　　　　Do　While　SecondActionLoop（）　

　　　　　　　　　　　　　　　　　　If　BreakOutOfLoops（）　Then　

　　　　　　　　　　　　　　　　　　　　　　GoTo　EXIT_ALL　

　　　　　　　　　　　　　　　　　　End　If　

　　　　　　　　　　　　　　Loop　

　　　　　　　　　　　Loop　

　　　　　　　　　　　EXIT_ALL：　


…………………………………………………………Page　445……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　423　



　　　　　This　code　has　two　loops。　If　the　code　is　executing　the　second　loop　and　decides　to　end　pro

cessing；　then　exiting　the　loop　bees　a　bit　tricky；　as　you　can　break　execution　only　one　loop　at　a　　

time　using　the　　Exit　Do　statement。　Thus；　one　solution　is　to　use　the　GoTo　statement；　as　shown。　

　　　　　The　GoTo　statement　is　associated　with　an　identifier　that　represents　a　label。　The　label　can　be　　

placed　almost　anywhere　in　the　declared　method。　An　exception　is　that　you　can’t　place　a　label　in　　

a　Select　statement。　However；　you　can　place　the　label　before　or　after　the　GoTo　keyword。　



　Generics　Constraints　



　generics　have　been　covered　in　several　chapters。　An　additional　aspect　of　　generics　is　　

constraints；　which　can　be　optionally　used　to　optimize　programming。　Constraints　limit　the　types　　

that　the　parameter　can　be。　

　　　　　Three　types　of　constraints　are　Class；　New；　and　a　specific　type。　As　a　general　rule；　a　constraint　　

is　added　in　the　form　of　an　As　statement；　as　follows：　



Class　Example（Of　DataType　As　｛New｝）　

End　Class　



　　　　　This　example　limits　DataType　to　types　that　have　a　default　constructor。　



Using　the　Type　Constraint　



Type　constraints　allow　you　to　associate　a　minimal　type　with　the　　generics　parameter。　For　　

example；　suppose　this　interface　is　defined：　



　　　　Interface　IExample　　

　　　　　　　　Sub　Method（）　

　　　　End　Interface　



　　　　　Adding　an　　IExample　constraint　to　the　　generics　parameter　allows　you　to　define　a　class　　

as　follows：　



Class　ExampleMgr（Of　DataType　As　｛　IExample｝）　　

　　　　Private　_inst　As　DataType　



　　　　Public　Sub　New（ByVal　inst　As　DataType）　　

　　　　　　　　_inst　=　inst　

　　　　End　Sub　



　　　　Public　Sub　DoSomething（）　　

　　　　　　　　_inst。Method（）　

　　　　End　Sub　

End　Class　



　　　　　In　the　example；　the　constraint　of　IExample　allows　a　developer　to　call　Method（）。　If　the　constraint　　

were　not　there；　the　reference　to　Method　would　generate　a　piler　error；　because　Method（）　is　　

not　a　method　of　DataType。　

　　　　　But　is　this　ability　to　reference　a　method　an　advantage？　After　all；　you　could　write　the　　

ExampleMgr　code　without　using　　generics；　like　this：　


…………………………………………………………Page　446……………………………………………………………

424　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　Class　ExampleMgr　　

　　　　　　　　　　　　　　Dim　_inst　As　IExample　



　　　　　　　　　　　　　　Public　Sub　New（ByVal　inst　As　IExample）　

　　　　　　　　　　　　　　　　　　Me。_inst　=　inst　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　　　　　Public　Sub　DoSomething（）　　

　　　　　　　　　　　　　　　　　　_inst。Method（）　

　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　The　　generics　code　and　the　interface…based　code　do　the　exact　same　thing；　and　using　　

　　　　　　　　　　　generics　offers　no　advantage　in　this　example。　But　that　is　not　always　the　case。　Consider　the　　

　　　　　　　　　　following　modified　example　of　　ExampleMgr。　



　　　　　　　　　　Class　ExampleMgr（Of　DataType　As　｛　IExample　｝）　

　　　　　　　　　　　　　　Dim　_inst　As　DataType　　



　　　　　　　　　　　　　　Public　Sub　New（ByVal　inst　As　IExample）　

　　　　　　　　　　　　　　　　　　Me。_inst　=　CType（inst；　DataType）　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　　　　　Public　Sub　DoSomething（）　　

　　　　　　　　　　　　　　　　　　_inst。Method（）　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　　　　　Public　ReadOnly　Property　Inst（）　As　DataType　

　　　　　　　　　　　　　　　　　　Get　　

　　　　　　　　　　　　　　　　　　　　　　Return　_inst　

　　　　　　　　　　　　　　　　　　End　Get　

　　　　　　　　　　　　　　End　Property　

　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　With　　generics；　you　can　write　a　property　that　contains　a　reference　to　the　base　type。　Had　　

　　　　　　　　　　you　used　the　pure　interface…based　code；　the　　Inst　property　would　need　to　be　of　type　IExample；　and　　

　　　　　　　　　　to　get　the　same　effect　as　the　　generics　example；　a　cast　would　be　involved。　A　cast　is　not　the　　

　　　　　　　　　　end　of　the　world；　but　it　is　inconvenient　and　not　type…safe；　since　you　don’t　know　if　a　cast　will　　

　　　　　　　　　　work　until　you　execute　the　code。　

　　　　　　　　　　　　　　　You　can　add　multiple　interfaces　and　classes　as　constraints；　although　you　are　limited。　The　　

　　　　　　　　　　limitations　are　identical　to　the　limitations　when　subclassing　a　class　or　interface：　



　　　　　　　　　　　　　　　o　You　can　subclass　only　a　sing