bluishglc
bluishglc

SCALA学习笔记（一）

SCALA学习笔记（一）

  • SCALA学习笔记一
    • 变量
    • 函数定义
    • 方法调用
    • 函数字面量FUNCTION LITERALS
    • 闭包Closure
    • Array与Array的基本操作
    • FOR循环
    • 模式匹配Pattern Matching
    • 类Class
    • Getter和Setter
      • 如何显示地定义一个字段的getter和setter
    • Primary Constructor声明的字段其读写属性是如何规定的
    • 构造函数
      • 主构造函数Primary Constructor
      • 关于构造函数重载
    • 关于Scala的脚本特性
      • Import
    • Object对象
      • 像使用function一样使用object
      • 将object类型作为工厂Factory来使用
    • Trait
    • Trait和多继承
    • Trait的堆栈化叠加特性
    • Case Class
      • 关于case class生成的companion object
    • 命名参数 Named Arguments
    • 类成员修饰符
    • Scala的类体系结构

变量

获取变量的值是一个耗时的工作时，可以考虑使用lazy var.
lazy val forLater = someTimeConsumingOperation()

scala> val first :: rest = List(1, 2, 3)
first: Int = 1
rest: List[Int] = List(2, 3)

函数定义

“=”并不只是用来分割函数签名和函数体的，它的另一个作用是告诉编译器是否对函数的返回值进行类型推断！如果省去=,则认为函数是没有返回值的！

比如：

scala> def myFirstMethod() = { “exciting times ahead” }
myFirstMethod: ()java.lang.String

scala> def myFirstMethod(){ “exciting times ahead” }
myFirstMethod: ()Unit

方法调用

注：和本文的其他部分不同，该章节总结自《Learning Scala》一书：Methods and Operators一节，因为《Scala In Action》一书没有集中对这个知识点的讲解

通常，scala和其他大多数的语言一样，对方法的调用使用是：infix dot notation格式，我们可以叫“小数点中辍格式”，也就是对象和方法名中间以“小数点”做中缀的方式：

<class instance>.<method>[()]

与此同时，scala还提供了另外一种方法调用方式：infix operator notation格式，我们可以叫“操作符中辍格式”，也就是把方法名当做一种操作符，使用对象 方法名 参数中间以空格分隔的方式：

 <method> <parameter> 
  
这我们思考一下为什么会出现这种样式的方法调用，应该说这是用于引入了“操作符做方法名”而产生的一种自然需要！实际上，scala中允许使用操作符做方法名基本上与C++中的操作符重载是一样的！
 
  
示例：
 
  
scala> val d = 65.642
d: Double = 65.642
scala> d.round
res13: Long = 66
scala> d.floor
res14: Double = 65.0
scala> d.compare(18.0)
res15: Int = 1
//对于Double类型，"+"是一个方法名。
scala> d.+(2.721)
res16: Double = 68.363
 
  
很显然，当我们引入了操作符重载之后，如果再使用“对象.方法名（参数）”的方式调用方法会看上去非常古怪，也就是这里的d.+(2.721)，此时就是使用infix operator notation样式的合适场所！
 
  
当然，这种调用样式并不是一定要使用在以操作符为方法名的方法上，如果你习惯，也可以使用在普通方法上。
 
  
 
  
函数字面量：FUNCTION LITERALS
 
  
 
  
In Scala you can also pass a function as a parameter to another function, and most of the time in those cases I provide an inline definition of the function. This passing of functions as a parameter is sometimes loosely called closure (passing a function isn’t always necessarily closure; you’ll look into that in chapter 4). Scala provides a shorthand way to create a function in which you write only the function body, called function literals. 
 
  
以下几个示例中，大括号里面的部分都是函数字面量，
 
  
例如：
 
  
//花括号中的部分是一个标准的函数字面量
scala> evenNumbers.foldLeft(0) { (a: Int, b:Int) => a + b }  

//花括号中的部分是一个省略了参数类型的函数字面量，它们的类型
//会通过类型推断进行确定
scala> evenNumbers.foldLeft(0) { (a, b) => a + b } 

