[Lecture Notes]Object-Oriented Software Development

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

本帖隐藏的内容

http://homepage.cs.uiowa.edu/~tinelli/classes/022/Spring15/lectures.shtml

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Development Oriented software Lecture Develop Software

1. /*
   
2.    CS:2820 Object Oriented Software Development
   
3.    Spring 2015
   
4.    The University of Iowa
   
5.    
   
6.    Instructor: Cesare Tinelli
   
7. */
   
8. 
   
9. 
   
10. 
    
11. /* Subtype polymorphism and dynamic binding */
    
12. 
    
13. class A {
    
14.   def f = println("f says: ``I'm f from A''")
    
15.   def g = {println("g says: ``I'm g from A, calling f''"); f}
    
16. }
    
17. 
    
18. val a = new A
    
19. 
    
20. a.f // will call method f from class A
    
21. 
    
22. a.g
    
23. 
    
24. class AA extends A {
    
25.   override def f = println("f says: ``I'm f from AA''")
    
26.   // Does not exist in A
    
27.   def h(n: Int) = n + 1
    
28. }
    
29. 
    
30. val aa = new AA
    
31. 
    
32. aa.f  // will call method f from AA
    
33. aa.g  // will call method g from A, which will then call f from _AA_
    
34. 
    
35. 
    
36. val a1:A = new AA // a1 has static type A, but dynamic type AA
    
37. 
    
38. a1.f // still calling f from AA!
    
39. 
    
40. a1.h // a1 is considered an A, and h is not a member of A. Error.
    
41. 
    
42. def m(a:A) = a.h
    
43. 
    
44. def m(a:A) = a.f
    
45. 
    
46. val aa = new AA
    
47. 
    
48. m(aa)
    
49. 
    
50. 
    
51. class AB extends A {}
    
52. 
    
53. 
    
54. val ab = new AB
    
55. 
    
56. ab.f  // calls f from A because it was not redefined in AB
    
57. 
    
58. 
    
59. class AAA extends AA {
    
60.   override def f = println("f says:I'm f from AAA")
    
61. }
    
62. 
    
63. 
    
64. val aaa: A = new AAA
    
65. 
    
66. aaa.g // most recent overriding is the one that matters
    
67. 
    
68. 
    
69. 
    
70. 
    
71. /* More on classes and inheritance in Scala */
    
72. 
    
73. /* Example adapted from Programming in Scala, Second Edition
    
74.    by Martin Odersky, Lex Spoon, and Bill Venners.
    
75.    Artima, 2010.
    
76. */
    
77. 
    
78. 
    
79. /* We want to work with "text boxes"
    
80.    A text box is an abstraction for a box of text
    
81.    consisting of one or more lines of the same length
    
82. */
    
83. 
    
84. /* Abstract classes */
    
85. 
    
86. abstract class TextBox {
    
87.   // contents returns the content of the textbox in an array,
    
88.   // with each element of the array containing one line
    
89.   // of the box, from top to bottom
    
90.   def contents(): Array[String]
    
91.   // height returns the number of lines in the text box
    
92.   def height(): Int
    
93.   // width returns the maximum length of the lines
    
94.   def width(): Int
    
95. }
    
96.   
    
97. new TextBox // gives error, abstract classes cannot be instantiated
    
98. 
    
99. 
    
100. // Scala allows parameterless methods
     
101. // It also allows the definition of some methods directly
     
102. // in an abstract class. These methods can use fields and
     
103. // methods defined in the abstract class itself, but they
     
104. // cannot use private fields and methods in concrete classes
     
105. // that implement the abstract class.
     
106. abstract class TextBox {
     
107.   def contents: Array[String]
     
108. 
     
109.   // height can be computed by obtaning the contents
     
110.   // array and returning its length
     
111.   def height: Int = contents.length
     
112. 
     
113.   // width can be computed by finding the maximum length among the lines
     
114.   def width: Int
     
115. }
     
116. 
     
117. 
     
118. 
     
119. 
     
120. /* Extending classes */
     
121. 
     
122. // Array Box is concrete class implementing text boxes
     
123. // by means of an array.
     
124. class ArrayBox(lines: Array[String]) extends TextBox {
     
125.     // since the text box is actually stored in an array
     
126.     // (as expected), content is implemented simply by
     
127.     // returning that array
     
128.     def contents: Array[String] = lines
     
129. }
     
130. 
     
131. val a = new ArrayBox(Array("hello", "world"))
     
132. 
     
133. a.width
     
134. 
     
135. a.height
     
136. 
     
137. 
     
138. 
     
139. 
     
140. /* Overriding methods and fields */
     
