Scala 基础语法代码<转>

最新推荐文章于 2025-03-07 16:36:21 发布

转载最新推荐文章于 2025-03-07 16:36:21 发布 · 504 阅读

Scala 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了Scala编程语言的基础知识，包括变量定义、函数、类与对象、继承、抽象类与特质等核心概念。通过实例展示了Scala的强大特性和简洁语法。

下面的代码包含了基本的Scala的语法内容。包括：判断，循环代码片段，方法定义，调用。虚拟类，继承，接口，case，package，单例模式

[java]view plaincopy 
   
 package org.exinglo.scala  
   
 class LearnScala {  
   
 }  
   
 object Test{  
   val variable1 = "this is my first scala variable"  
       
   def func1(): String = "hello world" //不带参数的函数被调用时，可以不加括号  
       
   def func2(who : String): String = { return "hello world " + who}  
     
   def func3 = (x : Int, y : Int) => x + y //这是个匿名函数的写法，调用的时候，func3(1,2)  
     
   //这里给了y一个默认值，如果用户传过来，那就用用户的  
   def func4(x: Int)(y : Int = 1): Int = x + y //加脂法的写法，调用时， func4(1)(2)  
     
   // * 代表多个参数的意思，比如 printEveryChar("c","b", "a"),可以传递多个string  
   def printEveryChar(c : String*) = {  
     c.foreach(x => println(x))  
   }  
       
   def main(args : Array[String]) {  
     println(variable1)  
       
     for(i <- 0 to 10 if i%2 == 0){  
     println("i is a even number: " + i)  
     }  
       
     for(i <- 0 until 10){  
       println("")  
     }  
       
     var (n, r) = (10, 0)  
     while(n > 0){  
       n = n - 1  
     }  
       
     val p = new Person //这里可以省略括号  
     println("information about person:" + p.name + " " + p.age) //如果p.name没有赋值的话，这里会显示为null  
       
   }  
     
     
 }  

[java]view plaincopy 
   
 package org.exinglo.scala  
   
 class Person{ //类默认是public类型的  
   var name : String = _ //会生成setter和getter方法  
   val age = 10 //只会生成getter方法  
   private[this] val gender = "male" //无法在下面的main方法访问gender，这个属性只能在对象内部访问  
       
 }  
   
   
 //生成对象时 val p = new Person2("Java", 10)  
 //如果参数声明时不带val或者var，那么这个变量相当于内部变量，比如 class Person(name: String) 这里的name就无法在外部被访问到了  
 class Person2(val name : String, val age : Int){//括号中的内容属于主构造器，其中的参数会作为类的属性存在  
   println("this is the person2's constructor")//这里属于默认构造器，生成对象时，会执行这句话  
     
   var gender : String = _ //这里要求初始化  
     
   //附属构造器必须叫做this，必须首先调用已经存在的子构造器或者其他附属构造器  
   def this(name : String, age : Int, gender : String){  
     this(name, age)//必须调用默认的构造器，=  
     this.gender = gender  
   }  
 }  
   
 //成成Student对象的时候，会先打印父类构造器的打印语句，然后但因student类的语句  
 class Student(val grade : Int, name : String, age : Int) extends Person2(name, age) {  
   println("this is the subclass of Person, grade is:" + grade)  
     
   override def toString() : String =  {""} //覆盖父类的方法，一定要加上override关键字，其实不仅仅是父类的方法，覆盖父类的var val都要加上override  
 }  

