scala 开发入门（5）-- 类与对象

类的定义

scala中的类与java语言中一样都是用class定义class Person{
//声明一个变量，这里成员变量必须初始化
var name:String = null //或者用占位符初始化 var name:String = _
} //类的成员变量在声明时必须初始化,除非是抽象类

//创建类对象
val p = new Person()
//直接修改成员变量name
p.name = "Jhon"

对象的定义

单例对象，使用时可以不创建对象而是直接用 类名.方法 来访问object Student{
private var studentNo:Int = 0
def uniqueStudentNo() = {
studentNo += 1
studentNo}
}

//直接通过单例对象名称访问其成员方法
Student.uniqueStudentNo()
res1:Int = 1
//单例对象中的成员变量状态随程序执行而改变
Student.uniqueStudentNo()
res2:Int = 2应用程序对象，定义一个main方法作为应用程序的入口/**
* 应用程序对象：通过定义main方法实现
*/
object Example{
object Student{
private var studentNo:Int = 0
def uniqueStudentNo()={
studentNo += 1
studentNo}
}
//通过 main 方法作为程序的入口
def main(args：Array[String]){
println(Student.uniqueStudentNo())
}
}

/**
*应用程序对象:通过混入 trait App 来实现
*/
object Example extends App {
object Student {
private var studentNo:Int = 0
def uniqueStudentNo() = {
studentNo += 1
studentNo}
}
//直接写可执行的代码
println(Student.uniqueStudentNo())

伴生类与伴生对象，将单例对象引申为类,区别其他类或对象非常重要的地方就是访问权限/**
*伴生对象与伴生类
*/
object Example extends App{
//伴生类 Student
class Student{
private var name:String = null}
//伴生对象
object Student{
private var studentNo:Int = 0
def uniqueStudentNo() = {
studentNo += 1
studentNo}
}
}

//访问权限展示
object Example2 extends App{
//伴生类Student
class Student{
private var name:String = null
def getStudentNo = {
Student.uniqueStudentNo()
//伴生类Student 中可以直接访问伴生对象 Student 的私有成员
Student.studentNo
}
}
//伴生对象
object Student {
private var studentNo：Int = 0
def uniqueStudentNo() = {
studentNo += 1
studentNo}
//直接访问伴生类对象的私有成员
def printStudentName = println(new Student().name)
}通过非显式使用new关键字创建对象，在集合那部分已经大量使用，使用的就是伴生对象apply方法。如果希望在编写代码时，不通过 new Student() 这样显式的调用 new 关键字来创建对象，可以使用如下方式/**
*伴生对象与伴生类：不显式的通过 new 关键字来创建对象
*/
object Example extends App{
//伴生类Student
class Student{
var name:String = null
}
//伴生对象
object Student{
//apply方法，供非显式 new 创建对象时调用
def apply() = new Student()
}

//无 new 方式创建对象，调用的是伴生对象的 apply 方法：def apply() = new Student()
val s = Student()
s.name = "John"
println(s.name)
}

主构造函数

//默认参数的主构造函数
class Person(var name:String = "",var age:Int = 18){
override def toString() = "name="+name",age="+age}

//不使用参数时，使用默认值
val p = new Person
p:Person = name=,age=18

//私有主构造函数,通过 private 关键字将主构造函数定义为私有
class Person private (var name:String,var age:Int)
val p = new Person("John",19)  //错误，外部不能调用私有主构造函数

辅助构造函数

同主构造函数一样，辅助构造函数也有默认参数
/**
*辅助构造函数
*/
object Example extends App{
//定义无参的主构造函数
class Person{
//类成员
private var name:String = null
private var age:Int = 18
private var sex:Int = 0

//带默认参数的辅助构造函数
def this(name:String = "",age:Int = 18,sex:Int = 1){
this()  //先调用主构造函数，否则会报错
this.name = name
this.age = age
this.sex = sex
}
override def toString = {
val sexStr = if(sex==1) "男" else "女"
s"name=$name,age=$age,sex=$sexStr"
}
}

println(new Person("John")) // name=John,age=18,sex=男
println(new Person)         // name=null,age=18,sex=女
}
从执行结果可以看出，第一个调用的是辅助构造函数，第二个调用的其实是无参的主构造函数
在创建对象时，编译器会首先查找是否有主构造函数与待调用的构造函数匹配，有则调用，没有才会查找相应的辅助构造函数

继承与多态

//类的继承
/**
*类继承
*/
object Example extends App{
class Person(var name:String,var age:Int){
override def toString:String = "name="+name+",age="+age
}

//通过extends 关键字实现类的继承，注意 Student 中的name和age前面没有 var 关键字修饰
//表示这两个成员继承自 Person 类，var studentNo:String 则为 Student 类中定义的新成员
class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){
override def toString:String = super.toString+",studentNo="+studentNo //方法重写 }

println(new Person("John",18))   //name=John,age=18/
println(new Student("Nancy",19,"110831") //name=Nancy,age=19,studentNo=110831

多态就是可对父类方法进行重写，未重写则继承父类方法

抽象类

抽象类是一种不能被实例化的类，抽象类中存在抽象成员变量或成员方法，这些成员方法或成员变量在子类中被具体化。//普通类成员变量在定义时必须显式初始化
class Person{
var name:String = _
}

class Person{
var name:String
} //报错

//成员变量如果不显式初始化，则将类声明为抽象类，通过 abstract 关键字来定义
abstract class Person{
var name:String
}

//当子类继承抽象类时，需在子类中对父类中的抽象成员变量进行初始化，否则子类也必须声明为抽象类
//在子类中对父类中的抽象成员变量初始化，使用 override 关键字
class Student extends Person{
override var name:String = _
}
//override 也可以省略
class Student extends Person{
var name:String = _
}

object Example extends App{
abstract class Person{
//抽象类中的具体成员变量
var age:Int = 0
//抽象类中的抽象成员变量
var name:String
//抽象类中的抽象方法
def walk()
//抽象类中的具体方法
override def toString = name
}

class Student extends Person{
//对继承自父类的抽象成员变量进行初始化，override 关键字可以省略
override var name = _
//对继承自父类的抽象成员方法进行初始化，override 关键字可以省略
override def walk():Unit = println("Walk like a Student")
}

val p = new Student
p.walk()
}