scala的类和构造器scala类的定义类是属性和行为的集合属性也叫成员变量：名词，用来描述事物的外在特征。行为也

scala类的定义

类是属性和行为的集合

属性也叫成员变量：名词，用来描述事物的外在特征。
行为也叫成员方法：动词，表示事物做什么。

object z11 {
  //1.定义一个类
  //类名:首字母大写
  // class 类名(){}
  class Student() {
    //属性
    //定义属性和定义变量一致
    var name:String = "小花"
    var age:Int = 18

    // 方法
    // 定义方法和定义函数一致
    def  sayHello() = {
      println(s"${age}${name}")
    }
  }

  def main(args: Array[String]): Unit= {
    // 2.创建对象（实例化对象）
    // 对象名 = new 类名()

    val st1 = new Student()

    // 通过 对象.属性名 来访问属性
    println(st1.name)

    // 通过 对象.方法名() 来调用方法
    st1.sayHello()
//     val st2 = new Student()
//     println(st2)
  }
}

scala的类成员

在定义一个类的时候，类中可以定义的成员主要有以下几种：

构造器/辅助构造器：为类创建不同的对象。

object z12 {
  class Student(var name:String = "小花", var age:Int = 18) {
    // 方法
    // 定义方法和定义函数一致
    def  sayHello() = {
      println(s"${age}${name}")
    }
  }

  def main(args: Array[String]): Unit= {
    // new Student("小明", 19)
    // 1.调用构造器，第5行
    // 2.没有传入相关的参数，使用默认值。

    val st1 = new Student()
    println(st1.name)

  // new Student("小明", 19)
  // 1.调用构造器，第5行
  // 2，传入相关数据
    val st2 = new Student()
    println(st2)
  }
}

属性：每一个对象所具有的特征。
方法：对象具有的行为动作。
类(内部类)：对象的属性封装。
对象：对象是累的具体实例，是具体的。

习题——三角形封装

object z13 {
  // 面向对象编程的三个特点
  // 封装，继承，多态
  class Triangle(a:Double, b:Double, c:Double) {
    def getArea(): Double = {
      //是否能根据三边长，来求面积？海伦公式
      var s = (a + b + c) / 2
      s = s * (s - a) * (s - b) * (s - c)
      return Math.sqrt(s) //Math.sqrt(4) ==> 2 开平方操作
    }
    //
    def check(): Boolean = {
      //
      return (a + b) > c && (a + c) > b && (b + c) > a
    }
  }
  def main(args: Array[String]): Unit= {
    // Triangle表示一个三角形
    // Triangle(边长1，边长2，边长3)
    val t1 = new Triangle(3,4,5)
    println(t1.getArea()) //获取面积

    val t2 = new Triangle(1,1,4)
    println(t2.getArea()) //获取面积
  }
}

构建器的参数修饰符

可以在两个地方写属性:
1. 构造器的参数列表
2. 构造器内部
构造器的参数列表：
1. val 表示不可以被修改的属性
2. var 表示可以被修改的属性
3. 没有修饰符，不是对象的属性，无法访问

object z14 {
 class Triangle(val a:Double,val b:Double, c:Double) {

    val d:Int = 1
    val e:Int = 2
  }

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

    val t = new Triangle(1,2,3)
    t.b = 2

    // t.c无法访问

    t.
  }
}

案例2：主构造器，辅构造器

写多个构造器：

主构造器：一个，就是class
辅构造器：多个，名称就是 this
构造器的作用：生产对象

支持多种创建对象的方式 ==== 在网站注册用户的时候，可有多种注册方式：手机号，微信号，邮箱号。

object z15 {
    class User(val phone:String, var pwd:String) {
      var email:String = ""
      var name:String = ""

      //辅构造器
      def this (emal:String,name:String,pwd:String){
        //调用一次主构造器
        this("",pwd)
        //再对其他的属性赋值
        this.name = name
        this.email = email
      }

      //辅构造器
      def this(email:String,name:String,pwd:String,phone:String){
        //调用一次主构造器
        this(phone,pwd)
        //再对其他的属性赋值
        this.name = name
        this.email = email
      }

      def say():Unit={
        println(s"我的信息如下：")
        println(s"姓名：${name}")
        println(s"手机号：${phone}")
        println(s"邮箱:${email}")
        println(s"密码：${pwd}")
      }
    }
    def main(args: Array[String]): Unit = {
      var u1 = new User("13617891234","123456")
      u1.say()

      var u2 = new User("12345@qq.com","小花","123456")
      u2.say()

输出结果：

makefile
 体验AI代码助手
 代码解读
复制代码
我的信息如下：
姓名：
手机号：13617891234
邮箱:
密码：123456
我的信息如下：
姓名：小花
手机号：
邮箱:
密码：123456
我的信息如下：
姓名：小花
手机号：13617891234
邮箱:12345@qq.com
密码：123456