Scala基础学习03

scala类

一般，Scala类名的第一个字母要大写，几个单词拼成一个类名，每个单词首字母大写。Scala中的类不声明为public,一个Scala类中可以有多个源文件，并且Scala类可以有参数。

定义一个类Point来计算二维坐标移动后的坐标

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Point(xc:Int,yc:Int){
    var x:Int=xc
    var y:Int=yc
def move(dx:Int,dy:Int){
    x=x+dx
    y=y+dy
    println("x: "+x)
    println("y: "+y)
    }
}
// Exiting paste mode, now interpreting.

defined class Point

scala> new Point(1,2).move(2,3)
x: 3
y: 5

Scala继承一个类需要使用关键字extends

scala> :paste
// Entering paste mode (ctrl-D to finish)

class Location(val xc:Int,val yc:Int,val zc:Int) extends Point(xc,yc){
    var z:Int=zc
def move(dx:Int,dy:Int,dz:Int){
    x=x+dx
    y=y+dy
    z=z+dz
println("x:"+x);
println("y:"+y);
println("z:"+z);
    }
}

// Exiting paste mode, now interpreting.

defined class Location

scala> new Location(1,2,3).move(1,1,1)
x:2
y:3
z:4

Scala只允许继承一个父类，并且继承父类的所有属性和方法。子类继承父类中已实现的方法需要使用关键字override，子类继承父类中未实现的方法可以不使用关键字override。

abstract class Father{
def fun1=1
def fun2:Int
}
class Child extends Father{
override def fun1=2
def fun2=1
}

Scala object

Scala中没有static关键字，因此Scala的类中不存在静态成员。但是Scala可以使用object关键字实现单例模式。单例对象就是在整个程序中只有这么一个实例。object对象与类的区别在于object对象不能带参数

object Person{
val age=10
def getAge=age
}

包含main方法的object对象可以作为程序的入口点。另外，当单例对象与某个类共享同一个名称时，单例对象被称作是这个类的伴生对象，类被称为是这个单例对象的伴生类。类和它的伴生对象可以互相访问其私有成员。必须在同一个源文件里定义类和它的伴生对象。

定义一个类Person，类中有私有成员name和私有方法getSkill,再定义类的伴生对象，伴生对象访问了伴生类的私有成员及私有方法，而伴生类访问了伴生对象的私有成员skill。
class Person private(val name:String){
private def getSkill()=name+"s skill is:"+Person.skill
}
object Person{
private val skill="basketball"
private val person=new Person("Tracy")
def printSkill=println(person.getSkill())
def main(args:Array[String]):Unit={
Person.printSkill
}
}

Scala模式匹配

scala> def matchTest(x:Int)=x match{
     | case 1=>print("one")
     | case 2=>print("two")
     | case _=>print("many")
     | }
matchTest: (x: Int)Unit

scala> matchTest(1)
one
scala> matchTest(3)
many

Scala的match语句不需要break语句，每个case都有一个隐含的break存在，只要发现有一个匹配的case，剩下的case不会继续匹配。

scala> def matchTest(x:List[Int])=x match{
     | case List(0,_,_)=>print("列表x有3个元素，并且第一个元素是0")
     | case List(1,_*)=>print("列表x有任意个元素，并且第一个元素是1")
     | case List(_,1,_*)=>print("列表至少有两个元素，并且第二个元素是1")
     | }
matchTest: (x: List[Int])Unit

scala> val a:List[Int]=List(0,1,2)
a: List[Int] = List(0, 1, 2)

scala> val b:List[Int]=List(1,0,2,3,4)
b: List[Int] = List(1, 0, 2, 3, 4)

scala> val c:List[Int]=List(5,1,0,2,3,4)
c: List[Int] = List(5, 1, 0, 2, 3, 4)

scala> matchTest(a)
列表x有3个元素，并且第一个元素是0
scala> matchTest(b)
列表x有任意个元素，并且第一个元素是1
scala> matchTest(c)
列表至少有两个元素，并且第二个元素是1

Scala读写文件

scala> import java.io._
import java.io._

scala> val pw=new PrintWriter(new File("/home/hadoop/桌面/ScalaLearn/test.txt"))
pw: java.io.PrintWriter = java.io.PrintWriter@76b07f29

scala> pw.write("I like Scala")

scala> pw.close

scala> import scala.io.Source
import scala.io.Source

scala> Source.fromFile("/home/hadoop/桌面/ScalaLearn/test.txt").foreach{print}
I like Scala

Scala练习题

编写函数过滤文本中的回文单词

vim pdhuiwen.scala

object pdhuiwen{
    def main(args:Array[String]):Unit={
    //测试回文
    import scala.io.StdIn
    println("请输入单词:")
    val x=StdIn.readLine()
    if(x==x.reverse)
    println(x)
    else println("不是回文")
    }
}

hadoop@master:~/桌面/ScalaLearn$ scalac pdhuiwen.scala 
hadoop@master:~/桌面/ScalaLearn$ scala pdhuiwen
请输入单词:
mom
mom
hadoop@master:~/桌面/ScalaLearn$ scala pdhuiwen
请输入单词:
scala
不是回文

使用Scala编程输出杨辉三角

vim yhsj.scala 

import scala.io.StdIn
object yhsj{
    def main(args:Array[String]):Unit={
    val num = pascal()
    val Value = Array.ofDim[Int](num,num)

    for (i <- 0 until num) { //行
      for (j <- 0 to i) { //列
        if (j == 0 || j == i) Value(i)(j) = 1
        else Value(i)(j) = Value(i - 1)(j - 1) + Value(i - 1)(j)
        print(Value(i)(j) + "\t")
      }
      println()
    }
  }

  def pascal():Int={
    println("请输入行列值：")
    val num:Int = StdIn.readInt()
    num
    }
}


hadoop@master:~/桌面/ScalaLearn$ scalac yhsj.scala 
hadoop@master:~/桌面/ScalaLearn$ scala yhsj
请输入行列值：
11
1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	
1	10	45	120	210	252	210	120	45	10	1
hadoop@master:~/桌面/ScalaLearn$ 

求100~999之间的所有水仙花数

个位十位百位，3个数的立方和等于这个数的本身
例如：1x1x1+5x5x5+3x3x3=153

vim sxhs.scala

object sxhs{
    def main(args:Array[String]):Unit={
    for(number<-100 to 999){
    val a=number/100
    val b=number%100/10
    val c=number%100%10
    if(a*a*a+b*b*b+c*c*c==number){
    println(number+" ")
            }
        }
    }
}


hadoop@master:~/桌面/ScalaLearn$ scalac sxhs.scala 
hadoop@master:~/桌面/ScalaLearn$ scala sxhs
153 
370 
371 
407