141. 
     
142. class ArrayBox(conts: Array[String]) extends TextBox {
     
143.     def contents: Array[String] = conts
     
144. }
     
145. 
     
146. // we can eliminate the need for the parameter lines above
     
147. // by turning contents into a field.
     
148. // putting the field in the parameter list makes it directly
     
149. // initializable by the constructor
     
150. 
     
151. class ArrayBox(
     
152.     val contents: Array[String]
     
153.     ) extends TextBox {
     
154. }
     
155. 
     
156. val a = Array("abc","123")
     
157. val ab = new ArrayBox(a) // contents is directly set to the value of a
     
158. 
     
159. 
     
160. /* Invoking superclass constructors */
     
161. 
     
162. // A line box is a text box with exactly one line
     
163. // We could implemened concretely as a special case of
     
164. // an array box
     
165. // we can override the definition of width and height
     
166. // with a more efficient one though
     
167. class LineBox(s: String) extends ArrayBox(Array(s)) {
     
168.     override def width = s.length
     
169.     override def height = 1
     
170. }
     
171. 
     
172. // A uniform box is a text box filled uniformly with the
     
173. // same character
     
174. // Its constructor needs the height and the width in advance
     
175. // We can override the method height and width of TextBox
     
176. // directly with parameters now
     
177. class UniformBox(
     
178.     ch: Char,
     
179.     override val width: Int,
     
180.     override val height: Int
     
181.     ) extends TextBox {
     
182.   private val line = ch.toString * width
     
183.   val contents = Array.fill(height)(line)
     
184. }
     
185. 
     
186. 
     
187. 
     
188. 
     
189. /* Composition vs inheritance */
     
190. 
     
191. // Is a LineBox really an ArrayBox?
     
192. // Not really, it is just a special case of a Text Box
     
193. // We do not need an array to implement it
     
194. // so maybe we should define it directly as a subclass
     
195. // of TextBox and store its content in a string
     
196. class LineBox(s: String) extends TextBox {
     
197.     val contents = Array(s)   // one line array
     
198.     // we can replace the generic implementations of
     
199.     // height and width by more efficient versions here too
     
200.     override val width = s.length
     
201.     override val height = 1
     
202.   }
     
203. 
     
204. val b1: TextBox = new ArrayBox(Array("hello", "world"))
     
205. 
     
206. val a: ArrayBox = new LineBox("hello")
     
207. 
     
208. val b2: TextBox = a
     
209. 
     
210. val b3: TextBox = new UniformBox('x', 2, 3)
     
211. 
     
212.   
     
213. 
     
214. /* Implementing above, beside, and toString */
     
215. 
     
216. object TB { // we pack all text box classes into module TB
     
217.   abstract class TextBox {
     
218.     def contents: Array[String]
     
219.     def height: Int = contents.length
     
220.     def width: Int = if (height == 0) 0 else contents(0).length
     
221. 
     
222.     // above puts a box on top of another into a new box
     
223.     // Assumes the two boxes to have the same width
     
224.     def above(that: TextBox): TextBox =
     
225.       new ArrayBox(this.contents ++ that.contents)
     
226. 
     
227.     // besides puts one box beside another into a new box
     
228.     // Assures the two boxes to have the same height
     
229.     def beside(that: TextBox): TextBox = {
     
230.       val contents = new Array[String](this.contents.length)
     
231.       for (i <- 0 until this.contents.length)
     
232.         contents(i) = this.contents(i) + that.contents(i)
     
233.       new ArrayBox(contents)
     
234.     }
     
235. 
     
236.     // toString puts all lines of the text box into a single
     
237.     // string, separating them with a new line character
     
238.     override def toString = contents mkString "\n"
     
239.   }
     
240. 
     
241.   class LineBox(s: String) extends TextBox {
     
242.     val contents = Array(s)
     
243.     override val width = s.length
     
244.     override val height = 1
     
245.   }
     
246. 
     
247.   class ArrayBox(conts: Array[String]) extends TextBox {
     
248.     def contents: Array[String] = conts
     
249.   }
     
250. }
     
251. 
     
252. 
     
253. import TB._ // imports all the contents of TB
     
254. 
     
255. val l1 = new LineBox("Han ")
     
256. val l2 = new LineBox("Solo ")
     
257. val l3 = new LineBox("Luke ")
     
258. val l4 = new LineBox("Skywalker ")
     
259. 
     
260. val b1 = l1 beside l2
     
261. val b2 = l3 beside l4
     
262. 
     
263. val b3 = b1 above b2
     
264. 
     
265. b3.height
     
266. b3.width

复制代码