Scala语法(三) 类与对象

深碍√TFBOYSˉ_ 2022-02-12 10:24 246阅读 0赞

### 前言 ###

在前面的章节内, 我们分别介绍了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]

##### 接口 & 抽象类 #####

`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

[Scala]: https://blog.csdn.net/hellojoy/article/details/81183490