Scala OOP
类(class)
抽象类(abstract class)
单例对象(object)
特质(trait)
样例类(case class)
1.类(class)
(1)类的基本概述
- 类通过class关键字定义
- 类通过new关键字创建实例
- 类拥有成员变量和方法
- 类的成员默认为public,也支持private、protected
- 类中无法定义静态成员变量和方法
- 类无需明确定义构造方法,通过构造参数列表声明为类的一部分
(2)类成员访问修饰符
- Java
Modifier | Class | Package | Subclass | World |
---|---|---|---|---|
public | Y | Y | Y | Y |
protected | Y | Y | Y | N |
default | Y | Y | N | N |
private | Y | N | N | N |
- Scala
Modifier | Class | Companion | Subclass | Package | World |
---|---|---|---|---|---|
default | Y | Y | Y | Y | Y |
protected | Y | Y | Y | N | N |
private | Y | Y | N | N | N |
(3)类的定义
- 构造器
主构造器
辅助构造器 - 成员变量与方法
- 类的实例化
class:类,object:单例对象,trait:特质
//主构造器的参数列表直接定义在类名后面
//主构造器执行类定义汇总的搜有哦语句
class Student {
//无参的主构造器
//定义成员变量
var name="zhang"
var age:Int=_ //0
var gender:String=_ //null
//辅助构造器可以调用主构造器,也可以调用其他辅助构造器
//定义一个辅助构造器1
def this(name:String,age:Int)={
//辅助构造器必须要从调用其它构造器开始
this()
this.name=name
this.age=age
}
//定义一个辅助构造器2
def this(gender:String)={
this("lisi",18)//调用辅助构造器1
this.gender=gender
}
//定义一个成员方法
def study()={
println("good good study,day day up")
}
}
//调用需要写在main方法里,main方法需要定义到object中
//测试
object Test01{
def main(args: Array[String]): Unit = {
//new一个对象出来后,可以使用成员变量和成员方法
//使用主构造器创建对象
val stu1 = new Student()
println(stu1.name)
println(stu1.age)
println(stu1.gender)
stu1.study()
//使用辅助构造器创建对象
val stu2 = new Student("zhangsan",20)
println(stu2.name)
println(stu2.age)
println(stu2.gender)
stu2.study()
stu2.age=25//可以自动生成get和set方法,可以对变量进行修改,需要是var定义的变量
val stu3=new Student("女")
println(stu3.name)
println(stu3.age)
println(stu3.gender)
stu3.study()
}
}
//输出
zhang
0
null
good good study,day day up
zhangsan
20
null
good good study,day day up
lisi
18
女
good good study,day day up
(4)类的继承
- Scala使用“extends”关键字实现继承
- 子类重写父类方法必须使用“override”关键字
class XiaoXueSheng extends Student {
//继承父类方法
override def study()={
println("小学生不爱学习")
}
//定义子类自己非方法
def play()={
println("小学生喜欢打游戏")
}
}
object Test02{
def main(args: Array[String]): Unit = {
val xiao:XiaoXueSheng=new XiaoXueSheng
println(xiao.age)
xiao.study()
xiao.play()
}
}
//输出
0
小学生不爱学习
小学生喜欢打游戏
2.抽象类(abstract class)
- 抽象类可包含未实现的方法,即抽象方法,无方法体
- 抽象类无法实例化
- 抽象类使用“abstract”关键字修饰
子类重写父类抽象方法时,“override”关键字可选
子类重写父类非抽象方法,“override”关键字必写
//定义一个抽象类,使用abstract修饰
abstract class Shape {
def draw():Unit
def write()={
println("写代码")
}
}
class Circle extends Shape {
//draw是抽象类的抽象方法,可以省略关键字override
override def draw(): Unit = {
println("画一个○")
}
}
//继承抽象类的普通方法必须写关键字override
object Test03{
def main(args: Array[String]): Unit = {
var circle=new Circle
circle.draw()
//如果没有重写方法,可直接调用抽象类方法
circle.write()
}
}
//输出
画一个○
写代码
3.单例对象(object)
- Scala的类中无法定义静态成员,即无static关键字。如何像Java一样表达类的静态成员变量、成员方法与静态代码块?
- Scala解决方案:单例对象
使用“object”关键字声明,可包含变量、方法与代码定义
单例对象中的成员变量、成员方法通过单例对象名直接调用
单例对象第一次被访问时初始化,并执行全部代码块
单例对象不能new,且无构造参数
程序入口main()方法必须定义在单例对象中
单例对象与同名类定义在同一文件中时形成绑定关系
//定义单例对象
object Blah {
//单例对象被访问的时候,执行所有代码
println("initializiing")
def sum