//花括号中的部分是一个省略了整个参数列表的函数字面量
//这里有一个问题就是：如果参数列表都省略了，那么在函数体内如
//要引用参数时改怎么办？于是scala就约定使用来表示参数，第一
//次出现的_表示第一个参数，第二次出现的_表示第二个参数，依次类推。
scala> evenNumbers.foldLeft(0) { _ + _ }  
 
  
在scala里， 一个下划线代表一个参数！
 
  
 
  
闭包：Closure
 
  
 
  
A closure is any function that closes over the environment in which it’s defined. For example, closure will keep track of any variable changes outside the function that are being referred to inside the function. 
 
  
 
  
def breakable(op: => Unit) { … }
 
  
What’s this op: => Unit? The special right arrow (=>) lets Scala know that the breakable function expects a function as a parameter. The right side of the => defines the return type of the function—in this case it’s Unit (similar to Java void)—and op is the name of the parameter. Because you haven’t specified anything on the left side of the arrow, it means that the function you’re expecting as a parameter doesn’t take any parameter for itself.
 
  
如果我们需要的传入参数是一个代参数且有返回值的函数呢? 这样的函数作参数应该如何描述呢?
 
  
def foldLeft(initialValue: Int, operator: (Int, Int) => Int)= { … }
 
  
让我们这样来理解吧：既然对于函数式编程语言来说，函数是第一位（first class)的，它可以像其他数据类型一样被使用，那么当它作为函数的参数时，我们需要约定一个语法来描述这个”参数”（实际上是一个函数）的”类型”（实际上应该是这个函数的”元信息“）,那么对于一个函数来说，它的”类型“应该怎样去描述呢？从语言的设计者角度来考虑的话，那当然最合理的描述方式是：陈述出这个函数的参数类型和它的返回值类型！这也正是operator: (Int, Int) => Int)所做的！简单明了，合情合理！
 
  
 
  
Array与Array的基本操作
 
  
 
  
scala> val array = new Array[String](3)
array: Array[String] = Array(null, null, null)
scala> array(0) = "This"
scala> array(1) = "is"
scala> array(2) = "mutable"
 
  
对于给数组赋值的语句：array(0) = “This”，这里要说明的是：不同于java中的array[0] = “This” 在scala中，[]永远是用来制定参数类型的！
 
  
迭代Array的操作是非常简单的，我们只需要使用它的foreach方法，同时传递一个函数字面量即可。下面典型的例子是在迭代main函数的args参数列表：
 
  
scala> array.foreach(println)
This
is
mutable
 
  
Array的基本操作
 
  
关于Array的基本操作应该参考scala.collection.mutable.ArrayLike这个trait，然而有趣是的，Array并没有实现这个trait. 这是非常有意思的。
 
  
关这个问题的答案是Predef! Scala的Predef会隐式地将一个Array转成一个scala.collection.mutable 
 .ArrayOps. 而ArrayOps 是ArrayLike的一个子类。
 
  
 
  
FOR循环
 
  
 
  
val files = new java.io.File(".").listFiles
    for(file <- files) {
    val filename = file.getName
    if(fileName.endsWith(".scala")) println(file)
}
 
  
The only thing that looks different from for loops in Java or C# is the expression file <- files. In Scala this is called a generator, and the job of a generator is to iterate through a collection.
 
  
scala> val aList = List(1, 2, 3)
aList: List[Int] = List(1, 2, 3)
scala> val bList = List(4, 5, 6)
bList: List[Int] = List(4, 5, 6)
scala> for { a <- aList; b <- bList } println(a + b)
5
6
7
6
7
8
7
8
9  
//yield直译是“产出”的意思，这里yield是专指把一个一个的元素加入到一个集合中去！
scala> val result = for { a <- aList; b <- bList } yield a + b
result: List[Int] = List(5, 6, 7, 6, 7, 8, 7, 8, 9)
scala> for(r <- result) println(r)
5
6
7
6
7
8
7
8
9 
 
  
注：for语句的花括号｛｝并不是必须的，你完全可以使用().
 
  
 
  
模式匹配:Pattern Matching
 
  
 
  
模式匹配，示例一：
 
  
ordinal(args(0).toInt)
def ordinal(number:Int) = number match {
    case 1 => println("1st")
    case 2 => println("2nd")
    case 3 => println("3rd") 
    case 4 => println("4th")
    case 5 => println("5th")
    case 6 => println("6th")
    case 7 => println("7th")
    case 8 => println("8th")
    case 9 => println("9th")
    case 10 => println("10th")
    case _ => println("Cannot do beyond 10")
} 
 
  
case _ to match everything else.
 
  
模式匹配，示例二：
 
  
在下面的这个例子中展示了scala一些内置的预定义的Pattern，专门应用于case上的，例如下面例子中的：f，s, rest
 
  
scala> List(1, 2, 3, 4) match {
case f :: s :: rest => List(f, s)
case _ => Nil
}
res7: List[Int] = List(1, 2)  
 
  
模式匹配，示例三：
 
  
val suffixes = List("th", "st", "nd", "rd", "th", "th", "th","th", "th","th");
println(ordinal(args(0).toInt))
def ordinal(number:Int) = number match {
    case tenTo20 if 10 to 20 contains tenTo20 => number + "th"
    case rest => rest + suffixes(number % 10)
} 
 
  
 
  
类：Class
 
  
 
  
What val and var do is define a field and a getter for that field, and in the case of var an additional setter method is also created. When both of them are missing, they’re treated as private instance values, not accessible to anyone outside the class. 
 对于Class的field的修饰符有如下约定：
 
  
     
   
  1. 使用var声明field,则该field将同时拥有getter和setter 
     scala> class MongoClient(var host:String, var port:Int)
    2.  
   
  2. 使用val声明field,则该field只有getter。这意味着在初始化之后，你将无法再修改它的值。 
     scala> class MongoClient(val host:String, val port:Int)
    3.  
   
  3. 如果没有任何修饰符，则该field是完全私有的。 
     scala> class MongoClient(host:String, port:Int)
    4.  
  
 
  
 
  