[java]view plaincopy 
   
 package org.exinglo.abstractandtrait  
   
 class ABstractAndTrait {  
   
 }  
   
 //抽象类（abstract class）  
 //• 类的⼀一个或者多个⽅方法没有没完整的定义, 当然也可以没有任何抽象方法。  
 //  对于子类覆盖父类的非抽象方法，一定要override关键字  
 //• 声明抽象⽅方法不需要加abstract关键字,只需要不写⽅方法体  
 //• ⼦子类重写⽗父类的抽象⽅方法时不需要加override  
 //• ⽗父类可以声明抽象字段(没有初始值的字段)  
 //• ⼦子类重写⽗父类的抽象字段时不需要加override  
 abstract class PersonX{  
   def speak  
   val name:String  
   val age:Int  
 }  
   
 class Student extends PersonX{  
     
   //必须要实现抽象方法，像这种不写等于号的情况，表示返回类型是Unit类型  
   def speak{  
     println("speak")  
   }  
     
   val name:String = ""  
   val age:Int = 3  
 }  
   
 trait Logger{  
   def log(msg:String)  
 }  
   
 //这里的trait consoleLogger可以不实现父类的方法，也可以覆盖父类的方法实现，也可以实现父类的虚方法  
 trait ConsoleLogger extends Logger{  
   def log(msg:String){  
     println("save money:" + msg)  
   }  
 }  
   
 //因为是覆盖上级的方法，必须使用override关键字  
 trait MessageLogger extends ConsoleLogger{  
   override def log(msg:String){  
     println("save money to account:" + msg)  
   }  
 }  
 //如果一个类没有继承其他的类，实现的第一个trait只能用extends，其他的用with关键字  
 class Test extends ConsoleLogger{  
   def test{  
     log("hellp")  
   }  
 }  
   
 abstract class Account{  
   def save  
 }  
   
 class MyAccount extends Account with ConsoleLogger{  
   def save{  
     log("100")  
   }  
 }  
     
 object Run extends App{  
     
   //这里是一个很好玩的地方，单独给一个对象混入了一个特质trait，并且这个特质与类的定义继承的特质有冲突  
   //打印出来的是MessageLogger中的log方法  
   val acc = new MyAccount with MessageLogger  
   acc.save  
 }  

[java]view plaincopy 
   
 package org.exinglo.abstractandtrait  
   
 class ApplyTest(val msg:String) {  
   def apply() = msg  
   def test{  
     println(msg)  
   }  
 }  
   
 object ApplyTest{  
   //下面是apply方法的最常用的方式  
   def apply() = new ApplyTest("object calls new")  
     
   //object的方法相当于java中的静态方法  
   def static{  
     println("I am a static method")  
   }  
 }  
   
 object Basic extends App{  
     
   //类似于下面，嗲用object的方法  
   ApplyTest.static  
     
   val t = new ApplyTest("new")  
   println(t())  
     
   //据说下面这样可以调用object ApplyTest中的apply方法，但是我的编译器总是报错  
   //后来发现是object的apply方法一开始声明没有加上小括号造成的，如def apply = xxxx  
   val tt = ApplyTest()  
   println(tt())  
     
   // ApplyTest()是调用object的apply方法  
   // val t = new ApplyTest(); t() 调用的是class ApplyTest的apply方法  
 }  

[java]view plaincopy 
   
 package org.exinglo.abstractandtrait  
 /* 
  * package com.xyz{ 
  * //------------- 
  *  package spark 
  *  } 
  * } 
  *  
  * { //这里只在程序块中可见 
  *   import com.yyy 
  *    
  * } 
  *  
  * import java.util.{HashMap =>JavaHashMap} //定义一个别名 
  *  
  *  
  * package aa.bb.cc.dd 
  *  
  * class Xxx{ 
  *   private[dd] def variable = {} //根据private[]中指定的不同，可见范围不同 
  * } 
  *  
  * */  
 class PackageAndCase {  
   
 }  
   
 object BasicT extends App{  
   val value = 3  
     
   val result = value match{  
     case 1 => "one"  
     case 2 => "two"  
     case _ => "some other number"  
   }  
     
   val result2 = value match{  
     case i if i == 1 => "one"  
     case i if i == 2 => "two"  
     case _ => "other number"  
   }  
     
   def t(obj : Any) = obj match{  
     case x:Int => println("Int")  
     case s:String => println("String")  
     case _ => println("unkonwn type")  
   }  
     
   t(2)  
 }  