[Scala] 面向对象

类定义

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

 1 package day0106
 2
 3 class Student1 {
 4   private var stuID:Int = 0
 5   private var stuName:String="Tom"
 6   private var age:Int = 20
 7
 8   def getStuName():String=stuName
 9   def setStuName(newName:String) = this.stuName = newName
10   def getStuAge():Int = age
11   def setStuAge(newAge:Int) = this.age = newAge
12 }
13 object Student1{
14   def main(args: Array[String]): Unit = {
15     //创建学生对象
16     var s1 = new Student1
17
18     //访问set方法
19     println(s1.getStuName()+"\t"+s1.getStuAge())
20
21     //输出，直接访问私有属性
22     s1.setStuName("Mary")
23     s1.setStuAge(25)
24     println(s1.getStuName()+"\t"+s1.getStuAge())
25
26     //访问私有属性
27     println(s1.stuName+"\t"+s1.age)
28   }
29 }

内部类

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

 1 package day0601
 2
 3 import scala.collection.mutable.ArrayBuffer
 4
 5 class Student1 {
 6     private var stuName:String = "Tom"
 7     private var stuAge:Int = 20
 8
 9     //定义一个可变数组保存学生的课程成绩
10     private var courseList = new ArrayBuffer[Course]()
11
12     //定义一个函数用于添加学生的课程成绩
13     def addNewCourse(cname:String,grade:Int){
14       var c = new Course(cname,grade)
15       courseList += c
16     }
17
18     //定义一个课程类：主构造器写在类的后面
19     class Course(val courseName:String,val grade:Int){
20       //其他函数
21     }
22 }
23
24 object Student1{
25   def main(args: Array[String]):Unit = {
26     var s = new Student1
27
28     s.addNewCourse("Chinese", 80)
29     s.addNewCourse("Math", 80)
30     s.addNewCourse("English", 80)
31
32     println(s.stuName + "\t" + s.stuAge)
33     println("*********成绩信息**********")
34     for(c <- s.courseList)
35       println(c.courseName+'\t'+c.grade)
36   }
37 }

构造器

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

 1 package day0601
 2
 3 class Student2(var stuName:String,var age:Int){
 4   def this(age:Int){
 5     // 在辅助构造器中调用主构造器
 6     this("no name",age)
 7     println("调用辅助构造器")
 8   }
 9   //定义其他的辅助构造器
10 }
11
12 object Student2 {
13   //测试程序
14   def main(args:Array[String]):Unit = {
15
16     //使用主构造器
17     var s1 = new Student2("Tom",20)
18     println(s1.stuName+"\t"+s1.age)
19
20     //使用辅助构造器
21     var s2 = new Student2(25)
22     println(s2.stuName+"\t"+s2.age)
23   }
24 }

Object对象

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

 1 package day0601
 2
 3 object HelloWorld extends App{
 4 //  def main(args:Array[String]): Unit = {
 5 //    println("Hello World")
 6 //  }
 7   //把main函数中的程序直接写在object中
 8   println("Hello World")
 9
10   if(args.length > 0){
11     println("有参数")
12   }else{
13     println("没有参数")
14   }
15 }

Hello World
没有参数

apply方法

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

 1 package day0601
 2
 3 class student3(var stuName:String)
 4
 5 object student3 {
 6   //定义apply方法
 7   def apply(name:String)={
 8     println("*******调用apply方法********")
 9     new student3(name)
10   }
11
12   def main(args:Array[String]): Unit = {
13     //通过主构造器创建对象
14     var s1 = new student3("Tom")
15     println(s1.stuName)
16
17     //通过apply方法创建对象
18     var s2 = student3("Mary")
19     println(s2.stuName)
20   }
21 }

继承

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

 1 package day0601
 2
 3 //定义父类
 4 class Person(val name:String,val age:Int) {
 5   def sayHello():String = "Hello"+name+" and the age is "+age
 6 }
 7
 8 //定义子类
 9 class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age)