Getter和Setter
 
  
如何显示地定义一个字段的getter和setter
 
  
在Scala里，如果需要手动地为一个字段添加getter和setter规则是这样的：
 
  
     
   
  1. 字段名应以_在前缀，如_age
    2.  
   
  2. getter是一个function,其命名在字段名上去除_即可，如def age=_age
    3.  
   
  3. setter的定义看似有些奇怪，其实只是一些约定，熟悉以后就可以了。setter的命名是在去除字段名上去除前缀，然后在后面添加”=”后缀，对是”_=”！然后再接参数列表，再之后就和普通的函数定义没有区别了！
    4.  
  
 
  
我们再来看这个例子：
 
  
class Person(var firstName:String, var lastName:String, private var _age:Int) {
    def age = _age //age是一个function,因为没有参数，所以参数列表为空，它是为私有字段_age定义的getter
    def age_=(newAge: Int) = _age = newAge //“age_=”是setter的函数名！这里如果写成def age_=(newAge: Int) = ｛_age = newAge｝看上去就不奇怪了。
}
 
  
之后，我们可以这样使用：
 
  
val p = new Person("Nima", "Raychaudhuri", 2)
p.age = 3
 
  
The assignment p.age = 3 could be replaced by p.age_=(3). When Scala encounters an assignment like x = e, it checks whether there’s any method defined like x_= and if so, it invokes the method.
 
  
 
  
Primary Constructor声明的字段其读写属性是如何规定的？
 
  
让我们通过一个完整的例子来看一下：
 
  
scala> class Person(val firstName:String, var lastName:String, gender:String)
defined class Person

scala> val p=new Person("Jim","White","male")
p: Person = Person@c80472c

scala> p.firstName
res2: String = Jim

scala> p.lastName
res3: String = White

scala> p.gender
:10: error: value gender is not a member of Person
              p.gender
                ^

scala> p.firstName="Tom"
:9: error: reassignment to val
       p.firstName="Tom"
                  ^

scala> p.lastName="Green"
p.lastName: String = Green

scala> p.gender="female"
:12: error: value gender is not a member of Person
val $ires6 = p.gender
               ^
:9: error: value gender is not a member of Person
       p.gender="female"
         ^
 
  
很明显： 
 如果是var:生成getter和setter 
 如果是val:只生成getter 
 如果没有变量修饰符：没有getter和setter，等同于private.
 
  
但是注意对于Case Class，则稍有不同！Case Class对于通过Primary Constructor声明的字段自动添加val修饰，使之变为只读的。
 
  
scala> case class Person2(firstName:String)
defined class Person2

scala> val p=Person2("Jim")
p: Person2 = Person2(Jim)

scala> p.firstName
res5: String = Jim

scala> p.firstName="Tom"
:10: error: reassignment to val
       p.firstName="Tom"
                  ^
 
  
 
  
构造函数
 
  
主构造函数：Primary Constructor
 
  
scala的主构造函数指的是在定义Class时声明的那个函数！简单的例子：
 
  
 class MongoClient(val host:String, val port:Int)
 
  
