Scala语言是完全面向对象的语言,所以并没有静态的操作(即在Scala中没有静态的概念)。但是为了能够和Java语言交互(因为Java中有静态概念),就产生了一种特殊的对象来模拟类对象,该对象为单例对象。若单例对象名与类名一致,则称该单例对象这个类的伴生对象,这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
总结:Scala中没有static关键字,所有的静态内容都写在object中。(main方法写在object中)
// scala默认构造函数
// 下面代码可以编译通过,但无法运行
class Oop1 {
def showInfo()={
println("this is oop1")
}
def main(args: Array[String]): Unit = {
val oop = new Oop1
oop.showInfo()
}
}
一、 单例对象语法
1)基本语法
object Person{
val country: String = "China"
}
2)说明
(1)单例对象采用object关键字声明
(2)单例对象对应的类称之为伴生类,伴生对象的名称应该和伴生类名一致。
(3)单例对象中的属性和方法都可以通过伴生对象名(类名)直接调用访问。
3)执行顺序
class Oop1(name:String,age:Int) { // scala默认构造函数
println("---oop1 class start---")
var userName = name;
var userAge = age;
def showInfo()={
println("this is oop1")
}
println("---oop1 class end---")
}
object Oop1Test {
def main(args: Array[String]): Unit = {
val oop = new Oop1("liwei",23)
oop.showInfo()
}
}
二、伴生类class与伴生对象object
伴生关系的条件:
1)class 和 object修饰的类 名字一致
2)在同一个文件中
类是对象的伴生类,对象是类的伴生对象。
可以访问彼此私有的内容,可以理解成一个整体,只是静态与非静态分离,使得程序运行起来更加高效。
// 互为伴生类、伴生对象
class Student{ } // 类
object Student { } // 对比java中的静态类,可以理解为对象
// 不是伴生关系
class Student{ }
object Stu { }
2)案例演示
(1)创建Student类
class Student{
private var stuName:String = "zs"
private var stuAge:Int = 18
def showInfo ={
println("show stu info method")
}
}
object Student {
var Name = "zss"
var Age = 20
}
(2)创建测试类
object Test01 {
def main(args: Array[String]): Unit = {
// 创建类的实例对象
val demo = new Student
demo.name // 私有属性,无法访问
// 通过类名访问伴生对象中的属性。调用方法类似于Java中 静态方法的调用
Student.Name
// Student.Age private定义的属性无法调用
}
}
(3)object Student伴生类
class Student{
private var name:String = "zs"
private var age:Int = 18
Student.Name // 可以访问
Student.Age // object中的私有属性,在伴生类中可以访问
}
object Student {
var Name = "zss"
private var Age = 20
def main(args: Array[String]): Unit = {
val student = new Student
// 外部类中无法访问,伴生对象中可以访问伴生类的privite私有属性
student.name
student.age
}
}
三、构造函数
在Scala中构造函数有2种:
构造函数的功能:在创建类的对象的时候,进行初始化操作
// 1. 默认无参构造
class Student {
var stuName:String = ""
var stuGrade:String = ""
var stuAge:Int = 0
// 定义有参构造
def this(name:String, grade:String, age:Int){
this()
this.stuName = name
this.stuAge = age
this.stuGrade = grade
}
// 定义两个参数的构造方法
def this(name:String,grade:String){
// 方法一:调用无参构造,并赋值
this()
this.stuName = name
this.stuGrade = grade
// 方法二:直接调用有参构造方法
this(name,grade,1)
}
}
// 2. 默认有参构造
class Student(name:String, grade:String, age:Int){
var stuName:String = ""
var stuGrade:String = ""
var stuAge:Int = 0
def this(name:String,grade:String){
this(name,grade,1)
}
def this(){
this("","",0)
}
}
1)主构造函数
只有一个
直接紧跟 在类class后面,如果没有属性的话,可以省略()
2)附属构造函数
可以有很多
一个.scala文件中,一个类的名字和对象的名字一致,
互为伴生对象和伴生类
可以互相访问私有的属性和方法
//伴生类
class People(val name:String,val age:Int){
var school:String = "huadian"
val money:Double = 10000000.0
//定义附属构造函数
def this(name:String, age:Int, school:String){
//第一行必须调用主构造函数
this(name, age)
this.school = school
println(People.yaoshi)
}
def this(name:String, school:String){
//第一行必须调用主构造函数
this(name,18)
this.school = school
}
}
//伴生对象
object People{
private val yaoshi:String = "XXXX"
def apply( name: String, age: Int): People = new People( name, age)
def apply( name: String, age: Int,school:String): People = new People( name, age,school)
def getMoney():Unit={
println((new People("zs",11)).money)
}
}
四、 apply方法
apply是一个特殊的方法,方法的调用可以省略方法名。
// 定义类
class Student (val name:String, val age:Int){
def printInfo(){
// 调用伴生对象的属性
println(s"student:name=${name},age=${age},school=${Student.school}")
}
}
// 伴生对象
object Student {
val school = "bj"
// 定义一个类的对象实例的创建方法
def newStu(name: String, age: Int):Student = new Student(name,age)
def apply(name: String, age:Int):Student = new Student(name,age)
}
// 测试类
object Test {
def main(args: Array[String]):Unit = {
// new对象
val student = new Student("alice",18)
student.printInfo()
// 使用apply方法调用
val demo2 = Student.apply("bob",21)
demo2.showInfo
// 简化apply关键字后的对象定义
val demo3 = Student("candy",14)
demo3.showInfo
}
}