导入: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(样例类)
- 和普通类相比,样例类会自动生成伴生对象,并提供了一些常用的方法:
apply
、unapply
、toString
、equals
、hashCode
、copy
… - 样例类可以直接使用模式匹配,因为其默认提供了
unapply
方法 - 构造器中的每一个参数都成为
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|
+----+-----+
*/