对于这个class的定义，实际上它也是同时声明了一个构造函数：this(val host:String, val port:Int), 它就是所谓的主构造函数！
 
  
关于构造函数重载
 
  
在scala中，构造函数的重载和普通函数的重载是基本一样的，区别只是构造函数使用this关键字指代！当然，也不能指定返回值。
 
  
对于重载构造函数：它的第一个语句必须是调用另外一个重载的构造函数或者是主构造函数！当然除了主构造函数以外！这个表述如果再深入地一想，那么我们就可以想到：所有的构造函数在一开始就会首先调用主函数！！这也是为什么：scala对写在Class内的零星的脚本和代码片段的处理是通过移到主构造函数内去执行的原因！
 
  
class MongoClient(val host:String, val port:Int) {
    def this() = {
        val defaultHost = "127.0.0.1"
        val defaultPort = 27017
        this(defaultHost, defaultPort)
    }
}
 
  
在上面的代码汇编出错，因为它的第一行并不是在调用另外一个构造函数！
 
  
 
  
关于Scala的脚本特性
 
  
这是一个明显不同于java的地方，我们来看一个Class:
 
  
class MyScript(host:String) {
    require(host != null, "Have to provide host name")
    if(host == "127.0.0.1") println("host = localhost")
    else println("host = " + host)
}
 
  
如果这是一个java类，则这显然是不合乎语法的。Scala的脚本特性体现在：*在一个类里，你可以随意的写一些脚本，或者说是代码片段更加形象，这些脚本会在对象实例化时被执行。
 
  
 
  
Packaging
 
  
两种风格，
 
  
风格一：
 
  
package com {
    package scalainaction {
        package mongo {
            import com.mongodb.Mongo
            class MongoClient(val host:String, val port:Int) {
                require(host != null, "You have to provide a host name")
                private val underlying = new Mongo(host, port)
                def this() = this("127.0.0.1", 27017)
            }
        }
    }
}
 
  
风格二：
 
  
package com.scalainaction.mongo {
    import com.mongodb.Mongo
    class MongoClient(val host:String, val port:Int) {
        require(host != null, "You have to provide a host name")
        private val underlying = new Mongo(host, port)
        def this() = this("127.0.0.1", 27017)
    }
}
 
  
每当你在类前声明：package com.scalainaction.mongo时，则package中的对应代码会自动执行！
 
  
scala的package机制有意思的一点是：包的结构并不需要对应映射和class的文件结构上，当一个package被编译时，编译器会根据package的声明生成对应的文件结构！
 
  
 
  
Import
 
  
import com.mongodb._
 
  
Here’s another use for _, and in this context it means you’re importing all the classes 
 under the com.mongodb package.
 
  
并且你可以在任何地方使用import:
 
  
scala> val randomValue = {
    import scala.util.Random
    new Random().nextInt
}
randomValue: Int = 1453407425
 
  
下面是一种类似java中的static import的方式，导入一个类的所有方法：
 
  
scala> import java.lang.System._
import java.lang.System._
scala> nanoTime
res0: Long = 1268518636387441000
 
  
scala中的import还有另外一个方便的特性：在导入时它可以重命名类或包，这样会增加可读性，比如下面的这个例子：
 
  
import java.util.Date
import java.sql.{Date => SqlDate}
import RichConsole._
val now = new Date
p(now)
val sqlDate = new SqlDate(now.getTime)
p(sqlDate)
 
  
 
  
Object对象
 
  
基于“纯OO”的理念，scala里没有static关键字的：一切皆对象! 
 但是为了能实现“全局唯一”的需要，scala支持一种叫做singleton object的对象，也就是限定一个类的实例只有唯一一个的机制。
 
  
object RichConsole {
    def p(x: Any) = println(x)
}

scala> RichConsole.p("rich console")
rich console
 
  
上述代码定义了一个object：RichConsole，对于它的调用和与java里调用static的字段和方法是极其类似的！
 
  
像使用function一样使用object.
 
  
Scala provides syntactic sugar that allows you to use objects as function calls. Scala achieves this by translating these calls into the apply method, which matches the given parameters defined in the object or class.
 
  
实际上，这是一种“约定”，只要你的object中定义了一个apply方法，你是可以直接使用object的名字作为函数名后接与 apply方法对应的参数就可以实现对这个apply方法的调用！我们看下面的这个例子：
 
  
scala> object A {
     | def apply(s:String)=println(s)
     | }
defined object A

scala> A("SDFSDF")
SDFSDF
 
  
这个语法机制多用于实例化一个对象，使得object成为一个工厂，我们接着看下面这个话题：
 
  
将object类型作为“工厂”Factory来使用
 
  
一个典型的工厂类（实际上我们这里指的是简单工厂（静态工厂）模式），通常是以static的工厂方法来create对象的，比如： 
 Factory.createObject("objectA"); 
 让我们来看一下scala中通过object来实现的工厂类：
 
  
//注意：class DB的primary constructor被标记为了private!!
//这意味着在class的外部将没有任何机会可以调用这个construtor.
//但是作为它的companion object: object DB是唯一的例外！
//Scala规定：一个Class的companion object可以访问这个class的任何私有成员！
class DB private(val underlying: MongoDB) {  
  private def collection(name: String) = underlying.getCollection(name)
  //with关键字是给类“混入”（mixin)一个trait!
  //后续针对DBCollection的多个trait的“混入”很好的诠释了
  //trait的含义！
  def localeAwareReadOnlyCollection(name: String) = 
      new DBCollection(collection(name)) with Memoizer with LocaleAware
  def readOnlyCollection(name: String) = 
      new DBCollection(collection(name)) with Memoizer
  def administrableCollection(name: String) = 
      new DBCollection(collection(name)) with Administrable with Memoizer
  def updatableCollection(name: String) = 
      new DBCollection(collection(name)) with Updatable with Memoizer  
  def collectionNames =  for(name <- new JSetWrapper(underlying.getCollectionNames)) yield name
}

 //在scala里，Class和object可以使用同一个名字
 //当它们的名字一样时，我们称object为companion object，class为companion class.
