目录
单例对象(伴生对象):
创建对象常用的两种方法:
(1)使用构造器构造(new)
(2)使用静态方法
伴生对象的定义:
apply方法:
apply方法的调用:
单例模式:
单例模式分为两种:
1.懒汉式
2.饿汉式:(推荐)
特质(Trait):
基本语法:
说明
特质叠加:
特质和抽象类的区别:
单例对象(伴生对象):
Scala语言是完全面向对象的语言,所以并没有静态的操作(即在Scala中没有静态的概 念)。但是为了能够和Java语言交互(因为Java中有静态概念),就产生了一种特殊的对象 来模拟类对象,该对象为单例对象。若单例对象名与类名一致,则称该单例对象这个类的伴 生对象,这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
创建对象常用的两种方法:
(1)使用构造器构造(new)
val person0 = new Person09()
(2)使用静态方法
(在Scala中没有静态方法与之等价的是object---伴生对象)
val person01: Person09 = Person09.getPerson()
伴生对象的定义:
object Person09{
def getPerson():Person09=new Person09
}
方法2主要是在将构造器私有化的时候是无法new的 这时就需要使用伴生对象构造
class Person09 private{
val name :String="张三"
}
apply方法:
在Scala中引入了一个apply()方法模板 来替代上述的伴生对象的构造方法 在伴生对象中创建了方法,直接在main方法中调用apply方法即可
apply()方法在Scala中是做出了改进 在函数进行调用的时候可以不写方法名,直接进行调用
apply方法的调用:
val person0: Person09 = Person09()
apply方法也是可以进行任意自定义的 没必要一定跟模板一样创建一个对象
特点就是可以不写方法名
直接Person09() 就能调用apply方法
系统在集合当中使用非常广泛,调用对象的apply方法
下边集合 Array就是一个对象 使用.var 自动生成对象 其实是Array集合
val ints: Array[Int] = Array(1, 2, 3, 4)
单例模式:
单例模式是确保一个类只有一个实例,即不能随便被创建对象,所以构造方法要使用private进行私有化,不能被外界进行实例化,这个实例是当前类的类成员变量,即类静态成员变量,这个静态变量需要提供给外界,所以需要提供静态方法向外界提供当前实例
单例模式分为两种:
1.懒汉式
占用内存少(减少创建对象的数量),线程不安全(在某个时间段 都进入if判断,都为真,都会赋值产生变量 就会产生线程安全---只会出现在第一次初始化的时候)
class Singleton09 private{
}
object Singleton09{ //相当于静态方法 在静态方法中创建对象 便于外边的访问
//先声明属性 先声明为null 后边获取的时候再赋值
private var singleton:Singleton09=null;
def apply(): Singleton09 = {
if (singleton==null)
{
singleton = new Singleton09
}
singleton
}
}
2.饿汉式:(推荐)
饿汉式没有线程安全问题,写起来简单,占用内存多(提前创建) 它是在伴生对象中先进行创建对象 在jvm中进行类加载,这样就避免了线程安全问题
object Singleton09 {
private var singleton: Singleton09 = new Singleton09;
def apply(): Singleton09 = singleton
}
判断单例模式:
def main(args: Array[String]): Unit = {
//判断单例模式是否正确
val singleton:Singleton09=Singleton09();
val singleton1:Singleton09=Singleton09();
println(singleton)
println(singleton1)
}
可以看到地址值相同
特质(Trait):
基本语法:
说明
class Person11 extends Young11 with old11 with java.io.Serializable{}
(6)动态混入:可灵活的扩展类的功能
特质叠加:
package chapter04
object Test11_TraitMinxin2 {
def main(args: Array[String]): Unit = {
val person1 = new Person12
println(person1.Info())
}
}
trait Age12{
val age:Int
def Info()="age "
}
//下边两个特质均继承自Age12
trait Young12 extends Age12{
override val age: Int = 12
override def Info(): String = super.Info()+"Young "
}
trait Old12 extends Age12{
override val age: Int = 13
override def Info(): String = super.Info()+"Old12 "
}
//钻石效应
class Person12 extends Young12 with Old12 {
override def Info(): String = super.Info()+"Person12 "
}
测试结果:
上述结果说明,在产生钻石问题的时候会按照继承关系进行一个排序来进行调用
当我们如果只想调用某一个类的时候方法的时候,可以对继承的类进行指定
对Person12类进行了修改:
class Person12 extends Young12 with Old12 {
override def Info(): String = super[Young12].Info()+"Person12 "
}
执行结果:文章来源:https://www.toymoban.com/news/detail-429512.html
文章来源地址https://www.toymoban.com/news/detail-429512.html
特质和抽象类的区别:
package chapter04
object Test_14_Rxtends {
def main(args: Array[String]): Unit = {
//多态
var son:father14 =new son14
val son1: son14 = son.asInstanceOf[son14]
son1.sayHi()
}
}
class father14{
}
class son14 extends father14 {
def sayHi(): Unit ={
println("hi son")
}
}
到了这里,关于Scala之面向对象(2)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!