Scala面向对象的学习

最新推荐文章于 2020-07-25 20:41:06 发布

暴风雨来临的前夕

最新推荐文章于 2020-07-25 20:41:06 发布

阅读量278

点赞数

CC 4.0 BY-SA版权

分类专栏： spark 文章标签： scala学习 spark初识

本文链接：https://blog.youkuaiyun.com/qq_40695037/article/details/81368938

spark 专栏收录该内容

1 篇文章

订阅专栏

曾经找工作的时候整理总结，现在稳定下来啦，有点时间，就重新整理拉下，和大家分享。

定义一个简单的类

class HelloWorld{
    private var name = "leo"
    def sayHello(){print("Hello,"+name)}#定义在类里面的叫方法，否则叫函数
    def getName = name
}

创建类的对象，并调用其方法

val helloWorld = new HelloWorld
helloWorld.sayHello()
print(helloWorld.getName)

getter与setter

定义不带private的var field，此时scala生成的面向JVM的类时，会定义为private的name字段，并提供public的getter和setter方法
而如果使用private修饰field,则生成的getter和setter也是private的。
如果定义val field，则只会生成getter方法
如果不希望生成setter和getter方法，则将field声明为private[this]

class Student{
    var name = "leo"
}

调用gettter和setter方法，分别叫做name和name_=

val leo = new Student
print(leo.name)
leo.name = "leo1"

自定义getter与setter

如果只是希望拥有简单的getter和setter方法，那么就按照scala提供的语法规则，根据需求为field选择合适的修饰符即可:var,val,private,private[this]
但是如果希望能够自己对getter与setter进行控制，则可以自定义getter与setter方法
自定义setter方法的时候一定要注意scala的语法限制，签名，=,参数间不能有空格

class Student{
    private var myName = "leo"
    def name = "your name is "+myName
    def name_=(newValue:String){
        print("you cannot edit your name")
    }
}

val leo = new Student
print(leo.name)
leo.name = "leo1"

private[this]的使用

如果将field使用private来修饰，那么代表这个field是类私有的，在类的方法中，可以直接访问类的其他对象的private field
这种情况下，如果不希望field被其他对象访问到，那么可以使用private[this]，意味着对象的私有的field，只有在本对象内可以访问到

class Student{
    private var myAge = 0
    def age_=(newValue:Int){
        if(newValue>0) myAge = newValue
        else print("illegal age!")
    }
    def age = myAge
    def older(s:Student)={
        myAge>s.myAge
    }
}

辅助constructor

Scala中，可以给类定义多个辅助constructor,类似于java中的构造函数重载
辅助constructor之间可以互相调用，而且必须第一行调用主constructor

class Student{
    private var name = ""
    private var age = 0
    def this(name:String){
        this()
        this.name = name
    }
    def this(name:String,age:Int){
        this(name)
        this.age = age
    }#个人感觉是从上往下编译的。所以之间的调用有约束
}

主constructor

Scala中，主constructor是与类名放在一起的，与java不同。
而且类中，没有定义在任何方法或者是代码块之中的代码，就是主constructor的代码，这点和java是不一样的。

class Student(val name:String,val age:Int){
    println("your name is"+name+,"your age is"+age)
}

主constructor还可以通过使用默认参数，来给参数默认的值

class Student(val name:String = "leo",val age:Int = 30){
      println("your name is"+name+,"your age is"+age)
}

如果主constructor传入的参数什么修饰都没有，比如name:String,那么如果方法用到啦，则会声明为private[this] name;否则没有该field，就只能被constructor代码使用而已。

内部类

Scala中，同样可以在类中定义内部类：但是与java不同的是，每个外部类的对象的内部类，都是不同的类。

import scala.collection.mutable.ArrayBuffer
class Class{
    class Student(val name:String){}
    val students = new ArrayBuffer[Student]
    def getStudent(name:String)={
        new Student(name)
    }
}
val c1 = new Class
val s1 = c1.getStudent("leo")
c1.students += s1

val c2 = new Class
val s2 = c2.getStudent("leo")
c1.students += s2 #这个是不行的，c1.getStudent与c2.getStudent是不同的。

object

object,相当于class的单个实例，通常在里面放一些静态的field或者method
第一次调用object的方法时，就会执行object的constructor，也就是object内部不在method中的代码；但是object不能定义接收参数的constructor
注意，object的constructor只会在其第一次被调用时执行一次，以后再次调用就不会再次执行constructor啦
object通常用于作为单例模式的实现，或者放class的静态成员，比如工具方法

object Person{
    private var eyeNum = 2
    println("this Person object")
    def getEyeNum = eyeNum
}

Person.getEyeNum

伴生对象

如果有一个class，还有一个与class同名的object，那么就称这个object是class的伴生对象，class是object的伴生类。
伴生类和伴生对象必须存放在一个.scala文件之中
伴生类与伴生对象，最大的特点就在于，互相可以访问private field

class Person(val name:String,val age:Int){
    def sayHello = println("Hi,"+name+",I guess you are"+age +"years old")
}

object Person{
    private val eyeNum = 2
    def getEyeNum = eyeNum
}