object DB {
    //apply方法，object类型特有的一个小特性，对于apply方法
    //的调用可以简写为DB（参数1， 参数2 ，...),这像看起来DB会像一个函数
    //更准确些说是一个工厂方法！
    def apply(underlying: MongDB) = new DB(underlying)
}

//初始化DB对象
//注意：这里实际的代码形式是：DB.apply(underlying.getDB(name))
DB(underlying.getDB(name))
 
  
像上面提到的，既然这是一个object类型，那么调用工厂方法apply的方式就应该是这样：DB.apply(myUnderlying)但是scala在这里有一个语法糖，它允许我们像使用函数一样使用object!所以上面的调用也可以写成这样：DB（myUnderlying)
 
  
让我们再来看另外一个更加明显和清晰的例子，这是scala里一个典型简单工厂（静态工厂方法)模式的实现:
 
  
abstract class Role { def canAccess(page: String): Boolean }
class Root extends Role {
  override def canAccess(page:String) = true
}
class SuperAnalyst extends Role {
  override def canAccess(page:String) = page != "Admin"
}
class Analyst extends Role {
  override def canAccess(page:String) = false }

//下面的object Role或许命名为RoleFactory更为恰当
//但是考虑到后面在使用它创建对象时 val root = Role("root") 的写法，还是定义为Role为好！

object Role {
  def apply(roleName:String) = roleName match {
    case "root" => new Root
    case "superAnalyst" => new SuperAnalyst
    case "analyst" => new Analyst
  }
}

//创建对象：
val root = Role("root")  //这里等同于Role.apply("root")
val analyst = Role("analyst")
 
  
 
  
Trait
 
  
A trait is like an abstract class meant to be added to other classes as a mixin.You can also view a trait as an interface with implemented methods. 
 在Scala里，Trait像一个抽象类，它用于作为一种“mixin”混入到其他类中！你也可以把它看作是带有方法实现的接口(Interface),另一方面，trait区别于抽象类的地方在于：抽象类可以有构造函数，且构造函数可以有参数！但是对于trait，是没有带参数的构造函数的！所以说它更像是“有实现方法的接口”。trait不同于接口和抽象类的另一个地方是：它是不仅可以有抽象方法，还可以有抽象字段！
 
  
memoization：In computing, memoization is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.
 
  
 
  
Trait和多继承
 
  
由于一个类可以混入多个Trait! 这很明显地让人联想到“多继承”机制，以及由此带来的问题！
 
  
这我们看下面这个例子：
 
  
Class UpdatableCollection
extends DBCollection(collection(name)) with Updatable
 
  
以下是类继承关系：
 
  
 
  
在这个类继承关系下，readonly的方法被Updatble和DBCollection两个条线路继承和改写，这样，对于UpdatableCollection来说就需要一种规则来确定继承路线,解决歧义性问题，scala使用的规则叫：class linearization这个原则简单表述为：右侧优先，深度优先！ 
 上面这个例子，在UpdatableCollection的类声明中，Updatable出现在最右侧，所以UpdatableCollection会优先继承Updatable里关于ReadOnly的实现，后续再出现相同的方法时就忽略掉。
 
  
Trait的“堆栈化”（叠加）特性
 
  
但是我们也要看到Trait这种类似多继承的特性对修改已存在组件的行为和构建可重用组件方面是有很大帮助的！我们只需要重新设计一个Trait，就可以轻松地把已有的Trait的行为替换掉，从这一点上我们也可以理解为什么在确定继承路线时，scala总是先从最右边开始了！这很像是一个堆栈！声明的每一个trait从左向右依次入栈,在解析时依次出栈，从最右则开始解析。
 
  
 
  
Case Class
 
  
以这样一段代码为例：
 
  
scala> case class Person(firstName:String, lastName:String)
defined class Person
 
  
当我们声明一个Case Class的时候，编译器会自动完成以下动作:
 
  
     
   
  • scala prefixes all the parameters with val, and that will make them public value. But remember that you still never access the value directly; you always access through accessors. 
     对于Case Class，它的主构造函数的所有参数会被自动限定为val,也就意味着这个字段是外部可读的。 这与普通的Class主构造函数不同。 
     对于普通的Class：
    •  
  
 
  
