10scala中的类和对象

内容：

1. Scala 中的类；

2. Scala中的对象；

3. 成员变量和成员方法；

4. 构造函数和辅助构造函数。

类与对象

1.面对对象的相关概念

2.创建类和对象

3.定义和访问成员变量

4.成员访问的本质

5.构造函数

（一）面向对象的相关概念

1. 什么是面向对象？

它是一种编程思想，它是基于面向对象的，强调的是以对象为基础完成各种操作。

2. 面向对象的三大思想特点是什么？

(1) 更符合人们的思考习惯

(2) 把复杂的事情简单化

(3) 把程序员从执行者变成指挥者

3. 什么是类class？ 类是属性和行为的集合。

(1) 属性也叫成员变量：名词，用来描述事物的外在特征

(2) 行为也叫成员方法：动词，表示事物能做什么

4. 面向对象的三大特征是

(1) 封装

(2) 继承

(3) 多态

（二）创建类和对象

在Scala中，用class来创建类，用new来创建对象。

（三）定义和访问成员变量

定义和访问成员变量：

1. var/val  来定义成员变量

2. 对象可以通过对象名. 成员变量的方式来访问成员变量

object base31 {
    // Person 就是一个类名，理解为页面层！
    // 首字母是大写的！
    // 类名一般都是名词


  //1.定义类

    class Person(){}

    class Student() {
      // 在类中，定义成员变量
      //var val 修饰的变量有什么区别？
      // var 可修改
      // val 不可修改
      var name:String = "小花"
      var age: Int = 18
    }

  def main (args: Array [String]): Unit = {
    //2.实例化对象

    val p1 = new Person()

    val s1 = new Student ()
    // 访问成员变量
    println (s1.name)
    // 修改成员变量
    s1.name = "小花花"

    println (s1.name)

    }

}

结果如图：

技巧：使用下划线初始化成员变量。var可以让系统去设置默认值；例如var name:String = _

（四）定义和访问成员方法

类可以有自己的行为，scala中也可以通过定义成员方法来定义类的行为。

在scala的类中，使用def定义成员方法:

def 方法名(参数1：数据类型 , 参数2：数据类型): [return type] = {

// 方法体

}

object base32 {

    // 把功能都封装在class中
    // 1. 属性
    // 2. 方法
    // 3. 辅助构造器
    class Student(var name: String = "小花", var age: Int = 18) {
      println("Student.....被调用了.....")
      // 1. 类的属性 - 变量
      // var name: String = "小花",
      // var age: Int = 18

      // 2. 类的方法 - 函数
      def say(): Unit = {
        println(s"${name}, ${age}")
      }
    }

  def main(args: Array[String]): Unit = {
    // 实例化对象
    val s1 = new Student()
    s1.say()

    val s2 = new Student("小明", 19)
    s2.say()
  }

}

结果如图：

注意：返回值的类型可以不写，由Scala自动进行类型推断。

案例：封装一个三角形类给中学生使用，根据三条边。

1. 求三角形的面积
2. 判断是否是一个三角形

object base33 {
  class Triangle(var a: Double = 1.0, var b: Double = 1.0, var c: Double = 1.0) {
    println(s"$a $b $c")
      // 检查是否构成三角形，结果是boolean
    def check(): Boolean = {
        // 构成三角形的条件是：任意两边之和 > 第三边
      return a + b > c && b + c > a && a + c > b
      }

      // 计算面积：根据三角形的三边计算面积？
    def getArea(): Double = {
      if (check()) {
        var s = (a + b + c) / 2
        s = Math.sqrt(s * (s - a) * (s - b) * (s - c))
        return s
      } else {
        println(s"${a} ${b} ${c} 不能构成一个三角形")
        return -1
      }
    }
  }

  def main(args: Array[String]): Unit = {
      // print("请输入第一条边")
      // val a = scala.io.StdIn.readDouble()
      // print("请输入第二条边")
      // val b = scala.io.StdIn.readDouble()
      // print("请输入第三条边")
      // val c = scala.io.StdIn.readDouble()
      // val t1 = new Triangle(a, b, c)
    val t1 = new Triangle(3, 4, 7)//6
    println(t1.getArea())

    val t2 = new Triangle(3, 4, 3) //8
    println(t2.getArea())

      // if(t1.check()){

      // }
  }
}

