Scala面向对象
1. 类 class
类的定义
// 定义一个类
class People {
// 定义属性
// var name:String = ""
var name:String = _ // name这里也可以直接使用占位符占位
val age = 10
private[this] val gender = "M" // gender是类People的一个私有属性，在外面是不能直接被调用的
def printInfo(): Unit = {
println(gender)
}
// 定义方法
def eat() = {
name + " eat banana."
}
}类的调用：如果要调用一个class类，要先new一个class出来
object SimpleClassApp {
def main(args: Array[String]): Unit = {
// 类的调用
// new 一个类出来
val people = new People
people.name = "scala"
// println(people.gender) // gender是私有属性，不能直接调用
people.printInfo() // 但是gender在这里是被class本身调用，可以合法使用
val a = people.eat()
println(a)
}
}2. 构造函数
主构造函数：构造函数的入参都可以作为class的属性来使用。
附属构造函数：第一行必须调用主构造器或者其他附属构造器；附属构造函数可以写一个或者多个。
object ConstructApp {
def main(args: Array[String]): Unit = {
// 创建一个对象
val girl = new Girl("Cindy", 18,"13000000000","somewhere")
println(girl.name + " : " + girl.age + " : " + girl.phone + " : " + girl.address)
girl.like()
println(girl.city)
}
}
// 构造函数中的参数以及类中的属性（非private的）都能直接能够当做对象的属性来使用
class Girl(val name:String, val age:Int) {
println("girl enter")
def like(): Unit = {
println(name + " like something.")
}
val city = "Shenzhen"
// 附属构造函数：第一行必须调用主构造器或者其他的附属构造器
var phone = ""
def this(name:String, age:Int, phone:String) {
this(name,age) // 第一行，调用主构造器
this.phone
}
// 再定义一个附属构造函数
var address = ""
def this(name:String, age:Int, phone:String, address:String) {
this(name,age,phone) // 这里的phone在前面的附属构造函数里面已经定义了，可以直接使用
this.address
}
println("girl exit")
}3. 类的继承
3.1 发生继承时，当外面创建子对象的时候，首先会调用父类的构造方法，然后才是调用子类的构造方法；
如果子类里面的属性不是父类里面已经有的，前面要加val修饰符，否则外面是访问不到的
创建一个子类，继承上面的Girl类
// 类的继承
/**
*
* 类的继承
* littleGirl的前半部分littleGirl(name:String, age:Int)是一个主构造器，
* 继承了Girl这个class
* 并且littleGirl还加入了自己的参数major
*
* 发生继承时，当我们创建子对象的时候，首先会调用父类的构造方法，然后才是调用子类的构造方法
* 如果子类里面的属性不是父类里面已经有的，前面要加val修饰符，否则外面是访问不到的
*/
class littleGirl(name:String, age:Int, val major :String) extends Girl(name,age) {
println("littleGirl enter")
println("littleGirl exit")
}调用这个子类
val littlegirl = new littleGirl("girl", 10, "computer")
println(littlegirl.name + " : " + littlegirl.age + " : " + littlegirl.major)3.2 继承是发生在子类和父类之间的
如果想重写弗雷中已有的方法时，一定要添加override修饰符。
class littleGirl(name:String, age:Int, val major :String) extends Girl(name,age) {
println("littleGirl enter")
// toString是scala内置的一个object类的方法，如果想重写父类中已有的方法时，一定需要添加override修饰符
override def toString = "littleGirl toString"
println("littleGirl exit")3.3 抽象类
扫描二维码关注公众号，回复：
2389808 查看本文章
类中有一个或者多个方法没有实现，换句话说：只有定义，没有实现。
这个抽象类是不能直接使用的，必须要通过实现了该抽象类的属性或者方法来使用。
子类重写父类中的属性或者方法，override可以不写。
定义一个抽象类
/**
* 抽象类的定义 abstract
* 抽象类可以有属性，有方法
* 属性和方法都只是定义，没有实现
* 这样的抽象类是不能直接被使用的
*/
abstract class Animal {
// 属性或方法只有定义没有实现
var name:String
var age:Int
def speak
}因为这个抽象类不能直接使用，再定义一个子类继承上面的抽象类
/**
* 定义一个字类继承上面的抽象类，这个子类要么再被定义成抽象类，或者实现父类的spark方法
* 在Dog上面按住ctrl+回车，选择实现这个方法(Implement methods)，选中所有的方法点OK
* 再给属性赋值，方法重写
* 子类重写父类中的方法或者属性，override可以省略不写
*/
class Dog extends Animal {
// 重写父类的属性
override var name: String = "Rich"
override var age: Int = 1
// 重写父类的方法
override def speak: Unit = {
println("wang wang wang")
}
}最后再调用这个子类，此时子类的属性和方法都可以被调用。
object AbstractApp {
def main(args: Array[String]): Unit = {
// 因为抽象类Animal是不能直接被使用的，所以new一个它的子类，再调用它的方法
val dog = new Dog
dog.speak
}
}思考：
抽象类的用途是什么？