scala> class MongoClient(host:String, port:Int)
 
  
如果没有任何修饰符，则该field是完全私有的，既无getter也无setter，只在类的内部可读。
 
  
     
   
  • Both equals and hashCode are implemented for you based on the given parameters.The compiler implements the toString method that returns the class name and its parameters.
    •  
   
  • Every case class has a method named copy that allows you to easily create a modified copy of the class’s instance. You’ll learn about this later in this chapter.
    •  
   
  • A companion object is created with the appropriate apply method, which takes the same arguments as declared in the class.
    •  
   
  • The compiler adds a method called unapply, which allows the class name to be used as an extractor for pattern matching (more on this later).
    •  
  
 
  
下面一组case class：
 
  
//sealed关键字声明其他trait都不能再继承当前的trait
//除非这个类与声明的这个trait在同一个class文件里!
sealed trait QueryOption
case object NoOption extends QueryOption
case class Sort(sorting: DBObject, anotherOption: QueryOption) extends QueryOption
case class Skip(number: Int, anotherOption: QueryOption) extends QueryOption 
case class Limit(limit: Int, anotherOption: QueryOption) extends QueryOption
 
  
 
  
关于case class生成的companion object
 
  
case class Person(firstName:String, lastName: String)
 
  
当我们声明上面这样一个case class的时候，我们知道scala会为case class自动生成一个companion object， 如果还原这个companion object的代码，应该是这样的：
 
  
//注意：case class的companion object是隐式自动生成的！下面的代码并不是手动编写的。
object Person {
    def apply(firstName:String, lastName:String) = {
        new Person(firstName, lastName)
    }
    def unapply(p:Person): Option[(String, String)] =
        Some((p.firstName, p.lastName))
}
 
  
     
   
  • 对于apply方法不必再多介绍了，它会在创建Persion Class实例时调用。
    •  
   
  • 对于unapply方法,它会在case class的模式匹配时使用！这个方法主要是把一个case class实例的进行“拆解”（unwrap)返回它的参数，以便进行模式匹配时使用！这大概的起名为unapply的原因吧。
    •  
  
 
  
 
  
命名参数 Named Arguments
 
  
先看例子：
 
  
scala> case class Person(firstName:String,lastName:String)
defined class Person
scala> val p = Person(lastName="lastname",firstName = "firstname")
p: Person = Person(firstname,lastname)
scala> println(p.lastName)
lastname
 
  
有时候，人们可能回错误地传递了参数，特别是当多个参数是同一类型时，这样编译器不能帮助我们检查出错误的。比如像上面的这个例子，如果我们在实例化p时错误的写成了val p = Person("lastname","firstname")，这种错误是无法依靠编译器来帮助我们发现的，scala中提供的“命名参数”机制可以帮助我们写出更加易读的代码，同时错误也更少！上面示例代码中，即使我们把参数的顺序都弄错了，但是由于传递的“实参”已被声明是指定给某个“形参”的，所以就不会出现任何错误和疏漏了！
 
  
在使用命名参数时，如果参数命名不匹配，编译器会报错，但是有这样一种case,如果一个方法，父类对参数有一个命名，子类在重写这个方法时把参数名也改了，那么在使用命名参数时应该使用哪一个？scala的原则是看实例化出来的对象是什么类型，如果是子类型，应该使用子类方法上的参数命名，如果这个对象被强制转换为了父类，则使用父类方法中的参数命名，看下面这个例子：
 
  
scala> trait Person { def grade(years: Int): String }
defined trait Person
scala> class SalesPerson extends Person { def grade(yrs: Int) = "Senior" }
defined class SalesPerson
scala> val s = new SalesPerson
s: SalesPerson = SalesPerson@42a6cdf5
scala> s.grade(yrs=1)
res17: java.lang.String = Senior
scala> s.grade(years=1)
:12: error: not found: value years
s.grade(years=1)
 
  
由于s的类型是SalesPerson，所以使用yrs命名参数1是OK的，使用Persion的years命名就报错！除非之前你把s强制转换成了Persion!
 
  
 
  
类成员修饰符
 
  
关于public: 
 By default, when you don’t specify any modifier, everything is public. Scala doesn’t provide any modifier to mark members as public.
 
  
关于abstract override 
 The override modifier can be combined with an 
 abstract modifier, and the combination is allowed only for members of traits. This 
 modifier means that the member in question must be mixed with a class that provides 
 the concrete implementation.
 
  
 
  
Scala的类体系结构
 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Scala语言)

        

            

                
    
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 使用Apify加载Twitter消息以进行微调的完整指南
                        nseejrukjhad
twittereasyui前端python
                        
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 如何部分格式化提示模板:LangChain中的高级技巧
                        nseejrukjhad
