[Scala] 面向对象

类定义

• 当属性是private时，scala会自动为其生成get和set方法
• 只希望scala生成get，不生成set，可定义为常量
• 不生成get和set方法，使用private[this]关键字

package day0106

class Student1 {
  private var stuID:Int = 0
  private var stuName:String="Tom"
  private var age:Int = 20
  
  def getStuName():String=stuName
  def setStuName(newName:String) = this.stuName = newName
  def getStuAge():Int = age
  def setStuAge(newAge:Int) = this.age = newAge
}
object Student1{
  def main(args: Array[String]): Unit = {
    //创建学生对象
    var s1 = new Student1
    
    //访问set方法
    println(s1.getStuName()+"	"+s1.getStuAge())
    
    //输出，直接访问私有属性
    s1.setStuName("Mary")
    s1.setStuAge(25)
    println(s1.getStuName()+"	"+s1.getStuAge()) 
    
    //访问私有属性
    println(s1.stuName+"	"+s1.age)
  }
}

内部类

• 在一个类内部定义另外一个类

package day0601

import scala.collection.mutable.ArrayBuffer

class Student1 {
    private var stuName:String = "Tom"
    private var stuAge:Int = 20
    
    //定义一个可变数组保存学生的课程成绩
    private var courseList = new ArrayBuffer[Course]()
    
    //定义一个函数用于添加学生的课程成绩
    def addNewCourse(cname:String,grade:Int){
      var c = new Course(cname,grade)
      courseList += c
    }
    
    //定义一个课程类：主构造器写在类的后面
    class Course(val courseName:String,val grade:Int){
      //其他函数
    }
}

object Student1{
  def main(args: Array[String]):Unit = {
    var s = new Student1
    
    s.addNewCourse("Chinese", 80)
    s.addNewCourse("Math", 80)
    s.addNewCourse("English", 80)
    
    println(s.stuName + "	" + s.stuAge)
    println("*********成绩信息**********")
    for(c <- s.courseList)
      println(c.courseName+'	'+c.grade)    
  }
}

构造器

• 主构造器：和类的声明在一起，一个类只有一个主构造器
• 辅助构造器：一个类有多个辅助构造器，通过关键字this

package day0601

class Student2(var stuName:String,var age:Int){
  def this(age:Int){
    // 在辅助构造器中调用主构造器
    this("no name",age)
    println("调用辅助构造器")
  }
  //定义其他的辅助构造器
}

object Student2 {
  //测试程序
  def main(args:Array[String]):Unit = {
    
    //使用主构造器
    var s1 = new Student2("Tom",20)
    println(s1.stuName+"	"+s1.age)
    
    //使用辅助构造器
    var s2 = new Student2(25)
    println(s2.stuName+"	"+s2.age)
  }
}

Object对象

• Object中的内容都是静态的
• Scala中，没有静态修饰符static
• 如果class的名字和object的名字一样，把这个object叫做类的伴生对象
• 可使用Object实现单例模式（Java中构造器定义为private，提供getInstance方法）
• 使用App对象（应用程序对象），可省略main方法

package day0601

object HelloWorld extends App{
//  def main(args:Array[String]): Unit = {
//    println("Hello World")
//  }
  //把main函数中的程序直接写在object中
  println("Hello World")
  
  if(args.length > 0){
    println("有参数")
  }else{
    println("没有参数")
  }
}

Hello World
没有参数

apply方法

• 可以省略new关键字
• 必须写在伴生对象中
• 类似辅助构造器

package day0601

class student3(var stuName:String)

object student3 {
  //定义apply方法
  def apply(name:String)={
    println("*******调用apply方法********")
    new student3(name)
  }
  
  def main(args:Array[String]): Unit = {
    //通过主构造器创建对象
    var s1 = new student3("Tom")
    println(s1.stuName)
    
    //通过apply方法创建对象
    var s2 = student3("Mary")
    println(s2.stuName)
  }
}

继承

•  override：用子类中的值覆盖父类中的值

package day0601

//定义父类
class Person(val name:String,val age:Int) {
  def sayHello():String = "Hello"+name+" and the age is "+age
}

//定义子类
class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age)

object Demo1{
  def main(args:Array[String]):Unit = {
    // 创建Person对象
    var p1 = new Person("Tom",20)
    println(p1.name+"	"+p1.age)
    println(p1.sayHello())
    
    // 创建Employee对象
    var p2:Person = new Employee("Mike",25,1000)
    println(p2.sayHello())
  }
}

• 重写方法

package day0601

//定义父类
class Person(val name:String,val age:Int) {
  def sayHello():String = "Hello"+name+" and the age is "+age
}

//定义子类
class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age){
  //重写父类函数
  override def sayHello():String = "子类中sayHello方法"
}

object Demo1{
  def main(args:Array[String]):Unit = {
    // 创建Person对象
    var p1 = new Person("Tom",20)
    println(p1.name+"	"+p1.age)
    println(p1.sayHello())
    
    // 创建Employee对象
    var p2:Person = new Employee("Mike",25,1000)
    println(p2.sayHello())
  }
}

•  匿名子类

package day0601

//定义父类
class Person(val name:String,val age:Int) {
  def sayHello():String = "Hello"+name+" and the age is "+age
}

//定义子类
class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age){
  //重写父类函数
  override def sayHello():String = "子类中sayHello方法"
}

object Demo1{
  def main(args:Array[String]):Unit = {
    // 创建Person对象
    var p1 = new Person("Tom",20)
    println(p1.name+"	"+p1.age)
    println(p1.sayHello())
    
    // 创建Employee对象
    var p2:Person = new Employee("Mike",25,1000)
    println(p2.sayHello())
    
    // 通过匿名子类实现继承
    var p3:Person = new Person("Mary",25){
      override def sayHello():String = "匿名子类中sayHello方法"
    }
    println(p3.sayHello())
  }
}

•  抽象类

package day0601

abstract class Vehicle{
  def checkType():String  
}

class Car extends Vehicle{
   def checkType():String = "I am a Car"
}

class Bike extends Vehicle{
   def checkType():String = "I am a Bike"
}


object Demo2 {
  def main(args:Array[String]):Unit={
    var v1:Vehicle = new Car
    println(v1.checkType())
    
    var v2:Vehicle = new Bike
    println(v2.checkType())
  }
}

• 抽象字段

package day0601

abstract class Person1{
  //定义抽象字段，只有get方法
  val id:Int
  val name:String
}

//若子类中没有提供父类的抽象字段的初始值，子类必须也是抽象的
abstract class Employee1 extends Person1{
  
}

//若不提供初始值，可把抽象字段放到构造器中
class Employee2(val id:Int,val name:String) extends Person1{
  //val id:Int = 1
  //val name:String = ""
}

object Demo3 {
  
}

trait（特质）

• 本质是抽象类，支持多重继承

package day0601

//代表人
trait Human{
  val id:Int
  val name:String
}
//代表动作
trait Actions{
  def getActionName():String
}

//把抽象字段放入构造器
class Student4(val id:Int,val name:String) extends Human with Actions{
  def getActionName():String = "Action is running"
}

object Demo4 {
  def main(args: Array[String]):Unit = {
    var s1 = new Student4(1,"Tom")
    println(s1.id+"	"+s1.name)
    println(s1.getActionName())
  }
}

包和包对象 

• 包定义：可嵌套定义
• 包引入：import可写在任何地方，_代表包下的所有内容（同 java * ）
• 包对象：可包含常量，变量，方法，类，对象，trait，包