Scala语法(三) 类与对象

版权声明:欢迎转载,转载请说明出处. 大数据Github项目地址https://github.com/SeanYanxml/bigdata。 https://blog.csdn.net/u010416101/article/details/89642346

前言

在前面的章节内, 我们分别介绍了Scala编程基础以及Scala的函数式编程. 本章, 我们将介绍Scala的类与对象的相关内容.


正文

类 & 对象

Scala中的类的概念与Java一样. 通常通过class <className>进行定义, 一般一个类还可以定义一个伴生对象object <objectName>. 与Java不同的是, Scala可以在一个文件内定义不同的类.

/**
 * scala创建一个simple类.
 * 
 * */
// scala中 类不用声明为public类型
// scala源文件内可以包含多个类, 所有的这些类都具有公共可见性.
class Person {
    // val修饰的成员变量, 只能读不能写
    val id =  "123"
    // var修饰的成员变量, 可以读也可以写
    var age:Int = 12
    // 类的私有字段, 只能在类的内部
    private var name:String = "Sean"
    // 对象私有字段,访问权限更加严格, 只能在类中访问.
    private [this] val dog = "HaSaKi"
    
    def printDog: Unit = {
      println(dog)
    }
    
}
class HelloKitty{
  val name = "hellokitty"
  
}


// 伴生对象
object Person{
  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.id
    person.age
    person.name
    
    person.printDog
  }
}
}
  • 类中对象访问权限
// val修饰的成员变量, 只能读不能写
    val id =  "123"
    // var修饰的成员变量, 可以读也可以写
    var age:Int = 12
    // 类的私有字段, 只能在类的内部
    private var name:String = "Sean"
    // 对象私有字段,访问权限更加严格, 只能在类中访问.
    private [this] val dog = "HaSaKi"
  • class访问权限
    class的访问权限通常在创建的时候进行指定, 指定为类在包内的权限.
//<私有/公有> [包访问权限] [class <类名>] [构造方法权限]
private [simple] class packageClass private{
  
}
  • 构造方法
    通常定义时,设定一个主构造方法与从构造相互协调的方式进行构建. 主构造方法可以直接跟随在方法后进行定义.
// 构造器
class PersonContructor(val id:String, val name:String, gender:String, val age:Int=18){
  println("123")
}

class PersonContructor2(){
  def this(id:String){
    // 调用主构造器
    this()
  }

Scala——构造函数

接口 & 抽象类

Scala内的接口与Java中类似. 只是换了一个关键字.

/**
 * trait 类似于Java中的接口.
 * 
 * */
trait Animal {
  def  run()
}
/**
 * 抽象类.
 * 
 * */
abstract class Human {
  
}
/**
 * Java与Scala都是单继承的.(With后面跟随需要实现的接口.)
 * 
 * */
class Chinese extends Human with Animal{
  // 重写抽象方法 override可加可不加
  // 重写非抽象方法 必须需要加上override
  // 实现 Animal内的接口
  override def run() :  Unit = {
    
  }
  
  def main(args: Array[String]): Unit = {
    val chinese = new Chinese()
  }
}
  • 类型转换
	val chinese = new Chinese()
    // instance of
    chinese.isInstanceOf[Chinese]
    // (T) 强制类型转换
    chinese.asInstanceOf[Chinese]
    // T.class
    classOf[Chinese]

  • Apply方法
    创建对象的时候, 有时可以通过<对象名>()进行创建. 这边是因为其会自动去调用匹配的Apply()方法. val array = Array(1,2,3)就是利用了此方法.

class ApplyMethod {
  
}
object ApplyMethod{
  def apply() : Unit = {
     println("No parameter Method.")
  }
  def apply(name:String) : Unit = {
     println("Name parameter Method.")
  }
  
  // apply方法改造成为构造函数
  def apply(method:Int) : ApplyMethod ={
    new ApplyMethod()
  }
  
  def main(args: Array[String]): Unit = {
    // 这样是直接找单例对象
    val obj = ApplyMethod
    // 这样写是直接找对应的apply方法.
    val obj2 = ApplyMethod()
    val obj3 = ApplyMethod("Name")
    
    val obj4 = ApplyMethod()
    //之前Array的定义 其实就是去找的Array类的apply方法.
    val array = Array(1,2,3,4,5)

    
  }
}
  • 单例对象
    使用伴生对象创建的对象是一个单例对象.
/**
 * scala实现单例对象.
 * 
 * */
class SingleObject {
  
}

object SingleObject{
  def main(args: Array[String]): Unit = {
    val objectOne =  SingleObject
    val objectTwo =  SingleObject
    println(objectOne)
    println(objectTwo)
  }
}

// 两者是一样的. Scala创建单例.
//com.yanxml.quick_scala.oop.simple.SingleObject$@330bedb4
//com.yanxml.quick_scala.oop.simple.SingleObject$@330bedb4
展开阅读全文

没有更多推荐了,返回首页