[Lecture Notes]Object-Oriented Software Development

1关注
62粉丝

VIP

已卖：4897份资源

学术权威

14%

还不是VIP/贵宾

-

TA的文库 其他...

R资源总汇

Panel Data Analysis

Experimental Design

0%

威望: 1 级
论坛币: 49635 个
通用积分: 55.6937
学术水平: 370 点
热心指数: 273 点
信用等级: 335 点
经验: 57805 点
帖子: 4005
精华: 21
在线时间: 582 小时
注册时间: 2005-5-8
最后登录: 2023-11-26

楼主

ReneeBK 发表于 2016-8-20 01:18:42 |AI写论文

是否 +2 论坛币

k人参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

http://homepage.cs.uiowa.edu/~ti ... ng15/lectures.shtml

扫码加我拉你入群

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

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

分享0 收藏1 回帖

关键词：Development Oriented software Lecture Develop Software

相关帖子

沙发

ReneeBK 发表于 2016-8-20 01:20:55

/*
CS:2820 Object Oriented Software Development
Spring 2015
The University of Iowa
Instructor: Cesare Tinelli
*/
/* Scala examples seen in class */
/* static scoping rules */
val a = 10
def f (x:Int) = a + x
f(4)
// *new* immutable variable a, distinct from the previous one
val a = 100
// the new a shadows the old one
a
// however, the old one is unchanged
f(4)
// blocks can contain both expression *and* (variable/method) definitions
// variable k1 is visible only in the block in which it is declared
{val k1 = 4
k1*k1
}
k1 // error
// within
{val x = 4
val x = 5
x
}
// local declarations shadow less local ones
val k = 1
{val k = 2;
{val k = 3
println(k)
}
println(k)
}
println(k)
// there is no shadowing within the same block though
{val x = 4
val x = 5 // will generate an error
x
}
// method definitions can have local scope too
{def h(x:Int) = x + 1
h(9)
}
h(9) // error
// this implies that methods can be defined locally
// within other methods
def f (x:Int) = {
def square (x:Int) = x * x
def double (x:Int) = x + x
square(x) - double(x)
}
// Scala has while "statements" too.
// As in the case of if, they are actually expressions of type Unit.
// While can be seen a mixfix operator with two arguments:
//
// while (_) _
//
// the first argument takes an expression of type bool,
// the second takes any expression
var j = 10
while (j > 0) j = j - 1
val u = while (j > 0) j = j - 1
// the second argument of while can be a block
j = 6
while (j > 0) {
println(j)
j = j - 1
}
// a block of two expressions, both of type Unit
{
j = 8
while (j > 0) {
println(j)
j = j - 1
}
}
// The body of a method can be a block
def print_range(m:Int, n:Int) = {
var i = m
println()
while (i <= n) {
print(i + " ")
i = i + 1
}
println()
}
print_range(4,9)
// imperative-style definition of factorial function
def fact (n:Int) = {
var i = n
var f = 1
while (i > 0) {
f = f * i
i = i - 1
}
f
}
// functional style, recursive definition of factorial
def rfact (n:Int) = if (n <= 1) 1 else n * rfact(n-1)
// declaring the return type of recursive methods is mandatory
def rfact (n:Int):Int = {
if (n <= 1)
1
else
n * rfact(n-1)
}
/* Pattern matching */
val t = (3,5,2)
// declare three new variables x1,x2,x3;
// the value of xi is the value of t's i-th component;
// the pattern (x1,x2,x3) is matched against (3,5,2)
val (x1,x2,x3) = t
// _ is for "don't care" positions
val (y1,y2,_) = t
// pattern matching can be used with nested patterns
val t = ((2,3),5,(6,2))
val (_, x, _) = t
val (_, _, (x,_)) = t
// patterns are extremely useful with the match construct:
//
// (_ match {case _ => _ ... case _ => _})
//
// the first argument of match is match agains the pattern given
// between case and => ;
// patterns are checked one at a time, top-down;
// the value of the whole match construct is the value of the expression
// on the right of the matching pattern
var n = 1
n match {
case 0 => "zero"
case 1 => "one"
case _ => "other"
}
// All right-hand sides of a 'case' clause must be of the same type
// if all cases fail an exception is raised
n match {
case 0 => "zero"
}
// match and patterns allow one to write cleaner and more compact code
def convert (n:Int) =
n match {
case 0 => "zero"
case 1 => "one"
case _ => "other"
}
// the bodies of the case statements can be any expression (in particular a block)
// but, like in the the two branches of the if construct, they all have to be of
// same type
def p (n: Int) =
n match {
case 0 => {
print("You entered ")
println("zero")
} // type of this is Unit
case _ => {
print("You did not enter ")
println("zero")
} // type of this is Unit
}
// patterns can be complex and nested
var v = (1, 2)
v match {
case (0, 0) => "a"
case (0, _) => "b"
case (_, 0) => "c"
}
// bothZero returns "OK" if both of its arguments are 0
// Otherwise it returns "NotOK"
// common (bad) coding style
def bothZero (x1:Int, x2:Int) = {
if (x1 == 0) {
if (x2 == 0)
"OK"
else
"NotOK"
}
else
"NotOK"
}
// same method but using match
def bothZero (x1:Int, x2:Int) =
(x1, x2) match {
case (0, 0) => "OK"
case _ => "NotOK"
}
// the input here is already a pair that can be pattern matched
// directly
def bz (p:(Int, Int)) =
p match {
case (0, 0) => true
case _ => false
}
def and (p:(Boolean, Boolean)) =
p match {
case (true, y) => y
case (false, _) => false
}
// the scope of a pattern variable in a case is the body of that case
def and (p:(Boolean, Boolean)) =
p match {
case (true, y) => y
case (false, _) => y // y is undefined here
}
// factorial with match
def fact (n:Int):Int =
n match {
case 0 => 1
case _ => n * fact(n - 1)
}
// you can match several values at the same time by putting them into a tuple
(0 < 1, 1 == 1) match {
case (true, y) => y
case (false, _) => false
}
// the match construct too builds expressions
val r = (0 < 1, 1 == 1) match {
case (true, y) => y
case (false, _) => false
}

