3.Scala的函数
1)scala中的类和java中基本类似。
2)scala中的类同样通过class来进行声明。
3)scala中的类同样可以具有成员变量和成员方法。
4)scala中的类同样可以通过new关键字来创建出对象。
5)Scala中的类的成员默认的访问权限是public。也可以加private或protected。
6)当成员变量或成员方法是私有属性时,外部将不能直接访问,这个同java一样。
示例:
class Person() {
//创建一个类,并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是:scala中变量(var)声明时需要指定初始值,
private var name = “”
private var age = 0
def eat(){
println("eat")
}
}
和java不同,scala中的类不需要明确声明一个构造器,而是直接将构造参数通过构造参数列表声明为类的一部分。
而直接写在类的体中的既不是类的成员变量也不是成员函数的部分,会自动收集为构造函数的体。
scala声明主构造的形式是在类右侧声明,如果不声明,Scala也提供了默认构造器。注意:当显示声明主构造器之后,默认的空构造器失效。
示例:
//scala中的类不需要明确声明一个构造器,而是直接将构造参数通过构造参数列表声明为类的一部分
class Person(v1: String, v2: Int) {
//创建一个类,并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是:scala中变量(var)声明时需要指定初始值,
private var name = v1
private var age = v2
//而直接写在类的体中的既不是类的成员变量也不是成员函数的部分,会自动收集为构造函数的体。
//当调用构造方法时,会打印 …… 和***
println("…………")
println("***")
}
有些时候,一个类里需要多个构造器。scala里除主构造器之外的构造器被称为辅助构造器。
1)Scala的辅助构造器定义开始于def this()。
2)Scala里每个辅助构造器的第一个动作都是调用同类的构造器。
示例:
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
//Scala的辅助构造器定义开始于 def this()
//Scala里每个辅助构造器的第一个动作都是调用同类的构造器
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
}
一个完整的示例:
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
println("…………")
println("***")
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
def getName() = {
this.name
}
def setName(name: String) = {
this.name = name
}
def getAge() = {
this.age
}
def setAge(age: Int) = {
this.age = age
}
def say() {
println("say word")
}
}
1)scala中的类(class)不能定义静态成员(或静态方法),而代之以定义单例对象来替代。
2)单例对象需要通过object关键字来声明。
3)一个单例对象可以单独存在,也可以绑定到一个类上。
4)单例对象当中的所有方法,都可以不需要创建对象而直接通过object单例对象的名字直接来调用,用起来感觉就像一个静态方法一样。
5)当一个单例对象和某个类写在同一个源文件中且共享同一个名字时,他们就产生了一个绑定的关系。此时单例对象称为该类的伴生对象。类称为该对象的伴生类。
6)类和他的伴生对象可以互相访问其私有成员。
7)以伴生的方式为类增加静态成员成为了可能。
8)单例对象不能new,因此也没有构造参数。
9)可以把单例对象当作是java中可能会用到的静态方法工具类。
10)作为程序的入口main方法必须是静态的,所以main方法必须处在一个单例对象中,而不能写在一个类中。
11)单例对象在第一次被访问时才会被初始化。
示例:
class Person(v1: String, v2: Int) {
//此私有变量,伴生类可以访问
private var name = v1
private var age = v2
}
//Person的单利对象,也即伴生类Person
object Person {
def shownamespace() {
val p = new Person
//可以访问类的私有变量
println(p.name)
}
def eat() {
println("eat")
}
}
scala中同样支持抽象类的使用,抽象类的内部可以包含抽象方法和非抽象方法。抽象类不允许被实例化,抽象类主要是用来被继承的。
Scala的抽象类同java,通过abstract关键字来定义。抽象方法的特点:没有{}方法体。
示例:
abstract class Teacher {
//抽象方法,返回值为Unit
def makeNote()
//抽象方法,返回值为String
def teach():String
def compute():Int
//实体方法
def say(){}
}
1)可以类比java中的接口,但是又和接口非常不一样,特质相当于java中的接口,java中称为类实现了接口,scala中称为混入了特质。
2)和java中的接口不同的是,scala中的特质可以包含具有方法体的方法。
和抽象类不同的地方在于,scala的类只能单继承,但是可以多混入,利用这种方式可以实现类似c语言中多继承的特性。
3)在类中可以通过extends或with关键字来让类混入特质,如果类没有明确继承父类,extends关键字没有被占用就可以使用extends。
4)但是如已经使用了extends显示的继承了父类,再向混入特质就要用with关键字了。
一个类的声明中只能有一个extends,但是可以有多个with。
示例:
trait Dance {
def Balei()
def floor()
//trait类似于java的接口,但可以做具体方法的实现
def eat(){}
}
trait Driver {
def shache():String
def piaoyi()
}
//scala中,只能继承一个父类,但是可以混入多个特质(trait)
//需要实现特质中未实现的方法
//此外,需要注意的是,如果未继承任何类或抽象类,在混入特质时,
//比如有且仅有一个特质需要用extends来混入,而其他特质用with混入
class ZhangTeacher extends Dance with Driver {
def Balei(): Unit = {
???
}
def floor(): Unit = {
???
}
def piaoyi(): Unit = {
???
}
def shache(): String = {
???
}
}
1)只要在声明类时,在class关键字前加上case关键字,这个类就成为了样例类。样例类必须要显式的声明一个主构造器。
2)当样例类声明一个主构造器后,会默认隐式的声明一个空构造器。
3)样例类默认实现序列化接口。
序列化的两个作用:①数据持久化;②网络数据传输。
4)样例类默认自动覆盖toString、equals、hashCode方法。
5)样例类不需要new可以直接生成对象。
示例:
//需要声明一个主构造器,主构造器可以是一个空构造器
case class Item(v1:Int,v2:String) {
var id=v1
var title=v2
}
//样例类不需要new,并且隐式的含有空构造器
val v1=Item(1,"phone")
//> v1 : Item = Item(1,phone)
val v2=Item
//> v2 : Item.type = Item
在Scala中用来表示一个结果,它可能有值,也可能没有值,它有两个子Option。一个是Some,一个是None。
示例:
def f1(a:Int,b:Int)={
if(b!=0){
Some(a/b)
}else{
None
}
}
//表示如果有正确结果,返回正确结果,没有则返回指定的默认值
f1(4,0).getOrElse("error")
类似于java中通过import关键字引入包/类,scala也可以实现这种方式引入,但是更强大一些。
1)scala中的import可以出现在代码任何地方。
2)scala中的import时可以指的是对象和包。
3)scala中的import可以重命名或隐藏一些被引用的成员。
4)scala默认会自动引入如下三个包下的所有内容。
java.lang:java中的通用类。
scala._:scala提供的通用类 主要是基本类型除了String。
Predef._:提供了单例对象 以及一些常用方法 print println。
示例:
import cn.tedu._
import cn.tedu.{Apple,Orange}
1)重写是指覆盖父类中的方法来在子类中做其他事项。
格式:
override def 父类方法名 参数列表 返回值 方法体
2)重载是指在同一个类中提供方法名相同但是参数不同的方法和java中基本一致。
示例:
可以用在成员变量、成员方法、类本身上,作用和java中相同。
示例:
object Demo13{
def main(args: Array[String]): Unit = {
val t1:Teacher=new TeacherChen("chen",32)
val t2:Teacher=new TeacherLiu("liu",32)
}
}
基本和java中相同,不同的是,泛型是用方括号引起来的。
val arr = Array[String]();
上一篇:Scala中的集合类型