大数据笔记（二十四）——Scala面向对象编程实例

===================== 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）辅助构造器

package main.scala

/**
  * Created by YOGA on 2018/2/3.
  * （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]) {
    //使用主构造器创建学生对象
    val 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、单例模式：一个类只有一个对象

举例：生成信用卡的卡号

package main.scala

/**
  * Created by YOGA on 2018/2/3.
  */
object CreditCard {
  //变量：保存信用卡的卡号
  //该属性只属于该对象
  private[this] var creditCardNumber:Long = 0

  //产生卡号
  def generateNewCCNumber() = {
    creditCardNumber += 1
    creditCardNumber
  }

  //测试
  def main(args: Array[String]) {
    //得到新的卡号：通过类名.方法
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
    println(CreditCard.generateNewCCNumber())
  }
}

运行：

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

package main.scala

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方法

package main.scala

/**
  * 主构造器
  */
class Student5(val stuName:String){

}
object Student5 {
  //定义类的Apply方法 位置：定义在类的伴生对象中
  def apply(stuName:String) ={
    println("调用到了apply方法")
    //调用主构造器
    new Student5(stuName)
  }
  def main(args: Array[String]) {
    //创建学生对象
    var s1 = new Student5("Tom")
    println(s1.stuName)

    //省略new 关键字
    var s2 = Student5("Mary")
    println(s2.stuName)
  }
}

运行：

八、继承 extends

子类与父类同名时，需要加override

package main.scala
//继承
/*
* 1、基本的继承
* 2.复写父类方法
* 2.使用匿名子类
* */
//定义父类
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())

  }
}

运行：

九、抽象类：方法只声明，不实现

package main.scala
//抽象类
//父类： 抽象 交通工具
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 main.scala.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：就是抽象类

与抽象类的最大区别：支持多重继承 ：extends... with

package main.scala.p2
//特质：trait
//有点像接口、也有点像抽象类 支持多重继承
trait Human{
  //抽象字段
  var id:Int
  var name:String

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

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

//定义一个子类，从上面两个继承
//关键字： 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]) {
    var s1 = new Student6(1,"Tom")
    println(s1.sayHello())
    println(s1.getActionName())
  }
}

运行：

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

包可以被引用在程序的任何地方

可以把工具函数或者常量添加到包对象里，在其他的类里导入这个包对象就可以引用。

包对象：常量，变量，特质，方法，类，对象