Scala编程（二）面向对象编程
Scala编程（二）面向对象编程
类
1.类的定义
//scala类
class Person {
//用val定义的成员变量，只提供了getter方法
val id = "1234"
//用var定义的成员变量，提供了setter和getter方法
var name = "jack"
var age = 20
//方法
def sleep()={
println("正在休息。。。。。")
}
}
object Person extends App {
val p = new Person()
//获取和修改成员变量
//p.id = "23432" 报错val修饰的成员变量不能修改
println("id：" + p.id)
p.age = 22
println("age：" + p.age)
println(p.name)
p.sleep()
}
2.构造器
Scala中的每个类都有一个主构造器，主构造器的参数直接放在类后面，并且主构造器会执行类中定义所有语句
//主构造器放在类名后面
class Student (val n :String,var a :Int){
val name :String = n
//var修饰可修改
a = a + 1
var age = a
//使用占位符时需要指定参数的类型
//scala类中所使用的占位符”_”，只有在声明var变量时才可以使用
var sex : String= _
println("主构造器执行了类中定义的所有语句")
//构造器（构造方法） 辅构造器
def this(n :String,a :Int,sex :String){
//调用主构造器，不可省略
this(n,a)
println("调用了辅构造器")
this.sex = sex
}
//方法
def study(s :String): Unit ={
println(name + "在学习" + s)
}
}
object Student extends App{
//主构造器
val stu1 = new Student("jack",20)
println(stu1.age) //21
//赋值操作会在其他语句之后执行
stu1.age = 30
stu1.study("scala")
println(stu1.age) //30
//辅构造器
val stu2 = new Student("lisi",20,"男")
stu2.study("hadoop")
}
执行结果：
主构造器执行了类中定义的所有语句
21
jack在学习scala
30
主构造器执行了类中定义的所有语句
调用了辅构造器
lisi在学习hadoop
3.访问权限
3.1构造器的访问权限
//主构造器放在类名后面
class Student private(val n :String,var a :Int){
val name :String = n
//var修饰可修改
a = a + 1
var age = a
//使用占位符时需要指定参数的类型
//scala类中所使用的占位符”_”，只有在声明var变量时才可以使用
var sex : String= _
println("主构造器执行了类中定义的所有语句")
//构造器（构造方法） 辅构造器
private def this(n :String,a :Int,sex :String){
//调用主构造器，不可省略
this(n,a)
println("调用了辅构造器")
this.sex = sex
}
//方法
def study(s :String): Unit ={
println(name + "在学习" + s)
}
}
object Test extends App{
val stu1 = new Student("张三",20)
val stu2 = new Student("李四",30,"女")
}
运行结果会出错：在主构造器或辅构造器修饰为private后，访问权限仅限：本类和伴生对象中使用
伴生对象：指的是对象名与类名相同的对象
3.2类中变量的访问权限
当类中的成员变量为私有时，有如下两种解决方法
1、在Student类中添加：getter、setter方法
2、使用伴生对象
//scala类
class Person {
private var name :String = _
private var age :Int = _
//方法
def sleep()={
println(s"年龄为:$age 的 $name 正在休息。。。。。")
}
}
object Test extends App{
//创建对象
var p = new Person()
//p.id 报错并不能访问私有的成员
p.sleep()
}
解决方法：
//scala类
class Person { //默认的无参主构造器
private var name :String = _
private var age :Int = _
//get和set方法
def setName(name: String) ={
this.name = name
}
def getName: String ={
this.name
}
def setAge(age :Int)={
this.age = age
}
def getAge : Int = {
this.age
}
//全参构造器(辅构造器)
def this(name :String,age : Int){
this()
this.name = name
this.age = age
}
//方法
def sleep()={
println(s"年龄为:$age 的 $name 正在休息。。。。。")
}
}
object Test extends App{
//创建对象 主构造器
var p = new Person()
//p.id 报错并不能访问私有的成员
p.setAge(20)
p.setName("jack")
p.sleep()
//辅构造器
var p1 = new Person("lisi",30)
p1.sleep()
}
对象
1.Scala中的object
object相当于class的单个实例（单例模式），通常在里面放一些静态的field或者method
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的
object的单例模式
class Session {}
object Session extends App {
//相当于静态块
val session = new Session
//相当于静态方法
def getSession() : Session={
session
}
}
object Test1 extends App {
//单例对象
val session1 = Session.session
val session2 = Session.getSession()
}
2.scala中的伴生对象
伴生对象的解释：
如果有一个class，还有一个与class同名的object，那么就称这个object是class的伴生对象，class是object的伴生类
要求： 伴生类和伴生对象必须存放在一个.scala文件中
特点： 伴生类和伴生对象的最大特点是，可以相互访问（可以访问私有成员）
//伴生类
class Student private{
//私有成员
private var name :String = _
private var age :Int = _
//get和set方法
def setName(name: String) ={
this.name = name
}
def getName: String ={
this.name
}
def setAge(age :Int)={
this.age = age
}
def getAge : Int = {
this.age
}
//私有全参构造器(辅构造器)
private def this(name :String,age : Int){
this()
this.name = name
this.age = age
}
//方法
def study(s :String): Unit ={
println(name + "在学习" + s)
}
}
//伴生对象
object Student{
val stu1 = new Student()
stu1.name = "zhangsan"
stu1.age = 20
stu1.study("java")
val stu2 = new Student("lisi",30)
}
3.Scala中的apply方法
//伴生类
class Student private{
//私有成员
private var name :String = _
private var age :Int = _
//get和set方法
def setName(name: String) ={
this.name = name
}
def getName: String ={
this.name
}
def setAge(age :Int)={
this.age = age
}
def getAge : Int = {
this.age
}
//私有全参构造器(辅构造器)
private def this(name :String,age : Int){
this()
this.name = name
this.age = age
}
//方法
def study(s :String): Unit ={
println(name + "在学习" + s)
}
}
//伴生对象
object Student{
//无参
def apply(): Student = new Student()
//有参
def apply(name : String,age : Int): Student = new Student(name,age)
}
//测试类
object Test1 extends App {
//利用伴生对象创建对象
var stu = Student()
//相当于 var stu = Student.apply()
stu.setName("张三")
stu.setAge(20)
stu.study("java")
//var stu = Student.apply(name,age)
var stu2 = Student("李四",30)
stu2.study("scala")
}
继承
1.继承的概念
继承是面向对象的概念，用于代码的可重用性。被扩展的类称为超类或父类, 扩展的类称为派生类或子类。
Scala 中，让子类继承父类，与 Java 一样，也是使用 extends 关键字；
//父类
class Person{
var name :String = _
var age :Int = _
}
//子类
class Student extends Person{
//子类特有的方法
def study(s : String): Unit ={
//name是继承的person中的变量
println(name + "在学习" + s)
}
}
object Test1 extends App {
var stu = new Student()
stu.name = "jack"
stu.age = 30
stu.study("scala")
}
继承就代表，子类可继承父类的field和method，然后子类还可以在自己的内部实现父类没有的，子类特有的 field 和method，使用继承可以有效复用代码
在Scala中的继承：
1、private修饰的field和method不可以被子类继承，只能在类的内部使用
2、使用final修饰符时，修饰类：类不能被继承、修饰field和method：不能被覆写
2.Scala中的override和super关键字
override
override的使用场景：
1、Scala中，如果子类要覆盖父类中的一个非抽象方法，必须要使用 override 关键字
2、子类可以覆盖父类的val修饰的field，只要在子类中使用 override 关键字即可
（注意：针对父类中的var修饰的field，子类不能覆写）
super
super的应用场景： super.父类中的方法
在子类覆盖父类方法后，如果在子类中要调用父类中被覆盖的方法，则必须要使用super关键字（显示的指出要调用的父类方法）
override和super的应用案例：
//父类
class Phone {
//val不可修改的变量
val id = "12345"
def call = println("打电话")
}
//子类
class NewPhone extends Phone {
//覆写父类中的val变量和非抽象方法必须使用override关键字
override val id: String = "6789"
override def call: Unit = {
//调用父类的方法使用super关键字
super.call
println("开启视频")
}
}
object Test1 extends App {
var p = new NewPhone()
//调用子类覆写的方法
p.call
}
3.scala中的protected
在Scala中同样提供了protected关键字来修饰field和method，方便子类去继承父类中的field和method
//父类
class Person{
//protected 是为继承提供的
//protected [this] 只允许在本类和子类中使用（子类的伴生对象不能访问）
protected [this] var name :String = _
protected var age :Int = _
protected def say(s :String)= println(s)
}
//子类
class Student extends Person{
//子类特有的方法
def study(s : String): Unit ={
//name是继承的person中的变量
println(name + "在学习" + s)
}
def setName(n :String)={
this.name = n
}
}
object Student extends App {
var stu = new Student()
//这里不能直接访问父类的name成员
stu.setName("张三")
stu.age = 20
stu.study("scala")
}
4.调用父类的constructor
创建子类对象时，会自动调用子类相应的构造器：
1、调用子类主构造器
2、调用子类辅助构造器，辅构造器会再去调用主构造器
和java一样，创建子类对象时，也会先去调用父类的构造器：子类主构造器去调用父类中的构造器
5.scala中的抽象类
一个类中，如果含有一个抽象方法或抽象field，就必须使用abstract将类声明为抽象类，该类是不可以被实例化的
在子类中覆盖抽象类的抽象方法时，可以不加override关键字
//抽象类 抽象field和方法都需要放在方法抽象类中
abstract class Person{
//抽象的field没有初始值
var name :String
var age :Int = _
//抽象方法没有方法体实现
def study(s: String)
def say:String
}
//子类继承抽象类
class Student extends Person{
//覆写所有的抽象内容 同时可以省略override
def study(s : String): Unit ={
//name是继承的person中的变量
println(name + "在学习" + s)
}
override var name: String = _
override def say: String = "hello"
}
object Student extends App {
var stu = new Student()
stu.name = "jack"
stu.age = 20
var hello = stu.say
stu.study("scala")
}
6.scala中的isInstanceOf和asInstanceOf 多态
在实例化了子类的对象，并将其赋予了父类类型的变量后，父引用无法去调用子类中特有的方法，如果想要调用子类中特有的方法，应该类型转换
在java中，进行类型转换时，为了避免类型转换异常，会使用instanceof先判断类型，再进行类型转换
//父类
class Person{
var name :String = _
var age :Int = _
def eat(s :String)={
println("吃" + s)
}
}
//子类
class Student extends Person{
//子类特有的方法
def study(s : String): Unit ={
//name是继承的person中的变量
println(name + "在学习" + s)
}
//子类覆写父类的方法
override def eat(s: String): Unit = {
println(this.name + "吃" + s)
}
}
object Test extends App {
//声明一个父类型变量指向子类型
var person : Person = new Student()
person.name = "jack"
person.age = 20
person.eat("米饭")
//判断person对象是否为student的实例
if (person.isInstanceOf[Student]){
//将person对象转成student实例
var stu : Student = person.asInstanceOf[Student]
//调用子类对象特有的方法
stu.study("java")
}
}
Trait
1.将trait作为接口使用
Scala中的Trait(特质)相当于Java的接口，但实际上它比接口要功能强大，与传统的接口不同之处是：它除了可以定义抽象方法外还可以定义属性和方法的实现
在Scala中没有 implement 的概念，无论继承类还是trait，统一都是 extends
类继承后，必须实现所有的抽象方法，实现时不需要使用 override 关键字
trait Demo1{
def sayHello(s :String)
}
//子类继承需要重写抽象方法
class Person extends Demo1 {
override def sayHello(s: String): Unit = {
println("打招呼," + s)
}
}
object TraitDemo1 extends App {
val p = new Person()
p.sayHello("jack")
}
Scala不支持对类进行多继承，但是支持多重继承 trait，使用 with 关键字即可
trait Demo1{
def sayHello(s :String)
}
trait Demo2{
def say():String
}
class Person extends Demo1 with Demo2 {
override def sayHello(s: String): Unit = {
println( say() + s)
}
override def say(): String = "你好"
}
object TraitDemo1 extends App {
val p = new Person()
p.sayHello("scala")
}
在Traint中除了可以书写抽象方法外，还可以书写：抽象字段、具体方法、具体字段
2.Trait高级应用
2.1在实例对象指定混入某个trait
Trait高级知识： 创建对象实例时，trait加入到对象实例中
可在创建类的对象时，为该对象指定混入某个trait，且只有混入了trait的对象才具有trait中的方法，而其他该类的对象则没有
格式： val 引用变量 = new 类名() with Trait
在创建对象时，使用with关键字指定混入某个trait
trait TraitLogger{
def log(msg : String)={
println("日志内容：------" + msg)
}
}
trait MyLogger extends TraitLogger{
override def log(msg: String): Unit = {
println(System.currentTimeMillis() + msg)
}
}
class Person extends TraitLogger{
log("打印日志。。。")
}
object TraitDemo2 extends App {
val p = new Person() with MyLogger
}
2.2Trait调用链
当去调用多个trait中的方法时，首先会从最右边的trait中的方法开始执行，然后依次往左边的trait执行，形成一个调用链条（这个特性非常强大：是设计模式中责任链模式的一种具体实现）
trait TraitOne{
def handle(data : String)={
println("获取数据--" + data)
}
}
trait TraitTwo extends TraitOne{
override def handle(data : String)={
println("处理数据--"+ data)
super.handle(data)
}
}
trait TraitThree extends TraitOne{
override def handle(data : String)={
println("分析数据--"+ data)
super.handle(data)
}
}
class RequestResult(val data : String) extends TraitThree with TraitTwo {
def getParam={
println("参数：" + data)
//调用多个trait中方法名相同的方法
handle(this.data)
}
}
object traitdemo3 extends App {
val p = new RequestResult("大数据")
p.getParam
}
2.3混合使用trait的具体方法和抽象方法
trait traitOne{
def getName : String
def valid(data : String):Boolean={
data.equals(this.getName)
}
}
class Person(data :String) extends traitOne{
override def getName: String = this.data
}
object traitdemo4 extends App {
val p = new Person("数据")
if (p.valid("测试")){
println("数据合法")
}else{
println("数据不合法")
}
}
2.4Trait的构造机制
2.4.1构造机制
在Trait中只有无参构造（主构造器）
trait TraitOne{
println("TraitOne的构造器。。。。")
}
trait TraitTwo{
println("TraitTwo的构造器。。。。")
}
class TraitChlid extends TraitOne with TraitTwo {
println("TraitChlid的构造器。。。。")
}
object traitdemo5 extends App {
val t = new TraitChlid()
}
子类没有继承父类，只继承多个独立的Trait(Trait没有继承)时，构造机制：
从extends后面第一个Trait构造器开始执行，依次向后面的Trait构造器执行
class Parent{
println("Parent的构造器。。。。")
}
trait MyTrait{
println("MyTrait的构造器。。。。")
}
trait TraitOne extends MyTrait{
println("TraitOne的构造器。。。。")
}
trait TraitTwo extends MyTrait{
println("TraitTwo的构造器。。。。")
}
class TraitChlid extends Parent with TraitOne with TraitTwo {
println("TraitChlid的构造器。。。。")
}
object traitdemo5 extends App {
val t = new TraitChlid()
}
子类继承了父类的同时，也继承了多个Trait(Trait也有继承)时，构造机制：
1、父类的构造器
2、多个Trait从左向右依次执行（构造Trait时，先构造父Trait）
注意：如果多个Trait继承同一个父Trait，则父Trait只会构造一次
3、子类的构造器
2.4.2Trait中的field初始化
提前定义Trait中的field
trait traitHello{
//抽象field
val msg : String
println("信息的长度："+ msg.length)
}
class TraitClass extends {override val msg :String = "初始化值"} with traitHello{
//方法一在类上覆写抽象field
}
object traitdemo6 extends App {
val t = new TraitClass()
//方法二在实例化时覆写抽象field
/**
* val t = new {
* override val msg :String = "初始化值"
* } with TraitClass with traitHello
*/
}