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

Scala类的定义

类是属性和行为的集合。

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

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

    // 方法
    // 定义方法和定义函数一致
    def sayHello(): Unit = {
      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的主要分类如下：

普通类：通过class关键字定义的类。
匿名类：指没有名字的类，可以利用接口和抽象类的名字创建匿名类。
内部类：在普通类中创建另外一个类。
抽象类：通过abstract关键字定义的类。

Scala的类成员

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

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

//new class会发生什么？
//会调用一次 构造器(或者叫构造函数) 代码
//构造器  ====  class
//构造器的作用：生产对象。

object work29 {

  // 带参数的构建器(构建函数)
  class Student(var name:String = "小花", var age:Int = 18) {
    // 方法
    // 定义方法和定义函数一致
    def sayHello(): Unit = {
      println(s"我是${age}岁的${name}")
    }
  }
  def main(args: Array[String]): Unit = {
    // new Student()
    // 1. 调用构造器，第五行。
    // 2. 没有传入相关的参数，使用默认值。
    val st1 = new Student()
    println(st1.name)

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

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

案例1：封装一个三角形类

object work30 {
  // 面向对象编程的三个特点
  // 封装，继承，多态
  class Triangle(a:Double, b:Double, c:Double) {
    //计算面积
    def getArea(): Double = {
      if(check()) {
        //能否根据三条边的边长，来计算面积？ 海伦公式
        var s = (a + b + c) / 2
        s = s * (s - a) * (s - b) * (s - c)
        return Math.sqrt(s)  // Math.sqrt(4) ==>2 就是开平方操作
      } else {
        print("不能构成三角形")
        return 0;
      }
    }

    // 检查是否能构成三角形
    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,3)
    println(t2.getArea()) // 获取面积
  }
}

构造器的参数修饰符

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

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

    val d:Int = 1
    var e:Int = 2
  }
  def main(args: Array[String]): Unit = {
   val t = new Triangle(1,2,3)
   t.b = 2
   
   // t.c无法访问
  }
}

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

写多个构造器：

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

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

object work32 {
  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()

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

输出结果：

我的信息如下：
姓名：
手机号：13617891234
邮箱:
密码：123456
我的信息如下：
姓名：小花
手机号：
邮箱:
密码：123456
我的信息如下：
姓名：小花
手机号：13617891234
邮箱:12345@qq.com
密码：123456