面向对象编程OOP：
Scala vs Java 都有这三特性
封装：把属性、方法封装到类中
Person:
int id, String name, Date birthday.... 需要getter/setter
eat、sleep....
继承：父类和子类之间的关系 override重写
User extends Person
exam...... //即可以继承别的类，也可以有自己的属性
多态：*****级别，父类引用指向子类对象 精髓所在 开发框架的基石。
Person person = new Person();
User user = new User();
Person person = new User();
类的定义和使用：
object SimpleObjectApp {
def main(args: Array[String]): Unit = {
val perosn = new People();
person.name = "Messi"
println(person.name + " .. " + person.age)
person.printInfo()
}
}
定义一个类：
class People {
//定义属性
var name:String = ""
val age:Int = 10
private [this] val gender = "male" //private 表示只在本类里生效，出了本类就失败。
def printInfo(): Unit = {
println("gender:" + gender)
}
//定义方法
def eat():String = {
name + "eat..."
}
def watchFootball(teamName: String): Unit = {
println(name + "is watching match of " + teamName)
}
}
构造器：
object ConstructorApp {
def main(args: Array[String]): Unit = {
val person = new Person("zhangsan", 30)
println(person.name + " : " + person.age + " : " + "person.school")
val person2 = new Person("lisi", 18, "M")
println(person2.name + " : " + person2.age + " : " + "person2.school" + " : " + person2.gender)
}
}
// 主构造器 (val name:String, val age:Int)
class Person(val name:String, val age:Int) {
println("Person Constructor enter...." )
val school = "ustc"
var gender:String = _
//附属构造器
def this(name:String, age:Int, gender:String) {
this(name,age) //附属构造器的第一行代码必须要调用主构造器或者其他附属构造器
this.gender = gender
}
println("Person Constructor leave...." )
}
继承：
object ConstructorApp {
def main(args: Array[String]): Unit = {
val student = new Student("xiaochun", 18, "Math")
println(student.name + " : " + student.gender)
}
}
class Student(name:String, age:Int, var major:String) extends Person(name,age) { //extends 关键字，继承。
println("Person Student enter...." )
println("Person Student leave...." )
}
注意：当我们子类去继承父类的时候，如果父类有的属性，子类不用写val或var。例如上面的name:String和age:Int。 但是major:String参数是父类里没有的，所以必须写var或val。
重写：
使用override可以对子类继承父类的属性或者方法改写的。
比如修改上面的学校名：必须加override关键字
override val school = "peking"
override def toString: String = "Person: override def toString :" + school
抽象类:
如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现不同的方法。
此时，可以将父类中的这些方法编写成只含有方法签名，不含方法体的形式，这种形式就叫做抽象方法。
一个类中，如果含有一个抽象方法或抽象field，就必须使用abstract将类声明为抽象类，该类是不可以被实例化的；在子类中覆盖抽象类的抽象方法时，可以不加override关键字。
object AbstractApp {
def main(args: Array[String]): Unit = {
val student = new Student2()
println(student.name)
student.speak
}
}
/**
* 类的一个或者多个方法没有完整的实现 (只有定义，没有实现)
*/
//抽象类
abstract class Person2 {
//抽象方法
def speak
//抽象字段
val names:String
val age:Int
}
//抽象类实现类
class Student2 extends Person2 {
override def speak: Unit = {
println("speak")
}
override val name: String = "xiaochun"
override val age: Int = 18
}
伴生类和伴生对象：
object ApplyApp {
}
//伴生类和伴生对象: class ApplyTest是object ApplyTest的伴生类，反之object ApplyTest是 class ApplyTest的伴生对象。两个是同名的。
class ApplyTest{
}
object ApplyTest{
}
apply方法:
object ApplyApp {
def main(args: Array[String]): Unit = {
for(i <- 1 to 10) {
ApplyTest.incr
}
println(ApplyTest.count) //10 说明object本身就是一个单例对象
var b = ApplyTest() // ==> 这句话调用的是Object里的apply方法
println("~~~~~~~~")
var c = new ApplyTest() // ==> 这句话调用的是class里的apply方法
println(c)
c()
//类名() ==> Object.apply
//对象() ==> Class.apply
}
}
class ApplyTest{
def apply() = {
println("class ApplyTest apply....")
}
}
object ApplyTest{
println("Object ApplyTest enter....")
var count = 0
def incr = {
count = count + 1
}
//最佳实践： 在Object的apply方法中去new Class
def apply() = {
println("Object ApplyTest apply....")
//在object中的apply中new class
new ApplyTest
}
println("Object ApplyTest leave....")
}
case class：
//通常用在模式匹配里面
object CaseClassApp {
def main(args: Array[String]): Unit = {
println(Dog("wangcai").name)
}
}
//case class 不用new，直接使用就行。
case class Dog(name:String)
trait： xxx extends Atrait with BTrait
class SparkConf(loadDefaults: Boolean)
extends Cloneable
with Logging
with Serializable
...
...
//这两个with的东西都是用 trait Logging和 trait Serializable
trait Partition extends Serializable {
def index: Int
override def hashCode(): Int = index
override def equals(other: Any): Boolean = super.equals(other)
}