一、类
(一)类的定义
- 对象是类的具体实例,类是抽象的,不占用内存,而对象是具体的,占用存储空间。
- 面向对象三大特性之一:封装(encapsulation) - 封装数据和操作
- Scala中一个简单的类定义是使用关键字
class
,类名首字母必须大写。类中的方法用关键字def
定义 - 创建
net.zhj.day04
包,在包里创建User
类,包含三个私有属性和一个公共方法
package net.zhj.day04
class User {
private var name = "张三"
private var gender = "男"
private var age = 20
def speak(): Unit = println("我叫" + name + "," + gender + age + "岁")
}
(二)类的实例化
- 关键字
new
用于创建类的实例 - 实例化
User
类,调用其speak()
方法 - 在
net.zhj.day04
包里创建TestUser
对象
package net.zhj.day04
object TestUser {
def main(args: Array[String]): Unit = {
val user = new User()
user.speak()
}
}
运行程序,查看结果
二、单例对象
(一)单例对象概念
- Scala中没有static关键字,当然没有
静态方法
或静态字段
,但是可以使用关键字objec
t定义一个单例对象
,单例对象中的方法相当于Java中的静态方法
,可以直接使用“单例对象名.方法名
”方式进行调用。单例对象除了没有构造器参数外,可以拥有类的所有特性。
(二)案例演示
- 在
net.zhj.day04
里创建Person
单例对象,包含三个私有属性和一个公共方法
package net.zhj.day04
object Person {
private var name = "李华"
private var gender = "女"
private var age = 19
def speak(): Unit = println("我叫" + name + "," + gender + age + "岁")
}
在net.zhj.day04
包里创建TestPerson
对象
package net.zhj.day04
object TestPerson {
def main(args: Array[String]): Unit = {
Person.speak()
}
}
运行程序,查看结果
·
三、伴生对象
(一)伴生对象概念
- 当单例对象的名称与某个类的名称一样时,该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中,且两者可以互相访问其私有成员。
(二)案例演示
- 在
net.zhj.day04
包里,创建Scala类Student
,在文件里创建其伴生对象Student
package net.zhj.day04
//伴生类
class Student {
private var name = "刘华强"
def speak():Unit = {
println("我叫" + name + Student.age +"岁")
}
}
//伴生对象
object Student{
private var age = 18
def main(args: Array[String]): Unit = {
val student = new Student()
println("姓名: " + student.name)
println("年龄:" + age)
student.speak()
}
}
运行程序,查看结果
四、get和set方法
(一)生成原则
- Scala默认会根据类的属性的修饰符生成不同的get和set方法
1、val修饰的属性 - 公共常量属性
- 系统会自动生成一个
公共常量属性
和一个公有get方法
。
2、var修饰的属性 - 公共变量属性
- 系统会自动生成一个
公共变量属性
和一对公有get/set方法
。
3、private var修饰的属性 - 私有变量属性
- 系统会自动生成一对
私有get/set
方法,相当于类的私有属性,只能在类的内部和伴生对象中使用。
4、private[this]修饰的属性 - 本地私有变量属性
- 系统不会生成get/set方法,即只能在类的内部使用该属性。
(二)案例演示
任务1、利用系统自动生成的get和set方法
(1)创建Dog类
- 在
net.zhj.day04
包里创建Dog
类
package net.zhj.day04
class Dog {
val Id: Int= 1
var name: String = "小黑"
private var gender: String = "公"
private[this] var age: Int = 4
}
(2)编译成字节码文件
-
将
Dog.scala
编译成Dog.class
-
任务2、用户自己编写私有属性的Scala风格的get和set方法
- 注意:set方法的写法 ——
方法名_=
- 在
net.zhj.day04
包里创建Cat
类
package net.zhj.day04
class Cat {
private var catName: String = "大黑"
//get方法
def name: String = catName
//set方法
def name_=(name:String):Unit = {
catName = name
}
}
object Cat{
def main(args: Array[String]): Unit = {
val cat : Cat = new Cat()
println("猫原名:"+cat.name)
cat.name_= ("小黄")
println("猫现名:"+cat.name)
}
}
运行程序,查看结果
任务3、用户自己编写私有属性的Java风格的get和set方法
- 注意:get方法 —— getXXX(),set方法——setXXX()
- 在
net.zhj.day04
包里创建Bird
类
package net.zhj.day04
class Bird {
private var name = "熊大"
def getName:String = name
def setName(name:String):Unit = {
this.name = name
}
}
object Bird{
def main(args: Array[String]): Unit = {
val bird = new Bird
println("鸟儿原名:"+bird.getName)
bird.setName("咯咯咯")
println("鸟儿现名:"+bird.name)
}
}
运行程序,查看结果
五、构造器
- Scala中的构造器分为主构造器和辅助构造器。Scala利用主构造器和辅构造器
(一)主构造器
1、构造器参数带val或var
- 主构造器的参数直接放在类名之后,且将被编译为类的成员变量,其值在初始化类时传入。注意,构造器参数必须指定类型
- 在
net.zhj.day05
包里创建Person
类
package net.zhj.day05
class Person (val name: String,var age:Int = 18) {
def speak():Unit = println("myname is"+name+",今年:"+age+"岁")
}
object Person{
def main(args: Array[String]): Unit = {
val person = new Person("小李子",20)
println("姓名:"+person.name)
println("年龄:"+person.age)
person.speak()
person.age_=(18)
person.speak()
}
}
运行程序,查看结果
因为主构造器第二个参数是有初始值,所以创建对象时可以不再初始化第二个参数,采用主构造器参数的初始值
2、构造器参数带访问权限
- 可以通过对主构造器的参数添加访问修饰符来控制参数的访问权限
- 创建Person类,将参数age设置为私有的,参数name设置为不可修改(val)
class Person (val name: String, private var age: Int) {
}
- 系统会为
name
属性添加一个公共的get方法 - 系统会为
age
属性添加一个私有的get和set方法
3、构造器参数不带var或val
- 构造参数也可以不带
val
或var
,此时默认为private[this] val
,这样会被编译成类的本地私有成员,不会生成get
和set
方法,只能在类的内部访问。
class Person (name: String, age: Int) {
}
可以改写成带访问权限的参数
class Person (private[this] val name: String, private[this] val age: Int) {
}
4、类的初始化语句
- 主构造器执行时,类中定义的语句作为初始化语句
- 在
net.zhj.day05
包里创建Dog
类
package net.zhj.day05
class Dog (var name:String,var age:Int) {
name = "大熊"
age = 2
println("主构造器被调用了")
def speak():Unit = println("我叫"+name+"今年"+age+"岁")
}
object Dog{
def main(args: Array[String]): Unit = {
val dog = new Dog("",0)
dog.speak()
}
}
运行程序,查看结果
说明:实例化Dog
时,传入的参数是""
与0
,但是会执行类里的两个给成员变量赋值的语句,于是name
成了大熊,age
成了2,于是调用对象的speak()
方法,会输出我叫大熊,今年2岁~
。
5、私有化构造器
- 如果需要将整个主构造器设置为私有的,那么只需要添加
private
关键字即可,注意,只有伴生对象里才能调用私有构造器来实例化,非伴生对象里就不能调用私有构造器来实例化 - 在
net.zhj.day05
包里创建Cat
类
package net.zhj.day05
class Cat private(var name:String,var age:Int){
def speak():Unit = {
println("我叫"+name+"今年"+age+"岁")
}
}
object Cat{
def main(args: Array[String]): Unit = {
val cat = new Cat("牛牛",1)
cat.speak()
}
}
运行程序,查看结果
6、无参构造器
- 主构造器也可以没有参数,一个类中如果没有显式地定义主构造器,就默认有一个无参构造器。
- 在
net.zhj.day05
包里创建Bird
类
package net.zhj.day05
class Bird {
var name = "小黑"
var age = 1
def speak():Unit={
println("我叫"+name+"今年"+age+"岁")
}
}
object Bird{
def main(args: Array[String]): Unit = {
val bird = new Bird
bird.speak()
}
}
运行程序,查看结果
(二)辅助构造器
- Scala类除了可以有主构造器外,还可以有任意多个辅助构造器。
1、定义辅助构造器的注意事项
- 辅助构造器的方法名称为
this
- 每一个辅助构造器的方法体中必须首先调用其他已定义的构造器
- 辅助构造器的参数不能使用
var
或val
进行修饰
2、案例演示
- 在
net.zhj.day05
包里创建Student
类
package net.zhj.day05
class Student {
private var name = "熊大"
private var age = 17
def this(name:String)={
this()
this.name = name
}
def this(name:String,age:Int)={
this(name)
this.age = age
}
override def toString :String = "我叫"+name+age+"岁"
}
object Student{
def main(args: Array[String]): Unit = {
//无参
val student1 = new Student()
println(student1)
//单参
val student2 = new Student("耗子")
println(student2)
//双参
val student3 = new Student("小八嘎",16)
println(student3)
}
}
(2)有参主构造器与有参辅助构造器
- 主构造器还可以与辅助构造器同时使用,在这种情况下,一般辅助构造器的参数要多于主构造器
- 在
net.zhj.day05
包里创建Teacher
类
package net.zhj.day05
class Teacher (private var name:String,private var age:Int){
private var gender = " "
def this(name:String,age:Int,gender:String) = {
this(name,age)
this.gender = gender
}
override def toString :String = "我叫"+name+age+"岁" + "性别"+gender
}
object Teacher{
def main(args: Array[String]): Unit = {
val teacher = new Teacher("草原三剑客",20,"男")
println(teacher)
}
}
运行程序,查看结果
六、抽象类
(一)抽象类的定义
- Scala的抽象类使用关键字
abstract
定义
(二)抽象类的特征
- 抽象类不能被实例化。
- 抽象类中可以定义抽象字段(没有初始化的字段)和抽象方法(没有被实现的方法),也可以定义被初始化的字段和被实现的方法。
- 若某个子类继承了一个抽象类,则必须实现抽象类中的抽象字段和抽象方法,且实现的过程中
可以添加override
关键字,也可以省略。若重写了抽象类中已经实现的方法,则必须添加override
关键字。
(三)案例演示
1、创建抽象类 - Person
- 在
net.zhj.day06
包里创建Person
抽象类
package net.zhj.day06
abstract class Person {
var name:String
var age:Int
var address:String = "牛马潭区长起桥桥洞"
def speak()
def walk():Unit={
println(name+"在捡瓶子")
}
}
2、继承抽象类,创建普通类 - Teacher
- 在
net.zhj
.day06
包里创建Teacher
普通类
package net.zhj.day06
abstract class Person {
var name:String
var age:Int
var address:String = "牛马潭区长起桥桥洞"
def speak()
def walk():Unit={
println(name+"在捡瓶子")
}
}
3、创建测试对象 - TestTeacher
- 在
net.zhj
.day06
包里创建TestTeacher
对象
package net.zhj.day06
object TestTeacher {
def main(args: Array[String]): Unit = {
val teacher = new Teacher()
teacher.speak()
teacher.walk()
}
}
运行程序,查看结果
5、简要说明
-
需要注意的是,上述Teacher类中
speak()
方法的地址字段(address
)是从父类(抽象类Person)中继承而来的。由于该字段在Person中有初始化值,不是抽象字段,若需要在Teacher类中修改该字段的值,则可以在Teacher类的构造函数或其它方法中使用this.address
对其重新赋值。例如,将地址改为“江阳区前进中路3号
”,可以使用以下代码:this.address="高坝"
。
运行程序,查看结果
七、特质
(一)特质的概念
- Scala特质使用关键字
trait
定义,类似Java 8
中使用interface
定义的接口。特质除了有Java接口的功能外,还有一些特殊的功能。Scala特质中,字段和方法的定义与Scala抽象类一样,可以定义抽象字段和抽象方法、非抽象字段和非抽象方法。
(二)特质的定义
1、语法格式
trait 特质名 {
// 抽象字段
// 抽象方法
// 普通字段
// 普通方法
}
2、案例演示
- 在
net.zhj.day07
包里创建Pet
特质
package net.zhj.day07
trait Pet {
var name:String
var age:Int
def speak
def eat:Unit = {
println(name + "在吃嘎嘎")
}
}
任务2、创建奔跑特质 - Runnable
- 在
net.zhj.day07
包里创建Runnable
特质
package net.huawei.day07
/**
* 功能:奔跑特质
* 作者:zhj
* 日期:2023年03月16日
*/
trait Runnable {
// 抽象方法
def run
}
任务3、创建飞翔特质 - Flyable
- 在
net.zhj
.day07
包里创建Flyable
特质
package net.huawei.day07
/**
* 功能:飞翔特质
* 作者:zhj
* 日期:2023年03月16日
*/
trait Flyable {
// 抽象方法
def fly
}
(三)特质的实现
- 类可以使用关键字
extends
实现特质,但必须实现特质中未实现的字段和方法(抽象字段和抽象方法),这一点与继承抽象类是一致的。
1、语法格式
class 类名 extends 特质名 {
// 实现抽象字段
// 实现抽象方法
}
(2)实现多个特质
- 如果需要实现的特质不止一个,那么可以通过
with
关键字添加额外特质,但位于最左侧的特质必须使用extends
关键字。
class 类名 extends 特质名1 with 特质名2 with 特质名3 …… with 特质名n {
// 实现抽象字段
// 实现抽象方法
}
2、案例演示
- 在
net.zhj.day07
包里创建Cat
类,实现Pet
特质
package net.zhj.day07
class Cat extends Pet {
var name:String = "梅里猫"
var age:Int = 1
def speak:Unit = {
println("我叫"+name+"今年"+age)
}
override def eat:Unit = {
println(name+"在吃暴龙")
}
}
object Cat{
def main(args: Array[String]): Unit = {
val cat = new Cat
cat.speak
cat.eat
}
}
运行程序,查看结果
任务2、实现多个特质
-
在
net.zhj.day07
包里创建Bird
类,实现Pet
、Runnable
、Flyable
特质
package net.zhj.day07
class Bird extends Pet with Runnable with Flyable {
var name: String = "玲玲"
var age: Int = 2
def speak: Unit = {
println("我叫" + name + ",今年" + age + "岁了~")
}
def run: Unit = {
println("鸟儿[" + name + "]在欢快地奔跑~")
}
def fly: Unit = {
println("鸟儿[" + name + "]在自由地飞翔~")
}
}
// 伴生对象
object Bird {
def main(args: Array[String]): Unit = {
// 创建鸟对象
val bird = new Bird()
// 调用对象方法
bird.speak
bird.run
bird.fly
}
}