Scala OOP（类，抽象类，伴生对象和伴生类，样例类，特质，型变）

类（class）
抽象类（abstract class）
单例对象（object）
特质（trait）
样例类（case class）

1.类（class）

（1）类的基本概述

• 类通过class关键字定义
• 类通过new关键字创建实例
• 类拥有成员变量和方法
• 类的成员默认为public，也支持private、protected
• 类中无法定义静态成员变量和方法
• 类无需明确定义构造方法，通过构造参数列表声明为类的一部分

（2）类成员访问修饰符

• Java

Modifier	Class	Package	Subclass	World
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

• Scala

Modifier	Class	Companion	Subclass	Package	World
default	Y	Y	Y	Y	Y
protected	Y	Y	Y	N	N
private	Y	Y	N	N	N

（3）类的定义

• 构造器
  主构造器
  辅助构造器
• 成员变量与方法
• 类的实例化

class：类，object：单例对象，trait：特质

//主构造器的参数列表直接定义在类名后面
//主构造器执行类定义汇总的搜有哦语句
class Student {
   //无参的主构造器
  //定义成员变量
  var name="zhang"
  var age:Int=_ //0
  var gender:String=_ //null
 
//辅助构造器可以调用主构造器，也可以调用其他辅助构造器
  //定义一个辅助构造器1
  def this(name:String,age:Int)={
   
   //辅助构造器必须要从调用其它构造器开始
    this()
    this.name=name
    this.age=age
  }

  //定义一个辅助构造器2
  def this(gender:String)={
   
    this("lisi",18)//调用辅助构造器1
    this.gender=gender
  }

  //定义一个成员方法
  def study()={
   
    println("good good study,day day up")
  }
}

//调用需要写在main方法里，main方法需要定义到object中
//测试
object  Test01{
   
  def main(args: Array[String]): Unit = {
   
   
    //new一个对象出来后，可以使用成员变量和成员方法
      //使用主构造器创建对象
    val stu1 = new Student()
    println(stu1.name)
    println(stu1.age)
    println(stu1.gender)
    stu1.study()
    
    //使用辅助构造器创建对象
    val stu2 = new Student("zhangsan",20)
    println(stu2.name)
    println(stu2.age)
    println(stu2.gender)
    stu2.study()
      stu2.age=25//可以自动生成get和set方法，可以对变量进行修改，需要是var定义的变量

    val stu3=new Student("女")
    println(stu3.name)
    println(stu3.age)
    println(stu3.gender)
    stu3.study()

  }
}
//输出
zhang
0
null
good good study,day day up

zhangsan
20
null
good good study,day day up

lisi
18
女
good good study,day day up

（4）类的继承

• Scala使用“extends”关键字实现继承
• 子类重写父类方法必须使用“override”关键字

class XiaoXueSheng extends  Student {
   
    //继承父类方法
   override def  study()={
   
            println("小学生不爱学习")
    }
    //定义子类自己非方法
    def play()={
   
        println("小学生喜欢打游戏")
    }
}

object  Test02{
   
    def main(args: Array[String]): Unit = {
   
        
        val xiao:XiaoXueSheng=new XiaoXueSheng
        println(xiao.age)
        xiao.study()
         xiao.play()
    }
}
//输出
0
小学生不爱学习
小学生喜欢打游戏

2.抽象类（abstract class）

• 抽象类可包含未实现的方法，即抽象方法，无方法体
• 抽象类无法实例化
• 抽象类使用“abstract”关键字修饰
  子类重写父类抽象方法时，“override”关键字可选
  子类重写父类非抽象方法，“override”关键字必写

//定义一个抽象类，使用abstract修饰
abstract  class Shape {
   
   def draw():Unit

   def write()={
   
    println("写代码")
  }
}

class Circle extends  Shape {
   
    //draw是抽象类的抽象方法，可以省略关键字override 
  override def draw(): Unit = {
   
    println("画一个○")
  }
}
 //继承抽象类的普通方法必须写关键字override
object  Test03{
   
  def main(args: Array[String]): Unit = {
   
    var circle=new Circle
    circle.draw()
      //如果没有重写方法，可直接调用抽象类方法
    circle.write()
  }
}
//输出
画一个○
写代码

3.单例对象（object）

• Scala的类中无法定义静态成员，即无static关键字。如何像Java一样表达类的静态成员变量、成员方法与静态代码块？
• Scala解决方案：单例对象
  使用“object”关键字声明，可包含变量、方法与代码定义
  单例对象中的成员变量、成员方法通过单例对象名直接调用
  单例对象第一次被访问时初始化，并执行全部代码块
  单例对象不能new，且无构造参数
  程序入口main()方法必须定义在单例对象中
  单例对象与同名类定义在同一文件中时形成绑定关系

//定义单例对象
object Blah {
   
    //单例对象被访问的时候，执行所有代码
 println("initializiing")
  def sum