scala之类的用法

概述

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

创建类

示例1：
//创建一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是：scala中变量(var)声明时需要指定初始值，

class Person {
var name:String=""; var age:Int=0;

def eat(){
println("吃饭")
}
}

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

示例2：

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

类的构造

和java不同，scala中的类不需要明确声明一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分。
而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的
体。
示例3：

//scala中的类不需要明确声明一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分
class Person(var1:String,var2:Int){ var name=var1;
var age=var2;
//而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。
println("……") println("***")
}
def main(args: Array[String]): Unit = {
//当调用构造方法时，会打印 …… 和*** val p=new Person("tom",23)
}

辅助构造器

有些时候 一个类里需要多个构造器。scala里主构造器之外的构造器被称为辅助构造器。
1）Scala的辅助构造器定义开始于def this()
2）Scala里每个辅助构造器的第一个动作都是调用同类的构造器。

示例4：

//scala支持辅助构造器，
class Person(var1:String,var2:Int){ var name=var1;
var age=var2;
//Scala的辅助构造器定义开始于 def this()
//Scala里每个辅助构造器的第一个动作都是调用同类的构造器。def this(var1:String){
this(var1:String,0)
}
//Scala的辅助构造器定义开始于 def this() def this(var2:Int){
this("",var2:Int)
}
}
def main(args: Array[String]): Unit = { val p1=new Person("tom")
val p2=new Person(23)
}

一个完整的示例：

class Person(v1:String,v2:Int){        
private var name=v1 private var age=v2    
def this(v1:String){ this(v1:String,0)
}    
def this(v2:Int){
this("",v2)       
}       
def setName(name:String)={this.name=name} def getName()={name}
def setAge(age:Int)={this.age=age} def getAge()={age}    
def eat()={println("eat")}   
def say()={println("say")}       
println("&&&&&&")
}

单例对象(object)

1）scala中的类(class)不能定义静态成员（或静态方法），而代之以定义单例对象来替代。
2）单例对象需要通过object关键字来声明
3）一个单例对象可以单独存在,也可以绑定到一个类上
4）单例对象当中的所有方法,都可以不需要创建对象而直接通过object单例对象的名字直接来调用，用起来感觉就像一个静态方法一样。
5）当一个单例对象和某个类写在同一个源文件中且共享同一个名字时，他们就产生了一个绑定的关系
6）此时单例对象称为该类的伴生对象。类称为该对象的伴生类。
7）类和他的伴生对象可以互相访问其私有成员。
8）以伴生的方式使为类增加静态成员称为了可能
9）单例对象不能new，因此也没有构造参数。
10）可以把单例对象当作是java中可能会用到的静态方法工具类。
11）比如作为程序的入口main方法必须是静态的，所以main方法必须处在一个单例对象中，

而不能写在一个类中。
12）单例对象在第一次被访问时才会被初始化。

示例5：

//类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)
}
}
def main(args: Array[String]): Unit = { Person.showTime(); Person.shownamespace()
}

重写和重载

1）重写是指覆盖父类中的方法来在子类中做其他事项
override def 父类方法名 参数列表 返回值 方法体

2）重载是指在同一个类中提供方法名相同但是参数不同的方法和java中基本一致

示例6：

final的使用

可以用在成员变量、成员方法、类本身上作用和java中相同

包的引用

类似于java中通过import关键字引入包/类 scala也可以实现这种方式引入，但是更强大一些
1）scala中的import可以出现在代码任何地方
2）scala中的import时可以指的是对象和包
3）scala中的import可以重命名或隐藏一些被引用的成员4）scala默认会自动引入如下三个包下的所有内容java.lang //java中的通用类
scala._ //scala提供的通用类 主要是基本类型除了String
Predef._ //提供了单例对象 以及一些常用方法print println

示例2：

import cn.tedu._

import cn.tedu.{Apple,Orange}

抽象类

scala中同样支持抽象类的使用，抽象类的内部可以包含抽象方法和非抽象方法。
抽象类不允许被实例化，抽象类主要是用来被继承的
示例3：

多态

示例5：

object Demo13{
    def main(args: Array[String]): Unit = {
    val t1:Teacher=new TeacherChen("chen",32) val t2:Teacher=new TeacherLiu("liu",32)
}    
}

特质trait

1）可以类比java中的接口，但是又和接口非常不一样，特质相当于java中的接口，java中称为

类实现了接口，scala中称为混入了特质。
2）和java中的接口不同的是，scala中的特质可以包含具有方法体的方法。
和抽象类不同的地方在于，scala的类只能单继承，但是可以多混入，利用这种方式可以实现类似c语言中多继承的特性。
3）在类中可以通过extends 或with 关键字来让类混入特质，如果类没有明确继承父类，
extends关键字没有被占用就可以使用extends。
4）但是如已经使用了extends显示的继承了父类，再向混入特质就要用with关键字了。

一个类的声明中只能有一个extends，但是可以有多个with
示例6：

//trait类似于java的接口，但可以做具体方法的实现trait Drive{
def piaoyi() def feiche(){
}
}
trait Cook{
def tudousi() def chaojidan()
}
//scala中，只能继承一个父类，但是可以混入多个特质（trait)
//需要实现特质中未实现的方法
//此外，需要注意的是，如果未继承任何类或抽象类，在混入特质时，比如有且仅有一个特质需要用extends来混入，而其他特质用with混入

class XueSheng extends Person with Drive with Cook{
override def piaoyi(){
}

override def tudousi(){
}

override def chaojidan(){
}
}

9）泛型

基本和java中相同，不同的是，泛型是用方括号引起来的

val arr = ArrayString; 10）lazy

•正常情况下通过val 和var定义的量都会直接分配空间，即使这个量要在很久以后才使用，这样就会造成内存空间白白被占用。
•这种情况下可以加上lazy关键字，延后变量/常量赋值的位置。这样直到后续真正用到这个量时才真正开辟空间赋值，减少了内存的浪费。
•val name = “zhang”//直接分配空间 即使一时半会用不到

•lazy val name = “zhang”//并不会立即分配空间 直到后续用到了才会分配

示例1：

object Demo01 {   

val val1="zhang"	//> val1 : String = zhang

//lazy

lazy val val2="zhang"	//> val2: => String

caseclass - 样例类

case class - 样例类
1）只要在声明类时 在class关键字前加上case关键字 这个类就成为了样例类样例类必须要显式的声明一个主构造器
2）当样例类声明一个主构造器后，会默认隐式的声明一个空构造器
3）样例类默认实现序列化接口（特质）
序列化的两个作用：①数据持久化 ②网络数据传输4）样例类默认自动覆盖toString equals hashCode方法5）样例类不需要new可以直接生成对象
}
示例3：

//需要声明一个主构造器，主构造器可以是一个空构造器case class Item(var1:String,var2:Int){
var name=var1; var age=var2;
}   

object Demo03 {   

def main(args: Array[String]): Unit = {
//样例类不需要new，并且隐式的含有空构造器val i1=Item
val i2=Item("tom",23)
println(i2.name+i2.age)
}
}

option
2017年12月12日 19:44

option
在Scala中用来表示一个结果，它可能有值，也可能没有值，它有两个子Option
示例2：

object Demo02 { 

def f1(a:Int,b:Int):Option[Int]={
if(b!=0){
Some(a/b)
}else{ None
}
}       
def main(args: Array[String]): Unit = {
//表示如果有正确结果，返回正确结果，没有则返回指定的默认值val Result=f1(4,2).getOrElse(0)
}
}