Scala | 类(上篇)

类（上篇）

概述

1. Scala中的类和java中基本类似
2. Scala中的类同样通过class来进行生命
3. Scala中的类同样可以具有成员变量和成员方法
4. Scala中的类同样通过new关键字来创建出对象

1、创建类

Demo01：

//创建一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是：scala中变量(var)声明时需要指定初始值，
 
class Person {
  var name:String="";
  var age:Int=0;
  
  def eat(){
    println("吃饭")
  }
}

注意：成员属性和成员方法默认都是public的，需要私有可以写private，需要保护可以写protected

Demo02：

//当成员变量或成员方法是私有属性时，外部将不能直接访问，这个同java一样
class Person {
  private var name:String="";
  private var age:Int=0;
  
  private def eat(){
    println("吃饭")
  }
}

object Demo02 { 
  def main(args: Array[String]): Unit = {
     val p=new Person
     //p.name="tom";
     //p.age=1;
     //p.eat();
   
   }
 }

2、类的构造

和Java不同，Scala中的类不需要明确生命一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分。

而直接写在类的体重的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体

Demo03：

//scala中的类不需要明确声明一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分
class Person(var1:String,var2:Int){
  var name=var1;
  var age=var2;
  
  //而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。
  println("……")
  println("***")
}

object Demo03 {
  
  def main(args: Array[String]): Unit = {
    //当调用构造方法时，会打印 …… 和***
     val p=new Person("tom",23)

  }
}

3、辅助构造器

有些时候一个类里需要多个构造器。Scala里主构造器之外的构造器被称之为辅助构造器

1. Scala的辅助构造器定义开始于def this()
2. Scala里每一辅助构造器的第一个动作都是调用同类的构造器

Demo04：

//scala支持辅助构造器，
class Person(var1:String,var2:Int){
  private var name=var1;
  private var age=var2;
  
  //Scala的辅助构造器定义开始于 def this() 
  //定义一个辅助构造器,只接受姓名
  def this(var1:String){
    this(var1:String,0)
  }
  
  //再定义两个辅助构造器,其中一个只接受年龄。另外一个是空构造器
  def this(var2:Int){
    this("",var2:Int)
  }
  
  def this(){
    this("",0)
  }
  
  def setName(name:String)={
    this.name=name
  }
  
  def getName()={
    this.name
  }
  
  def setAge(age:Int)={
    this.age=age
  }
  
  def getAge()={
    this.age
  }
  
  def say()={
    println("hello world")
  }
}

object Demo04 {
    def main(args: Array[String]): Unit = {
        val p1=new Person("tom")
        val p2=new Person(23)
        val p3=new Person()

        println(p1.getName())
        println(p1.say)
    
        println(p2.getAge())
    
        println(p3.getName())
        println(p3.getAge())
        
        
    
  }
}

4、重载和重写

1. scala也支持重载和重写。定义同java。重载: def add(a:Int,b:Int)={} def add(a:Int,b:Int,c:Int)={}
2. scala的class支持继承,通过extends关键字来继承。
3. 在重写方法时,如果重写的是一个普通方法,则需要加override 关键字
4. 如果重写的是一个抽象方法,则不需要加override

Demo05-重载：

class Person{
    def add(a:Int, b:Int){
        var sum = a+b
        println(sum)
    }
    def add(a:Int, b:Int, c:Int){
        var sum = a+b+c
        println(sum)
    }
}

object Demo05{
   def main(args: Array[String]): Unit = {
        var a  = new Person();
        a.add(10, 10);
        a.add(10, 10, 10);
    }
}

Demo06-重写：

class Person(var1:String,var2:Int) {
  
  private var name=var1
  private var age=var2
  
  
  def say()={
    println("hello world")
  }
}

class Student extends Person{
  
  override def say()={
    println("hello scala")
  }
  
}

5、单例对象(object)

1. scala中的类(class)不能定义静态成员（或静态方法），而代之以定义单例对象来替代。

2. 单例对象需要通过object关键字来声明

3. 一个单例对象可以单独存在,也可以绑定到一个类上

4. 单例对象当中的所有方法,都可以不需要创建对象而直接通过object单例对象的名字直接来调用，用起来感觉就像一个静态方法一样。

5. 当一个单例对象和某个类写在同一个源文件中且共享同一个名字时，他们就产生了一个绑定的关系

6. 此时单例对象称为该类的伴生对象。类称为该对象的伴生类。

7. 类和他的伴生对象可以互相访问其私有成员。

8. 以伴生的方式使为类增加静态成员称为了可能

9. 单例对象不能new，因此也没有构造参数。

10. 可以把单例对象当作是java中可能会用到的静态方法工具类。

11. 比如作为程序的入口main方法必须是静态的，所以main方法必须处在一个单例对象中，而不能写在一个类中。

12. 单例对象在第一次被访问时才会被初始化。

Demo07：

//类Person
class Person{
  
  //此私有变量，伴生类可以访问
  private val namespace="1706"
  
}

//Person的单利对象，也即伴生类Person,
object Person{
  
  def showTime(){
    println(System.currentTimeMillis())
  }
  
  def shownamespace(){
    val p=new Person
    //可以访问类的私有变量
    println(p.namespace)
  }
  
}

object Demo07{
  
  def main(args: Array[String]): Unit = {
    Person.showTime(); //1595471481495
    
    Person.shownamespace()  //1706
  }
}