class（类）

Scala中定义类和Java一样，都是使用 class 关键字
和Java一样，使用new关键字创建对象

  1. class Person {
  3.   var name = "scala"
  5.   def sayHello(): Unit = {
  6.     println("hello," + name)
  7.   }
  9.   def getName = name
  11. }

注意： 如果在定义方法的时候指定了()，那么在调用的时候()可写可不写 如果在定义方法的时候没指定()，则调用方法时不能带()

测试：

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

    val p = new Person()
    p.sayHello()
    println(p.getName)

  }

image.png

constructor

Scala类中的构造函数可以分为主构造函数和辅助构造函数

主constructor

类似Java的默认构造函数 this()
Scala的主constructor是与类名放在一起的，与Java不同，Java中的构造函数是写在类内部的
在类中，没有定义在任何方法或者是代码块之中的代码就是主constructor的代码

class Student(val name: String , val age: Int) {

  //在类中，没有定义在任何方法或者是代码块之中的代码就是主constructor的代码
  println("name is " + name + ",age is " + age)

}

测试：new Student("zs", 25)
image.png
主constructor中还可以通过使用默认参数，来给参数设置默认值

class Student(val name: String = "jack", val age: Int = 20) {

  //在类中，没有定义在任何方法或者是代码块之中的代码就是主constructor的代码
  println("name is " + name + ",age is " + age)

}

测试：new Student()
image.png

辅助constructor

类似Java的重载构造函数 this(name,age)

class Stu {

  var name = "jack"
  var age = 10

  def this(name: String) {
    this()
    this.name = name
  }

  def this(name: String, age: Int) {
    //    this()
    //    this.name=name
    //    this.age=age

    this(name: String)
    this.age = age
  }

}

  def main(args: Array[String]): Unit = {
    val s = new Stu("zs")
    val s2 = new Stu("ls", 26)
  }

object（对象）

前面我们学习的scala中的class和java中的class是类似的，下面来看一个java中没有的内容，叫Object
那大家可能有疑问了，Java中也有object，通过class就可以创建object
但是注意了，在scala中，我们可以直接定义一个object，就像定义class一样。

object：相当于class的单个实例，通常在里面放一些静态的field或者method

object不能定义带参数的constructor，只有空参的constructor

第一次调用object的方法时，会执行object的constructor，也就是执行object内部不在任何方法中的代码，因为它只有空参的构造函数
但是注意，object的constructor的代码只会在他第一次被调用时执行一次，以后再次调用就不会再执行了

object通常用于作为单例模式的实现，或者放class的一些静态成员，比如工具方法

object可以直接使用，不能new

object Man {

  var age = 1

  println("this Person object!")

  def getAge = age

  def main(args: Array[String]): Unit = {
    //object可以直接使用，不能new
    Man

    println(Man.age)

    println(Man.getAge)
  }

}

image.png

伴生对象

如果有一个class，还有一个与class同名的object，那么就称这个object是class的 伴生对象 ，class是object的 伴生类

注意：伴生类和伴生对象必须存放在一个.scala文件之中 伴生类和伴生对象最大特点在于可以互相访问private field

object Employee {
  private val fdNum = 1

  def getFdNum = fdNum
}

class Employee(val name: String, val age: Int) {
  def sayHello(): Unit = {
    println("Hi, " + name + ",you are " + age + " years old!" + ", and you  have " + Employee.fdNum + " friend.")
  }
}

object Test {

  def main(args: Array[String]): Unit = {
    new Employee("tom", 20).sayHello()

    //此处报错，说明：object无法访问自己的私有方法，但是它的伴生类可以
    //Employee.fdNum
  }
}

image.png

apply（创建对象的另一种方式）

apply是object中非常重要的一个特殊方法，通常在伴生对象中实现apply方法，并在其中实现构造伴生类对象的功能

在创建对象的时候，就不需要使用new Class的方式，而是使用Class()的方式，隐式调用伴生对象的apply方法，这样会让对象创建更加简洁

class Cat(val name: String) {
  println("my name is," + name)
}

object Cat {
  def apply(name: String): Cat = {
    println("apply execute...")
    new Cat(name)
  }
}

1、使用new+class的方式创建对象new Cat("tom")
image.png
2、使用object的apply方法创建对象Cat("tom")
image.png

main方法

和Java一样，在Scala中如果要运行一个应用程序，必须有一个main方法，作为入口
Scala中的main方法必须定义在object中，格式为def main(args: Array[String])

object mainDemo {
  /**
   * 注意：main方法只能定义在object中，不能定义在class中
   */
  def main(args: Array[String]): Unit = {
    println("hello scala!")
  }

}

trait（接口）

trait类似于Java中的interface
在triat中可以定义抽象方法
类可以使用extends关键字继承trait，无论继承类还是trait统一都是使用extends这个关键字

object ChildDemo {

  def main(args: Array[String]): Unit = {
    val c1 = new Child("tom")
    val c2 = new Child("jack")
    c1.sayHello(c2.name)
    c1.makeFriends(c2)
  }

}

trait HelloTrait {
  def sayHello(name: String)
}

trait MakeFriendsTrait {
  def makeFriends(p: Child)
}

class Child(val name: String) extends HelloTrait with MakeFriendsTrait {

  def sayHello(name: String): Unit = println("Hello, " + name)

  def makeFriends(p: Child): Unit = println("Hello, my name is " + name + ", your name is " + p.name)
}

image.png