大数据（7f）比较Python和Scala面向对象

导入：import

from sklearn.svm import *
from sklearn.svm import SVC
from sklearn.svm import SVC as S, SVR

import java.util._
import java.util.ArrayList
import java.util.{ArrayList=>AL,HashSet}

类：class

Scala的this类似Python的self和__init__

class Batman:
    def __init__(self, name, mp=10):
        self.__name = name  # 私有属性
        self.mp = mp
    def info(self):
        print(self.__name, self.mp)

dogface = Batman('dogface')
dogface.info()
print(dogface._Batman__name)  # 私有属性（IDE报错）

class Batman {
  // 主构造器
  private var name: String = _  // 私有属性
  var mp: Int = 10

  def this(name:String) {
    // 辅助构造器1
    this()
    this.name = name
  }
  def this(name:String, mp:Int) {
    // 辅助构造器2
    this(name)
    this.mp = mp
  }

  def info(): Unit = {
    print(name, mp)
  }
}

object Hello {
  def main(args: Array[String]): Unit = {
    val dogface = new Batman("dogface", 3)
    dogface.info()
    // println(dogface.name) 私有属性不能访问
  }
}

继承

class Batman:
    def __init__(self, name, mp=10):
        self.name = name
        self.mp = mp

class Hero(Batman):
    def __init__(self, name, mp=20, ad=5):
        super().__init__(name, mp)
        self.ad = ad
    # 多态：Batman和Hero都可传入
    def attack(self, enemy: Batman):
        print(enemy.mp - self.ad)

bm = Hero('Blade Master')
mk = Hero('Mountain King')
bm.attack(mk)

class Batman(var name:String, var hp:Int=10) {}

class Hero(name:String, hp:Int=20, var ad:Int=5) extends Batman(name, hp) {
  // 多态：Batman和Hero都可传入
  def attack(enemy: Batman): Unit = {
    println(enemy.hp - ad)
  }
}

object Hello {
  def main(args: Array[String]): Unit = {
    val bm = new Hero("Blade Master")
    val dh = new Hero("Demon Hunter")
    bm.attack(dh)
  }
}

抽象类：abstract

父类先定义好一些方法，要求子类必须重写这些方法

from abc import ABCMeta, abstractmethod


class Animal(metaclass=ABCMeta):
    @abstractmethod
    def eat(self):
        raise NotImplementedError

    @classmethod
    @abstractmethod
    def drink(cls):
        pass

    @staticmethod
    @abstractmethod
    def run():
        pass


class Dog(Animal):
    def eat(self):
        print('重写方法才不报错')

    @classmethod
    def drink(cls):
        print('重新类方法')

    @staticmethod
    def run():
        print('重新静态方法')


dog = Dog()

关键字abstract和override

// 抽象类：abstract关键字标记的类
abstract class Animal {
  // 抽象属性：属性没有赋值
  val name: String
  // 抽象方法：只声明而没有实现的方法
  def eat(): Unit
  // 非抽象方法
  def run(): Unit = {
    println("run1")
  }
}

class Dog extends Animal {
  val name: String = "dog"
  def eat(): Unit = {
    println("实现抽象方法可省略`override` " + name)
  }
  // 重写非抽象方法要写`override`
  override def run(): Unit = {
    super.run()
    println("run2")
  }
}

object Hello {
  def main(args: Array[String]): Unit = {
    val d: Dog = new Dog()
    d.eat()
    d.run()
  }
}

单例对象

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, '_instance'):
            Singleton._instance = object.__new__(cls)
        return Singleton._instance

for i in range(9):
    print(Singleton())

// 1、主构造方法私有化
class Singleton private() {}

object Singleton{
  // 2、提供 私有静态属性，接收单例对象
  private val s: Singleton = new Singleton()
  // 3、公共的、静态的【获取单例对象】方法
  def getInstance(): Singleton = s
}

object Hello {
  def main(args: Array[String]): Unit = {
    for (i <- 0 to 9) {
      println(Singleton.getInstance())
    }
  }
}

特质（多继承）：trait

class Man:
    name = '男人'
    def run(self):
        print('奔跑吧，' + self.name)

class Bird:
    name = '鸟'
    def fly(self):
        print('起飞吧，' + self.name)

class BirdMan(Man, Bird):
    pass

bm = BirdMan()
bm.run()
bm.fly()

如上Python多继承，若存在同名，前者会遮蔽后者
打印结果：

奔跑吧，男人
起飞吧，男人

class Man {
  val name : String = "男人"
  def run(): Unit = {
    println("奔跑吧，" + name)
  }
}

trait Bird {
  val name : String = "鸟"
  def fly(): Unit = {
    println("起飞吧，" + name)
  }
}

class BirdMan extends Man with Bird {
  // 不重写 name 会报错：特质冲突
  override val name : String = "鸟 人"
}

object Hello {
  def main(args: Array[String]): Unit = {
    val bm : BirdMan = new BirdMan()
    bm.run()
    bm.fly()
  }
}

如上Scala特质打印结果

奔跑吧，鸟 人
起飞吧，鸟 人

封装属性（property）

class Round:
    __radius = 0

    @property
    def radius(self):
        return self.__radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError('要求半径大于零')
        self.__radius = value

    @property
    def perimeter(self):
        return '{}pi'.format(self.radius * 2)


r = Round()
r.radius = 2.5
print(r.radius, r.perimeter)
# 以下操作报错
# r.perimeter = 9  # AttributeError: can't set attribute
# r.radius = -1  # ValueError: 要求半径大于零

class Round {
  var radius: Float = _
  def perimeter: String = s"${radius * 2}pi"
}

object Hello {
  def main(args: Array[String]): Unit = {
    val r : Round = new Round()
    r.radius = 2.5f
    println(r.radius, r.perimeter)
    // r.perimeter = 5  报错
  }
}

apply

Scala创建对象要默认有new，使用apply可以不用new

class Hero private(n: String) {
  private val name: String = n

  def info(): Unit = {
    printf(s"姓名：${name}\n")
  }
}

object Hero {
  def apply(): Hero = {
    new Hero("小兵")
  }

  def apply(name: String): Hero = {
    new Hero(name)
  }
}

val b1 = Hero()
val b2 = Hero("剑圣")
b1.info()  // 打印结果：小兵
b2.info()  // 打印结果：剑圣

case class（样例类）

1. 和普通类相比，样例类会自动生成伴生对象，并提供了一些常用的方法：apply、unapply、toString、equals、hashCode、copy…
2. 样例类可以直接使用模式匹配，因为其默认提供了unapply方法
3. 构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议）

case class Hero(name: String, lv: Int)

val h1: Hero = Hero("剑圣", 10)

val result = h1 match {
  case Hero("剑圣", 9) => "未满级"
  case Hero("剑圣", 10) => "满级"
  case _ => "不知道"
}

println(result) //满级

用样例类来定义DataSet中数据的结构信息，样例类中每个属性的名称直接映射到字段名称

import org.apache.spark.sql.{SparkSession, Dataset}

object Hello {
  def main(args: Array[String]): Unit = {
    // 创建SparkSession对象 并 设置隐式转换
    val spark: SparkSession = SparkSession.builder()
      .master("local[*]").appName("a").getOrCreate()
    import spark.implicits._
    // 创建DataSet
    val ds: Dataset[Hero] = Seq(Hero("剑圣", 9), Hero("先知", 7)).toDS
    ds.show()
  }
}

case class Hero(name: String, level: Int)

/*
+----+-----+
|name|level|
+----+-----+
|剑圣|    9|
|先知|    7|
+----+-----+
*/