Scala面向对象

与java的区别和联系

 类的定义：

class Person{
var name = "scala"
def sayHello(){
println("Hello,"+name)
}
def getName= name
}

注意：如果在定义方法的时候指定了()，那么在调用的时候()可写可不写，如果在定义方法的时候
没指定()，则调用方法时肯定不能带()

scala> val p = new Person()
p: Person = Person@23b8d9f3
scala> p.sayHello()
Hello,scala
scala> p.sayHello
Hello,scala
scala> println(p.getName)
scala
scala> println(p.getName())
Unspecified value parameter index.
println(p.getName())

构造方法：

Scala类中的构造函数可以分为主构造函数和辅助构造函数
这两种构造函数的区别
主constructor：类似Java的默认构造函数 this()
辅助constructor：类似Java的重载构造函数 this(name,age)

主constructor

Scala的主constructor是与类名放在一起的，与Java不同，Java中的构造函数是写在类内部的

定义一个student类

class Student(val name:String,val age:Int){
println("your name is " + name + ", your age is " + age)
}

创建对象

scala> new Student("zs",19)
your name is zs, your age is 19
res8: Student = Student@3134153d

在创建对象的时候，类中的println语句执行了，说明这个语句属于主构造函数中的代码
主constructor中还可以通过使用默认参数，来给参数设置默认值

class Student(val name:String = "jack",val age:Int = 20){
println("your name is " + name + ", your age is " + age)
}scala> new Student()
your name is jack, your age is 20
res10: Student = Student@7ddd84b5
scala> new Student("tom",18)
your name is tom, your age is 18
res11: Student = Student@a09303

Scala中，可以给类定义多个辅助constructor，类似于java中的构造函数重载
辅助constructor之间可以互相调用，但是第一行必须调用主constructor

class Student {
var name = "jack"
var age = 10
def this(name: String) {
this()
this.name = name
}
def this(name: String, age: Int) {
this(name)
this.age = age
}
}

创建对象：

scala> val s = new Student("tom")
s: Student = Student@1a538ed8
scala> val s = new Student("mick",30)
s: Student = Student@319642db

对象-Object

在scala中，我们可以直接定义一个object，就像定义class一样。

object：相当于class的单个实例，通常在里面放一些静态的field或者method
object不能定义带参数的constructor，只有空参的constructor
第一次调用object的方法时，会执行object的constructor，也就是执行object内部不在任何方法中的代码，因为它只有空参的构造函数

注意

1）object的constructor的代码只会在他第一次被调用时执行一次，以后再次调用就不会再执行了

2）object通常用于作为单例模式的实现，或者放class的一些静态成员，比如工具方法 

3） object可以直接使用，不能new

代码：

object Person {
var age = 1
println("this Person object!")
def getAge = age
}

执行，直接通过Object的名称调用属性或者方法即可，类似于Java中的静态类

scala> Person.age
res19: Int = 1
scala> Person.getAge
res20: Int = 1

伴生对象

如果有一个class，还有一个与class同名的object，那么就称这个object是class的 伴生对象 ，class是object的 伴生类

注意：

1）伴生类和伴生对象必须存放在一个.scala文件之中
2）伴生类和伴生对象最大特点在于可以互相访问private field

创建一个Person object 和Person class

object Person {
private val fdNum= 1
def getFdNum = fdNum
}
class Person(val name: String, val age: Int) {
def sayHello = println("Hi, " + name + ",you are " + age + " years old!" +
}

执行：

scala> new Person("tom",20).sayHello
Hi, tom,you are 20 years old!, and you have 1 friend.
scala> Person.fdNum
<console>:9: error: value fdNum is not a member of object Person
Person.fdNum
^
scala> Person.getFdNum
res26: Int = 1

apply方法
apply是object中非常重要的一个特殊方法，通常在伴生对象中实现apply方法，并在其中实现构造伴生类
对象的功能
在创建对象的时候，就不需要使用new Class的方式，而是使用Class()的方式，隐式调用伴生对象的apply方法，这样会让对象创建更加简洁

例如：Array的伴生对象的apply方法就实现了接收可变数量的参数，以及会创建一个Array对象
val a = Array(1, 2, 3, 4, 5)

定义半生类和对象

class Person(val name: String){
println("my name is,"+name)
}
object Person {
def apply(name: String) = {
println("apply exec...")
new Person(name)
}
}

执行：

scala> new Person("tom")
my name is,tom
res29: Person = Person@63917fe1
scala> Person("tom")
apply exec...
my name is,tom
res30: Person = Person@35e74e08

注意：在这里new Person(“zhang”) 等于 Person(“zhang”)，都是获取Person的对象
只不过Person(“zhang”)是用的object中apply方法
而new Person(“zhang”)是直接基于class创建的

main方法

和Java一样，在Scala中如果要运行一个应用程序，必须有一个main方法，作为入口
Scala中的main方法必须定义在object中，格式为 def main(args: Array[String])

object mainDemo {
def main(args: Array[String]): Unit = {
println("hello scala!")
}
}

接口-trait

Scala中的接口称为trait，trait类似于Java中的interface
在triat中可以定义抽象方法

1) 类可以使用 extends 关键字继承trait，无论继承类还是trait统一都是使用 extends 这个关键字
2) 类继承trait后，必须实现trait中的抽象方法，实现时不需要使用 override 关键字

3) scala不支持对类进行多继承，但是支持对trait进行多重继承，使用 with 关键字即可

代码：

object PersonDemo {
def main(args: Array[String]): Unit = {
val p1 = new Person("tom")
val p2 = new Person("jack")
p1.sayHello(p2.name)
p1.makeFriends(p2)
}
}
trait HelloTrait { def sayHello(name: String)}
trait MakeFriendsTrait { def makeFriends(p: Person)}
class Person(val name: String) extends HelloTrait with MakeFriendsTrait {
def sayHello(name: String) = println("Hello, " + name)
def makeFriends(p: Person) = println("Hello, my name is " + name + ", your
}