10
11 object Demo1{
12   def main(args:Array[String]):Unit = {
13     // 创建Person对象
14     var p1 = new Person("Tom",20)
15     println(p1.name+"\t"+p1.age)
16     println(p1.sayHello())
17
18     // 创建Employee对象
19     var p2:Person = new Employee("Mike",25,1000)
20     println(p2.sayHello())
21   }
22 }

• 重写方法

 1 package day0601
 2
 3 //定义父类
 4 class Person(val name:String,val age:Int) {
 5   def sayHello():String = "Hello"+name+" and the age is "+age
 6 }
 7
 8 //定义子类
 9 class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age){
10   //重写父类函数
11   override def sayHello():String = "子类中sayHello方法"
12 }
13
14 object Demo1{
15   def main(args:Array[String]):Unit = {
16     // 创建Person对象
17     var p1 = new Person("Tom",20)
18     println(p1.name+"\t"+p1.age)
19     println(p1.sayHello())
20
21     // 创建Employee对象
22     var p2:Person = new Employee("Mike",25,1000)
23     println(p2.sayHello())
24   }
25 }

• 匿名子类

 1 package day0601
 2
 3 //定义父类
 4 class Person(val name:String,val age:Int) {
 5   def sayHello():String = "Hello"+name+" and the age is "+age
 6 }
 7
 8 //定义子类
 9 class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age){
10   //重写父类函数
11   override def sayHello():String = "子类中sayHello方法"
12 }
13
14 object Demo1{
15   def main(args:Array[String]):Unit = {
16     // 创建Person对象
17     var p1 = new Person("Tom",20)
18     println(p1.name+"\t"+p1.age)
19     println(p1.sayHello())
20
21     // 创建Employee对象
22     var p2:Person = new Employee("Mike",25,1000)
23     println(p2.sayHello())
24
25     // 通过匿名子类实现继承
26     var p3:Person = new Person("Mary",25){
27       override def sayHello():String = "匿名子类中sayHello方法"
28     }
29     println(p3.sayHello())
30   }
31 }

• 抽象类

 1 package day0601
 2
 3 abstract class Vehicle{
 4   def checkType():String
 5 }
 6
 7 class Car extends Vehicle{
 8    def checkType():String = "I am a Car"
 9 }
10
11 class Bike extends Vehicle{
12    def checkType():String = "I am a Bike"
13 }
14
15
16 object Demo2 {
17   def main(args:Array[String]):Unit={
18     var v1:Vehicle = new Car
19     println(v1.checkType())
20
21     var v2:Vehicle = new Bike
22     println(v2.checkType())
23   }
24 }

• 抽象字段

 1 package day0601
 2
 3 abstract class Person1{
 4   //定义抽象字段，只有get方法
 5   val id:Int
 6   val name:String
 7 }
 8
 9 //若子类中没有提供父类的抽象字段的初始值，子类必须也是抽象的
10 abstract class Employee1 extends Person1{
11
12 }
13
14 //若不提供初始值，可把抽象字段放到构造器中
15 class Employee2(val id:Int,val name:String) extends Person1{
16   //val id:Int = 1
17   //val name:String = ""
18 }
19
20 object Demo3 {
21
22 }

trait（特质）

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

 1 package day0601
 2
 3 //代表人
 4 trait Human{
 5   val id:Int
 6   val name:String
 7 }
 8 //代表动作
 9 trait Actions{
10   def getActionName():String
11 }
12
13 //把抽象字段放入构造器
14 class Student4(val id:Int,val name:String) extends Human with Actions{
15   def getActionName():String = "Action is running"
16 }
17
18 object Demo4 {
19   def main(args: Array[String]):Unit = {
20     var s1 = new Student4(1,"Tom")
21     println(s1.id+"\t"+s1.name)
22     println(s1.getActionName())
23   }
24 }

包和包对象

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