声明一个变量
声明一个常量
显式指定类型
定义一个main函数
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println("hello scala")
}
}
定义一个普通函数
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(hello("scala"))
}
def hello(name : String) : String = {
"hello " + name
}
}
函数不带参数时可以省略括号
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(hello())
}
def hello() : String = {
"hello scala"
}
}
定义一个匿名函数
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(add(,))
}
def add = (x : Int,y : Int) => x + y
}
把函数赋给一个常量
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(add(,))
}
val add = (x : Int,y : Int) => x + y
}
柯里化
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(add()())
}
def add(x : Int)(y : Int) = x + y
}
可变参数
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(variable("hello","admln"))
}
def variable(s : String*) = {
s.foreach(x => println(x))
}
}
参数默认值
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
println(theDefault())
println(theDefault("scala"))
}
def theDefault(s : String="admln") : String= {
"hello " + s
}
}
判断表达式
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
val num = ;
val result = if(num > ) else
println(result)
}
}
while循环表达式
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
var (n,r) = (,)
while(n>) {
r = r + n
n = n -
}
println(r)
}
}
for循环表达式
package org.admln.scala
class HelloScala {
}
object HelloScala {
def main (args: Array[String]) {
//1<=10
for(i <- to ) {
println(i)
}
//1<10
for(i <- until ) {
println(i)
}
//只输出偶数
for(i <- to if i % == ) {
println(i)
}
}
}
创建一个类
package org.admln.scala
class HelloScala {
}
class Person {
var name : String = _
val age =
}
object MyPerson {
def main(args: Array[String]) {
val p = new Person
p.name = "admln"
println(p.name + " " + p.age)
}
}
使用私有属性（外部不能访问）
package org.admln.scala
class HelloScala {
}
class Person {
var name : String = _
val age =
private[this] val gender = "male"
}
object MyPerson {
def main(args: Array[String]) {
val p = new Person
p.name = "admln"
println(p.name + " " + p.age)
}
}
构造器
package org.admln.scala
class HelloScala {
}
class Person(var name : String,val age : Int){
println("main constructor")
var gender : String = _
def this(name : String,age : Int,gender : String) {
this(name,age)
this.gender = gender
}
}
object MyPerson {
def main(args: Array[String]) {
val p = new Person("admln",,"male")
println(p.name + " " + p.age)
}
}
继承
package org.admln.scala
class HelloScala {
}
class Person(var name : String,val age : Int){
println("main constructor")
var gender : String = _
def this(name : String,age : Int,gender : String) {
this(name,age)
this.gender = gender
}
}
class Student(name : String,age : Int,val major : String) extends Person(name,age) {
println("subclass is person,major is" + major)
}
object MyPerson {
def main(args: Array[String]) {
val s = new Student("admln",,"spark")
}
}
覆写父类的方法和字段
package org.admln.scala
class HelloScala {
}
class Person(var name : String,val age : Int){
println("main constructor")
var gender : String = "mail"
def this(name : String,age : Int,gender : String) {
this(name,age)
this.gender = gender
}
val school = "usa"
}
class Student(name : String,age : Int,val major : String) extends Person(name,age) {
println("subclass is person,major is" + major)
override def toString = "override method"
override val school = "china"
}
object MyPerson {
def main(args: Array[String]) {
val s = new Student("admln",,"spark")
println(s.toString)
println(s.gender)
}
}
抽象类
package org.admln.scala
class HelloScala {
}
abstract class Person {
def speak
var name : String
val age : Int
}
class Worker extends Person {
def speak {
println("speak")
}
var name = "admln"
val age =
}
object HelloScala extends App {
val worker = new Worker
worker.speak
println(worker.name + " " + worker.age)
}
App是trait的子类，内部实现了main方法并管理我们写的代码
trait
trait中可以带有实现的方法，也可以带有抽象方法，使用trait的方式是使用with混入类中
package org.admln.scala
class UseTrait {
}
trait Logger {
def log(msg : String) {
println("log: " + msg)
}
}
class ConcreteLogger extends Logger {
def concreteLog {
log("It's admln")
}
}
object UseTrait {
def main(args: Array[String]) {
val logger = new ConcreteLogger
logger.concreteLog
}
}
覆写父类的抽象方法（不用使用override关键字）
package org.admln.scala
class UseTrait {
}
trait Logger {
def log(msg : String)
}
trait ConcreteLogger extends Logger {
def log(msg : String) {
println("log: " + msg)
}
}
class Test extends ConcreteLogger {
def test {
log("It's admln")
}
}
object UseTrait {
def main(args: Array[String]) {
val test = new Test
test.test
}
}
如果子trait覆写父trait已经实现的方法，就必须使用override关键字
package org.admln.scala
class UseTrait {
}
trait Logger {
def log(msg : String) {
println("log: " + msg)
}
}
trait ConcreteLogger extends Logger {
override def log(msg : String) {
println(" child log: " + msg)
}
}
class Test extends ConcreteLogger {
def test {
log("It's admln")
}
}
object UseTrait {
def main(args: Array[String]) {
val test = new Test
test.test
}
}
在对象中混入trait
package org.admln.scala
class UseTrait {
}
trait Logger {
def log(msg : String) {
println("log: " + msg)
}
}
trait ConcreteLogger extends Logger {
override def log(msg : String) {
println(" child log: " + msg)
}
}
class Test extends Logger{
def test {
log("It's admln")
}
}
object UseTrait {
def main(args: Array[String]) {
val test = new Test with ConcreteLogger
test.test
}
}
apply方法和静态方法
package org.admln.scala
class UsageOfApply {
}
class ApplyTest {
def test {
println("test")
}
}
object ApplyTest {
def apply() = new ApplyTest
def staticTest {
println("It's static method")
}
}
object UsageOfApply {
def main(args: Array[String]) {
ApplyTest.staticTest
val at = ApplyTest()
at.test
}
}
object 中的方法和属性都是静态的，所以是单例对象的理想载体
object本身就是一个单例对象
函数式编程，把运算过程尽量写成一系列嵌套的函数调用
函数的定义
def 函数名称(变量名称 ： 变量类型) : 函数返回值类型 = { 函数体 }
如果函数仅包含一条语句，那么花括号可以选择不写
值函数
匿名函数
(参数名称 ： 参数类型) => 表达式
把匿名函数赋值给一个常量
闭包
代码与用到的非局部变量的混合
闭包 = 代码 + 非局部变量
高阶函数map函数
下划线代表数组中的每一个元素
高阶函数filter函数
高阶函数reduce函数
scala中的集合：List、Set、Tuple、Map
它们内部都是以apply方式来完成实例化的
List和Set
和java中的Set一样，里面不会存在相同元素
Tuple
下标从1开始
Map
Option
Option代表一个可有可无的值，有两个子类：Some和None
zip操作
partition操作
flatten操作
flatmap操作：map和flatten的结合