复制代码

藤椅

ReneeBK 发表于 2016-8-20 01:21:55

/*
CS:2820 Object Oriented Software Development
Spring 2015
The University of Iowa
Instructor: Cesare Tinelli
*/
/* Scala examples seen in class */
/* Collections: Lists */
// lists are finite sequences of elements
val l = List(1, 2, 3)
// Main list methods
l.head
l.tail
l.length
// individual elements can be accessed with this syntax
// with indices starting at zero (like in arrays)
l(0) // first element of l
l(3) // fourth element of l
// a list can be built with elements of *any* type,
// but all elements must be of the *same* type
List('a', 'b')
List("hi", "there")
List((1, 2), (1, 4))
List(List(1, 2), List(1, 4, 3))
List(1, "a") // types as a list of Any
val l1 = List(1, 2, 3)
val l2 = List(1, 2, 3)
// list identity
l1 eq l2
val l3 = l1
l1 eq l3
// structural equality
l1 == l2
// order and number of occurrences of elements matters for equality
List(1,2,3) == List(2,1,3)
List(1,2) == List(1,2,2)
// Empty list, prints as List()
Nil
// Evaluates to Nil
List()
Nil eq List()
// bad practice, gives you a list of elements of type Nothing.
val l = List()
// recommended, specify the element type of an empty list explicitly
val il = List[Int]()
var x = List("a", "b")
// Causes an implicit conversion of 1 and 2 to Long.
var y = List[Long](1, 2)
// if T1 and T2 are different types,
// List[T1] is a different type from List[T2]
// no implict conversions are defined for them
x = il
y = il
// Lists are built by increasingly adding elements in front
// of Nil with the "cons" operator ::
val x = 6 :: Nil
val y = 5 :: x
// note that x is unchanged
x
y.tail eq x
// :: is right associative.
3 :: 4 :: Nil
// same as
3 :: (4 :: Nil)
// List(3, 4) can be understood as syntactic sugar for
3 :: (4 :: Nil)
3 :: 4 // error, right-hand argument not a list
// can mix and match notation
3 :: List(4)
// note type here
List(7) :: Nil
val l = List(1, 2, 3)
// invariant defining head and tail in terms of ::
// for any non-empty list
//
(l.head :: l.tail) == l
// pattern matching also works with ::
val h :: t = l
// why it works: l is really 1 :: (2 :: (3 :: Nil))
val h :: t = 1 :: (2 :: (3 :: Nil))
// deeper patters for lists with at least two elements
val x1 :: x2 :: t = l
val x1 :: x2 :: x3 :: t = l
val x1 :: x2 :: x3 :: x4 :: t = l // fails because l has < 4 elements
// 'List' syntax can also be used for pattern matching
val List(x1, x2, x3) = l
// fails because l has length 3
val List(x1) = l
// also fails
val List(x1, x2) = List("a")
// recursive definition of length function for lists
// based on navigating the list structure.
// If l is empty its length is 0. If l is non-empty,
// and so has a tail t, its lenght is 1 + the length of t
//
def len (l: List[Int]): Int =
l match {
case Nil => 0
case _ :: t => 1 + len(t)
}
len(List(1, 1, 1))
// min returns the minimun element of an non-empty integer list,
// it raises an exception with empty lists
//
// if l has only one element n, the minimum is n
// if l has at least two elements its miminum is the smaller
// between l's head and the minimun of l's tail.
//
def min (l:List[Int]):Int =
l match {
case Nil => throw new IllegalArgumentException
case n :: Nil => n
case n :: t => {
val m = min(t)
if (n < m) n else m
}
}
// concat contatenates two lists
def concat(l:List[Int], m:List[Int]):List[Int] =
l match {
// when l is empty, its concatenation with m is just m
case Nil => m
// when l has a head h and a tail t, its contatenation with m
// is obtained by inserting h in front of the contatenation
// of t with m
case h :: t => h :: concat(t, m)
}
concat(List(1, 2), List(3, 4, 5))
// the effect of concat is achieved with the predefined overloaded operator ++
List(1,2) ++ List(3,4,5)
// reverse reverses a list
def reverse (l:List[Int]):List[Int] =
l match {
// when l is empty it is its own reverse
case Nil => l
// when l has a head h and a tail t, its reverse is the contatenation
// of the reverse of t with a list containing just h
case h :: t => {
val rt = reverse(t)
val lh = List(h)
concat(rt, lh)
}
}
reverse(List(3, 4, 5))
// more compact version of the implementation above
// both version are inefficient because each reverse(t) is
// scanned linearly by concat each time
def reverse (l:List[Int]):List[Int] =
l match {
case Nil => l
case h :: t => concat(reverse(t), List(h))
}
// this reverse uses a local auxiliary function rev
// rev is "tail-recursive", it builds the reverse of l as it scans it
// by incrementally moving its elements into an initially empty list rl.
// l is scanned only once
def reverse (x:List[Int]):List[Int] = {
def rev (l:List[Int], rl:List[Int]):List[Int] =
l match {
// when l has a head h and a tail t, put h in front of rl
// and continue with t and h::rl
case h :: t => rev(t, h :: rl)
// when l is Nil, rl contains by construction the reverse
// of the original list
case Nil => rl
}
rev(x, Nil)
}

