[Scala] Scala 学习笔记 (10) - 面向对象（待补充）

小咪咪 2022-05-19 12:34 234阅读 0赞

# Scala面向对象 #

## 1. 类 class ##

**类的定义**

// 定义一个类
    class People {
    
      // 定义属性
    //  var name:String = ""
      var name:String = _   // name这里也可以直接使用占位符占位
      val age = 10
      private[this] val gender = "M"   // gender是类People的一个私有属性，在外面是不能直接被调用的
    
      def printInfo(): Unit = {
        println(gender)
      }
    
      // 定义方法
      def eat() = {
        name + " eat banana."
      }
    
    }

**类的调用：**如果要调用一个class类，要先new一个class出来

object SimpleClassApp {
    
      def main(args: Array[String]): Unit = {
    
        // 类的调用
        // new 一个类出来
        val people = new People
        people.name = "scala"
    
    //    println(people.gender)   // gender是私有属性，不能直接调用
        people.printInfo()  // 但是gender在这里是被class本身调用，可以合法使用
    
        val a = people.eat()
        println(a)
      }
    
    }

## 2. 构造函数 ##

主构造函数：构造函数的入参都可以作为class的属性来使用。

附属构造函数：第一行必须调用主构造器或者其他附属构造器；附属构造函数可以写一个或者多个。

object ConstructApp {
    
      def main(args: Array[String]): Unit = {
    
        // 创建一个对象
        val girl = new Girl("Cindy", 18,"13000000000","somewhere")
        println(girl.name + " : " + girl.age + " : " + girl.phone + " : " + girl.address)
    
        girl.like()
    
        println(girl.city)
      }
    
    }
    
    // 构造函数中的参数以及类中的属性（非private的）都能直接能够当做对象的属性来使用
    class Girl(val name:String, val age:Int) {
      println("girl enter")
    
      def like(): Unit = {
        println(name + " like something.")
      }
    
      val city = "Shenzhen"
    
      // 附属构造函数：第一行必须调用主构造器或者其他的附属构造器
      var phone = ""
      def this(name:String, age:Int, phone:String) {
        this(name,age)    // 第一行，调用主构造器
        this.phone
      }
    
      // 再定义一个附属构造函数
      var address = ""
      def this(name:String, age:Int, phone:String, address:String) {
        this(name,age,phone)  // 这里的phone在前面的附属构造函数里面已经定义了，可以直接使用
        this.address
      }
    
      println("girl exit")
    
    }

### 3. 类的继承 ###

3.1 发生继承时，当外面创建子对象的时候，首先会调用父类的构造方法，然后才是调用子类的构造方法；

如果子类里面的属性不是父类里面已经有的，前面要加val修饰符，否则外面是访问不到的

创建一个子类，继承上面的Girl类

// 类的继承
    /**
      *
      * 类的继承
      * littleGirl的前半部分littleGirl(name:String, age:Int)是一个主构造器，
      * 继承了Girl这个class
      * 并且littleGirl还加入了自己的参数major
      *
      * 发生继承时，当我们创建子对象的时候，首先会调用父类的构造方法，然后才是调用子类的构造方法
      * 如果子类里面的属性不是父类里面已经有的，前面要加val修饰符，否则外面是访问不到的
      */
    class littleGirl(name:String, age:Int, val major :String) extends Girl(name,age) {
    
      println("littleGirl enter")
    
    
      println("littleGirl exit")
    }

调用这个子类

val littlegirl = new littleGirl("girl", 10, "computer")
        println(littlegirl.name + " : " + littlegirl.age + " : "  + littlegirl.major)

3.2  继承是发生在子类和父类之间的

如果想重写弗雷中已有的方法时，一定要添加override修饰符。

class littleGirl(name:String, age:Int, val major :String) extends Girl(name,age) {
    
      println("littleGirl enter")
    
      // toString是scala内置的一个object类的方法，如果想重写父类中已有的方法时，一定需要添加override修饰符
      override def toString = "littleGirl toString"
    
    
      println("littleGirl exit")

3.3 抽象类

类中有一个或者多个方法没有实现，换句话说：只有定义，没有实现。

这个抽象类是不能直接使用的，必须要通过实现了该抽象类的属性或者方法来使用。

子类重写父类中的属性或者方法，override可以不写。

定义一个抽象类

/**
      * 抽象类的定义 abstract
      * 抽象类可以有属性，有方法
      * 属性和方法都只是定义，没有实现
      * 这样的抽象类是不能直接被使用的
      */
    abstract class Animal {
      // 属性或方法只有定义没有实现
      var name:String
      var age:Int
      def speak
    }

因为这个抽象类不能直接使用，再定义一个子类继承上面的抽象类

/**
      * 定义一个字类继承上面的抽象类，这个子类要么再被定义成抽象类，或者实现父类的spark方法
      * 在Dog上面按住ctrl+回车，选择实现这个方法(Implement methods)，选中所有的方法点OK
      * 再给属性赋值，方法重写
      * 子类重写父类中的方法或者属性，override可以省略不写
      */
    class Dog extends Animal {
      
      // 重写父类的属性
      override var name: String = "Rich"
      override var age: Int = 1
    
      // 重写父类的方法
      override def speak: Unit = {
        println("wang wang wang")
      }
    }

最后再调用这个子类，此时子类的属性和方法都可以被调用。

object AbstractApp {
    
      def main(args: Array[String]): Unit = {
    
        // 因为抽象类Animal是不能直接被使用的，所以new一个它的子类，再调用它的方法
        val dog = new Dog
        dog.speak
      }
    
    }

思考：

抽象类的用途是什么？