===================== 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 常量
等等
}
包可以被引用在程序的任何地方
可以把工具函数或者常量添加到包对象里，在其他的类里导入这个包对象就可以引用。
包对象：常量，变量，特质，方法，类，对象