复制代码

板凳

ReneeBK 发表于 2016-8-20 01:23:24

/*
CS:2820 Object Oriented Software Development
Spring 2015
The University of Iowa
Instructor: Cesare Tinelli
*/
/* Collection types: Arrays */
// creates an array with 5 elements and calls it a
val a = new Array(5)
// more typically, one specifies the element type as well;
// the array elements start with a type-dependent default value
val a = new Array[Double](5)
a[1] // standard notation *not* used in Scala
a(1) // Scala's notation for array access
a(0) = 2.5 // array update
a(5) // generates out of bound error
// generates an Array[Int] of length 3 and elements 10,11, and 12;
// element type Int is inferred
Array(10, 11, 12)
val a = Array(10, 11, 12)
// 3 different ways to generate an Array[Long]
// from Int initial values
val a = Array[Long](10, 11, 12) // preferred one
val a:Array[Long] = Array(10, 11, 12)
val a = Array(10:Long, 11, 12)
// note the tricky difference
val a = Array[Long](10) // a is an Array[Long] with one element: 10
val b = new Array[Long](10) // n is an Array[Long] with 10 elements
// array length
a.length
// multidimentional arrays are arrays of arrays
val m = new Array[Array[Int]](10)
val m = Array(Array(1, 2, 3),
Array(4, 5, 6),
Array(7, 8, 9),
Array(10, 11, 12))
m(2)(1) // no special syntax for matrix access
/* Scala examples seen in class */
/* Built-in control structures */
/* for loops */
// The for loop is an expression of type Unit
// It can be seen as a mixfix operator with two arguments:
//
// for (_) _
//
// The second argument (the "body") is any expression.
// The first argument is a sequence of one or more *generators*
// separated by ';'
//
// A generator is an expression of the form _ <- _ where the first
// argument is a pattern and the second is an expression of a collection
// type (Range, List, Array, ...)
// below, the pattern 3 is matched against each element of the list.
// each time there is a match, the body of for is evaluated
for (3 <- List(1,3,4,3,5,3,6,3)) println("Hi")
// as in the match and val constructs, patterns can contain variables
for (i <- List(1,2,14,52,7,10)) println("high five")
// any variables in the pattern have local scope within the for
for (i <- List(1,2,14,52,7,10)) println("i = " + i)
i // gives an error
// patterns in a generator can be arbitrarily complex, depending
// on the type of the collection
val l = List((1,2), (1,4), (6,7), (3,6))
for ( (i, j) <- l ) println("i = " + i + ", j = " + j)
for ( (i, _) <- l ) println(i) // ignores the second component of each pair
for ( (1, j) <- l ) println(j) // only matches pairs starting with 1
// *any collection* type can be used in a generator
for (i <- Array(1.2, 2.5, 4.5, 7.1)) println("i = " + i)
for (i <- Set(1,2,4,5,7,10,4)) println("i = " + i)
// even strings, which are seen as the collection of their characters
for (i <- "abcd") println("i = " + i)
// ranges are sequences of consecutive integers
val r = Range(1,5) // contains values 1, 2, 3, 4
for (i <- r) println("i = " + i)
// Expression 1 to 4 is the same as Range(1,5)
for (i <- 1 to 4) println("i = " + i)
// Putting more than one generator has the effect of nested for loops
for (i <- 1 to 2; j <- 1 to 3) println("i = " + i + ", j = " + j)
// the above for has the same effect as
for (i <- 1 to 2) {
for (j <- 1 to 3) println("i = " + i + ", j = " + j)
}
// and it can also be written as
for {
i <- 1 to 2
j <- 1 to 3
} println("i =" + i + ", j = " + j)
// a generator can be optionally followed by a *filter* of the form: if b
// where b is a Boolean expression.
// the matched value is used if and only if b evaluates to true
for (i <- List(1,9,2,4,5,7,10) if i > 4) println("i = " + i)
val l = List((1,2), (1,4), (6,7), (3,6))
for ( (i,j) <- l if j == 2*i )
println((i,j))
for {
c1 <- "hi"
c2 <- "fifi"
if c1 == c2
} println("character match found for letter " + c1)
// BTW, matching filters can be used with the match construct too
val l = List(2, 1, 3)
l match {
case x :: y :: t if (x > y) => y :: x :: t
case _ => l
}
// the first case applies only if l has at least two elements *and*
// its first element is greater than the second
// this version of reverse scans the input list x using
// a for loop instead of a recursive call,
// each element of x is inserted into an initialy empty list;
// a mutable variable is necessary to store the growing reversed list
//
def reverse(x:List[Int]):List[Int] = {
var l = List[Int]()
for (h <- x) l = h :: l
l
}

