Scala语言的面向对象编程

一、面向对象的基本概念:把数据和操作数据的方法放到一起，作为一个整体（类 class）
    面向对象的特征：
    （1）封装
    （2）继承
    （3）多态

二、定义类: class，没有类的修饰符: public、protected、private

class Student1 {
  //定义属性
  private var stuName:String = "Tom"
  private var stuAge:Int = 20

  //定义方法（函数）
  def getStuName():String = stuName
  def setStuName(newName:String) = this.stuName = newName

  def getStuAge():Int = stuAge
  def setStuAge(newAge:Int) = this.stuAge = newAge
}

//开发一个测试程序，创建学生对象
// Java: public static void main()******
//概念：objec对象可以跟类名不一样，如果一样，这个object对象就是该类的伴生对象
object Student1{
  //都是静态
  def main(args: Array[String]): Unit = {
    //创建学生对象
    var s1 = new Student1

    //第一次输出
    println(s1.getStuName()+"\t" + s1.getStuAge())

    //调用set方法
    s1.setStuName("Mary")
    s1.setStuAge(25)

    //第二次输出
    println(s1.getStuName()+"\t" + s1.getStuAge())

    //第三次输出: 直接访问类的私有成员
    //问题：为什么可以直接访问类的私有成员？？？ ----> 讨论：属性的set和get方法
    println(s1.stuName + "\t" + s1.stuAge)

  }
}

三、属性的get和set方法

/*
属性的get和set方法
1、当定义属性的时候，如果是private，Scala会自动生成对应的set和get方法
     private var stuName:String = "Tom"
     (1) get方法：stuName
     (2) set方法： stuName_

2、如何只有get方法，没有set方法？ ---> 将属性定义为: 常量 val
      private val money:Int = 1000

3、不希望生成get和set方法: private[this]
   该属性只属于该对象私有
 */

class Student2 {
  //定义属性
  private var stuName:String = "Tom"

  //只有get方法
  private val money:Int = 1000
}

object Student2{
  def main(args: Array[String]): Unit = {
    var s2 = new Student2

    println(s2.stuName)

    //修改money值 ===> error 错误
    //s2.money = 2000
  }
}

四、嵌套类（内部类）: 类：Student  包含：课程Course

import scala.collection.mutable.ArrayBuffer

class Student3 {

  //定义一个内部类（嵌套类）: 学生选修的课程
  //通过主构造器
  class Course(val courseName:String,val credit:Int){
    //其他的方法
  }

  //属性
  private var stuName:String = "Tom"
  private var stuAge:Int = 20

  //定义一个数组来保存该学生选修的课程
  private var courseList = new ArrayBuffer[Course]()

  //定义方法：往学生信息中添加新的课程
  def addNewCourse(cname:String,credit:Int): Unit ={
    //创建一门课程
    var c = new Course(cname,credit)

    //加入list
    courseList += c
  }
}

object Student3{
  def main(args: Array[String]): Unit = {
    //创建学生
    var s3 = new Student3

    //给学生添加课程
    s3.addNewCourse("Chinese",3)
    s3.addNewCourse("English",3)
    s3.addNewCourse("Math",3)

    //输出
    println(s3.stuName+"\t"+s3.stuAge)
    for(s <- s3.courseList) println(s.courseName + "\t" + s.credit)
  }

}

五、构造器：（1）主构造器  （2）辅助构造器

/*
构造器：（1）主构造器  : 和类的申明在一起，只能有一个主构造器
       （2）辅助构造器:  多个辅助构造器，通过关键字：this
 */

class Student4(val stuName:String,val stuAge:Int) {
  //定义一个辅助构造器
  def this(age:Int){
    //调用主构造器
    this("No Name",age)
  }
}

object Student4{
  def main(args: Array[String]): Unit = {
      //使用主构造器创建学生对象
    var s4 = new Student4("Tom",24)
    println(s4.stuName + "\t" + s4.stuAge)

    //使用辅助构造器创建学生对象
    var s5 = new Student4(25)
    println(s5.stuName + "\t" + s5.stuAge)
  }
}

