Scala编程语言day3

函数

语法： val 函数变量名 = （参数名:参数类型，参数名:参数类型.....）=>函数体

在Scala中，函数是一个对象（变量）

类似于方法，函数也是有参数列表和返回值

函数定义不需要def

无需指定返回值

val getSum=(a:Int,b:Int)=>a+b
val sum=getSum(1,2)

方法和函数的区别

在Java中，方法和函数之间没有任何区别，只是叫法不同，但是在Scala中，函数和方法就有区别了，具体如下：

1.方法是隶属于类或者对象的，在运行中，他是加载在JVM的方法区中

2.可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中

3.函数是一个对象，方法时属于对象的

//函数
val getSum=(a:Int,b:Int)=>a+b
val sum=getSum(1,2)
//方法
def add(a:Int,b:Int) = a+b
val a=add    //会报错

//将方法转换为函数
val a=add _

val sum1=a(1,2)

第六章类和对象

概念

类是属性和行为的集合，是一个抽象的概念，看不见，也摸不着

对象是类的具体体现，实现

创建类和对象

 如果类是空的，没有任何成员，可以省略{}　　　　如果构造器的参数为空，可以省略()

package project

object oop {//创建people类
    class Person
    
    //main方法
    def main(args: Array[String]): Unit = {
      val person=new Person
      
      println(person)
    }
}

定义和访问成员变量

在类中使用val/var来定义成员变量　　　　对象可以通过　　对象名. 的方式来访问成员变量

package project

object oop {

    //创建people类
    class Person {
      var name = ""
      var age = 0
    }

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

      val p=new Person()

      p.name="张三"
      p.age=18

      println(p.name,p.age)
    }
}

使用下划线初始化成员变量

在定义var类型的成员变量时，可以使用_来初始化成员变量

　　String=>null

　　Int=>0

　　Boolean=>false

　　Double=>0.0

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

实例：var name:String = _

定义和访问成员方法

package project

object CustomerObject {
  class Customer{
    var name=""
    var sex=""

    def printInfo()={
      println("欢迎光临"+name)
    }

  }

  def main(args: Array[String]): Unit = {
    val c=new Customer()
    c.name="张三"
    c.sex="男"
    c.printInfo()
  }
}

访问权限修饰符

Scala中的权限修饰符只有private(供本类使用)、private[this](伴生类，伴生对象)、protected(供子类使用)、默认(全部可以使用)这四类

主构造器

语法:　　class 类名(val/var 参数名:类型 = 默认值，val/var 参数名:类型值=默认值){}

注意:　　1.主构造器的参数列表定义在类名后面，添加了var/val表示直接通过主构造器定义成员变量

　　　　 2.构造器参数列表可以指定默认值

　　　　 3.创建实例，调用构造器可以指定字段进行初始化

　　　　 4.整个class中处理字段定义和方法定义的代码都是构造代码

package project

object PeopleObject {
  class People(var name:String = "张三",var age:Int=18)
  {
    println("hello主构造器")
  }

  def main(args: Array[String]): Unit = {
    val p1=new People()
    val p2=new People("王五",18)
    println(p1.name,p1.age)
    println(p2.name,p2.age)
  }
}

辅助构造器

定义辅助构造器与定义方法一样，也使用def关键字来定义　　辅助构造器的默认名字都是this，且不能修改

def this(参数名：类型,参数名:类型){

　　//第一行需要调用主构造器或者其他构造器

　　//构造器代码

}

  class People(var name:String ,var sex:String)
  {
    //println("hello主构造器")
    def this(arr:Array[String]){
      this(arr(0),arr(1))
    }
  }

  def main(args: Array[String]): Unit = {
    val p1=new People(Array("张三","男"))
    println(p1.name,p1.sex)
  }

定义单例对象

单例对象表示全局仅有一个对象，也叫孤立对象

语法：object 单例对象名{}　　　　！！！在object中定义的成员变量类似于Java中的静态变量，在内存中都只有一个对象，调用通过 单例对象名. 

在单例对象中定义方法

  object Dog{
    var dogLength=4
    def printAdd()=for(i <- 1 to 15) print("-")
  }

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

如何定义程序的入口

定义程序的入口有两种：定义main方法　　继承APP特质

创建一个object继承自App特质(Trait)，然后将需要编写在main方法中的代码，写在object的构造方法体内

object 单例对象名 extends App{}
定义伴生对象

一个class和object具有相同的名字。这个object称为伴生对象，这个class称为半生类，他们可以互相访问private属性

class General{
    def printGeneral()= print(s"拿着${General.name}勇往直前")
  }
  //伴生对象
  object General{
    //里面的都是静态的
    private val name="长枪"
  }

  def main(args: Array[String]): Unit = {
    val g =new General()
    g.printGeneral()
  }

private[this]的访问权限

在伴生类中定义private[this]的成员，这个成员只能在当前类中访问，伴生对象也不能访问

apply()方法

 伴生对象可以通过apply()来实现免new的动作

定义apply()方法的格式

object 伴生对象名{

　　def apply(参数名:参数类型,参数名:参数类型......)=new 类( . . .)

}

创建对象：val 对象名=伴生对象名(参数1,参数2...)

  //半生类
  class General(var name:String,var age:Int){}
  //伴生对象
  object General{
    //里面的都是静态的
    def apply(name:String,age:Int) =new General(name,age)
  }

  def main(args: Array[String]): Unit = {
    val g=General("张三",18)
    println(g.name,g.age)
  }