langchainjava服务器python
                        
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 梁文道《尽头:怎样是好的阅读和书写》 片段
                        白夜书摘

                        
    1、写小说的人，有时会强烈地感到一种现实的召唤，想去面对和回应现实。这时他们会觉得自己正站在时代中心，就像黑格尔说的，要把时代精神掌握在自己的小说（不是哲学）里面。但是这也很危险，当一个作家像一个时代那样书写，可能就会出现问题了。2、文字是远比语言大块而且湿冷的木头，又距离我们内心的火花稍远，不容易瞬间点燃起来，这处隙缝，给了我们回身的余地，可以再多看一下想一下设身处地一下；人类过往这最后五千年，
    
                    
    • 
                    
  • pyecharts——绘制柱形图折线图
                        2224070247
信息可视化pythonjava数据可视化
                        
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
    
                    
    • 
                    
  • 第六集如何安装CentOS7.0，3分钟学会centos7安装教程
                        date分享

                        
    从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
    
                    
    • 
                    
  • Rust基础知识
                        GRKF15
rust开发语言后端
                        
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
    
                    
    • 
                    
  • 简介Shell、zsh、bash
                        zhaosuningsn
Shellzshbashshelllinuxbash
                        
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
    
                    
    • 
                    
  • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
    
                    
    • 
                    
  • 希望和悲伤都是照亮我们人生的一缕光
                        山月映雪

                        
    我开始并不想读《云边有个小卖部》，但看到好几个学生就都在读这本书，为了了解学生的阅读实际，我就拿起这本书翻看起来。读了十几页，发现小说的语言中不时有一些粗俗的字眼，感觉自己读不下去了。小说一开始把云边镇风景写的特别的美好，我错判为脱离现实的鸳鸯蝴蝶派小说，对于人为制造的童话世界的人与物，我真的不太感兴趣，所以就没有再读了。有天在教室闲转，顺手又拿起了这本书看了起来，这次我才真的看进去了。这部小说除
    
                    
    • 
                    
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验
                        张风捷特烈
iderust开发语言后端
                        
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
    
                    
    • 
                    
  • C语言 判断回文数
                        Y雨何时停T
c语言学习
                        
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • 自然语言处理_tf-idf
                        _feivirus_
