scala008_面向对象编程之继承

最新推荐文章于 2022-07-29 19:58:00 发布

花开cium

最新推荐文章于 2022-07-29 19:58:00 发布

阅读量120

点赞数

分类专栏： Spark

本文链接：https://blog.csdn.net/weixin_44133661/article/details/100143729

版权

Spark 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1 extends

scala中，让子类继承父类，与java一样，也是使用extends关键字
继承就代表，子类可以从父类继承父类的field和method；然后子类可以在自己内部放入父类所没有，子类特有的field和method；使用继承可以有效复用代码
子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，field和method是无法被覆盖的。

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 private var name = "leo"
 def getName = name
}
class Student extends Person{
 private var score = "A"
 def getScore = score
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student
s: Student = Student@73302995

scala> s.getScore
res0: String = A

scala> s.getName
res1: String = leo
#私有的只能再当前类可用，在类的外部，不能访问
scala> s.score
<console>:15: error: variable score in class Student cannot be accessed in Student
       s.score
         ^

scala>

不设置private

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 val name = "leo"
}
class Student extends Person{
 val score = "A"
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student
s: Student = Student@7c3ebc6b

scala> s.name
res3: String = leo

2 override和super

scala中，如果子类需要覆盖一个父类中的非抽象方法，则必须使用override关键字
override关键字可以帮助我们尽早地发现代码里的错误，比如：override修饰的父类方法的方法名我们拼写错了；比如要覆盖的父类方法的参数我们写错了；等等
此外，在子类覆盖父类方法之后，如果我们在子类中就是调用父类的被覆盖的方法呢？那就可以使用super关键字，显式地指定要调用父类的方法

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 private var name = "leo"
 def getName = name
}
class Student extends Person{
 private var score = "A"
 def getScore = score
 override def getName = "Hi,I'm " + super.getName
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student
s: Student = Student@3e7545e8

scala> s.getName
res5: String = Hi,I'm leo

scala>

3 override field

scala中，子类可以覆盖父类的val field，而且子类的val field还可以覆盖父类的val field的getter方法；只要在子类中使用override关键字即可。

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 private var name = "leo"
 def getName = name
}
class Student extends Person{
 private var score = "A"
 def getScore = score
 override def getName = "Hi,I'm " + super.getName
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student
s: Student = Student@3e7545e8

scala> s.getName
res5: String = Hi,I'm leo

scala>

scala>

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 val name :String = "Person"
 def age : Int = 0
}
class Student extends Person{
 override val name :String = "leo"
 override val age : Int = 30
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val p  = new Person
p: Person = Person@7fd69dd

scala> p.name
res6: String = Person

scala> p.age
res7: Int = 0

scala> val s = new Student
s: Student = Student@30e6a763

scala> s.name
res8: String = leo

scala> s.age
res9: Int = 30

scala>

4 isInstanceOf和asInstanceOf

如果我们创建了子类的对象，但是又将其赋予了父类类型的变量。则在后续的程序中，我们又需要将父类类型的变量转换为子类类型的变量，应该如何做呢？
首先，需要使用isInstanceOf判断对象是否是指定类的对象，如果是的话，则可以使用asInstanceOf将对象转换为指定类型
注意：如果对象时null，则isInstanceOf一定返回false，asInstanceOf一定返回null
注意：如果没有用isInstanceOf先判断对象是否为指定类的实例，就直接用你asInstanceOf转换，则可能会抛出异常

scala> class Person
defined class Person

scala> class Student extends Person
defined class Student

scala> val p:Person = new Student
p: Person = Student@262816a8

scala> var s : Student = null
s: Student = null

scala> if(p.isInstanceOf[Student]) s = p.asInstanceOf[Student]

scala> s
res15: Student = Student@262816a8

scala> p
res16: Person = Student@262816a8

scala>

5 getClass和classOf

isInstanceOf只能判断出对象是否是指定类以及其子类的对象，而不能精确判断出，对象就是指定类的对象

scala> p
res16: Person = Student@262816a8

scala> p.isInstanceOf[Student]
res17: Boolean = true

scala> p.isInstanceOf[Person]
res18: Boolean = true

scala>

如果要求精确地判断对象就是指定类的对象，那么就只能使用getClass和classOf了
对象.getClass可以精确获取对象的类，classOf[类] 可以精确获取类，然后使用 == 操作符即可判断

scala> class Person
defined class Person

scala> class Student extends Person
defined class Student

scala> val p : Person = new Student
p: Person = Student@f5b6e78

scala> p.isInstanceOf[Person]
res19: Boolean = true

scala> p.getClass == classOf[Person]
res20: Boolean = false

scala> p.getClass == classOf[Student]
res21: Boolean = true

scala>

6 使用模式匹配进行类型判断

但是在实际开发中，比如spark的源码中，大量的地方都是使用模式匹配的方式来进行类型的判断，这种方式更加地简洁明了，而且代码得可维护性和可扩展性也非常的高
使用模式匹配，功能性上来说，与isInstanceOf一样，也是判断主要是该类以及该类的子类的对象即可，不是精准判断

scala> class Person
defined class Person

scala> class Student extends Person
defined class Student

scala> val p : Person = new Student
p: Person = Student@31e2232f

scala> p match{
     | case person:Person => print("it's Person's object")
     | case _ => println("unknown type")
     | }
it's Person's object
scala>

7 protected

跟java一样，scala中同样可以使用protected关键字来修饰field和method，这样子类中就不需要super关键字了，直接就可以访问父类中field和method
还可以使用protected[this] ，则只能在当前子类对象中访问父类的field和method，无法通过其他子类对象访问父类field和method

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 protected var name :String = "leo"
}
class Student extends Person{
 def makeFridends(s:Student){
  println("Hi,my name id " + name + ",your name is" + s.name)
 }
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s1 = new Student
s1: Student = Student@61149fa5

scala> val s2 = new Student
s2: Student = Student@741741d0

scala> s1.makeFridends(s2)
Hi,my name id leo,your name isleo

scala>

prodected[this]

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person{
 prodected[this] val name:String = "leo"
}
class Student extends Person{
 def makeFridends(s : Student){
  println("my name is " + name + ",your name is " + s.name)
 }
}

// Exiting paste mode, now interpreting.

<console>:2: error: '.' expected but ']' found.
 prodected[this] val name:String = "leo"
               ^
<console>:3: error: identifier expected but '}' found.
}
^