结果如图：

提示：

（五）成员访问的本质

在本质上和java的set，get类似。 要注意：

1.val定义的变量可以生成 get。可以访问。

2.var定义的变量可以生成 get + set。可以访问 + 修改。

3.使用private修饰的变量，既不可以访问，也不可以修改。

object Main {

    // 定义类

class Customer() {

    private var age = 10

  }

  def main(args: Array[String]): Unit = {

    val c = new Customer()

    println(c.age) // 报错

  }

（六）主构造函数

有没有方法可以直接在定义对象的时候就去给成员赋值？在java中，使用public定义与类同名的方法。

在scala中，直接在定义类时，补充参数即可。

 

Class 类名（参数列表），参数列表中的变量可以用var|val，也可以不用。

用val或var定义，在类外可以访问

不用val|var定义，在类外不可以访问 内部只读，不可改写

（七）辅助构造函数

构造函数只能有一个吗？

可以有很多个。

object base35 {
  // 性别：男
  // 构造器的默认值
  // 必传值：姓名，年龄。
  // 有默认值的：
  // 民族：汉
  class Student(var name: String, var age: Int, var gender: String = "男", var nav: String = "汉族") {
    def say(): Unit = {
      println(s"${name}, ${age}, ${gender}, ${nav}")
    }
  }

  def main(args: Array[String]): Unit = {
    //    var s0 = new Student() // gender 和 nav 使用默认值
    var s1 =new Student("小明", 19) // gender 和 nav 使用默认值
    s1.say()

    var s2 =new Student("小花", 18, "女", "回族")
    s2.say()
  }
}

结果如图：

案例（二）

object base36 {
     //构造器中的参数的类型
    // 1. val定义的属性，不能修改
    // 2. var定义的属性，可以修改
    // 3. 没有val，也没有var的，不是对象的属性。不能使用.语法来访问。
    class Student(val name: String, var age: Int, gender: String = "男") {
      def say(): Unit = {
        println(s"${name}, ${age}, ${gender}")
      }
    }

    def main(args: Array[String]): Unit = {
      var s1 =new Student("小明", 19) // gender 和 nav 使用默认值
      s1.age = 20
      s1.say()
    }
}

辅助构造器的作用

1. 提供多种初始化方式：

辅助构造器允许您为类提供多种初始化选项，使得创建对象时更加灵活。例如，您可以定义一个不需要所有参数的构造器。

2.简化对象创建：

通过定义多个辅助构造器，您可以简化对象的创建过程，避免在主构造器中处理过多的参数。

3.调用主构造器：

辅助构造器可以通过 this 关键字调用主构造器，从而确保所有初始化逻辑都集中在主构造器中。

object base37 {
  // 多种注册用户的方式 --- 辅助构造器
  // 1. 手机号 + 密码
  // 2. 邮箱 + 密码 + 用户名
  // 姓名
  class Register(val name: String, var email: String, var pwd: String, var phone: String) {
    println("主构造器被调用")

    // 辅助构造器
    // 1. 名称一定是this
    // 2. 在辅助构造器内部，一定要调用主构造器this
    // 3. 可以有多个
    def this(phone: String, pwd: String) {
      this("随机用户xxxx", "xxx@qq.com", pwd, phone) // 调用主构造器
      println("辅助构造器被调用")
    }

    def this(email: String, pwd: String, name: String) {
      this(name, email, pwd, "13600000000") // 调用主构造器
      println("辅助构造器被调用")
    }

    def say(): Unit = {
      println(s"姓名: ${name}, 邮箱: ${email}, 密码: ${pwd}, 手机号: ${phone}")
    }
  }

  def main(args: Array[String]): Unit = {
    // val r1 = new Register("小明", "123123@qq.com", "123456", "13617885566")
    // 调用辅助构造器
    val r1 = new Register("13617885566", "123456")
    val r2 = new Register("9456651@qq.com", "123456", "小明")

    r1.say()
    r2.say()
  }
}

结果如图：