关键词：
文章目录
函数式编程
基础函数编程
函数定义
package learn03
object demo01
def main(args: Array[String]): Unit =
//无参、无返回值
def fun1(): Unit =
println("函数体")
fun1()
//无参、有返回值
def fun2(): String =
"xwk"
println(fun2())
//有参、无返回值
def fun3(name: String): Unit =
println(name)
fun3("xwk")
//有参、有返回值
def fun4(name: String): String =
"Hello " + name
println(fun4("xwk"))
//多参、无返回值
def fun5(hello: String, name: String): Unit =
println(hello + " " + name)
fun5("Hello", "xwk")
//多参、有返回值
def fun6(hello: String, name: String): String =
hello + " " + name
println(fun6("Hello", "xwk"))
函数参数
package learn03
object demo02
def main(args: Array[String]): Unit =
//可变参数
def fun7(names: String*): Unit =
println(names)
fun7()
fun7("xwk")
fun7("xwk", "zxy")
//可变参数不能放置在参数列表的前面，一般放置在参数列表的最后
//def fun77(names:String*,name:String):Unit=,这是错误的写法
def fun77(name: String, names: String*): Unit =
println(name)
println(names)
//参数默认值
def fun8(name: String, password: String = "000000"): Unit =
println(name + "," + password)
fun8("xwk", "123456")
fun8("xwk")
//带名参数
def fun9(password: String = "000000", name: String): Unit =
println(name + "," + password)
fun9("123456", "xwk")
fun9(name = "xwk")
函数至简原则
package learn03
object demo03
def main(args: Array[String]): Unit =
//省略return关键字
def fun1(): String =
return "省略return关键字前"
def fun11(): String =
"省略return关键字"
println(fun1())
println(fun11())
//省略花括号
def fun2(): String = "省略花括号"
println(fun2())
//省略返回值类型
def fun3() = "省略返回值类型"
println(fun3())
//省略参数列表
def fun4 = "省略参数列表"
println(fun4) //正确
//fun4()错误
//省略等号
//如果函数体中有明确的return语句，那么返回值类型不能省略
def fun5_1(): String =
return "省略等号1"
println(fun5_1())
//如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用
def fun5_2(): Unit =
return "省略等号2"
println(fun5_2())
//如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略
def fun5_3()
return "省略等号3"
println(fun5_3())
//省略名称和关键字
() =>
println("省略名称和关键字")
高阶函数编程
所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构。
package learn03
object demo04
def main(args: Array[String]): Unit =
//函数作为值
def fun1(): String =
"xwk"
val a = fun1
val b = fun1 _
val c: () => Unit = fun1
println(a)
println(b)
//函数作为参数
def fun2(i: Int): Int =
i * 2
def fun22(f: Int => Int): Int =
f(10)
println(fun22(fun2))
//函数作为返回值
def fun3(i: Int): Int =
i * 2
def fun33() =
fun3 _
println(fun33()(10))
//匿名函数
def fun4(f: Int => Int): Int =
f(10)
println(fun4((x: Int) =>
x * 20
))
println(fun4((x) =>
x * 20
))
println(fun4((x) => x * 20))
println(fun4(x => x * 20))
println(fun4(_ * 20))
//控制抽象
def fun7(op: => Unit) =
op
fun7
println("xx")
//闭包
def fun5() =
val i = 20
def fun55() =
i * 2
fun55 _
fun5()()
//函数柯里化
def fun6(i: Int)(j: Int) =
i * j
//递归函数
def fun8(j: Int): Int =
if (j <= 1)
1
else
j * fun8(j - 1)
println(fun8(5))
//惰性函数
def fun9(): String =
println("function......")
"xwk"
lazy val x = fun9()
println("........")
println(x)
面向对象编程
基础面向对象编程
包
package关键字可以嵌套声明使用
package learn03
package p1
package p2
package p3
object demo01
def main(args: Array[String]): Unit =
println("test...")
同一个源码文件中子包可以直接访问父包中的内容，而无需import
Scala中package也可以看作对象，并声明属性和函数
导入
scala中基本的import导入语法和java完全一致
java中import导入的语法比较单一，scala对此进行扩展
package learn03
object demo05
def main(args: Array[String]): Unit =
//scala中的import语法可以在任意位置使用
import java.util.ArrayList
new ArrayList()
//scala中可以导包，而不是岛类
import java.util
new util.ArrayList()
//scala可以在同一行中导入相同包中的多个类，简化代码
import java.util.List,ArrayList
//屏蔽某个包中的类
import java.util._
import java.sql.Date=>_,Array=>_,_
//给类起别名
import java.util.ArrayList=>AList
new AList()
//可以使用类的绝对路径而不是相对路径
import _root_.java.util.ArrayList
//默认情况下,scala中会导入如下包和对象
import java.lang._
import scala._
import scala.Predef._
类
class User
//类的主体内容
//对象 : new 类名(参数列表)
new User()
scala中的一个源文件中可以声明多个公共类
属性
package learn03
object demo06
def main(args: Array[String]): Unit =
class User
var name : String = _ // 类属性其实就是类变量
var age : Int = _ // 下划线表示类的属性默认初始化
访问权限
private : 私有访问权限
private[包名]: 包访问权限
protected : 受保护权限，不能同包
: 公共访问权限（默认）
方法
Scala中的类的方法其实就是函数，所以声明方式完全一样，但是必须通过使用对象进行调用
package learn03
object demo07
def main(args: Array[String]): Unit =
val user=new User
user.login("xwk","000000")
class User
def login(name:String,password:String):Boolean=
false
对象
val | var 对象名 [:类型] = new 类型()
var user : User = new User()
构造方法
package learn03
class User() // 主构造函数
var username : String = _
def this( name:String ) // 辅助构造函数，使用this关键字声明
this() // 辅助构造函数应该直接或间接调用主构造函数
username = name
def this( name:String, password:String )
this(name) // 构造器调用其他另外的构造器，要求被调用构造器必须提前声明
高阶面向对象编程
继承
package learn03
class Person
package learn03
class User extends Person
抽象
Scala将一个不完整的类称之为抽象类
abstract class Person
Scala中如果一个方法只有声明而没有实现，那么是抽象方法，因为它不完整。
abstract class Person
def test():Unit
Scala中如果一个属性只有声明没有初始化，那么是抽象属性，因为它不完整。
abstract class Person
var name:String
子类如果继承抽象类，必须实现抽象方法或补全抽象属性，否则也必须声明为抽象的，因为依然不完整。
class User extends Person
var name:String="xwk"
abstract class Person
var name:String
单例对象
所谓的单例对象，就是在程序运行过程中，指定类的对象只能创建一个，而不能创建多个。这样的对象可以由特殊的设计方式获得，也可以由语言本身设计得到，比如object伴生对象
Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明，然后通过伴生对象名称直接调用
如果类名和伴生对象名称保持一致，那么这个类称之为伴生类。Scala编译器可以通过伴生对象的apply方法创建伴生类对象。apply方法可以重载，并传递参数，且可由Scala编译器自动识别。所以在使用时，其实是可以省略的。
class User // 伴生类
object User // 伴生对象
def apply() = new User() // 构造伴生类对象
...
val user1 = new User()// 通过构造方法创建对象
Val user2 = User.apply() // 通过伴生对象的apply方法构造伴生类对象
val user3 = User() // scala编译器省略apply方法，自动完成调用
scala学习——基础语法
Scala语言是一种面向对象语言，结合了命令式（imperative）和函数式（functional）编程风格，其设计理念是创造一种更好地支持组件的语言。 特性多范式（Multi-Paradigm）编程语言，类似Java、C#；继承面向对象编程和函数式编程的... 查看详情
scalaidea安装配置入门helloworld(代码片段)
...门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala是一门以java虚拟机（JVM）为目标运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。Scala是一门多范式(multi-paradi... 查看详情
scala学习之函数式风格编程(代码片段)
...unctional-programming.htmlScala允许您以面向对象编程(OOP)风格、函数式编程(FP)风格甚至混合风格编写代码，结合使用这两种方法。本书假设您是从Java、C++或C#等OOP语言来到Scala的& 查看详情
函数式编程(代码片段)
...在函数的参数中传递函数(higher-orderfunction--高阶函数)。Why学习一点新的编程范式可以有效防止老年痴呆。真的很有趣相比于过程化、面向对象，函数式书写的代码更易读，更简短。因为函数式编程是无副作用(sideeffects)的，不需... 查看详情
spark基础学习笔记08：scala简介与安装(代码片段)
文章目录零、本讲学习目标一、Scala简介（一）Scala概述（二）函数式编程（三）Scala特性1、一切都是对象2、一切都是函数3、一切都是表达式（四）在线运行Scala二、Windows上安装Scala（一）... 查看详情
函数式编程和面向对象编程(代码片段)
介绍函数式编程，以函数思维作为核心，在这种思维的角度去思考问题。这种编程最重要的基础就是λ演算，接受函数当作输入输出。面向对象编程，把问题看作由对象的属性与对象所进行的行为组成。基于对象的概念，以类作... 查看详情
函数式编程与面向对象编程[3]:scala的oop-fp混合式编程与抽象代数理论
函数式编程与面向对象编程[3]:Scala的OOP-FP混合式编程与抽象代数理论之剑2016.5.423:55:19目录函数式编程与面向对象编程[3]:Scala的OOP-FP混合式编程与抽象代数理论 查看详情
scala基础：scala函数式编程基础概念定义调用机制
1 概念的说明1）在scala中，方法和函数几乎可以等同(比如他们的定义、使用、运行机制都一样的)，只是函数的使用方式更加的灵活多样。2）函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当... 查看详情
scala学习之路一
所谓学习，那么首先就先简单介绍一下scala吧1.scala的介绍Scala是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行在Java虚拟机上，并兼容现有的Java程序。Scala源代码被编... 查看详情
函数式编程--为什么要学习函数式编程？(代码片段)
函数式编程（FunctionalProgramming,FP)什么是函数式编程？通过纯函数来实现一些细粒度的函数，然后把这些细粒度的函数组合成功能更强大的函数，这一过程就是函数式编程，经典函数式编程库：lodash函数式编程是编程范式之一，... 查看详情
函数式编程java函数式编程学习(代码片段)
函数式编程-Stream流函数式编程思想概述面向对象思想关注的是用什么对象完成什么事情，而函数式编程思想就类似于数学中的函数，主要关注的是对数据进行了什么操作优点代码简洁，开发快；接近自然语言... 查看详情
函数式编程java函数式编程学习(代码片段)
函数式编程-Stream流函数式编程思想概述面向对象思想关注的是用什么对象完成什么事情，而函数式编程思想就类似于数学中的函数，主要关注的是对数据进行了什么操作优点代码简洁，开发快；接近自然语言... 查看详情
编程语言scala一般用于做啥样的项目
...命令行(REPL),可以在上面快速的试各种语法和代码。这对学习新特性，或者实验新想法非常有用。(第1章)一致性:尽管Scala融合了静态类型系统、面向对象、函数式编程等语言特性，但却很少能看出融合的痕迹。Scala是我见到融合最... 查看详情
scala函数式编程函数式的错误处理(代码片段)
前情提要Scala函数式编程指南（一）函数式思想介绍scala函数式编程（二）scala基础语法介绍Scala函数式编程（三）scala集合和函数Scala函数式编程（四）函数式的数据结构上Scala函数式编程（四）函数式的数据结构下1.面向对象的... 查看详情
scala学习函数式编程续case类(代码片段)
文章目录CASECLASSESWith`apply`youdon’tneed`new`NomutatormethodsAn`unapply`method`copy`method`equals`and`hashCode`methods`toString`methodsThebiggesta 查看详情
python学习-面向对象1(代码片段)
参考：http://www.cnblogs.com/wupeiqi/概述python的编程方式分为三种面向过程：根据业务的逻辑，从上到下一行一行的编写代码函数式：将某些功能封装在函数里，需要调用时只需要调用函数面向对象：对函数进行再次封装与分类，更... 查看详情
面向对象编程
一、概述 在学习面向对象之前，我们用函数来封装我们的功能，当我们要使用时，就调用函数来实现我们的需求。现在我们学习了面向对象的知识，知道了类和对象，其实函数式编程和面向对象编程都可以减少重复代码，不... 查看详情
为什么说面向对象编程和函数式编程都有问题(代码片段)
我不理解为什么人们会对面向对象编程和函数式编程做无休无止的争论。就好象这类问题已经超越了人类智力极限，所以你可以几个世纪的这样讨论下去。经过这些年对编程语言的研究，我已经清楚的看到了问题的答案，所以，... 查看详情