scala>

8 调用父类的constructor

scala中，每个类可以有一个主constructor和任意多个辅助constructor，而每个辅助constructor的第一行都必须调用其他辅助其他辅助constructor或者是主constructor；因此子类的辅助constructor是一定不可能直接调用父类的constructor
只能在子类的主constructor中调用父类的constructor，以下这种语法，就是通过子类的主构造函数来调用父类的构造函数
注意！如果是父类中的接收的参数，比如name和age，子类中接收时，就不要用任何val或var来修饰了，否则会认为是子类覆盖父类的field

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person(val name:String,val age:Int)
class Student(name:String,age:Int,var score:Double) extends Person(name,age){
 def this(name:String){
  this(name,0,0)
 }
 def this(age:Int){
  this("leo",age,0)
 }
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student("leo",30,100)
s: Student = Student@2da59753

scala> s.name
res0: String = leo

scala> s.age
res1: Int = 30

scala> s.score
res2: Double = 100.0

scala> val s2 = new Student("leo")
s2: Student = Student@4566d049

scala> s2.name
res3: String = leo

scala> s2.age
res4: Int = 0

scala> s2.score
res5: Double = 0.0

scala> val s3 = new Student(30)
s3: Student = Student@fb9c7aa

scala> s3.name
res6: String = leo

scala> s3.age
res7: Int = 30

scala> s3.score
res8: Double = 0.0

scala>

9 匿名子类

匿名内部类
在scala中，匿名子类是非常常见，而且非常强大的，Spark的远吗中也大量使用了这种匿名子类。
匿名子类，也就是说，可以定义一个类的没有名称的子类，并直接创建其中对象，然后将对象的引用赋予一个变量。之后甚至可以将匿名子类的对象传递给其他函数。

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Person(protected val name:String){
 def sayHello = "Hello I'm " + name
}

val p = new Person("leo") {
 override def sayHello = "Hi I'm "+name
}
def greeting(p : Person{def sayHello:String}){
 println(p.sayHello)
}

// Exiting paste mode, now interpreting.

defined class Person
p: Person = $anon$1@10fde30a
greeting: (p: Person{def sayHello: String})Unit

scala> greeting(p)
Hi I'm leo

scala>

10 抽象类

如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现自己不同的方法实现，此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这种方法就是抽象方法。
而一个类中如果有一个抽象方法，那么类就必须用abstract来声明为抽象类，此时抽象类是不可以实现实例化的。
在子类中覆盖抽象类的抽象方法时，不需要使用override关键字。

scala> :paste
// Entering paste mode (ctrl-D to finish)

abstract class Person(val name:String){
 def sayHello:Unit
}
class Student(name:String) extends Person(name){
 def sayHello:Unit = println("Hello " + name)
}

// Exiting paste mode, now interpreting.

defined class Person
defined class Student

scala> val s = new Student("leo")
s: Student = Student@182f1e9a

scala> s.sayHello
Hello leo

#抽象类是不能被实例化的
scala> val p = new Person
<console>:12: error: class Person is abstract; cannot be instantiated
       val p = new Person
               ^

scala>

11 抽象field

如果在父类中，定义了field，但是没有给出初始值，则此类field为抽象field
抽象field意味着，scala会根据自己的规则，为var或val类型的field生成对应的getter和setter方法，但是父类汇总是没有该field的
子类必须覆盖field，以定义自己的具体field，并且覆盖抽象field，不需要使用override关键字

scala> abstract class Person{
     |  val name : String
     | }
defined class Person

scala> class Student extends Person{
     |  val name : String = "leo"
     | }
defined class Student

scala> val s =  new Student
s: Student = Student@7772054c

scala> s.name
res13: String = leo

scala>

花开cium

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
scala008_面向对象编程之继承

1 extendsscala中，让子类继承父类，与java一样，也是使用extends关键字继承就代表，子类可以从父类继承父类的field和method；然后子类可以在自己内部放入父类所没有，子类特有的field和method；使用继承可以有效复用代码子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，fi...
复制链接

扫一扫