让object继承抽象类

object的功能其实和class类似，除啦不能定义接受参数的constructor之外
object也可以继承抽象类，并覆盖抽象类中的方法

abstract class Hello(var message:String){
    def sayHello(name:String):Unit
}

object HelloImpl extends Hello("hello"){
    override def sayHello(name:String)={
        println(message + ","+name)
    }
}

apply方法

object中非常重要的一个特殊方法，就是apply方法
通常在伴生对象中实现apply方法，并在其中实现构造伴生类的对象的功能。
而创建伴生类的对象时，通常不会使用new Class的方式，而是使用Class()的方式，隐式的调用伴生对象的apply方法，这样让对象创建更加简介。
比如，定义自己的伴生类和伴生对象

class Person(val name:String)
object Person{
    def apply(name:String) = new Person(name)
}

main方法

就如同java中，如果要运行一个程序，必须编写一个包含main方法类一样；在scala中，如果要运行一个应用程序，那么必须有一个main方法，作为入口
scala中的main方法定义为def main(args:Array[String]),而且必须定义在object中

object HelloWorld{
    def main(args:Array[String]){
        println("Hello World !")
    }
}

除啦自己实现main方法之外，还可以继承App Trait，然后将需要在main方法中运行的代码，直接作为object的的constructor代码；而且可以接受传入的参数。

object HelloWorld extends App{
    if(args.length>0)
    println("hello," + args(0))
    else println("Hello World !")
}

extends

scala中，让子类继承父类，与java一样，也是使用extends关键字
子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，field和method是无法覆盖的。

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

override和super

scala中，如果子类要覆盖一个父类中的非抽象方法，则必须使用override关键字
override关键字可以帮助我们尽早的发现代码里的错误
此外，在子类覆盖父类方法之后，如果我们在子类中就是要调用父类的被覆盖的方法呢？：那就可以使用super关键字，显示的指示要调用父类的方法。

isInstanceOf和asInstanceOf

如果我们创建啦子类的对象，但是又将其赋予啦父类类型的变量转换给子类类型的变量，要如何做？
首先，需要使用isInstanceOf判断对象是否是指定类的对象，如果是的话，则可以使用asInstance将对象转换为指定类型。
注意，如果对象是null,则isInstanceOf一定返回false,asInstanceOf一定返回Null
注意，如果没有用isInstanceOf先判断对象是否为指定类的实例，就直接用asInstanceOf转换，则可能会抛出异常。

class Person
class Student extends Person
val p:Person = new Person
val s:Student = null
if(p.isInstanceOf[Student])
s=p.asInstanceOf[Student]

getClass和classOf

isInstanceOf只能判断出对象是否是指定类以及其子类的对象，而不能精确判断出，对象就是指定类的对象
如果要求精确地判断对象就是指定类的对象，那么就只能使用getClass和classOf啦
对象.getClass可以精确获取对象的类，classOf[类]可以精确获取类，然后使用==操作符即可判断。

class Person
class Student extends Person
p.isInstanceOf[Person]
p.getClass == classOf[Person]
p.getClass == classOf[Student]

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

在实际开发中，比如spark的源码中，大量的地方都是使用到啦模式匹配的方式来进行类型的判断，这种方式更加简介明了。
使用模式匹配，功能性上来说，与isInstanceOf一样，也是判断主要是该类以及该类的子类的对象即可，不用精确判断

class Person
class Student extends Person
val p:Person = new Student

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

调用父类的constructor

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

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)
    }
}

匿名内部类

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

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)
}

抽象类

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

abstract class Person(val name:String){
    def sayHello:Unit
}
class Student(name:String) extends Person(name){
    def sayHello:Unit = print
}

抽象field

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

abstract class Person{
    val name:String
}
class Student extends Person{
    val name:String = "leo"
}

将trait作为接口使用

我们可以将Trait作为接口来使用，此时的Trait就与Java中的接口非常类似。
在trait中可以定义抽象方法，就与抽象类中的抽象方法一样，只是不给出方法的具体实现即可。
类可以使用extends关键字继承trait,注意，这里不是implement,而是extends，在scala中没有implements的概念，无论继承类还是trait，统一都是extends.
类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字
scala不支持对类进行多继承，但是支持多重继承trait,使用with关键字即可。

trait HelloTrait{
    def sayHello(name:String)
}
trait MakeFriendsTrait{
    def makeFriends(p:Person)
}
class Person(val name:String) extends HelloTrait with MakeFriends with Cloneable with Serializable{
    def sayHello(name:String)=println("Hello,"+name)
    def makeFriends(p:Person)=println("hello" + name)
}

在trait中定义具体方法

scala中的trait可以不是只定义抽象方法，还可以定义具体方法，此时trait更像是包含啦通用工具方法的东西。
trait中可以包含一些很多类都通用的功能方法，比如打印日志等等，spark中就使用啦trait来定义啦通用的日志打印方法

trait Logger{
    def log(message:String)=println(messsage)
}

class Person(val name:String) extends Logger{
    def makeFriends(p:Person){
        println("Hi,"+p.name)
        log("makeFriends method")
    }
}