算法机器学习和数学自然语言处理tf-idf逆文档频率词频
                        
    importpandasaspdimportmath1.数据预处理docA="Thecatsatonmyface"docB="Thedogsatonmybed"wordsA=docA.split("")wordsB=docB.split("")wordsSet=set(wordsA).union(set(wordsB))print(wordsSet){'on','my','face','sat',
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 2022.01.22 有用
                        谨言的成长

                        
    写作，对我来说，更像是一个自说自话，自我观察，自我反思，自我探索的途径。可以写我的心情故事，写我的观点而不用担心任何人的评论，写我的情绪，写我想说的，有时候觉得只是简单用语言还不能表现出那份深刻，但是文字可以给自己一个更长的时间来思考，来做深度思考，表达得更透彻。写作，有时候我会写自己看了某个电影后的一点感悟，自己的真实感受，不管它和专业影评人相比是不是很肤浅，是不是片面了，只是有时候我也想发声，
    
                    
    • 
                    
  • BART&BERT
                        Ambition_LAO
深度学习
                        
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
    
                    
    • 
                    
  • C语言代码练习（第十九天）
                        小小框架
C语言C语言重点练习c语言
                        
    今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
    
                    
    • 
                                
  • apache ftpserver-CentOS config
                                    gengzg
apache
                                    
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://mina.apache.o
    
                                
    • 
                                
  • 优化MySQL数据库性能的八种方法
                                    AILIKES
sqlmysql
                                    
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    
                                
    • 
                                
  • JeeSite 企业信息化快速开发平台
                                    Kai_Ge
JeeSite
                                    
    JeeSite 企业信息化快速开发平台  
平台简介 
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    
                                
    • 
                                
  • 通过Spring Mail Api发送邮件
                                    120153216
邮件main
                                    
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 
Spring Mail API都在org.spri
    
                                
    • 
                                
  • Pysvn 程序员使用指南
                                    2002wmj
SVN
                                    
    源文件:http://ju.outofmemory.cn/entry/35762 
这是一篇关于pysvn模块的指南. 
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. 
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 
该
    
                                
    • 
                                
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
                                    357029540
SQL Server
                                    
    SELECT  R.session_id AS BlockedSessionID ,  
        S.session_id AS BlockingSessionID ,  
        Q1.text AS Block
    
                                
    • 
                                
  • Intent 常用的用法备忘
                                    7454103
.netandroidGoogleBlogF#
                                    
    Intent 
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 
 
下面列出几种Intent 的用法 
显示网页: 
 

    
                                
    • 
                                
  • Spring定时器时间配置
                                    adminjun
spring时间配置定时器
                                    
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />  
测试的时候，由于是每天定时执行，所以后面三个数
    
                                
    • 
                                
  • POJ 2421 Constructing Roads 最小生成树
                                    aijuans
最小生成树
                                    
    来源：http://poj.org/problem?id=2421 
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 
代码： 
 
#include <iostream>
#include <cstdio>
    
                                
    • 
                                
  • 重构笔记——提取方法（Extract Method）
                                    ayaoxinchao
java重构提炼函数局部变量提取方法
                                    
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。 
  
下面是我学习这个重构手法的笔记： 
  
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    
                                
    • 
                                
  • 为UILabel添加点击事件
                                    bewithme
UILabel
                                    
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。 
  
  UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
                                    bijian1013
redis数据库NoSQL
                                    
    一.redis.php 
<?php
      //实例化
      $redis = new Redis();
      //连接服务器
      $redis->connect("localhost");
      //授权
      $redis->auth("lamplijie");
      //相关操
    
                                
    • 
                                
  • SecureCRT使用备注
                                    bingyingao
secureCRT每页行数
                                    
    SecureCRT日志和卷屏行数设置 
 
一、使用securecrt时，设置自动日志记录功能。 
 
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 
 
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    
                                
    • 
                                
  • 【Scala九】Scala核心三：泛型
                                    bit1129
scala
                                    
    泛型类 
package spark.examples.scala.generics

class GenericClass[K, V](val k: K, val v: V) {
  def print() {
    println(k + "," + v)
  }
}

object GenericClass {
  def main(args: Arr
    
                                
    • 
                                
  • 素数与音乐
                                    bookjovi
素数数学haskell
                                    
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。 
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-IdentityHashMap
                                    BrokenDreams
Collections
                                    
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。 
        简单的说，IdentityHashMap和HashM
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 



import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    
                                
    • 
                                
  • PS人像润饰&调色教程集锦
                                    cherishLC
PS
                                    
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 
 
http://www.howzhi.com/course/retouching/ 
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。 
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    
                                
    • 
                                
  • 更新多个字段的UPDATE语句
                                    crabdave
update
                                    
    更新多个字段的UPDATE语句 
  
                 
                update tableA a
                   set (a.v1, a.v2, a.v3, a.v4) =   --使用括号确定更新的字段范围
          
    
                                
    • 
                                
  • hive实例讲解实现in和not in子句
                                    daizj
hivenot inin
                                    
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 
 
 
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 
 
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    
                                
    • 
                                
  • 一道24点的10+种非人类解法（2,3,10,10）
                                    dsjt
算法
                                    
    这是人类算24点的方法？！！！ 
 
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 
 
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 
 
然后么。。。我就在深夜很得瑟的问室友求室友算 
 
刚出完题，文哥的暴走之旅开始了 
 
5秒后
    
                                
    • 
                                
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
                                    dcj3sjt126com
yiiframework
                                    
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    
                                
    • 
                                
  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
                                    come_for_dream
对象
                                    
    概述 
  
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。 
  
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    
                                
    • 
                                
  • 学习编程那点事
                                    gcq511120594
编程互联网
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • Reverse Linked List II
                                    hcx2013
list
                                    
    Reverse a linked list from position m to n. Do it in-place and in one-pass. 
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, 
return 
    
                                
    • 
                                
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Hadoop集群工具distcp
                                    liyonghui160com

                                    
      
  
1. 环境描述 
两个集群：rock 和 stone 
rock无kerberos权限认证，stone有要求认证。 
1. 从rock复制到stone，采用hdfs 
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    
                                
    • 
                                
  • 一个备份MySQL数据库的简单Shell脚本
                                    pda158
mysql脚本
                                    
    　　主脚本（用于备份mysql数据库）：   　　该Shell脚本可以自动备份 
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。   　　 
1. 分别建立目录“backup”和“oldbackup”   　　#mkdir /backup   　　#mkdir /oldbackup   　
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
                                    shoothao
IT资源图标库图片库色彩板字体
                                    
     
 A. 免费的设计资源 
 
 
  Freebbble:来自于Dribbble的免费的高质量作品。 
  Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 
  Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 
  Pixel Buddha:免费和优质资源的专业社区。 
  Premium Pixels:为那些有创意的人提供免费的素材。 
  
    
                                
    • 
                                
  • thrift总结 - 跨语言服务开发
                                    uule
thrift
                                    
    官网 
官网JAVA例子 
thrift入门介绍 
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 
Thrift入门及Java实例演示 
thrift的使用介绍 
  
RPC  
  
POM： 
<dependency>
  <groupId>org.apache.thrift</groupId>
  
    
                                
    •