复制代码

报纸

ReneeBK 发表于 2016-8-20 01:26:23

/*
CS:2820 Object Oriented Software Development
Spring 2015
The University of Iowa
Instructor: Cesare Tinelli
*/
/* Classes and class instances */
/* User-defined classes */
// One can define new classes with the construct of the form
//
// class Name(a1,...,an) { ... }
//
// where Name is an identifier for the class,
// a1, ..., an for n >= 0 are any values
// { ... } is the "body" of the class definition
class A() {}
// equivalently:
class A {}
// or even
class A
// Every class C defines a type C
// Each *instance* of a class C, which we call an object,
// is a value of type C
// objects are created with the construct (new _)
new A
val a1 = new A
val a2 = new A
a1 == a2
a1 eq a2
// The body of a class declaration is a block and
// can contain anything allowed in a block
// Any declarations within the body have only local scope in there
class B {
var x = 1
val s = "abc"
def m(n: Int) = x + n
}
// variables in a class are also called "fields"
// The fields of an instance of class B constitute's
// the object's *internal state*.
// Fields and methods can be accessed using the common
// dot notation
val b = new B
b.x
b.s
b.m(10)
// the value stored in a mutable field can be modified
// with assignments
b.x = 7
b.m(10)
// Whatever expressions are in a class' body they are
// evaluated at object creation time
// The effect of this evaluation is a new object
class B {
println("Starting creating new object of class B")
var x = 1
val s = "abc"
def m(n: Int) = x + n
def g = 33 // parameterless method
println("Done creating new object of class B")
}
new B
/* Operational difference between fields and
parameterless methods
*/
// The value of an object's field is determined at object
// creation time. In contrast, a parameterless method is
// still a method, so its returned value is computed
// anew each time the method is called.
class A {
var x = 0
val y = x + 1 // y will be initialized to 1 and stay so
def f = x + 1 // the value returned by f each time depends
// on the current value of x
}
val a = new A
a.x
a.y // evaluates to 1
a.f // evaluates to 1
a.x = 4
a.y // still evaluates to 1
a.f // evaluates to 5
// A class declaration can have input parameters
class Point(x0:Double, y0:Double) {
val x = x0
val y = y0
}
val p = new Point(4.5, 3.9)
p.x
p.y
// input parameters are used only at object creation time
p.x0 // error
// but they can turned into fields as in the example below
class Point(val x:Double, val y:Double) {}
// x, y are both input parameters and (immutable) fields
val p = new Point(6.5, 3.1)
p.x
p.y
// "class Point(val x:Double, val y:Double) {}" is just
// an abbreviation for a declaration of the form
class Point(x0:Double, y0:Double) {
val x = x0
val y = y0
}
// Fields and methods are exposed by default: they are "public"
// They can be hidden inside by declaring them as "private"
// private fields and methods are visible only by objects of the same class
class Point(x0:Double, y0:Double) {
private val x = x0
private val y = y0
def coincidesWith (other: Point) =
(x == other.x) && (y == other.y)
// other.x and other.y are visible by current point
}
val p1 = new Point(6.5, 3.1)
p1.x // error
val p2 = new Point(6.5, 3.1)
p1.coincidesWith(p2)
p1 == p2
// note less verbose alternative notation
p1 coincidesWith p2
// more abbreviations:
class Point(private val x:Double, private val y:Double) {
}
// abbreviates something like
class Point(x0:Double, y0:Double) {
private val x = x0
private val y = y0
}
// inside a class method definition the object that receives the calls
// can be referred to by 'this'
class Point(private val x:Double, private val y:Double) {
def coincidesWith (other:Point) =
(this.x == other.x) && (y == other.y)
// 'this.x' is the same as just x
def sameAs (other:Point) =
this eq other
}
val p1 = new Point(6.5, 3.1)
val p2 = new Point(6.5, 3.1)
p1 sameAs p2
p1 sameAs p1
val p3 = p1
p1 sameAs p3
// 'this' can be used also to define alternative object constructors
class Point(val x:Double, val y:Double) {
// new object constructor, taking only one parameter
def this(x: Double) =
this(x, x) // call to basic constructor, implicitly defined
// by parameters (x0:Double, y0:Double) above
// another constructor, taking no parameters
def this() =
this(0.0) // call to unary constructor above
}
val p1 = new Point(4.1, 5.9)
val p2 = new Point(1.7)
val p3 = new Point
p2.x
p2.y
p3.x
p3.y
// methods called 'apply' can be called with shorthand syntax
class Point(private val x:Double, private val y:Double) {
def apply(i:Int) =
i match {
case 0 => x
case 1 => y
case _ => throw new IllegalArgumentException
}
}
val p = new Point(4.6, 9.1)
p.apply(0)
// can be abbreviated as
p(0)
// operator symbols like +, -, ++, *, **, etc. can be used
// as method names in user-defined classes
class Point(private val x:Double, private val y:Double) {
def +(other: Point) =
new Point(x + other.x, y + other.y)
def -(other: Point) =
new Point(x - other.x, y - other.y)
def apply(i:Int) =
i match {
case 0 => x
case 1 => y
case _ => throw new IllegalArgumentException
}
}
val p1 = new Point(4.0, 9.0)
val p2 = new Point(3.0, 1.0)
val p = p1.+(p2)
p(0)
p(1)
// leaner syntax
p1 + p2
// user-defined binary operators are left-associative by default
p1 - p2 - p2
// same as
(p1 - p2) - p2
// Scala is pervasively object-oriented
// *every value* is an object of some class
// All basic types (Boolean, Int, Double, Unit, ...) are classes
// Their elements are objects with predefined methods
// Basic operators are actually all methods
// E.g.
val x = 4
// as with user defined classes x + 2 is syntactic sugar for
x.+(2)
// i.e. + is a method of class Int that takes an integer
// (the second operand of +) and returns its addition with
// the receiving object (the first operand)
// 3.2 - 1.7 is syntactic sugar for
3.2.-(1.7)
// true && false is syntactic sugar for
true.&&(false)
// x == 3 is syntactic sugar for
x.==(3)
// Tuples, Lists, Arrays types are also all classes
val l = List(10, 11, 12)
// l is an object
// l ++ l is syntactic sugar for
l.++(l)
// 9 :: l is syntactic sugar for
l.::(9)
// note the opposite order of the arguments
// :: is a List method, not an Int method
// any predefined or user-defined binary operator starting with ':'
// is treated as a method of its *second* argument as above
// l(1) is syntactic sugar for
l.apply(1)
// head, tail, length are all parameterless methods
l.head
l.tail
l.length
// All tuple types (e.g., (Int, String) ) are classes
val p = (100, "abc")
// _1 and _2 are methods of the (Int, String) class
p._1
p._2

复制代码

[Lecture Notes]Object-Oriented Software Development [推广有奖]

经管之家送您一份

经管之家联合CDA

感谢您参与论坛问题回答

扫码加我拉你入群

相关帖子

浏览过的帖子

浏览过的版块

本版微信群

[Lecture Notes]Object-Oriented Software Development [推广有奖]

经管之家送您一份

经管之家联合CDA

感谢您参与论坛问题回答

扫码加我 拉你入群

相关帖子

浏览过的帖子

浏览过的版块

本版微信群

扫码加我拉你入群