六、Object对象：相当于static关键字
    1、单例模式：一个类只有一个对象
                举例：生成信用卡的卡号

object CreditCard {

  //定义变量：保存信用卡的卡号
  //该属性只属于该对象
  private[this] var creditCardNumbe:Long = 0

  //产生卡号
  def generateNewCCNumber():Long = {
    creditCardNumbe += 1
    creditCardNumbe
  }

  //测试程序
  def main(args: Array[String]): Unit = {
    //得到新的卡号
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
  }
}

    2、应用程序对象: App  -----> 可以省略main方法

object MainAppObject extends App {
  //创建一个main方法
//  def main(args: Array[String]): Unit = {
//    println("Hello World")
//  }

  println("Hello World")
}

七、类的apply方法：省略new关键字
                   需要定义在类的伴生对象中

    举例：val s1 =  new Student
          val s2 = Student  ---> 必须要定义Student类的apply方法

class Student5(val stuName:String){
}

object Student5 {
  //定义类的apply方法
  def apply(stuName:String) = {
    println("调用到了apply方法")

    //调用主构造器
    new Student5(stuName)
  }

  def main(args: Array[String]): Unit = {
    //创建学生对象
    var s1 = new Student5("Tom")
    println(s1.stuName)

    //创建学生对象，省略new关键字
    var s2 = Student5("Mary")
    println(s2.stuName)
  }
}

八、继承 extends
    1、基本的继承
    2、复写父类中的方法
    3、使用匿名子类
    4、抽象类:   包含抽象方法，抽象类只能用来继承
       抽象字段: 就是一个没有初始值的字段

//继承
/*
1、基本的继承
2、复写父类中的方法
3、使用匿名子类
 */

//定义父类
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,salary:Int) extends Person(name,age){
  //重写父类中的sayHello方法
  override def sayHello(): String = "子类中的sayHello方法"
}

object Demo1 {
  def main(args: Array[String]): Unit = {
    //创建一个Person对象
    var p1 = new Person("Tom",20)
    println(p1.sayHello())

    //创建一个子类
    var p2:Person = new Employee("Mike",25,1000)
    println(p2.sayHello())

    //创建一个匿名子类，从Person继承
    var p3:Person = new Person("Jerry",26){
      //在匿名子类中，重写父类的方法
      override def sayHello(): String = "匿名子类中的sayHello方法"
    }
    println(p3.sayHello())
  }
}

//抽象类型

//父类：抽象  交通工具
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
    var v2:Vehicle = new Bike

    println(v1.checkType())
    println(v2.checkType())
  }
}

package p1

//父类：抽象
abstract class Person{
  //就是一个抽象字段
  var id:Int
  var name:String
}

//一种做法
abstract class Employee1 extends  Person{
  //var id:Int = 1
  var name:String = "No Name"
}

//另一种做法: 定义一个主构造器，在主构造器中，提供抽象字段
class Employee2(var id:Int) extends  Person{

  //只提供name
  var name:String = "No Name"
}


class Demo3 {

}

九、特质trait：有点像接口、也有点像抽象类
               支持多重继承

package p2

//特质：trait
//定义第一个trait
trait Human{
  //定义抽象字段
  var id:Int
  var name:String

  //方法：可以是抽象的 也可以不是抽象
  def sayHello():String = "Hello " + name
}

//定义第二个trait
trait Action{
  //定义一个抽象方法
  def getActionName():String
}

//定义一个子类：从上面的两个trait继承
//关键字:  extends ... with
class Student6(var id:Int,var name:String) extends Human with Action{

  //实现Action中的getActionName
  def getActionName():String = "Action is Running"
}

object Demo4 {

  def main(args: Array[String]): Unit = {
    //创建一个学生对象
    var s6 = new Student6(1,"Tom")
    println(s6.sayHello())
    println(s6.getActionName())
  }
}

十、包和包对象
      举例：package  ****{
               class ****
               def 函数
               val 常量

               等等
            }