Scala中的类和对象

简介: scala中有一个更简洁的初始化成员变量的方式，可以让代码看起来更加简洁。

用法:

1. 在定义var类型的成员变量时，可以使用 _ 来初始化成员变量
2. String => null
3. Int => 0
4. Boolean => false
5. Double => 0.0

注意: val类型的成员变量，必须要自己手动初始化

object _04ClassDemo {
​	
	//定义类
  class Person{
    // 使用下划线进行初始化成员变量
    var name:String = _
    var age:Int = _
  }
​
  def main(args: Array[String]): Unit = { //main方法  
  //创建对象
    val person = new Person
    
    println(person.name)
    println(person.age)
  }
  
}

定义成员方法:

object _05ClassDemo {
​
  class Customer {
    var name:String = _
    var sex:String = _
​
    // 定义成员方法
    def sayHi(msg:String) = {
      println(msg)
    }
    
  }
​
  def main(args: Array[String]): Unit = {
    val customer = new Customer  //创建对象
    customer.name = "张三"
    customer.sex = "男"
    customer.sayHi("你好")
  }
}

• 类的构造器

语法

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
    // 构造代码块
}

1. 主构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
2. 构造器参数列表可以指定默认值
3. 创建实例，调用构造器可以指定字段进行初始化
4. 整个class中除了字段定义和方法定义的代码都是构造代码

object _06ConstructorDemo {
​
  // 定义类的主构造器
  // 指定默认值   参数
  class Person(var name:String = "", var age:Int = 0) {
    println("调用主构造器")
  }
​
  def main(args: Array[String]): Unit = {
    // 给构造器传入参数
    val zhangsan = new Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)
​
    println("="*100)
​
    // 不传入任何参数
    val empty = new Person
    println(empty.name)
    println(empty.age)
​
    println("="*100)
​
    // 指定字段进行初始化
    val man40 = new Person(age = 40)
    println(man40.name)
    println(man40.age)
  }
}

• 单例对象
  scala中没有Java中的静态成员，我们想要定义类似于Java的static变量、static方法，就要使用到scala中的单例对象——object.

单例对象表示全局仅有一个对象（类似于Java static概念）

1. 定义单例对象和定义类很像，就是把class换成object
2. 在object中定义的成员变量类似于Java的静态变量
3. 可以使用object直接引用成员变量

object _08ObjectDemo {
​
  // 定义一个单例对象
  object Dog {
    // 定义腿的数量
    val LEG_NUM = 4

	
  }
​
  def main(args: Array[String]): Unit = {
    println(Dog.LEG_NUM)
  }
}

• 伴生对象
  一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类

1. 伴生对象必须要和伴生类一样的名字
2. 伴生对象和伴生类在同一个scala源文件中
3. 伴生对象和伴生类可以互相访问private属性

在Java中，经常会有一些类，同时有实例成员又有静态成员:

public class CustomerService {
​
    private static String SERVICE_NAME = "CustomerService";
​
    public void save() {
        // 保存客户
        System.out.println(SERVICE_NAME + ":保存客户");
    }
​
    public static void main(String[] args) {
        new CustomerService().save();
    }
}

在scala中，要实现类似的效果，可以使用伴生对象来实现:

object _11ObjectDemo {

  // 1-编写一个英雄Hero类，  伴生类
  class Hero {
  
  // 2-有一个作战方法，打印  "我要用【方天画戟】作战了"
    def fight() = {
      println(s"我要用【${Hero.WEAPON}】作战了")  //插值表达式
    }
    
  }
  
  // 3-编写一个Hero伴生对象，定义一个私有变量，用于保存作战武器的名称
  object Hero{
    private val WEAPON = "方天画戟"
  }

  // 4-main方法中创建Hero类的对象吕布，调用fight方法
  def main(args: Array[String]): Unit = {
    val lvbu = new Hero
    lvbu.fight